Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Assegnazione e riferimento a variabili nelle regole di Guard Assegnazione e riferimento a variabili nelle regole di Guard Puoi assegnare variabili nei tuoi file di AWS CloudFormation Guard regole per archiviare le informazioni a cui desideri fare riferimento nelle regole di Guard. Guard supporta l'assegnazione di variabili in un colpo solo. Le variabili vengono valutate pigramente, il che significa che Guard valuta le variabili solo quando vengono eseguite le regole. **Topics** + [ ## Assegnazione di variabili ](#assigning-variables) + [ ## Variabili di riferimento ](#referencing-variables) + [ ## Ambito variabile ](#variable-scope) + [ ## Esempi di variabili nei file delle regole di Guard ](#variables-examples) ## Assegnazione di variabili Assegnazione di variabili Utilizzate la `let` parola chiave per inizializzare e assegnare una variabile. Come best practice, utilizzate snake case per i nomi delle variabili. Le variabili possono memorizzare valori letterali statici o proprietà dinamiche risultanti dalle query. Nell'esempio seguente, la variabile `ecs_task_definition_task_role_arn` memorizza il valore della stringa statica. `arn:aws:iam:123456789012:role/my-role-name` ``` let ecs_task_definition_task_role_arn = 'arn:aws:iam::123456789012:role/my-role-name' ``` Nell'esempio seguente, la variabile `ecs_tasks` memorizza i risultati di una query che cerca tutte le `AWS::ECS::TaskDefinition` risorse in un CloudFormation modello. È possibile fare riferimento `ecs_tasks` all'accesso alle informazioni su tali risorse quando si scrivono le regole. ``` let ecs_tasks = Resources.*[ Type == 'AWS::ECS::TaskDefinition' ] ``` ## Variabili di riferimento Variabili di riferimento Utilizzate il `%` prefisso per fare riferimento a una variabile. In base all'esempio di `ecs_task_definition_task_role_arn` variabile in[Assegnazione di variabili](#assigning-variables), è possibile fare riferimento `ecs_task_definition_task_role_arn` nella `query|value literal` sezione di una clausola della regola Guard. L'utilizzo di tale riferimento garantisce che il valore specificato per la `TaskDefinitionArn` proprietà di qualsiasi `AWS::ECS::TaskDefinition` risorsa in un CloudFormation modello sia il valore `arn:aws:iam:123456789012:role/my-role-name` della stringa statica. ``` Resources.*.Properties.TaskDefinitionArn == %ecs_task_definition_role_arn ``` In base all'esempio della `ecs_tasks` variabile in[Assegnazione di variabili](#assigning-variables), è possibile fare riferimento `ecs_tasks` in una query (ad esempio, %ECS\$1Tasks.properties). Innanzitutto, Guard valuta la variabile `ecs_tasks` e quindi utilizza i valori restituiti per attraversare la gerarchia. Se la variabile si `ecs_tasks` risolve in valori non di stringa, Guard genera un errore. **Nota** Attualmente, Guard non supporta il riferimento a variabili all'interno di messaggi di errore personalizzati. ## Ambito variabile Ambito variabile L'ambito si riferisce alla visibilità delle variabili definite in un file di regole. Un nome di variabile può essere utilizzato solo una volta all'interno di un ambito. Esistono tre livelli in cui è possibile dichiarare una variabile o tre possibili ambiti variabili: + A **livello di file**: in genere dichiarate nella parte superiore del file delle regole, è possibile utilizzare variabili a livello di file in tutte le regole all'interno del file delle regole. Sono visibili all'intero file. Nel seguente file di regole di esempio, le variabili `ecs_task_definition_task_role_arn` e `ecs_task_definition_execution_role_arn` sono inizializzate a livello di file. ``` 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 } ``` + A **livello di regola**: dichiarate all'interno di una regola, le variabili a livello di regola sono visibili solo per quella regola specifica. Qualsiasi riferimento esterno alla regola genera un errore. Nel seguente file di regole di esempio, le variabili `ecs_task_definition_task_role_arn` e `ecs_task_definition_execution_role_arn` vengono inizializzate a livello di regola. `ecs_task_definition_task_role_arn`È possibile fare riferimento solo all'interno della regola denominata. `check_ecs_task_definition_task_role_arn` È possibile fare riferimento solo alla `ecs_task_definition_execution_role_arn` variabile all'interno della regola `check_ecs_task_definition_execution_role_arn` denominata. ``` 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 } ``` + A **livello di blocco**: dichiarate all'interno di un blocco, ad esempio una `when` clausola, le variabili a livello di blocco sono visibili solo per quel blocco specifico. Qualsiasi riferimento esterno al blocco genera un errore. Nel seguente file di regole di esempio, le variabili `ecs_task_definition_task_role_arn` e `ecs_task_definition_execution_role_arn` sono inizializzate a livello di blocco all'interno del `AWS::ECS::TaskDefinition` blocco di tipo. È possibile fare riferimento solo alle `ecs_task_definition_execution_role_arn` variabili `ecs_task_definition_task_role_arn` and all'interno dei blocchi `AWS::ECS::TaskDefinition` di tipo per le rispettive regole. ``` 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 } } ``` ## Esempi di variabili nei file delle regole di Guard Esempi Le sezioni seguenti forniscono esempi di assegnazione statica e dinamica delle variabili. ### Assegnazione statica Assegnazione statica Di seguito è riportato un CloudFormation modello di esempio. ``` Resources: EcsTask: Type: 'AWS::ECS::TaskDefinition' Properties: TaskRoleArn: 'arn:aws:iam::123456789012:role/my-role-name' ``` Sulla base di questo modello, è possibile scrivere una regola denominata `check_ecs_task_definition_task_role_arn` che garantisce che la `TaskRoleArn` proprietà di tutte le risorse del `AWS::ECS::TaskDefinition` modello sia`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 } ``` Nell'ambito della regola, è possibile inizializzare una variabile chiamata `ecs_task_definition_task_role_arn` e assegnarle il valore di stringa statico. `'arn:aws:iam::123456789012:role/my-role-name'` La clausola della regola verifica se il valore specificato per la `TaskRoleArn` proprietà della `EcsTask` risorsa proviene `arn:aws:iam::123456789012:role/my-role-name` dal riferimento alla `ecs_task_definition_task_role_arn` variabile nella sezione. `query|value literal` ### Assegnazione dinamica Assegnazione dinamica Di seguito è riportato un CloudFormation modello di esempio. ``` Resources: EcsTask: Type: 'AWS::ECS::TaskDefinition' Properties: TaskRoleArn: 'arn:aws:iam::123456789012:role/my-role-name' ``` Sulla base di questo modello, è possibile inizializzare una variabile chiamata nell'`ecs_tasks`ambito del file e assegnarle la query. `Resources.*[ Type == 'AWS::ECS::TaskDefinition'` Guard interroga tutte le risorse nel modello di input e memorizza le informazioni su di esse. `ecs_tasks` Puoi anche scrivere una regola chiamata `check_ecs_task_definition_task_role_arn` che assicura che la `TaskRoleArn` proprietà di tutte le risorse del `AWS::ECS::TaskDefinition` modello sia `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 clausola della regola verifica se il valore specificato per la `TaskRoleArn` proprietà della `EcsTask` risorsa proviene `arn:aws:iam::123456789012:role/my-role-name` dal riferimento alla `ecs_task_definition_task_role_arn` variabile nella `query` sezione. ### Applicazione CloudFormation della configurazione del modello Applicazione della configurazione del modello CloudFormation Esaminiamo un esempio più complesso di caso d'uso in produzione. In questo esempio, scriviamo regole Guard per garantire controlli più rigorosi su come vengono definite le attività di Amazon ECS. Di seguito è riportato un modello di esempio CloudFormation . ``` 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' ``` Sulla base di questo modello, scriviamo le seguenti regole per garantire che questi requisiti siano soddisfatti: + A ogni `AWS::ECS::TaskDefinition` risorsa del modello sono associati sia un ruolo di attività che un ruolo di esecuzione. + I ruoli di attività e i ruoli di esecuzione sono ruoli AWS Identity and Access Management (IAM). + I ruoli sono definiti nel modello. + La `PermissionsBoundary` proprietà è specificata per ogni ruolo. ``` # 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 } } ```