How to use stack policies - Resource Orchestration Service - Centre de documentation Alibaba Cloud

Une politique de stack empêche la mise à jour ou la suppression accidentelle des ressources d'une stack lors d'une mise à jour. Cette rubrique décrit le fonctionnement d'une politique de stack ainsi que les méthodes pour la définir et la modifier.

Informations générales

Une politique de stack est un document au format JSON ou YAML définissant les actions de mise à jour autorisées sur des ressources spécifiques. Lors de la création d'une stack, tout utilisateur disposant des permissions nécessaires peut mettre à jour l'ensemble de ses ressources. Certaines mises à jour peuvent entraîner une interruption de service. Une fois la politique de stack configurée, ROS protège toutes les ressources qu'elle contient. Ajoutez ensuite des instructions Allow explicites à la politique pour autoriser les mises à jour sur certaines ressources.

Remarque

Chaque stack n'accepte qu'une seule politique, mais celle-ci peut protéger plusieurs ressources simultanément.
Lors d'une mise à jour de stack, ROS met automatiquement à jour les ressources dépendantes. Par exemple, si une ressource en référence une autre qui a été modifiée, elle sera également mise à jour. Toutefois, si ces ressources sont couvertes par une politique de stack, vous devez posséder les permissions requises pour les modifier.

La politique de stack s'applique uniquement pendant les mises à jour. Contrairement à une politique RAM, elle n'assure pas le contrôle d'accès. Elle agit comme un mécanisme de sécurité destiné à empêcher les modifications accidentelles de ressources spécifiques au sein de la stack.

Définir une politique de stack

En l'absence de politique de stack lors de sa création, toutes les actions de mise à jour sont autorisées sur l'ensemble des ressources. Pour restreindre ces opérations, définissez une politique de stack et appliquez-la. Configurez cette politique dès la création de la stack, soit via un fichier texte, soit par saisie directe. Une fois la politique en place, toute mise à jour non explicitement autorisée est refusée par défaut.

Une politique de stack se compose de cinq éléments : Effect, Action, Principal, Resource et Condition.

Statement:
  - Effect: Deny_or_Allow
    Action: update_actions
    Principal: '*'
    Resource: LogicalResourceId/resource_logical_ID
    Condition:
      StringEquals_or_StringLike:
        ResourceType:
          - resource_type
          - ...

Voici la description de chaque élément :

Effect

Cet élément détermine si les actions spécifiées sur les ressources ciblées sont autorisées ou refusées. Les valeurs possibles sont Deny ou Allow. Exemple :
```
Effect: Deny
```
Remarque
Si une politique contient des instructions contradictoires (autorisant et refusant simultanément une mise à jour sur la même ressource), l'instruction Deny prévaut toujours sur l'instruction Allow. Pour garantir la protection d'une ressource, utilisez une instruction Deny.
Action

Cet élément liste les actions de mise à jour autorisées ou interdites :
- Update:Modify
  
  Opérations de mise à jour modifiant une ressource, avec ou sans interruption de service.
- Update:Delete
  
  Cette action est nécessaire lorsque la mise à jour du modèle de stack entraîne la suppression d'une ressource.
- Update:*
  
  Toutes les opérations de mise à jour. L'astérisque (*) est un caractère générique représentant l'ensemble des actions de mise à jour.
Remarque
Bien qu'il soit possible de spécifier Update:Replace pour l'élément Action, cette fonctionnalité est réservée et n'est pas prise en charge actuellement.

L'exemple suivant illustre comment autoriser uniquement les opérations de modification et de suppression :
```
Action:
  - Update:Modify
  - Update:Delete
```
Pour autoriser toutes les mises à jour sauf une spécifique, utilisez NotAction. Par exemple, pour tout permettre excepté Update:Delete, recourez à NotAction.
```
Statement:
  - Effect: Allow
    NotAction: Update:Delete
    Principal: '*'
    Resource: '*'
```
Principal

Entité concernée par la politique. Seul l'astérisque (*) est pris en charge ; il indique que la politique s'applique à tous les principaux.
Resource

ID logique de la ressource concernée par la politique. Pour cibler un type de ressource plutôt qu'une ressource unique, utilisez l'élément Condition.

Spécifiez une ressource à l'aide de son ID logique. Exemple :
```
Resource: - LogicalResourceId/myECS
```
L'utilisation d'un astérisque () dans l'ID logique est possible. Ainsi, si plusieurs ressources partagent un préfixe commun, utilisez ce préfixe suivi d'un caractère générique () pour toutes les cibler.
```
Resource: - LogicalResourceId/Prefix*
```
L'élément Not est également disponible pour les ressources. Par exemple, pour autoriser les mises à jour sur toutes les ressources sauf une, utilisez NotResource afin de désigner la ressource protégée.
```
Statement:
  - Effect: Allow
    Action: Update:*
    Principal: '*'
    NotResource: LogicalResourceId/WebServers
```
Lorsqu'une politique de stack est active, toute mise à jour non explicitement permise est rejetée. En autorisant les modifications sur toutes les ressources hormis WebServers, vous bloquez implicitement toute mise à jour concernant la ressource WebServers.
Condition

Type de ressource auquel la politique s'applique. Pour cibler l'ID logique d'une ressource précise, servez-vous de l'élément Resource.

Spécifiez des types de ressources, tels que les instances ECS ou ApsaraDB RDS.
```
Statement:
  - Effect: Deny
    Principal: '*'
    Action: Update:*
    Resource: '*'
    Condition:
      StringEquals:
        ResourceType:
          - ALIYUN::ECS::Instance
          - ALIYUN::RDS::DBInstance
  - Effect: Allow
    Principal: '*'
    Action: Update:*
    Resource: '*'
```
L'instruction Allow accorde les droits de mise à jour sur toutes les ressources, tandis que l'instruction Deny bloque spécifiquement les instances ECS et ApsaraDB RDS. Notez que l'instruction Deny prime toujours sur les instructions Allow.

L'usage de l'astérisque (*) est autorisé pour les types de ressources. Cela permet, par exemple, d'interdire les mises à jour pour l'ensemble des ressources ECS (instances, groupes de sécurité, sous-réseaux, etc.).
```
Condition:
  StringLike:
    ResourceType:
      - ALIYUN::ECS::*
```
Remarque
L'utilisation d'un caractère générique (*) impose le recours à la condition StringLike.

Configurer une politique de stack

Appliquez une politique de stack lors de la création via la console ROS ou Alibaba Cloud CLI. Pour une stack existante, l'utilisation d'Alibaba Cloud CLI est obligatoire. Une fois appliquée, la politique ne peut être retirée, mais reste modifiable via la CLI.

Définir une politique de stack lors de la création (console)
1. Connectez-vous à la console ROS.
2. Dans le volet de navigation de gauche, cliquez sur Stacks.
3. Dans la barre de navigation supérieure, sélectionnez une région dans la liste déroulante, par exemple China (Hangzhou).
4. Sur la page Stacks, cliquez sur Create Stack, puis choisissez Use ROS dans la liste déroulante.
5. Dans l'assistant Create Stack, à l'étape Select Template, choisissez un modèle et cliquez sur Next.
6. Toujours dans l'assistant Create Stack, sur la page Configure Parameters, renseignez le Stack Name ainsi que les paramètres du modèle.
7. Dans la section Configure Stack Settings, réglez Stack Policy sur Input Stack Policy.
8. Configurez la politique de stack et cliquez sur Next.
  - Input Stack Policy : Saisissez directement le contenu de la politique.
  - Upload File : Importez un fichier JSON ou YAML contenant la politique de stack.
9. Sur la page Compliance Precheck, effectuez la vérification de conformité et cliquez sur Next.
  
  Remarque
  La fonctionnalité Compliance Precheck n'est disponible que pour certaines ressources. Pour plus de détails, consultez Vérification préalable de la conformité.
  1. Dans la section Detection Rule, ajoutez des règles de détection.
    
    Sélectionnez les règles adaptées aux ressources cloud présentes dans votre modèle ROS.
  2. Cliquez sur Check.
    
    Modifiez le modèle selon les solutions de correction suggérées pour les ressources non conformes afin d'assurer leur conformité.
10. Suivez les instructions à l'écran pour terminer la création de la stack.
Définir une politique de stack lors de la création (CLI)

Deux méthodes permettent de configurer la politique :
- Appeler l'opération CreateStack
  
  Exécutez la commande aliyun ros CreateStack avec le paramètre --StackPolicyBody pour fournir la politique directement, ou utilisez la même commande avec le paramètre aliyun ros CreateStack et --StackPolicyURL pour indiquer un fichier contenant la politique.
- Appeler l'opération CreateChangeSet
  
  Exécutez la commande aliyun ros CreateChangeSet avec le paramètre --StackPolicyBody pour fournir la politique directement, ou utilisez la même commande avec le paramètre aliyun ros CreateChangeSet et --StackPolicyURL pour indiquer un fichier contenant la politique.
Appliquer une politique de stack à une stack existante (CLI uniquement)

Exécutez la commande aliyun ros SetStackPolicy avec le paramètre --StackPolicyBody pour fournir la politique directement, ou utilisez la commande aliyun ros SetStackPolicy avec le paramètre --StackPolicyURL pour indiquer un fichier contenant la politique.

Remarque
L'ajout d'une politique à une stack existante requiert les permissions associées à l'opération SetStackPolicy.

Mettre à jour des ressources protégées

Pour modifier des ressources protégées, créez une politique temporaire qui remplace la politique de stack actuelle et autorise ces mises à jour. Cette substitution n'altère pas définitivement la politique de stack d'origine.

La mise à jour de ressources protégées nécessite les permissions liées à l'opération SetStackPolicy. Pour configurer les permissions ROS, reportez-vous à Utiliser RAM pour contrôler l'accès aux ressources.

Mettre à jour des ressources protégées (console)
1. Connectez-vous à la console ROS.
2. Dans le volet de navigation de gauche, cliquez sur Stacks.
3. Dans la barre de navigation supérieure, sélectionnez une région dans la liste déroulante, par exemple China (Hangzhou).
4. Sur la page Stacks, localisez la stack cible et cliquez sur Update dans la colonne Actions.
5. Dans la section Configure Stack Settings, sélectionnez Input Stack Policy comme indiqué.
6. Configurez une politique de stack temporaire.
  
  Définissez une politique temporaire valable uniquement pour la mise à jour en cours. Celle-ci doit contenir une instruction Allow pour les ressources protégées que vous souhaitez modifier. Par exemple, pour mettre à jour toutes les ressources protégées, spécifiez une politique de remplacement autorisant toutes les actions.
```
Statement:
  - Effect: Allow
    Action: Update:*
    Principal: '*'
    Resource: '*'
```
7. Suivez les instructions à l'écran pour terminer la mise à jour de la stack.
Mettre à jour des ressources protégées (CLI)

Deux approches sont possibles pour mettre à jour des ressources protégées :
- Appeler l'opération UpdateStack
  
  Exécutez la commande aliyun ros UpdateStack avec le paramètre --StackPolicyDuringUpdateBody pour fournir la politique directement, ou utilisez la commande aliyun ros UpdateStack avec le paramètre --StackPolicyDuringUpdateURL pour indiquer un fichier contenant la politique.
- Appeler l'opération CreateChangeSet
  
  Exécutez la commande aliyun ros CreateChangeSet avec le paramètre --StackPolicyDuringUpdateBody pour fournir la politique directement, ou utilisez la commande aliyun ros CreateChangeSet avec le paramètre --StackPolicyDuringUpdateURL pour indiquer un fichier contenant la politique.
Remarque
ROS applique la politique de remplacement uniquement pour la mise à jour en cours ; la politique de stack permanente reste inchangée.

Modifier une politique de stack

Mettez à jour une politique de stack pour étendre la protection à de nouvelles ressources ou lever la protection de ressources existantes. Par exemple, lors de l'ajout d'une base de données sensible à une stack, insérez une instruction Deny correspondante dans la politique. Cette opération exige les permissions associées à SetStackPolicy.

Modifier une politique de stack (console)
1. Connectez-vous à la console ROS.
2. Dans le volet de navigation de gauche, cliquez sur Stacks.
3. Dans la barre de navigation supérieure, sélectionnez une région dans la liste déroulante, par exemple China (Hangzhou).
4. Sur la page Stacks, cliquez sur l'ID de la stack souhaitée dans la colonne Stack Name.
5. Dans l'onglet Stack Information, sous la section Stack Policy, cliquez sur Edit.
6. Dans la boîte de dialogue Modify resource stack policy, saisissez la nouvelle politique de stack.
7. Cliquez sur OK.
Modifier une politique de stack (CLI)

Exécutez la commande aliyun ros SetStackPolicy avec le paramètre --StackPolicyBody pour fournir la politique directement, ou utilisez la commande aliyun ros SetStackPolicy avec le paramètre --StackPolicyURL pour indiquer un fichier contenant la politique.

La politique ci-dessous autorise toutes les mises à jour sur l'ensemble des ressources :
```
Statement:
  - Effect: Allow
    Action: Update:*
    Principal: '*'
    Resource: '*'
```
Modifier une politique de stack lors d'une mise à jour (CLI)

Exécutez la commande aliyun ros UpdateStack avec le paramètre --StackPolicyBody pour fournir la politique directement, ou utilisez la commande aliyun ros UpdateStack avec le paramètre --StackPolicyURL pour indiquer un fichier contenant la politique.

Alternativement, exécutez la commande aliyun ros CreateChangeSet avec le paramètre --StackPolicyBody pour fournir la politique directement, ou utilisez la commande aliyun ros CreateChangeSet avec le paramètre --StackPolicyURL pour indiquer un fichier contenant la politique.

Exemples de politiques de stack

Les exemples suivants montrent comment bloquer les mises à jour pour toutes les ressources d'une stack, pour des ressources spécifiques ou pour certains types d'opérations.

Bloquer les mises à jour pour toutes les ressources de la stack
Pour interdire toute modification, cette politique utilise une instruction Deny couvrant toutes les actions de mise à jour sur toutes les ressources.
```
Statement:
  - Effect: Deny
    Action: Update:*
    Principal: '*'
    Resource: '*'
```
Bloquer les mises à jour pour une ressource unique (WebServers)
- Exemple 1 : Utilisation d'une instruction Deny pour empêcher la modification de la ressource WebServers.
```
Statement:
  - Effect: Allow
    Action: Update:*
    Principal: '*'
    Resource: '*'
  - Effect: Deny
    Action: Update:*
    Principal: '*'
    Resource: LogicalResourceId/WebServers
```
  Cette politique comprend les instructions suivantes :
  - Allow : Autorise toutes les actions de mise à jour sur toutes les ressources.
  - Deny : Interdit toute action de mise à jour sur la ressource ayant l'ID logique WebServers.
  - Principal : Entité concernée par la politique. Seul l'astérisque (*) est pris en charge, indiquant une application universelle.
- Exemple 2 : Utilisation d'une instruction Allow pour autoriser les mises à jour sur toutes les ressources, à l'exception de WebServers.
```
Statement:
  - Effect: Allow
    Action: Update:*
    Principal: '*'
    NotResource: LogicalResourceId/WebServers
```
  Remarque
  - Par défaut, lorsqu'une politique de stack est active, toute mise à jour non explicitement autorisée est refusée.
  - Se reposer uniquement sur le refus par défaut comporte des risques. Si votre politique contient ailleurs une instruction Allow trop large, telle qu'une instruction Allow utilisant un caractère générique, vous pourriez accidentellement autoriser la mise à jour d'une ressource. Puisqu'un refus explicite prévaut toujours sur une autorisation, l'usage d'une instruction Deny constitue le moyen le plus sûr de protéger une ressource.
Bloquer les mises à jour pour toutes les instances d'un type de ressource

La politique suivante interdit toute mise à jour pour le type de ressource instance ApsaraDB RDS. Elle utilise parallèlement une instruction Allow pour autoriser les modifications sur les autres ressources de la stack. L'instruction Allow ne s'applique pas aux instances ApsaraDB RDS car l'instruction Deny prévaut systématiquement.
```
Statement:
  - Effect: Deny
    Action: Update:*
    Principal: '*'
    Resource: '*'
    Condition:
      StringEquals:
        ResourceType:
          - ALIYUN::RDS::DBInstance
  - Effect: Allow
    Action: Update:*
    Principal: '*'
    Resource: '*'
```
Bloquer les mises à jour pour les stacks imbriquées
Cette politique refuse toutes les mises à jour pour le type de ressource stack ROS, correspondant aux stacks imbriquées. Elle inclut une instruction Allow permettant les modifications sur les autres ressources. Cependant, l'instruction Allow ne s'applique pas aux stacks ROS, l'instruction Deny étant prioritaire sur toute instruction Allow.
```
Statement:
  - Effect: Deny
    Action: Update:*
    Principal: '*'
    Resource: '*'
    Condition:
      StringEquals:
        ResourceType:
          - ALIYUN::ROS::Stack
  - Effect: Allow
    Action: Update:*
    Principal: '*'
    Resource: '*'
```