Création de modèles de paramètres gérés par l'entreprise

Dans une entreprise où il existe de nombreux comptes enfants, la configuration manuelle des paramètres IAM pour chaque compte peut prendre beaucoup de temps et être source d'erreurs. Assurez-vous que tous les comptes de votre entreprise respectent les exigences de sécurité de votre organisation en utilisant des modèles de paramètres.

Vous ne pouvez affecter qu'un seul modèle de paramétrage à un compte ou à un groupe de comptes. Créer un modèle de paramètres qui s'applique à la plupart des comptes et en créer un nouveau uniquement pour les comptes qui ont des exigences particulières. Par exemple, vous pouvez avoir des exigences plus strictes en matière d'authentification multifactorielle (MFA) dans les comptes de l'environnement de production.

Lorsque vous attribuez un modèle de paramètres, les utilisateurs de comptes enfants ayant le rôle d'administrateur sur le service d'identité IAM peuvent toujours gérer les paramètres de leur compte. En cas de conflit entre les paramètres définis par le modèle et les paramètres gérés dans le compte, le paramètre le plus strict est appliqué au compte. Cela signifie que la configuration la plus restrictive est prioritaire et appliquée pour ce compte particulier.

Avant de commencer

  • Pour savoir comment les modèles IAM gérés par l'entreprise renforcent la sécurité de votre entreprise, consultez Comment fonctionne l'accès IAM géré par l'entreprise.

  • Être membre du compte d'entreprise pour créer et attribuer des modèles IAM gérés par l'entreprise.

  • Pour créer un modèle IAM géré par l'entreprise, assurez-vous que vous disposez des droits d'accès suivants :

    • Une politique associée au rôle « Administrateur de modèles » sur tous les services de gestion des comptes IAM
  • Pour attribuer un modèle IAM géré par l'entreprise à des comptes enfants, assurez-vous que vous disposez des droits d'accès suivants :

    • Une politique avec le rôle Administrateur d'attribution de modèles sur Tous les services de gestion de compte IAM
    • Une politique avec au moins le rôle Viewer sur le service Enterprise

    Par défaut, aucun utilisateur n'a les rôles Administrateur de modèles ou Administrateur d'attribution de modèles, y compris le propriétaire du compte.

  • Les comptes nouveaux et existants de votre entreprise doivent adhérer à la gestion IAM de l'entreprise. Pour plus d'informations, voir Opting in to enterprise-managed IAM.

  • Le paramètre défini au niveau du compte enfant s'applique si le paramètre géré par l'entreprise est moins strict ou supprimé.

Création d'un modèle de paramétrage

Envisagez d'utiliser des modèles de paramètres lorsque vous avez de nombreux comptes enfants qui nécessitent les mêmes paramètres IAM. Par exemple, votre organisation peut avoir des normes internes ou exiger le respect des réglementations sectorielles.

Pour créer un modèle de paramètres, procédez comme suit :

  1. Accédez à « Gérer > Accès (IAM) > Modèles » dans l' IBM Cloud.
  2. Cliquez sur Paramètres > Créer.
  3. Saisissez un nom et une description pour le modèle de paramètres qui décrivent son objectif pour les utilisateurs de l'entreprise.
  4. Cliquez sur Créer.

(Facultatif) Ajout des paramètres du compte IAM

Personnalisez votre entreprise pour répondre aux exigences commerciales et réglementaires en définissant les paramètres de compte IAM dans les comptes enfants.

Restriction des domaines pour les invitations de compte

Par défaut, vous pouvez envoyer des invitations à l'ouverture d'un compte à des adresses électroniques de n'importe quel domaine. Toutefois, si vous activez le paramètre Restreindre les invitations des utilisateurs, vous pouvez limiter les invitations aux seules adresses électroniques appartenant aux domaines autorisés spécifiés. Pour activer des restrictions sur des domaines spécifiques, procédez comme suit :

  1. Activez le paramètre Restreindre les invitations des utilisateurs dans la section Compte. Lorsque ce paramètre est activé, la page Inviter un utilisateur dans les sous-comptes limite les invitations aux adresses électroniques des domaines autorisés spécifiés.
  2. Sélectionnez Plus strict ou Plus souple pour déterminer comment les paramètres des modèles et des sous-comptes sont appliqués.
  3. Cliquez sur Modifier pour modifier le domaine existant ou ajouter de nouveaux domaines à la liste autorisée. Cette fonction renforce la sécurité de votre compte tout en vous donnant la possibilité de le mettre à jour à tout moment et d'ajouter d'autres domaines si nécessaire.

Vous pouvez implémenter des restrictions relatives aux domaines en définissant des modèles d'adresse électronique. Par exemple, **@ibm.com, **@*.ibm.com, **@?.ibm.com. Un seul astérisque *représente une séquence de zéro ou plusieurs caractères dans une chaîne, à l'exception de la fin de la séquence si une période . ou le signe @ est trouvé. Un double astérisque ** représente une séquence de zéro ou plusieurs caractères dans la chaîne sans limite. Un point d'interrogation ? représente n'importe quel caractère unique.

En examinant de plus près l'exemple **@*.ibm.com. La partie nom d'utilisateur de l'adresse électronique indique **. Étant donné que la séquence n'est pas limitée par ., une adresse électronique telle que my.name.is.bob@us.ibm.com est valide. Le sous-domaine us est également valide car il s'agit d'une chaîne de lettres, où la séquence se termine par ..

Limiter la visibilité des utilisateurs

Par défaut, tous les utilisateurs d'un compte peuvent voir tous les autres utilisateurs sur la page Utilisateurs. Cependant, en activant le paramètre Restreindre la visibilité de la liste des utilisateurs, vous pouvez contrôler quels utilisateurs sont visibles, de sorte que chaque utilisateur voit les membres du compte auxquels il est directement associé.

Pour appliquer des restrictions à des utilisateurs spécifiques, activez le paramètre Restreindre la visibilité de la liste des utilisateurs dans la section Compte. Il vous permet de contrôler la façon dont les utilisateurs voient les autres membres dans les sous-comptes auxquels ce modèle est attribué.

Restriction de l'accès à la création des clés d'API à certains utilisateurs uniquement

Par défaut, tous les membres d'un compte peuvent créer des clés d'API IBM Cloud®. Cependant, en utilisant le paramètre de création de clé API, cet accès peut être restreint de sorte que seuls les membres disposant de l'accès approprié puissent créer ces clés API utilisateur.

Il est judicieux de limiter la possibilité de créer des clés API si vous souhaitez que les utilisateurs d'un compte enfant spécifique se connectent toujours de manière interactive; cela signifie que vous ne voulez pas que des scripts d'automatisation puissent se lancer pour connecter automatiquement des utilisateurs à l'aide d'une clé API. Pour plus d'informations sur les clés d'API, voir Gestion des clés d'API d'utilisateur.

Si vous activez le paramètre « Restreindre la création de clés API », les utilisateurs de votre compte, y compris le titulaire du compte, devront disposer d'un accès spécifique pour créer des clés API. Pour limiter les personnes pouvant créer des clés d'API, procédez comme suit :

L'activation de ce paramètre n'affecte que la création des clés d'API utilisateur. Il ne concerne pas les clés d'API pour les ID de service.

  1. Activez le paramètre Restreindre la création de clés API dans la section Compte.
  2. Cliquez sur Oui pour confirmer.

Maintenant que le paramètre permettant d'empêcher les utilisateurs de créer des clés API est activé, vous pouvez créer un modèle de groupe d'accès qui accorde les droits nécessaires pour permettre à certains utilisateurs de continuer à créer des clés API utilisateur. N'oubliez pas que le titulaire du compte doit également disposer de cet accès explicite. Pour plus d'informations, voir Attribution de l'accès à la création de clés API avec des restrictions activées.

Restriction de l'accès à la création des ID de service à certains utilisateurs uniquement

Par défaut, tous les membres d'un compte peuvent créer des ID de service. Cependant, en utilisant le paramètre de création d'ID de service, l'accès peut être restreint de sorte que seuls les membres disposant de l'accès approprié puissent créer des ID de service. Pour plus d'informations sur les ID de service, voir Création et utilisation des ID de service.

Si vous activez le paramètre de création d'identifiants de service, les utilisateurs des comptes enfants, y compris le titulaire du compte, doivent disposer d'un accès spécifique pour créer des identifiants de service. Pour limiter les personnes pouvant créer des ID de service, procédez comme suit :

  1. Activez le paramètre Restreindre la création d'ID de service dans la section Compte.
  2. Cliquez sur Oui pour confirmer.

Maintenant que le paramètre permettant d'empêcher les utilisateurs de créer des identifiants de service est activé, vous pouvez créer un modèle de groupe d'accès qui accorde les droits nécessaires pour permettre à certains utilisateurs de continuer à créer des identifiants de service. N'oubliez pas que le titulaire du compte doit également disposer de cet accès explicite. Pour plus d'informations, consultez la section « Attribution d'un accès à la création d'identifiants de service avec les restrictions activées ».

Autorisation d'adresses IP spécifiques

Par défaut, toutes les adresses IP peuvent être utilisées pour la connexion à la console IBM Cloud® et l'accès aux API d'infrastructure classique. Vous pouvez définir quelles adresses IP ont accès au site et lesquelles sont bloquées. Vous pouvez spécifier cet accès pour les comptes enfants. Actuellement, seules les adresses IP publiques sont prises en charge.

Lorsque vous autorisez uniquement des adresses IP spécifiques à accéder à un compte IBM Cloud, les utilisateurs ne peuvent pas accéder à l'interface de ligne de commande IBM Cloud. Cela est dû au fait que l' Cloud Shell est hébergé sur une plateforme partagée qui ne peut pas satisfaire la liste blanche des adresses IP.

Les administrateurs de comptes enfants peuvent définir une restriction d'adresse IP pour les utilisateurs individuels. Lorsqu'une restriction d'adresse IP est définie à la fois pour le compte et pour l'utilisateur, l'adresse IP doit correspondre aux deux spécifications pour pouvoir générer un jeton IAM.

Pour empêcher tous les utilisateurs de recourir uniquement à des adresses IP spécifiques, procédez comme suit :

  1. Dans la section « Compte », activez le paramètre « Restreindre l'accès par adresse IP ».

  2. Entrez les adresses IP. Les adresses IP indiquées sont les seules à partir desquelles les utilisateurs des comptes enfants peuvent se connecter à IBM Cloud®.

    Vous pouvez entrer une adresse IP 17.5.7.8 unique, une plage d'adresses IP 17.5.7.8 - 17.5.9.5, des sous-réseaux IP 17.5.7.8.0/16 ou une zone réseau networkZoneName. Prenez soin d'utiliser des adresses IPv4 ou IPv6 et de séparer chaque valeur par une virgule, le cas échéant. En cas de restriction des adresses IP, la ressource ignore la restriction.

  3. Cliquez sur Sauvegarder.

Le compte enfant peut restreindre l'accès à un sous-ensemble d'adresses IP dans la liste gérée par l'entreprise. Par exemple, l'administrateur d'un compte enfant de production peut spécifier une liste d'autorisation plus granulaire.

(Facultatif) Ajout d'un paramètre d'authentification

Il est utile de prendre en compte les informations suivantes avant d'activer l'authentification multifacteur dans les comptes enfants afin de vous assurer que vous savez comment elle affecte tous les utilisateurs des comptes enfants :

  • L'activation de l'authentification à plusieurs facteurs (MFA) pour tous les utilisateurs de votre compte a des répercussions sur tous les membres de ce compte. Si les utilisateurs de votre compte sont membres de plusieurs comptes IBM Cloud, ils doivent s'inscrire à MFA lors de leur prochaine connexion, même s'ils n'ont pas l'intention d'utiliser les ressources du compte sur lequel MFA est activé.
  • Les clés d'API pour vos utilisateurs et les ID de service continuent de fonctionner après l'activation de l'authentification multi-facteur.
  • L'authentification MFA pour vos comptes enfants s'applique aux connexions des utilisateurs, mais pas aux appels API. Si un utilisateur dispose des autorisations nécessaires pour effectuer des appels API vers les ressources du compte, il peut le faire sans passer par l'authentification à deux facteurs (MFA). Si l'utilisateur appartient à d'autres comptes, il peut effectuer des appels API vers des ressources de votre compte en utilisant une clé d'API d'un compte pour lequel l'authentification multi-facteur n'est pas requise.
  • Planifiez une stratégie de communication et de support pour les utilisateurs ajoutés à votre compte :
    • Choisissez une date et une heure d'activation de l'authentification multi-facteur dont l'impact sur votre activité doit être minimal.
    • Une fois l'authentification à plusieurs facteurs (MFA) activée, informez les utilisateurs de votre compte en leur indiquant comment la configurer.

L'activation de la MFA n'affecte pas les utilisateurs déjà connectés, car la MFA ne prend effet qu'au moment de la connexion. Veillez à informer les utilisateurs des comptes enfants que l'authentification multifactorielle (MFA) est activée, et expliquez-leur les conséquences que cela aura lors de leur prochaine connexion.

Pour activer MFA dans un modèle de paramètres, procédez comme suit :

  1. Accédez à la section « Authentification ».
  2. Sélectionnez le type d'authentification multifactorielle (MFA) que vous souhaitez activer sur votre compte. Pour plus d'informations sur les options MFA, voir Options MFA.

Le niveau MFA défini par le compte enfant s'applique si le paramètre géré par l'entreprise est moins strict ou supprimé. Par exemple, l'administrateur d'un compte enfant de production peut spécifier un niveau d'authentification multifacteur plus strict que celui défini par le modèle de paramètres gérés par l'entreprise.

(Facultatif) Ajout des paramètres de session de connexion

Renforcez la sécurité des comptes au sein de votre entreprise en exigeant que les utilisateurs saisissent leurs identifiants de connexion à des intervalles que vous définirez. Vous pouvez sélectionner la durée pendant laquelle la session active d'un utilisateur peut durer avant qu'il ne doive saisir à nouveau ses identifiants. Vous pouvez également choisir la durée d'inactivité d'un utilisateur avant qu'il ne soit déconnecté de sa session et qu'il n'ait besoin de saisir à nouveau ses données d'identification.

Si un utilisateur est membre de plusieurs comptes, la valeur la plus faible de chaque paramètre est appliquée à sa session. Par exemple, un utilisateur est titulaire de deux comptes : dev account et prod account. Si prod account a un délai d'inactivité de 15 minutes et que dev account a un délai d'inactivité de 30 minutes, c'est le délai d'inactivité de 15 minutes qui s'applique aux deux comptes.

Définir la durée des sessions actives

Une session active correspond à la durée pendant laquelle un utilisateur utilise son compte. La méthode de mesure d'une session active dépend également de la durée d'inactivité de votre session avant sa fermeture. Par exemple, si vous définissez la fermeture de session sur 2 heures, l'utilisateur devra interagir avec le compte une fois au cours de ces 2 heures.

Pour définir les paramètres des sessions actives, procédez comme suit :

  1. Cliquez sur Gérer > Accès (IAM) > Modèles > Paramètres dans la console d' IBM Cloud®.
  2. Sélectionnez votre modèle de paramètres.
  3. Cliquez sur Sessions de connexion.
  4. Accédez à la section « Sessions de connexion », puis cliquez sur l'icône « Modifier »
  5. Entrez la limite de temps. La durée de session la plus longue est de 720 heures.
  6. Cliquez sur Enregistrer.

Vérification de votre modèle de paramètres

Passez en revue le modèle de paramètres et validez-le afin qu'aucune modification ne puisse être apportée à la version. De cette façon, l'administrateur de l'attribution des modèles peut être sûr d'attribuer la version lorsque vous confirmez qu'elle est prête.

  1. Cliquez sur Vue d'ensemble > Révision.
  2. Vérifiez que le modèle de paramètres est configuré selon vos attentes.
  3. Cochez la case pour confirmer que vous ne pouvez pas modifier la version.
  4. Cliquez sur Valider.

Attribution d'un modèle de paramètres aux comptes enfants

Vous ne pouvez attribuer les versions que d'un seul modèle de paramètres à la fois au sein de votre entreprise. Vous pouvez attribuer différentes versions du même modèle de paramètres, mais vous ne pouvez pas utiliser plusieurs modèles de paramètres dans une entreprise. Vous pouvez attribuer différentes versions aux comptes ayant des exigences différentes, comme les comptes de production et de test.

Vous ne pouvez pas attribuer de modèle IAM au compte Entreprise, mais uniquement aux comptes enfants.

Pour attribuer un modèle de paramètres, procédez comme suit :

  1. Cliquez sur Gérer > Accès (IAM) > Modèles > Paramètres dans la console d' IBM Cloud®.
  2. Sélectionnez votre modèle de paramètres.
  3. Cliquez sur Affecter des comptes.
  4. Sélectionnez des comptes spécifiques ou des groupes de comptes entiers dans votre entreprise.

Lorsque vous sélectionnez un groupe de comptes, tous les comptes que vous ajouterez ultérieurement à ce groupe hériteront des paramètres que vous leur attribuez.

  1. Cliquez sur Affecter des comptes.

Si une affectation échoue, cliquez sur Réessayer.

Création d'une nouvelle version

Pour créer une nouvelle version d'un modèle de paramètres, procédez comme suit :

  1. Cliquez sur Gérer > Accès (IAM) > Modèles > Paramètres dans la console d' IBM Cloud®.

  2. Sélectionnez votre modèle de paramètres.

  3. Cliquez sur l'icône Nouvelle version. Icône Nouvelle version..

  4. Saisissez un nouveau nom et une nouvelle description pour le modèle ou conservez ceux que vous utilisez déjà.

    La saisie d'un nouveau nom de modèle met à jour le nom du modèle pour cette version et toutes les versions précédentes. La description du modèle est stockée séparément pour chaque version.

  5. Sélectionnez les paramètres que vous souhaitez transférer vers votre nouvelle version.

  6. Cliquez sur Créer.

  7. Effectuez les autres modifications nécessaires à la configuration.

  8. Cliquez sur Réviser et validez la nouvelle version. Pour plus d'informations, voir Révision de votre modèle de groupe d'accès.

Pour attribuer une nouvelle version d'un modèle de paramètres, procédez comme suit :

  1. Accédez à « Gérer > Accès (IAM) > Modèles » dans la console d' IBM Cloud.
  2. Cliquez sur Paramètres.
  3. Cliquez sur l'icône Développer le tableau Développer le tableau du modèle avec lequel vous souhaitez travailler.
  4. Sélectionnez la version attribuée aux comptes enfants.
  5. Cliquez sur Affectations.
  6. Cliquez sur Mettre à jour dans l'affectation du compte ou du groupe de comptes auquel vous souhaitez attribuer une version différente.
  7. Cliquez sur « Sélectionner une version ».
    1. Sélectionnez la version que vous souhaitez remplacer par la version actuelle.
  8. Cliquez sur Mettre à jour.
  9. Répétez ces étapes pour chaque compte ou groupe de comptes auquel vous souhaitez attribuer une version différente.

La nouvelle version du modèle que vous attribuez remplace l'ancienne version. En savoir plus sur l'attribution d'une nouvelle version.

Supprimer une affectation

Vous pouvez supprimer l'affectation d'un modèle d'un compte ou d'un groupe de comptes auquel le modèle est affecté. Vous pouvez le faire si le modèle ne fonctionne pas comme prévu. Lorsque vous supprimez l'affectation d'un modèle à un compte, la version précédente du modèle est rétablie par défaut. Si la cession que vous supprimez concerne la première ou la seule version d'un modèle, les préférences de paramètres attribuées dans le compte enfant sont supprimées.

Pour supprimer une affectation, procédez comme suit :

  1. Cliquez sur Gérer > Accès (IAM) > Modèles > Paramètres dans la console d' IBM Cloud®.
  2. Cliquez sur Paramètres et sélectionnez votre modèle de paramètres.
  3. Cliquez sur Affectations.
  4. Cliquez sur l'icône Actions Icône Actions > Supprimer sur le compte ou le groupe de comptes où vous souhaitez supprimer l'affectation.

Lorsque vous supprimez toutes les affectations de modèles de paramètres, le paramètre défini au niveau du compte enfant est rétabli.

Supprimer un modèle de paramétrage

Avant de pouvoir supprimer un modèle de paramétrage, vous devez supprimer toutes les affectations pour toutes les versions du modèle. La suppression d'un modèle de paramètres entraîne la suppression de toutes les versions.

Pour supprimer un modèle de paramètres, procédez comme suit :

  1. Cliquez sur Gérer > Accès (IAM) > Modèles > Paramètres dans la console d' IBM Cloud®.
  2. Cliquez sur Paramètres.
  3. Cliquez sur l'icône Actions Icône Actions sur le modèle de paramètres que vous souhaitez supprimer.
  4. Cliquez sur Supprimer le modèle.
  5. Confirmez que vous souhaitez supprimer le modèle de paramètres.

Suppression d'une version

Vous pouvez également supprimer une version spécifique en suivant les étapes suivantes : Pour supprimer un modèle de paramètres, procédez comme suit :

  1. Cliquez sur Gérer > Accès (IAM) > Modèles > Paramètres dans la console d' IBM Cloud®.
  2. Cliquez sur Paramètres.
  3. Cliquez sur l'icône Développer le tableau Développer le tableau du modèle avec lequel vous souhaitez travailler.
  4. Cliquez sur l'icône Actions Icône Actions sur la version que vous souhaitez supprimer.
  5. Cliquez sur Supprimer la version.
  6. Confirmez que vous souhaitez supprimer cette version.

Création d'un modèle de paramètres à l'aide de l'interface de ligne de commande (CLI)

Envisagez d'utiliser des modèles de paramètres lorsque vous avez de nombreux comptes enfants qui nécessitent les mêmes paramètres IAM. Par exemple, votre organisation peut avoir des normes internes ou exiger le respect des réglementations sectorielles.

Pour créer un modèle de paramètres à l'aide de l'interface de ligne de commande (CLI), procédez comme suit :

  1. Créer un fichier JSON qui configure la définition du modèle de paramètres. Pour plus d'informations sur les attributs que vous pouvez utiliser dans votre fichier JSON, consultez l'API d'identité IAM.

    L'exemple de fichier JSON suivant spécifie l' account_id e du compte d'entreprise, l' name e du modèle et l' account_settings. La création de clés API est réservée aux utilisateurs ayant le rôle Créateur de clés API sur le service d'identité. La création d'ID de service n'est pas limitée, de sorte que tous les membres peuvent créer des ID de service dans les comptes auxquels le modèle de paramètres est attribué. Le nombre maximum de sessions par identité est fixé à 5, et l'authentification multifacteur est fixée à LEVEL3, ce qui oblige tous les utilisateurs à utiliser l'authentification multifacteur U2F.

    {
       "account_id": "5bbe28be34524sdbdaa34d37d1f2294a",
       "name": "AccountSettingsTemplate",
       "account_settings": {
          "restrict_create_platform_apikey": "RESTRICTED",
          "restrict_create_service_id":  "NOT_RESTRICTED",
          "max_sessions_per_identity": 5,
          "mfa": "LEVEL3",
       }
    }
    
  2. Créez le modèle de paramètres à l'aide de la commande account-settings-template-create comme indiqué dans l'exemple de requête suivant :

    ibmcloud iam account-settings-template-create AccountSettingsTemplate --file /path/to/account_settings_template.json
    

Mise à jour d'un modèle de paramètres à l'aide de l'interface de ligne de commande (CLI)

Vous pouvez mettre à jour un modèle de paramétrage à tout moment avant de le valider. Pour mettre à jour une version spécifique d'un modèle de paramètres de compte, procédez comme suit :

  1. Mettez à jour votre fichier JSON avec la nouvelle configuration du modèle de paramètres. Pour plus d'informations sur les attributs que vous pouvez utiliser dans votre fichier JSON, consultez l'API d'identité IAM.

    L'exemple de fichier JSON suivant spécifie l' account_id e du compte d'entreprise, l' name e du modèle et l' account_settings. La nouvelle configuration réinitialise MFA sur « NONE » et supprime les autres paramètres.

    {
     "account_id": "5bbe28be34524sdbdaa34d37d1f2294a",
     "name": "AccountSettingsTemplateUpdated",
     "account_settings": {
         "mfa": "NONE",
     },
    }
    

    Lorsque vous mettez à jour le nom du modèle, le nom de chaque version est également mis à jour.

  2. Pour mettre à jour une version spécifique d'un modèle de paramètres de compte, utilisez la commande account-settings-template-version-update comme indiqué dans l'exemple de requête suivant :

    ibmcloud iam account-settings-template-version-update AccountSettingsTemplateUpdated 1 --file /path/to/account_settings_template.json
    

Engagement d'un modèle de paramétrage

Passez en revue le modèle de paramètres et validez-le afin qu'aucune modification ne puisse être apportée à la version. L'engagement d'une version est une étape nécessaire avant de pouvoir l'attribuer à des comptes enfants. De cette façon, l'administrateur de l'attribution des modèles peut être sûr qu'il n'attribue la version que lorsque vous avez confirmé qu'elle est prête.

L'exemple de requête suivant engage la version 1 du modèle de paramètres nommé AccountSettingsTemplateUpdated:

ibmcloud iam account-settings-template-commit AccountSettingsTemplateUpdated 1

Attribution d'un modèle de paramètres aux comptes enfants à l'aide de l'interface de ligne de commande

Vous ne pouvez attribuer les versions que d'un seul modèle de paramètres à la fois au sein de votre entreprise. Vous pouvez attribuer différentes versions du même modèle de paramètres, mais vous ne pouvez pas utiliser plusieurs modèles de paramètres dans une entreprise. Vous pouvez attribuer différentes versions aux comptes ayant des exigences différentes, comme les comptes de production et de test.

Vous ne pouvez pas attribuer de modèle IAM au compte Entreprise, mais uniquement aux comptes enfants.

Pour créer une affectation pour un modèle de paramètres de compte, procédez comme suit :

  1. Répertoriez les modèles de paramètres dans votre compte d'entreprise et notez le nom du modèle et le numéro de version du modèle de paramètres que vous souhaitez attribuer aux comptes enfants :

    ibmcloud iam account-settings-templates
    
  2. Assignez le modèle à un Account ou AccountGroup en utilisant la commande account-settings-assignment-create.

    ibmcloud iam account-settings-assignment-create AccountSettingsTemplateUpdated 1 AccountGroup 955fc2274567474f8da802d5c376504b
    

Si une affectation échoue, utilisez la méthode account-settings-assigment-update pour réessayer.

Création d'une nouvelle version à l'aide de l'interface de ligne de commande (CLI)

Créez une nouvelle version d'un modèle de paramètres de compte lorsque vous devez mettre à jour une version validée. Pour créer une nouvelle version, procédez comme suit.

  1. Mettez à jour votre fichier JSON avec la nouvelle configuration du modèle de paramètres. Pour plus d'informations sur les attributs que vous pouvez utiliser dans votre fichier JSON, consultez l'API d'identité IAM.

  2. Utilisez la méthode « account-settings-template-version-create » pour créer une nouvelle version. L'exemple de requête suivant crée une nouvelle version du modèle AccountSettingsUpdated.

    ibmcloud iam account-settings-template-version-create AccountSettingsUpdated --file /path/to/account_settings_template.json
    

Mise à jour d'une affectation à l'aide de l'interface de ligne de commande (CLI)

Mettre à jour une affectation pour réessayer une affectation qui a échoué ou migrer vers une nouvelle version.

La nouvelle version du modèle que vous attribuez remplace l'ancienne version. En savoir plus sur l'attribution d'une nouvelle version.

  1. Listez les affectations dans le compte en utilisant la méthode de l' account-settings-assignments. Prenez note de l' ASSIGNMENT_ID e de la cession que vous souhaitez mettre à jour.

  2. Mettez à jour l'affectation des paramètres du compte. Si vous réessayez une affectation, utilisez le même numéro de version. L'exemple de requête suivant migre l'affectation AccountSettingsAssignment-63d65ed159ff463b8ec09ea77d22a05b vers la version 2.

    ibmcloud iam account-settings-assignment-update AccountSettingsAssignment-63d65ed159ff463b8ec09ea77d22a05b 2
    

Suppression d'une affectation à l'aide de l'interface de ligne de commande (CLI)

Vous pouvez supprimer l'affectation d'un modèle d'un compte ou d'un groupe de comptes auquel le modèle est affecté. Vous pouvez le faire si le modèle ne fonctionne pas comme prévu. Lorsque vous supprimez l'affectation d'un modèle à un compte, la version précédente du modèle est rétablie par défaut. Si la cession que vous supprimez concerne la première ou la seule version d'un modèle, les préférences de paramètres gérés par l'entreprise dans le compte enfant sont supprimées.

Pour supprimer une affectation, procédez comme suit :

  1. Listez les affectations dans le compte en utilisant la méthode de l' account-settings-assignments. Prenez note de l' ASSIGNMENT_ID e de la cession que vous souhaitez supprimer.

  2. Supprimez l'affectation en utilisant la méthode " account-settings-assigment-delete ". L'exemple de requête suivant supprime l'affectation AccountSettingsAssignment-63d65ed159ff463b8ec09ea77d22a05b.

    ibmcloud iam account-settings-assignment-delete AccountSettingsAssignment-63d65ed159ff463b8ec09ea77d22a05b
    

Suppression d'une version à l'aide de l'interface de ligne de commande (CLI)

Avant de pouvoir supprimer une version de modèle de paramétrage, vous devez supprimer toutes les affectations de cette version du modèle. Supprimer une version spécifique en suivant les étapes suivantes :

  1. Listez les modèles de paramètres dans votre compte d'entreprise et notez le nom du modèle et le numéro de version de la version que vous souhaitez supprimer :

    ibmcloud iam account-settings-templates
    
  2. Supprimer la version :

    ibmcloud iam account-settings-template-delete AccountSettingsTemplateUpdated 2
    
  3. Pour supprimer toutes les versions, répétez ces étapes. Assurez-vous d'abord de supprimer les affectations pour chaque version.

Création d'un modèle de paramètres à l'aide de l'API

Envisagez d'utiliser des modèles de paramètres lorsque vous avez de nombreux comptes enfants qui nécessitent les mêmes paramètres IAM. Par exemple, votre organisation peut avoir des normes internes ou exiger le respect des réglementations sectorielles.

Pour créer un modèle de paramètres à l'aide de l'API, procédez comme suit :

  1. Configurer les paramètres de définition du modèle. Pour plus d'informations sur les attributs que vous pouvez utiliser dans votre fichier JSON, consultez l'API d'identité IAM.

    L'exemple de fichier JSON suivant spécifie l' account_id e du compte d'entreprise, l' name e du modèle et l' account_settings. La création de clés API est réservée aux utilisateurs ayant le rôle Créateur de clés API sur le service d'identité. La création d'ID de service n'est pas limitée, de sorte que tous les membres peuvent créer des ID de service dans les comptes auxquels le modèle de paramètres est attribué. Le nombre maximum de sessions par identité est fixé à 5, et l'authentification multifacteur est fixée à LEVEL3, ce qui oblige tous les utilisateurs à utiliser l'authentification multifacteur U2F.

    curl -X POST 'https://iam.cloud.ibm.com/v1/account_settings_templates' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN' -d '{
       "account_id": "5bbe28be34524sdbdaa34d37d1f2294a",
       "name": "my template",
       "account_settings": {
          "restrict_create_platform_apikey": "RESTRICTED",
          "restrict_create_service_id":  "NOT_RESTRICTED",
          "max_sessions_per_identity": 5,
          "mfa": "LEVEL3",
       },
    }'
    
    AccountSettingsComponent accountSettings = new AccountSettingsComponent.Builder()
       .mfa("LEVEL1")
       .systemAccessTokenExpirationInSeconds("3000")
       .build();
    CreateAccountSettingsTemplateOptions createOptions = new CreateAccountSettingsTemplateOptions.Builder()
       .accountId(enterpriseAccountId)
       .name(accountSettingsTemplateName)
       .description("IAM enterprise account settings template example")
       .accountSettings(accountSettings)
       .build();
    Response<AccountSettingsTemplateResponse> createResponse = service.createAccountSettingsTemplate(createOptions).execute();
    AccountSettingsTemplateResponse createResult = createResponse.getResult();
    // Save the id for use by other test methods.
    accountSettingsTemplateId = createResult.getId();
    accountSettingsTemplateVersion = createResult.getVersion().longValue();
    System.out.println(createResult);
    
    const settings = {
    mfa: "LEVEL1",
    system_access_token_expiration_in_seconds: "3000",
    }
    const templateParams = {
    name: "Example-Account-Settings-Template",
    description: "IAM enterprise account settings template example",
    accountId: enterpriseAccountId,
    accountSettings: settings,
    }
    try {
    const res = await iamIdentityService.createAccountSettingsTemplate(templateParams);
    accountSettingsTemplateEtag = res.headers.etag;
    const { result } = res;
    accountSettingsTemplateId = result.id;
    accountSettingsTemplateVersion = result.version;
    console.log(JSON.stringify(result, null, 2));
    } catch (err) {
    console.warn(err);
    }
    
    account_settings = {}
    account_settings['mfa'] = 'LEVEL1'
    account_settings['system_access_token_expiration_in_seconds'] = 3000
    create_response = iam_identity_service.create_account_settings_template(
    name='Example-Account-Settings-Template',
    description='IAM enterprise account settings template example',
    account_id=enterprise_account_id,
    account_settings=account_settings,
    )
    account_settings_template = create_response.get_result()
    print('\ncreate_account_settings_template() response: ', json.dumps(account_settings_template, indent=2))
    global account_settings_template_id
    account_settings_template_id = account_settings_template['id']
    global account_settings_template_version
    account_settings_template_version = account_settings_template['version']
    
    settings := &iamidentityv1.AccountSettingsComponent{
    Mfa:                                  core.StringPtr("LEVEL1"),
    SystemAccessTokenExpirationInSeconds: core.StringPtr("3000"),
    }
    createOptions := &iamidentityv1.CreateAccountSettingsTemplateOptions{
    Name:            &accountSettingsTemplateName,
    Description:     core.StringPtr("GoSDK test Account Settings Template"),
    AccountID:       &enterpriseAccountID,
    AccountSettings: settings,
    }
    createResponse, response, err := iamIdentityService.CreateAccountSettingsTemplate(createOptions)
    b, _ := json.MarshalIndent(createResponse, "", "  ")
    fmt.Println(string(b))
    // Grab the ID and Etag value from the response for use in the update operation.
    accountSettingsTemplateId = *createResponse.ID
    accountSettingsTemplateVersion = *createResponse.Version
    accountSettingsTemplateEtag = response.GetHeaders().Get("Etag")
    

Mise à jour d'un modèle de paramètres à l'aide de l'API

Vous pouvez mettre à jour un modèle de paramétrage à tout moment avant de le valider. Pour mettre à jour une version spécifique d'un modèle de paramètres de compte, procédez comme suit :

  1. Listez les modèles de paramètres dans votre compte d'entreprise et notez l'ID d' AccountSettingsTemplate s et l'ETag dans la réponse pour la version du modèle que vous souhaitez mettre à jour.

    curl -X GET 'https://iam.cloud.ibm.com/v1/account_settings_templates?account_id=5bbe28be34524sdbdaa34d37d1f2294a' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN'
    
    ListAccountSettingsTemplatesOptions listOptions = new ListAccountSettingsTemplatesOptions.Builder()
       .accountId(enterpriseAccountId)
       .build();
    Response<AccountSettingsTemplateList> response = service.listAccountSettingsTemplates(listOptions).execute();
    AccountSettingsTemplateList result = response.getResult();
    System.out.println(result);
    
    const params = {
    accountId: enterpriseAccountId,
    }
    try {
    const res = await iamIdentityService.listAccountSettingsTemplates(params);
    console.log(JSON.stringify(res.result, null, 2));
    } catch (err) {
    console.warn(err);
    }
    
    list_response = iam_identity_service.list_account_settings_templates(account_id=enterprise_account_id)
    account_settings_template_list = list_response.get_result()
    print('\nlist_account_settings_templates response: ', json.dumps(account_settings_template_list, indent=2))
    
    listOptions := &iamidentityv1.ListAccountSettingsTemplatesOptions{
    AccountID: &enterpriseAccountID,
    }
    listResponse, response, err := iamIdentityService.ListAccountSettingsTemplates(listOptions)
    b, _ := json.MarshalIndent(listResponse, "", "  ")
    fmt.Println(string(b))
    
  2. Mettre à jour la définition du modèle de paramètres.

    Lorsque vous mettez à jour le nom du modèle, le nom de chaque version est également mis à jour.

    curl -X POST 'https://iam.cloud.ibm.com/v1/account_settings_templates/{template_id}/version' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN' -d '{
       "account_id": "5bbe28be34524sdbdaa34d37d1f2294a",
       "name": "my template name",
       "account_settings": {
          "mfa": "NONE",
       },
    }'
    
    AccountSettingsComponent accountSettings = new AccountSettingsComponent.Builder()
       .mfa("LEVEL1")
       .systemAccessTokenExpirationInSeconds("3000")
       .build();
    UpdateAccountSettingsTemplateVersionOptions updateOptions = new UpdateAccountSettingsTemplateVersionOptions.Builder()
       .accountId(enterpriseAccountId)
       .templateId(accountSettingsTemplateId)
       .version(Long.toString(accountSettingsTemplateVersion))
       .ifMatch(accountSettingsTemplateEtag)
       .name(accountSettingsTemplateName)
       .description("IAM enterprise account settings template example - updated")
       .accountSettings(accountSettings)
       .build();
    Response<AccountSettingsTemplateResponse> updateResponse = service.updateAccountSettingsTemplateVersion(updateOptions).execute();
    AccountSettingsTemplateResponse updateResult = updateResponse.getResult();
    accountSettingsTemplateEtag = updateResponse.getHeaders().values("Etag").get(0);
    System.out.println(updateResult);
    
    const settings = {
    mfa: "LEVEL1",
    system_access_token_expiration_in_seconds: "3000",
    }
    const params = {
    accountId: enterpriseAccountId,
    templateId: accountSettingsTemplateId,
    version: accountSettingsTemplateVersion,
    ifMatch: accountSettingsTemplateEtag,
    name: "Example-Account-Settings-Template",
    description: "IAM enterprise account settings template example - updated",
    accountSettings: settings,
    }
    try {
    const res = await iamIdentityService.updateAccountSettingsTemplateVersion(params);
    accountSettingsTemplateEtag = res.headers.etag;
    console.log(JSON.stringify(res.result, null, 2));
    } catch (err) {
    console.warn(err);
    }
    
    account_settings = {}
    account_settings['mfa'] = 'LEVEL1'
    account_settings['system_access_token_expiration_in_seconds'] = 3000
    update_response = iam_identity_service.update_account_settings_template_version(
    account_id=enterprise_account_id,
    template_id=account_settings_template_id,
    version=str(account_settings_template_version),
    if_match=account_settings_template_etag,
    name='Example-Account-Settings-Template',
    description='IAM enterprise account settings template example - updated',
    account_settings=account_settings,
    )
    account_settings_template = update_response.get_result()
    print('\nupdate_account_settings_template() response: ', json.dumps(account_settings_template, indent=2))
    account_settings_template_etag = update_response.get_headers()['Etag']
    
    settings := &iamidentityv1.AccountSettingsComponent{
    Mfa:                                  core.StringPtr("LEVEL1"),
    SystemAccessTokenExpirationInSeconds: core.StringPtr("3000"),
    }
    updateOptions := &iamidentityv1.UpdateAccountSettingsTemplateVersionOptions{
    AccountID:       &enterpriseAccountID,
    TemplateID:      &accountSettingsTemplateId,
    Version:         core.StringPtr(strconv.FormatInt(accountSettingsTemplateVersion, 10)),
    IfMatch:         &accountSettingsTemplateEtag,
    Name:            &accountSettingsTemplateName,
    Description:     core.StringPtr("GoSDK test Account Settings Template - updated"),
    AccountSettings: settings,
    }
    updateResponse, response, err := iamIdentityService.UpdateAccountSettingsTemplateVersion(updateOptions)
    b, _ := json.MarshalIndent(updateResponse, "", "  ")
    fmt.Println(string(b))
    accountSettingsTemplateEtag = response.GetHeaders().Get("Etag")
    

Engagement d'un modèle de paramètres à l'aide de l'API

Passez en revue le modèle de paramètres et validez-le afin qu'aucune modification ne puisse être apportée à la version. L'engagement d'une version est une étape nécessaire avant de pouvoir l'attribuer à des comptes enfants. De cette façon, l'administrateur de l'attribution des modèles peut être sûr qu'il n'attribue la version que lorsque vous avez confirmé qu'elle est prête.

  1. Obtenez la version d'un modèle de profil de confiance que vous souhaitez examiner et valider.

    curl -X GET 'https://iam.cloud.ibm.com/v1/account_settings_templates/AccountSettingsTemplate-767fc1f6-c77c-4196-b3d6-a009a5a536e9/versions/1' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN'
    
    GetAccountSettingsTemplateVersionOptions getOptions = new GetAccountSettingsTemplateVersionOptions.Builder()
       .templateId(accountSettingsTemplateId)
       .version(Long.toString(accountSettingsTemplateVersion))
       .build();
    Response<AccountSettingsTemplateResponse> response = service.getAccountSettingsTemplateVersion(getOptions).execute();
    AccountSettingsTemplateResponse getResult = response.getResult();
    // Grab the Etag value from the response for use in the update operation.
    accountSettingsTemplateEtag = response.getHeaders().values("Etag").get(0);
    System.out.println(getResult);
    
    get_response = iam_identity_service.get_account_settings_template_version(
    template_id=account_settings_template_id, version=str(account_settings_template_version)
    )
    account_settings_template = get_response.get_result()
    print('\nget_account_settings_template response: ', json.dumps(account_settings_template, indent=2))
    global account_settings_template_etag
    account_settings_template_etag = get_response.get_headers()['Etag']
    
    get_response = iam_identity_service.get_account_settings_template_version(
    template_id=account_settings_template_id, version=str(account_settings_template_version)
    )
    account_settings_template = get_response.get_result()
    print('\nget_account_settings_template response: ', json.dumps(account_settings_template, indent=2))
    global account_settings_template_etag
    account_settings_template_etag = get_response.get_headers()['Etag']
    
    getOptions := &iamidentityv1.GetAccountSettingsTemplateVersionOptions{
    TemplateID: &accountSettingsTemplateId,
    Version:    core.StringPtr(strconv.FormatInt(accountSettingsTemplateVersion, 10)),
    }
    getResponse, response, err := iamIdentityService.GetAccountSettingsTemplateVersion(getOptions)
    b, _ := json.MarshalIndent(getResponse, "", "  ")
    fmt.Println(string(b))
    // Grab the Etag value from the response for use in the update operation.
    accountSettingsTemplateEtag = response.GetHeaders().Get("Etag")
    
  2. Vérifiez la réponse pour confirmer qu'elle est prête à être validée.

  3. Valider la version du modèle de profil de confiance.

    curl -X POST 'https://iam.cloud.ibm.com/v1/account_settings_templates/{template_id}/{version}/commit' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN'
    
    CommitAccountSettingsTemplateOptions commitOptions = new CommitAccountSettingsTemplateOptions.Builder()
       .templateId(accountSettingsTemplateId)
       .version(Long.toString(accountSettingsTemplateVersion))
       .build();
    Response<Void> commitResponse = service.commitAccountSettingsTemplate(commitOptions).execute();
    
    const commitParams = {
    templateId: accountSettingsTemplateId,
    version: accountSettingsTemplateVersion,
    }
    try {
    const res = await iamIdentityService.commitAccountSettingsTemplate(commitParams);
    } catch (err) {
    console.warn(err);
    }
    
    commit_response = iam_identity_service.commit_account_settings_template(
    template_id=account_settings_template_id, version=str(account_settings_template_version)
    )
    
    commitOptions := &iamidentityv1.CommitAccountSettingsTemplateOptions{
    TemplateID: &accountSettingsTemplateId,
    Version:    core.StringPtr(strconv.FormatInt(accountSettingsTemplateVersion, 10)),
    }
    response, err := iamIdentityService.CommitAccountSettingsTemplate(commitOptions)
    

Attribution d'un modèle de paramètres aux comptes enfants à l'aide de l'API

Vous ne pouvez attribuer les versions que d'un seul modèle de paramètres à la fois au sein de votre entreprise. Vous pouvez attribuer différentes versions du même modèle de paramètres, mais vous ne pouvez pas utiliser plusieurs modèles de paramètres dans une entreprise. Vous pouvez attribuer différentes versions aux comptes ayant des exigences différentes, comme les comptes de production et de test.

Vous ne pouvez pas attribuer de modèle IAM au compte Entreprise, mais uniquement aux comptes enfants.

Pour créer une affectation pour un modèle de paramètres de compte, procédez comme suit :

  1. Listez les modèles de paramètres dans votre compte d'entreprise et notez l'ID d' AccountSettingsTemplate s et l'ETag dans la réponse pour la version du modèle que vous souhaitez attribuer aux comptes enfants.

    curl -X GET 'https://iam.cloud.ibm.com/v1/account_settings_templates?account_id=5bbe28be34524sdbdaa34d37d1f2294a' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN'
    
    ListAccountSettingsTemplatesOptions listOptions = new ListAccountSettingsTemplatesOptions.Builder()
       .accountId(enterpriseAccountId)
       .build();
    Response<AccountSettingsTemplateList> response = service.listAccountSettingsTemplates(listOptions).execute();
    AccountSettingsTemplateList result = response.getResult();
    System.out.println(result);
    
    const params = {
    accountId: enterpriseAccountId,
    }
    try {
    const res = await iamIdentityService.listAccountSettingsTemplates(params);
    console.log(JSON.stringify(res.result, null, 2));
    } catch (err) {
    console.warn(err);
    }
    
    list_response = iam_identity_service.list_account_settings_templates(account_id=enterprise_account_id)
    account_settings_template_list = list_response.get_result()
    print('\nlist_account_settings_templates response: ', json.dumps(account_settings_template_list, indent=2))
    
    listOptions := &iamidentityv1.ListAccountSettingsTemplatesOptions{
    AccountID: &enterpriseAccountID,
    }
    listResponse, response, err := iamIdentityService.ListAccountSettingsTemplates(listOptions)
    b, _ := json.MarshalIndent(listResponse, "", "  ")
    fmt.Println(string(b))
    
  2. Attribuer le modèle de réglage à un site Account ou AccountGroup.

    curl -X POST 'https://iam.cloud.ibm.com/v1/account_settings_assignments' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN' -d '{
       "template_id": "AccountSettingsTemplate-cac1b203-5956-4981-bdec-0a4af4feab4d",
       "template_version": 1,
       "target_type": "Account",
       "target": "5bbe28be34524e88a34d37d1f2294a8a"
    }'
    
    CreateAccountSettingsAssignmentOptions assignOptions = new CreateAccountSettingsAssignmentOptions.Builder()
       .templateId(accountSettingsTemplateId)
       .templateVersion(accountSettingsTemplateVersion)
       .targetType("Account")
       .target(enterpriseSubAccountId)
       .build();
    Response<TemplateAssignmentResponse> assignResponse = service.createAccountSettingsAssignment(assignOptions).execute();
    TemplateAssignmentResponse assignmentResult = assignResponse.getResult();
    // Save the id for use by other test methods.
    accountSettingsTemplateAssignmentId = assignmentResult.getId();
    // Grab the Etag value from the response for use in the update operation.
    accountSettingsTemplateAssignmentEtag = assignResponse.getHeaders().values("Etag").get(0);
    System.out.println(assignmentResult);
    
    const assignParams = {
    templateId: accountSettingsTemplateId,
    templateVersion: accountSettingsTemplateVersion,
    targetType: "Account",
    target: enterpriseSubAccountId,
    }
    try {
    const assRes = await iamIdentityService.createAccountSettingsAssignment(assignParams);
    const { result } = assRes;
    accountSettingsTemplateAssignmentId = result.id;
    accountSettingsTemplateAssignmentEtag= assRes.headers.etag;
    console.log(JSON.stringify(result, null, 2));
    } catch (err) {
    console.warn(err);
    }
    
    assign_response = iam_identity_service.create_account_settings_assignment(
    template_id=account_settings_template_id,
    template_version=account_settings_template_version,
    target_type='Account',
    target=enterprise_subaccount_id,
    )
    assignment = assign_response.get_result()
    print('\ncreate_account_settings_assignment() response: ', json.dumps(assignment, indent=2))
    global account_settings_template_assignment_id
    account_settings_template_assignment_id = assignment['id']
    global account_settings_template_assignment_etag
    account_settings_template_assignment_etag = assign_response.get_headers()['Etag']
    
    assignOptions := &iamidentityv1.CreateAccountSettingsAssignmentOptions{
    TemplateID:      &accountSettingsTemplateId,
    TemplateVersion: &accountSettingsTemplateVersion,
    TargetType:      core.StringPtr("Account"),
    Target:          &enterpriseSubAccountID,
    }
    assignResponse, response, err := iamIdentityService.CreateAccountSettingsAssignment(assignOptions)
    b, _ := json.MarshalIndent(assignResponse, "", "  ")
    fmt.Println(string(b))
    accountSettingsTemplateAssignmentEtag = response.GetHeaders().Get("Etag")
    accountSettingsTemplateAssignmentId = *assignResponse.ID
    

Si une affectation échoue, utilisez la méthode account-settings-assigment-update pour réessayer.

Création d'une nouvelle version à l'aide de l'API

Si vous souhaitez modifier un modèle de paramétrage validé ou attribué, créez une nouvelle version.

settings := &iamidentityv1.AccountSettingsComponent{
Mfa:                                  core.StringPtr("LEVEL1"),
SystemAccessTokenExpirationInSeconds: core.StringPtr("2600"),
RestrictCreatePlatformApikey:         core.StringPtr("RESTRICTED"),
RestrictCreateServiceID:              core.StringPtr("RESTRICTED"),
}
createOptions := &iamidentityv1.CreateAccountSettingsTemplateVersionOptions{
Name:            &accountSettingsTemplateName,
Description:     core.StringPtr("GoSDK test Account Settings Template - new version"),
AccountID:       &enterpriseAccountID,
TemplateID:      &accountSettingsTemplateId,
AccountSettings: settings,
}
createResponse, response, err := iamIdentityService.CreateAccountSettingsTemplateVersion(createOptions)
b, _ := json.MarshalIndent(createResponse, "", "  ")
fmt.Println(string(b))
accountSettingsTemplateVersion = *createResponse.Version

Enregistrez l'ID d' AccountSettingsTemplate s et la version de la nouvelle version à utiliser dans les appels suivants.

Mise à jour d'un devoir à l'aide de l'API

Mettre à jour une affectation pour migrer vers une nouvelle version ou réessayer une affectation ayant échoué.

La nouvelle version du modèle que vous attribuez remplace l'ancienne version. En savoir plus sur l'attribution d'une nouvelle version.

  1. Listez les affectations de modèles de paramètres dans votre compte d'entreprise et notez l'ID d'affectation, l'ETag et la version de l'affectation que vous souhaitez mettre à jour :
curl -X GET 'https://iam.cloud.ibm.com/v1/account_settings_assignments?account_id=5bbe28be34524sdbdaa34d37d1f2294a' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN'
ListAccountSettingsTemplatesOptions listOptions = new ListAccountSettingsTemplatesOptions.Builder()
   .accountId(enterpriseAccountId)
   .build();
Response<AccountSettingsTemplateList> listResponse = service.listAccountSettingsTemplates(listOptions).execute();
AccountSettingsTemplateList listResult = listResponse.getResult();
System.out.println(listResult);
const params = {
accountId: enterpriseAccountId,
templateId: accountSettingsTemplateId,
}
try {
const res = await iamIdentityService.listAccountSettingsAssignments(params);
console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
console.warn(err);
}
list_response = iam_identity_service.list_account_settings_assignments(
account_id=enterprise_account_id, template_id=account_settings_template_id
)
assignment_list = list_response.get_result()
print('\ncreate_account_settings_assignment() response: ', json.dumps(assignment_list, indent=2))
listOptions := &iamidentityv1.ListAccountSettingsAssignmentsOptions{
AccountID:  &enterpriseAccountID,
TemplateID: &accountSettingsTemplateId,
}
listResponse, response, err := iamIdentityService.ListAccountSettingsAssignments(listOptions)
b, _ := json.MarshalIndent(listResponse, "", "  ")
fmt.Println(string(b))
  1. Mettez à jour l'affectation des paramètres du compte. Si vous réessayez une affectation, utilisez le même numéro de version.
curl -X PATCH 'https://iam.cloud.ibm.com/v1/account_settings_assignments/<assignment_id>' -H 'Authorization: Bearer $TOKEN' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN' -d '{
   "template_version": 2
}'
UpdateAccountSettingsAssignmentOptions updateOptions = new UpdateAccountSettingsAssignmentOptions.Builder()
   .assignmentId(accountSettingsTemplateAssignmentId)
   .templateVersion(accountSettingsTemplateVersion)
   .ifMatch(accountSettingsTemplateAssignmentEtag)
   .build();
Response<TemplateAssignmentResponse> updateResponse = service.updateAccountSettingsAssignment(updateOptions).execute();
TemplateAssignmentResponse updateResult = updateResponse.getResult();
// Grab the Etag value from the response for use in the update operation.
accountSettingsTemplateAssignmentEtag = updateResponse.getHeaders().values("Etag").get(0);
System.out.println(updateResult);
const assignParams = {
assignmentId: accountSettingsTemplateAssignmentId,
templateVersion: accountSettingsTemplateVersion,
ifMatch: accountSettingsTemplateAssignmentEtag,
}
try {
const assRes = await iamIdentityService.updateAccountSettingsAssignment(assignParams);
console.log(JSON.stringify(assRes.result, null, 2));
} catch (err) {
console.warn(err);
}
assign_response = iam_identity_service.update_account_settings_assignment(
assignment_id=account_settings_template_assignment_id,
template_version=account_settings_template_version,
if_match=account_settings_template_assignment_etag,
)
assignment = assign_response.get_result()
print('\nupdate_account_settings_template_assignment response: ', json.dumps(assignment, indent=2))
account_settings_template_assignment_etag = assign_response.get_headers()['Etag']
updateOptions := &iamidentityv1.UpdateAccountSettingsAssignmentOptions{
AssignmentID:    &accountSettingsTemplateAssignmentId,
TemplateVersion: &accountSettingsTemplateVersion,
IfMatch:         &accountSettingsTemplateAssignmentEtag,
}
updateResponse, response, err := iamIdentityService.UpdateAccountSettingsAssignment(updateOptions)
b, _ := json.MarshalIndent(updateResponse, "", "  ")
fmt.Println(string(b))

Suppression d'une affectation à l'aide de l'API

Vous pouvez supprimer l'affectation d'un modèle d'un compte ou d'un groupe de comptes auquel le modèle est affecté. Vous pouvez le faire si le modèle ne fonctionne pas comme prévu. Lorsque vous supprimez l'affectation d'un modèle à un compte, la version précédente du modèle est rétablie par défaut. Si la cession que vous supprimez concerne la première ou la seule version d'un modèle, les préférences de paramètres gérés par l'entreprise dans le compte enfant sont supprimées.

Pour supprimer une affectation, procédez comme suit :

  1. Listez les affectations dans le compte et notez l'ID d'affectation de l'affectation que vous souhaitez supprimer.
curl -X GET 'https://iam.cloud.ibm.com/v1/account_settings_assignments?account_id=5bbe28be34524sdbdaa34d37d1f2294a' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN'
ListAccountSettingsTemplatesOptions listOptions = new ListAccountSettingsTemplatesOptions.Builder()
   .accountId(enterpriseAccountId)
   .build();
Response<AccountSettingsTemplateList> listResponse = service.listAccountSettingsTemplates(listOptions).execute();
AccountSettingsTemplateList listResult = listResponse.getResult();
System.out.println(listResult);
const params = {
accountId: enterpriseAccountId,
templateId: accountSettingsTemplateId,
}
try {
const res = await iamIdentityService.listAccountSettingsAssignments(params);
console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
console.warn(err);
}
list_response = iam_identity_service.list_account_settings_assignments(
account_id=enterprise_account_id, template_id=account_settings_template_id
)
assignment_list = list_response.get_result()
print('\ncreate_account_settings_assignment() response: ', json.dumps(assignment_list, indent=2))
listOptions := &iamidentityv1.ListAccountSettingsAssignmentsOptions{
AccountID:  &enterpriseAccountID,
TemplateID: &accountSettingsTemplateId,
}
listResponse, response, err := iamIdentityService.ListAccountSettingsAssignments(listOptions)
b, _ := json.MarshalIndent(listResponse, "", "  ")
fmt.Println(string(b))
  1. Supprimez l'affectation.

La suppression d'une affectation peut entraîner l'activation d'une affectation précédente. Pour plus d'informations, voir Utilisation des versions de modèle.

curl -X DELETE 'https://iam.cloud.ibm.com/v1/account_settings_assignments/<assignment_id>' -H 'Authorization: Bearer $TOKEN' }'
DeleteAccountSettingsAssignmentOptions deleteOptions = new DeleteAccountSettingsAssignmentOptions.Builder()
   .assignmentId(accountSettingsTemplateAssignmentId)
   .build();
Response<ExceptionResponse> deleteResponse = service.deleteAccountSettingsAssignment(deleteOptions).execute();
const params = {
assignmentId: accountSettingsTemplateAssignmentId,
}
try {
const res = await iamIdentityService.deleteAccountSettingsAssignment(params);
} catch (err) {
console.warn(err);
}
delete_response = iam_identity_service.delete_account_settings_assignment(
assignment_id=account_settings_template_assignment_id
)
deleteOptions := &iamidentityv1.DeleteAccountSettingsAssignmentOptions{
AssignmentID: &accountSettingsTemplateAssignmentId,
}
excResponse, response, err := iamIdentityService.DeleteAccountSettingsAssignment(deleteOptions)

Suppression d'une version à l'aide de l'API

Avant de pouvoir supprimer une version de modèle de paramétrage, vous devez supprimer toutes les affectations de cette version du modèle. Supprimer une version spécifique en suivant les étapes suivantes :

  1. Listez les modèles de paramètres dans votre compte d'entreprise et notez l'ID du modèle de paramètres et le numéro de version de la version que vous souhaitez supprimer :
   curl -X GET 'https://iam.cloud.ibm.com/v1/account_settings_templates?account_id=5bbe28be34524sdbdaa34d37d1f2294a' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN'
ListAccountSettingsTemplatesOptions listOptions = new ListAccountSettingsTemplatesOptions.Builder()
   .accountId(enterpriseAccountId)
   .build();
Response<AccountSettingsTemplateList> response = service.listAccountSettingsTemplates(listOptions).execute();
AccountSettingsTemplateList result = response.getResult();
System.out.println(result);
const params = {
accountId: enterpriseAccountId,
}
try {
const res = await iamIdentityService.listAccountSettingsTemplates(params);
console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
console.warn(err);
}
list_response = iam_identity_service.list_account_settings_templates(account_id=enterprise_account_id)
account_settings_template_list = list_response.get_result()
print('\nlist_account_settings_templates response: ', json.dumps(account_settings_template_list, indent=2))
listOptions := &iamidentityv1.ListAccountSettingsTemplatesOptions{
AccountID: &enterpriseAccountID,
}
listResponse, response, err := iamIdentityService.ListAccountSettingsTemplates(listOptions)
b, _ := json.MarshalIndent(listResponse, "", "  ")
fmt.Println(string(b))
  1. Supprimer la version :

Suppression de toutes les versions à l'aide de l'API

Assurez-vous d'abord de supprimer les affectations pour chaque version.

curl -X DELETE 'https://iam.cloud.ibm.com/v1/account_settings_templates/AccountSettingsTemplate-767fc1f6-c77c-4196-b3d6-a009a5a536e9' -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN'
DeleteAllVersionsOfAccountSettingsTemplateOptions deleteTeplateOptions = new DeleteAllVersionsOfAccountSettingsTemplateOptions.Builder()
    .templateId(accountSettingsTemplateId)
    .build();
Response<Void> deleteResponse = service.deleteAllVersionsOfAccountSettingsTemplate(deleteTeplateOptions).execute();
const params = {
  templateId: accountSettingsTemplateId,
}
try {
  const res = await iamIdentityService.deleteAllVersionsOfAccountSettingsTemplate(params);
} catch (err) {
  console.warn(err);
}
delete_response = iam_identity_service.delete_all_versions_of_account_settings_template(
  template_id=account_settings_template_id
)
deleteOptions := &iamidentityv1.DeleteAllVersionsOfAccountSettingsTemplateOptions{
  TemplateID: &accountSettingsTemplateId,
}
response, err := iamIdentityService.DeleteAllVersionsOfAccountSettingsTemplate(deleteOptions)

Limitations du modèle de paramètres

Un seul modèle de paramétrage peut être affecté dans une entreprise. Vous pouvez attribuer plusieurs versions du modèle, mais pas différents modèles.