Creazione di modelli di impostazioni gestite dall'azienda

In un'azienda in cui si hanno molti account secondari, configurare manualmente le impostazioni IAM per ogni account può richiedere molto tempo ed essere fonte di errori. Assicurati che tutti gli account della tua azienda rispettino i requisiti di sicurezza della tua organizzazione utilizzando modelli di impostazioni.

È possibile assegnare un solo modello di impostazioni a un account o a un gruppo di account. Creare un modello di impostazioni che si applichi alla maggior parte degli account e crearne uno nuovo solo per gli account che hanno requisiti speciali. Ad esempio, potresti avere requisiti di autenticazione multifattore (MFA) più rigorosi negli account dell'ambiente di produzione.

Quando si assegna un modello di impostazioni, gli utenti di account figlio con il ruolo di amministratore sul servizio di identità IAM possono comunque gestire le impostazioni del proprio account. Se vi sono impostazioni in conflitto tra quelle definite dal modello e quelle gestite all'interno dell'account, all'account viene applicata l'impostazione più rigorosa. Ciò significa che la configurazione più restrittiva ha la precedenza e viene applicata per quel particolare account.

Prima di iniziare

  • Per sapere come i modelli IAM gestiti a livello aziendale rendono la tua azienda più sicura, consulta Come funziona l'accesso IAM gestito a livello aziendale.

  • Essere un membro dell'account aziendale per creare e assegnare modelli IAM gestiti dall'azienda.

  • Per creare un modello IAM gestito dall'azienda, assicurati di avere i seguenti diritti di accesso:

    • Una policy con il ruolo di amministratore dei modelli su tutti i servizi di gestione degli account IAM
  • Per assegnare un modello IAM gestito dall'azienda agli account secondari, assicurati di avere i seguenti diritti di accesso:

    • Una politica con il ruolo di amministratore assegnazione modelli su tutti i servizi di gestione account IAM
    • Una policy con almeno il ruolo di Viewer sul servizio Enterprise

    Per impostazione predefinita, nessun utente ha i ruoli di amministratore dei modelli o di amministratore delle assegnazioni dei modelli, incluso il proprietario dell'account.

  • Gli account nuovi ed esistenti nella tua azienda devono aderire all'IAM gestito dall'azienda. Per ulteriori informazioni, vedere Opting in to enterprise-managed IAM.

  • L'impostazione definita a livello di account figlio si applica se l'impostazione gestita dall'azienda è meno rigorosa o rimossa.

Creazione di un modello di impostazioni

Considera l'utilizzo di modelli di impostazioni quando hai molti account figlio che richiedono le stesse impostazioni IAM. Ad esempio, la tua organizzazione potrebbe avere standard interni o richiedere la conformità alle normative di settore.

Per creare un modello di impostazioni, procedere come segue:

  1. Vai a Gestione > Accesso (IAM) > Modelli nell' IBM Cloud.
  2. Fare clic su Impostazioni > Crea.
  3. Immettere un nome e una descrizione per il modello di impostazioni che ne descrive lo scopo per gli utenti aziendali.
  4. Fai clic su Crea.

(Opzionale) Aggiunta delle impostazioni dell'account IAM

Personalizza la tua azienda per soddisfare i requisiti aziendali e normativi definendo le impostazioni dell'account IAM negli account secondari.

Limitazione dei domini per gli inviti agli account

Per impostazione predefinita, è possibile inviare inviti all'account a indirizzi e-mail di qualsiasi dominio. Tuttavia, se si attiva l'impostazione Limita inviti utente, è possibile limitare gli inviti solo agli indirizzi e-mail che appartengono ai domini consentiti specificati. Per abilitare le restrizioni su domini specifici, completare i seguenti passaggi:

  1. Attivare l'impostazione Limita inviti utente nella sezione Account. Quando questa impostazione è attivata, la pagina Invita utente negli account secondari limita gli inviti agli indirizzi e-mail dei domini consentiti specificati.
  2. Selezionare Più severo o Più flessibile per determinare il modo in cui vengono applicate le impostazioni dei modelli e dei sottoconti.
  3. Fare clic su Modifica per modificare il dominio esistente o aggiungere nuovi domini all'elenco consentito. Questa funzione aumenta la sicurezza del vostro account e vi offre la flessibilità di aggiornarlo in qualsiasi momento e di aggiungere altri domini se necessario.

Le limitazioni dei domini vengono implementate impostando modelli di email. Ad esempio, **@ibm.com, **@*.ibm.com, **@?.ibm.com. Un singolo asterisco * rappresenta una sequenza qualsiasi di zero o più caratteri in una stringa, a meno che la sequenza non termini con un punto . o con il simbolo @ @. Un doppio asterisco ** rappresenta una sequenza illimitata di zero o più caratteri nella stringa. Un punto interrogativo ? rappresenta un qualsiasi carattere singolo.

Guardando più da vicino l'esempio **@*.ibm.com. La parte username dell'indirizzo e-mail specifica **. Poiché la sequenza non è limitata da ., un indirizzo e-mail come my.name.is.bob@us.ibm.com è valido. Anche il sottodominio us è valido perché è una stringa di lettere, dove la sequenza termina con ..

Limitare la visibilità degli utenti

Per impostazione predefinita, tutti gli utenti di un account possono vedere tutti gli altri utenti nella pagina Utenti. Tuttavia, attivando l'impostazione Limita visibilità elenco utenti, è possibile controllare quali utenti sono visibili, in modo che ogni utente veda i membri dell'account a cui è direttamente associato.

Per applicare restrizioni a utenti specifici, attivare l'impostazione Limita visibilità elenco utenti nella sezione Account. Consente di controllare il modo in cui gli utenti visualizzano gli altri membri nei sottoconti a cui è assegnato questo modello.

Limitare la possibilità degli utenti di creare chiavi API

Per impostazione predefinita, tutti i membri di un account possono creare chiavi API per l' IBM Cloud®. Tuttavia, utilizzando l'impostazione di creazione della chiave API, tale accesso può essere limitato in modo che solo i membri con l'accesso corretto possano creare queste chiavi API utente.

Limitare la possibilità di creare chiavi API ha senso se si desidera che gli utenti di un account secondario specifico effettuino sempre l'accesso in modo interattivo, il che significa che non si desidera che vengano eseguiti script di automazione in grado di accedere automaticamente agli utenti utilizzando una chiave API. Per ulteriori informazioni sulle chiavi API, vedere Gestione delle chiavi API utente.

Se attivi l'impostazione Limita creazione chiave API, gli utenti del tuo account, incluso il proprietario dell'account, richiedono un accesso specifico per creare chiavi API. Per limitare chi può creare chiavi API, procedere come segue:

L'abilitazione di questa impostazione influisce solo sulla creazione delle chiavi API utente. Non influisce sulle chiavi API per gli ID di servizio.

  1. Abilita l'impostazione Limita creazione chiave API nella sezione Account.
  2. Fai clic su Yes per confermare.

Ora che l'impostazione è abilitata per impedire agli utenti di creare chiavi API, è possibile creare un modello di gruppo di accesso che conceda l'accesso necessario per consentire a utenti specifici di continuare a creare chiavi API utente. Ricorda, anche il titolare dell'account deve avere questo accesso esplicito. Per ulteriori informazioni, vedere Assegnazione dell'accesso per la creazione di chiavi API con restrizioni abilitate.

Limitare la possibilità per gli utenti di creare ID di servizio

Per impostazione predefinita, tutti i membri di un account possono creare ID di servizio. Tuttavia, utilizzando l'impostazione di creazione dell'ID di servizio, è possibile limitare l'accesso in modo che solo i membri con l'accesso corretto possano creare ID di servizio. Per ulteriori informazioni sugli ID servizio, consulta Creazione e gestione degli ID servizio.

Se si abilita l'impostazione di creazione dell'ID servizio, gli utenti negli account figlio richiedono un accesso specifico per creare gli ID servizio, incluso il proprietario dell'account. Per limitare chi può creare ID di servizio, procedere come segue:

  1. Abilita l'impostazione Limita la creazione di ID servizio nella sezione Account.
  2. Fai clic su Yes per confermare.

Ora che l'impostazione è abilitata per impedire agli utenti di creare ID di servizio, è possibile creare un modello di gruppo di accesso che conceda l'accesso necessario per consentire a utenti specifici di continuare a creare ID di servizio. Ricorda, anche il titolare dell'account deve avere questo accesso esplicito. Per ulteriori informazioni, consultare la sezione " Assegnazione dell'accesso alla creazione di ID di servizio con restrizioni attivate "

Consentire indirizzi IP specifici

Per impostazione predefinita, è possibile utilizzare tutti gli indirizzi IP per accedere alla console IBM Cloud® e alle API dell'infrastruttura classica. È possibile specificare quali indirizzi IP hanno accesso e quali sono soggetti a restrizioni. È possibile specificare questo accesso per gli account dei bambini. Attualmente sono supportati solo gli indirizzi IP pubblici.

Quando si consente l'accesso a un account IBM Cloud solo a indirizzi IP specifici, gli utenti non possono accedere alla CLI della shell IBM Cloud. Questo perché l' Cloud Shell e è ospitato su una piattaforma condivisa che non può soddisfare l'elenco degli indirizzi IP consentiti.

Gli amministratori degli account dei bambini possono impostare una restrizione dell'indirizzo IP per i singoli utenti. Quando viene definita una restrizione dell'indirizzo IP sia per l'account che per l'utente, l'indirizzo IP deve corrispondere a entrambe le specifiche per poter generare un token IAM.

Per limitare tutti gli utenti all'utilizzo esclusivo di determinati indirizzi IP, procedere come segue:

  1. Dalla sezione Account, abilita l'impostazione Limita accesso indirizzo IP.

  2. Inserire gli indirizzi IP. Gli indirizzi IP elencati sono gli unici dai quali gli utenti degli account secondari possono accedere a IBM Cloud®.

    È possibile inserire un singolo indirizzo IP 17.5.7.8, un intervallo di indirizzi IP 17.5.7.8 - 17.5.9.5, sottoreti IP 17.5.7.8.0/16 o una zona di rete networkZoneName. Assicurati di utilizzare indirizzi IPv4 o IPv6 e di separare i valori multipli con una virgola. Se esiste già una restrizione dell'indirizzo IP, la risorsa ignora la restrizione.

  3. Fare clic su Salva.

L'account bambino può limitare l'accesso a un sottoinsieme di IP all'interno dell'elenco gestito dall'azienda. Ad esempio, l'amministratore di un account figlio di produzione potrebbe specificare una lista di autorizzazioni più granulare.

(Opzionale) Aggiunta dell'impostazione di autenticazione

Le seguenti informazioni sono utili da considerare prima di abilitare l'MFA negli account figlio per assicurarsi di sapere come influisce su tutti gli utenti negli account figlio:

  • L'abilitazione dell'MFA per tutti gli utenti del tuo account influisce su tutti i membri dell'account. Se gli utenti del tuo account sono membri di più account IBM Cloud, devono iscriversi a MFA al loro prossimo accesso anche se non intendono utilizzare le risorse nell'account in cui MFA è abilitato.
  • Le chiavi API per gli utenti e gli ID servizio continuano a funzionare dopo l'abilitazione di MFA.
  • L'MFA per gli account dei tuoi figli si applica agli accessi degli utenti, ma non alle chiamate API. Se un utente dispone dell'autorizzazione a effettuare chiamate API alle risorse dell'account, può farlo senza completare l'autenticazione a più fattori (MFA). Se l'utente appartiene ad altri account, l'utente può effettuare chiamate API alle risorse nel tuo account utilizzando una chiave API da un account che non ha richiesto la MFA.
  • Pianifica una strategia di comunicazione e supporto per gli utenti nel tuo account:
    • Scegli una data e ora in cui intendi abilitare la MFA che produca il minimo impatto sulla tua attività aziendale.
    • Dopo aver attivato l'autenticazione a più fattori (MFA), invia una notifica agli utenti del tuo account con le istruzioni su come configurarla.

L'abilitazione dell'autenticazione a più fattori non influisce sugli utenti già connessi, poiché l'autenticazione a più fattori ha effetto solo al momento dell'accesso. Assicurati di informare gli utenti degli account secondari che l'autenticazione a più fattori (MFA) è stata abilitata e di spiegare loro le conseguenze al loro prossimo accesso.

Per abilitare MFA in un modello di impostazioni, completare i seguenti passaggi:

  1. Vai alla sezione "Autenticazione".
  2. Seleziona il tipo di MFA che desideri abilitare nel tuo account. Per ulteriori informazioni sulle opzioni MFA, vedere Opzioni MFA.

Il livello MFA definito dall'account figlio si applica se l'impostazione gestita dall'azienda è meno rigorosa o rimossa. Ad esempio, l'amministratore di un account figlio di produzione potrebbe specificare un livello di MFA più rigoroso rispetto a quello definito dal modello di impostazioni gestito dall'azienda.

(Opzionale) Aggiunta delle impostazioni della sessione di accesso

Migliora la sicurezza degli account della tua azienda richiedendo agli utenti di inserire le proprie credenziali di accesso a intervalli personalizzati. È possibile selezionare il tempo che la sessione attiva di un utente può durare prima che debba inserire nuovamente le proprie credenziali. È inoltre possibile scegliere la durata dell'inattività di un utente prima che venga disconnesso dalla sessione e gli venga richiesto di inserire nuovamente le proprie credenziali.

Se un utente è membro di più account, alla sua sessione viene applicato il valore più basso di ciascuna impostazione. Ad esempio, un utente è membro di due account: dev account e prod account. Se prod account ha un timeout di inattività di 15 minuti e dev account ha un timeout di inattività di 30 minuti, il timeout di inattività di 15 minuti viene applicato a entrambi gli account.

Imposta la durata delle sessioni attive

Una sessione attiva è il tempo in cui un utente lavora ininterrottamente nel proprio account. Il modo in cui viene misurata una sessione attiva dipende anche dalla durata della sessione, dalla disconnessione a causa del limite di inattività. Ad esempio, se si imposta la durata di 2 ore, l'utente dovrà interagire con l'account una volta entro queste 2 ore.

Per definire le impostazioni delle sessioni attive, completare i seguenti passaggi:

  1. Fare clic su Gestisci > Accesso (IAM) > Modelli > Impostazioni nella console di amministrazione ( IBM Cloud® ).
  2. Seleziona il modello delle impostazioni.
  3. Fare clic su Sessioni di accesso.
  4. Vai alla sezione Sessione di accesso, fai clic sull' icona Modifica Modifica dal riquadro Sessioni attive.
  5. Immettere il limite di tempo. La durata massima di una sessione è di 720 ore.
  6. Fai clic su Save.

Rivedere il modello delle impostazioni

Rivedere il modello delle impostazioni e confermarlo in modo che non possano essere apportate ulteriori modifiche alla versione. In questo modo, l'amministratore dell'assegnazione dei modelli può essere sicuro di assegnare la versione quando confermi che è pronta.

  1. Fare clic su Panoramica > Revisione.
  2. Verificare che il modello di impostazioni sia configurato secondo le proprie aspettative.
  3. Fare clic sulla casella di controllo per confermare che non è possibile modificare la versione.
  4. Fai clic su Commit.

Assegnazione di un modello di impostazioni agli account figlio

All’interno della propria azienda è possibile assegnare le versioni di un solo modello di impostazioni alla volta. È possibile assegnare diverse versioni dello stesso modello di impostazioni, ma non è possibile utilizzare più modelli di impostazioni in un'azienda. Potresti voler assegnare versioni diverse ad account con requisiti diversi, come account di produzione e di prova.

Non è possibile assegnare un modello IAM all'account aziendale, ma solo agli account secondari.

Per assegnare un modello di impostazioni, procedere come segue:

  1. Fare clic su Gestisci > Accesso (IAM) > Modelli > Impostazioni nella console di amministrazione ( IBM Cloud® ).
  2. Seleziona il modello delle impostazioni.
  3. Fare clic su Assegna account.
  4. Seleziona account specifici o interi gruppi di account nella tua azienda.

Quando si seleziona un gruppo di account, tutti gli account futuri aggiunti a tale gruppo erediteranno le impostazioni assegnate.

  1. Fare clic su Assegna account.

Se un'operazione non riesce, fare clic su Riprova.

Creazione di una nuova versione

Per creare una nuova versione di un modello di impostazioni, completare i seguenti passaggi:

  1. Fare clic su Gestisci > Accesso (IAM) > Modelli > Impostazioni nella console di amministrazione ( IBM Cloud® ).

  2. Seleziona il modello delle impostazioni.

  3. Fare clic sull'icona Nuova versione. Icona Nuova versione..

  4. Inserisci un nuovo nome e una nuova descrizione per il modello o mantieni quelli che stai già utilizzando.

    L'inserimento di un nuovo nome modello aggiorna il nome modello per questa versione e per tutte le versioni precedenti. La descrizione del modello è memorizzata separatamente per ogni versione.

  5. Seleziona le impostazioni che desideri trasferire alla nuova versione.

  6. Fai clic su Crea.

  7. Apportare eventuali altre modifiche alla configurazione.

  8. Fare clic su Rivedi e confermare la nuova versione. Per ulteriori informazioni, vedere Revisione del modello del gruppo di accesso.

Per assegnare una nuova versione di un modello di impostazioni, completare i seguenti passaggi:

  1. Vai a Gestisci > Accesso (IAM) > Modelli nella console di amministrazione ( IBM Cloud ).
  2. Fai clic su Settings.
  3. Fare clic sull'ic ona Espandi tabella Espandi tabella sul modello con cui si desidera lavorare.
  4. Selezionare la versione assegnata agli account figlio.
  5. Fare clic su Assegnazioni.
  6. Fare clic su Aggiorna nell'account o nell'assegnazione del gruppo di account in cui si desidera assegnare una versione diversa.
  7. Fai clic su " Seleziona una versione ".
    1. Selezionare la versione che si desidera sostituire alla versione attuale.
  8. Fai clic su Aggiorna.
  9. Ripetere questi passaggi per ogni account o gruppo di account a cui si desidera assegnare una versione diversa.

La nuova versione del modello che assegni sostituisce la vecchia versione. Ulteriori informazioni su Assegnazione di una nuova versione.

Rimozione di un incarico

È possibile rimuovere un'assegnazione di modello da un account o da un gruppo di account a cui è assegnato il modello. Potresti volerlo fare se il modello non funziona come previsto. Quando si rimuove un modello assegnato da un account, per impostazione predefinita viene ripristinata la versione precedente del modello. Se l'assegnazione rimossa è per la prima o unica versione di un modello, le preferenze di impostazione assegnate nell'account figlio vengono rimosse.

Per rimuovere un incarico, segui questi passaggi:

  1. Fare clic su Gestisci > Accesso (IAM) > Modelli > Impostazioni nella console di amministrazione ( IBM Cloud® ).
  2. Fare clic su Impostazioni e selezionare il modello di impostazioni.
  3. Fare clic su Assegnazioni.
  4. Fare clic sull 'icona Azioni Icona Azioni > Rimuovi sull'account o sul gruppo di account in cui si desidera rimuovere l'assegnazione.

Quando si rimuovono tutte le assegnazioni dei modelli di impostazioni, viene ripristinata l'impostazione definita a livello di account figlio.

Eliminazione di un modello di impostazioni

Prima di poter eliminare un modello di impostazioni, è necessario rimuovere tutte le assegnazioni per tutte le versioni del modello. L'eliminazione di un modello di impostazioni comporta l'eliminazione di tutte le versioni.

Per eliminare un modello di impostazioni, procedere come segue:

  1. Fare clic su Gestisci > Accesso (IAM) > Modelli > Impostazioni nella console di amministrazione ( IBM Cloud® ).
  2. Fai clic su Settings.
  3. Fare clic sull'icona Azioni Icona Azioni sul modello di impostazioni che si desidera eliminare.
  4. Fare clic su Elimina modello.
  5. Conferma che desideri eliminare il modello di impostazioni.

Eliminazione di una versione

È inoltre possibile eliminare una versione specifica completando i seguenti passaggi: Per eliminare un modello di impostazioni, procedere come segue:

  1. Fare clic su Gestisci > Accesso (IAM) > Modelli > Impostazioni nella console di amministrazione ( IBM Cloud® ).
  2. Fai clic su Settings.
  3. Fare clic sull'ic ona Espandi tabella Espandi tabella sul modello con cui si desidera lavorare.
  4. Fare clic sull'icona Azioni Icona Azioni sulla versione che si desidera eliminare.
  5. Fare clic su Elimina versione.
  6. Conferma che desideri eliminare la versione.

Creazione di un modello di impostazioni tramite la CLI

Considera l'utilizzo di modelli di impostazioni quando hai molti account figlio che richiedono le stesse impostazioni IAM. Ad esempio, la tua organizzazione potrebbe avere standard interni o richiedere la conformità alle normative di settore.

Per creare un modello di impostazioni tramite la CLI, procedere come segue:

  1. Creare un file JSON che configuri la definizione del modello delle impostazioni. Per ulteriori informazioni sugli attributi che è possibile utilizzare nel file JSON, consultare l'API di identità IAM.

    Il seguente file JSON di esempio specifica l' account_id e dell'account aziendale, l' name e del modello e l' account_settings. La creazione di chiavi API è riservata agli utenti con il ruolo API Key Creator sul servizio di identità. La creazione di ID di servizio non è limitata, quindi tutti i membri possono creare ID di servizio negli account a cui è assegnato il modello di impostazioni. Il numero massimo di sessioni per identità è impostato su 5 e l'autenticazione a più fattori è impostata su LEVEL3, che richiede a tutti gli utenti di utilizzare l'autenticazione a più fattori 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. Creare il modello delle impostazioni utilizzando il comando " account-settings-template-create " come mostrato nella seguente richiesta di esempio:

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

Aggiornamento di un modello di impostazioni utilizzando la CLI

È possibile aggiornare un modello di impostazioni in qualsiasi momento prima di confermarlo. Per aggiornare una versione specifica di un modello di impostazioni dell'account, completare i seguenti passaggi:

  1. Aggiorna il tuo file JSON con la nuova configurazione del modello di impostazioni. Per ulteriori informazioni sugli attributi che è possibile utilizzare nel file JSON, consultare l'API di identità IAM.

    Il seguente file JSON di esempio specifica l' account_id e dell'account aziendale, l' name e del modello e l' account_settings. La nuova configurazione reimposta MFA su " NONE " e rimuove le altre impostazioni.

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

    Quando si aggiorna il nome del modello, questo aggiorna il nome per ogni versione.

  2. Per aggiornare una versione specifica di un modello di impostazioni account, utilizzare il comando account-settings-template-version-update come mostrato nella seguente richiesta di esempio:

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

Impegno di un modello di impostazioni

Rivedere il modello delle impostazioni e confermarlo in modo che non possano essere apportate ulteriori modifiche alla versione. L'impegno di una versione è un passo necessario prima di poterla assegnare agli account figlio. In questo modo, l'amministratore dell'assegnazione dei modelli può essere sicuro di assegnare la versione solo quando hai confermato che è pronta.

La seguente richiesta di esempio esegue la versione 1 del modello di impostazioni denominato AccountSettingsTemplateUpdated:

ibmcloud iam account-settings-template-commit AccountSettingsTemplateUpdated 1

Assegnazione di un modello di impostazioni agli account secondari utilizzando la CLI

All’interno della propria azienda è possibile assegnare le versioni di un solo modello di impostazioni alla volta. È possibile assegnare diverse versioni dello stesso modello di impostazioni, ma non è possibile utilizzare più modelli di impostazioni in un'azienda. Potresti voler assegnare versioni diverse ad account con requisiti diversi, come account di produzione e di prova.

Non è possibile assegnare un modello IAM all'account aziendale, ma solo agli account secondari.

Per creare un'assegnazione per un modello di impostazioni account, completare i seguenti passaggi:

  1. Elenca i modelli di impostazioni nel tuo account aziendale e annota il nome del modello e il numero di versione per il modello di impostazioni che desideri assegnare agli account secondari:

    ibmcloud iam account-settings-templates
    
  2. Assegni il modello a un Account o a un AccountGroup utilizzando il comando account-settings-assignment-create.

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

Se un'operazione non riesce, utilizzare il metodo " account-settings-assigment-update " per riprovare.

Creazione di una nuova versione tramite la CLI

Creare una nuova versione di un modello di impostazioni dell'account quando è necessario apportare aggiornamenti a una versione impegnata. Per creare una nuova versione, segui questi passaggi.

  1. Aggiorna il tuo file JSON con la nuova configurazione del modello di impostazioni. Per ulteriori informazioni sugli attributi che è possibile utilizzare nel file JSON, consultare l'API di identità IAM.

  2. Utilizzare il metodo " account-settings-template-version-create " per creare una nuova versione. La seguente richiesta di esempio crea una nuova versione del modello AccountSettingsUpdated.

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

Aggiornamento di un incarico utilizzando la CLI

Aggiorna un'assegnazione per riprovare un'assegnazione non riuscita o migrare a una nuova versione.

La nuova versione del modello che assegni sostituisce la vecchia versione. Ulteriori informazioni su Assegnazione di una nuova versione.

  1. Elenca gli incarichi nel conto utilizzando il metodo dell' account-settings-assignments. Prendi nota dell' ASSIGNMENT_ID e per l'incarico che vuoi aggiornare.

  2. Aggiornare l'assegnazione delle impostazioni dell'account. Se si sta riprovando un incarico, utilizzare lo stesso numero di versione. La seguente richiesta di esempio migra l'assegnazione AccountSettingsAssignment-63d65ed159ff463b8ec09ea77d22a05b alla versione 2.

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

Rimuovere un'assegnazione utilizzando la CLI

È possibile rimuovere un'assegnazione di modello da un account o da un gruppo di account a cui è assegnato il modello. Potresti volerlo fare se il modello non funziona come previsto. Quando si rimuove un modello assegnato da un account, per impostazione predefinita viene ripristinata la versione precedente del modello. Se l'assegnazione rimossa è per la prima o unica versione di un modello, le preferenze delle impostazioni gestite dall'azienda nell'account figlio vengono rimosse.

Per rimuovere un incarico, segui questi passaggi:

  1. Elenca gli incarichi nel conto utilizzando il metodo dell' account-settings-assignments. Prendi nota dell' ASSIGNMENT_ID e per l'assegnazione che vuoi rimuovere.

  2. Rimuovere l'assegnazione utilizzando il metodo " account-settings-assigment-delete ". La seguente richiesta di esempio rimuove l'assegnazione AccountSettingsAssignment-63d65ed159ff463b8ec09ea77d22a05b.

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

Eliminazione di una versione tramite la CLI

Prima di poter eliminare una versione del modello di impostazioni, è necessario rimuovere tutte le assegnazioni per quella versione del modello. Eliminare una versione specifica completando i seguenti passaggi:

  1. Elenca i modelli di impostazioni nel tuo account aziendale e annota il nome del modello e il numero di versione per la versione che desideri eliminare:

    ibmcloud iam account-settings-templates
    
  2. Elimina la versione:

    ibmcloud iam account-settings-template-delete AccountSettingsTemplateUpdated 2
    
  3. Per eliminare tutte le versioni, ripetere questi passaggi. Assicurati di rimuovere prima le assegnazioni per ogni versione.

Creazione di un modello di impostazioni utilizzando l'API

Considera l'utilizzo di modelli di impostazioni quando hai molti account figlio che richiedono le stesse impostazioni IAM. Ad esempio, la tua organizzazione potrebbe avere standard interni o richiedere la conformità alle normative di settore.

Per creare un modello di impostazioni tramite l'API, procedere come segue:

  1. Configurare le impostazioni di definizione del modello. Per ulteriori informazioni sugli attributi che è possibile utilizzare nel file JSON, consultare l'API di identità IAM.

    Il seguente file JSON di esempio specifica l' account_id e dell'account aziendale, l' name e del modello e l' account_settings. La creazione di chiavi API è riservata agli utenti con il ruolo API Key Creator sul servizio di identità. La creazione di ID di servizio non è limitata, quindi tutti i membri possono creare ID di servizio negli account a cui è assegnato il modello di impostazioni. Il numero massimo di sessioni per identità è impostato su 5 e l'autenticazione a più fattori è impostata su LEVEL3, che richiede a tutti gli utenti di utilizzare l'autenticazione a più fattori 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")
    

Aggiornamento di un modello di impostazioni utilizzando l'API

È possibile aggiornare un modello di impostazioni in qualsiasi momento prima di confermarlo. Per aggiornare una versione specifica di un modello di impostazioni dell'account, completare i seguenti passaggi:

  1. Elenca i modelli di impostazioni nel tuo account aziendale e annota l'ID dell' AccountSettingsTemplate e e l'ETag nella risposta per la versione del modello che desideri aggiornare.

    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. Aggiorna la definizione del modello delle impostazioni.

    Quando si aggiorna il nome del modello, questo aggiorna il nome per ogni versione.

    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")
    

Impegnare un modello di impostazioni utilizzando l'API

Rivedere il modello delle impostazioni e confermarlo in modo che non possano essere apportate ulteriori modifiche alla versione. L'impegno di una versione è un passo necessario prima di poterla assegnare agli account figlio. In questo modo, l'amministratore dell'assegnazione dei modelli può essere sicuro di assegnare la versione solo quando hai confermato che è pronta.

  1. Ottieni la versione di un modello di profilo attendibile che desideri esaminare e confermare.

    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. Rivedere la risposta per confermare che è pronta per l'impegno.

  3. Impegna la versione del modello di profilo attendibile.

    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)
    

Assegnazione di un modello di impostazioni agli account secondari utilizzando l'API

All’interno della propria azienda è possibile assegnare le versioni di un solo modello di impostazioni alla volta. È possibile assegnare diverse versioni dello stesso modello di impostazioni, ma non è possibile utilizzare più modelli di impostazioni in un'azienda. Potresti voler assegnare versioni diverse ad account con requisiti diversi, come account di produzione e di prova.

Non è possibile assegnare un modello IAM all'account aziendale, ma solo agli account secondari.

Per creare un'assegnazione per un modello di impostazioni account, completare i seguenti passaggi:

  1. Elenca i modelli di impostazioni nel tuo account aziendale e annota l'ID AccountSettingsTemplate e l'ETag nella risposta per la versione del modello che desideri assegnare agli account secondari.

    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. Assegna il modello di impostazioni a un Account o 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
    

Se un'operazione non riesce, utilizzare il metodo " account-settings-assigment-update " per riprovare.

Creazione di una nuova versione utilizzando l'API

Se si desidera apportare modifiche a un modello di impostazioni che è stato confermato o assegnato, creare una nuova versione.

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

Salvare l'ID dell' AccountSettingsTemplate e e la versione della nuova versione da utilizzare nelle chiamate successive.

Aggiornamento di un incarico utilizzando l'API

Aggiorna un incarico per migrare a una nuova versione o riprova un incarico non riuscito.

La nuova versione del modello che assegni sostituisce la vecchia versione. Ulteriori informazioni su Assegnazione di una nuova versione.

  1. Elenca le assegnazioni dei modelli di impostazioni nel tuo account aziendale e annota l'ID assegnazione, l'ETag e la versione per l'assegnazione che desideri aggiornare:
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. Aggiornare l'assegnazione delle impostazioni dell'account. Se si sta riprovando un incarico, utilizzare lo stesso numero di versione.
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))

Rimuovere un incarico utilizzando l'API

È possibile rimuovere un'assegnazione di modello da un account o da un gruppo di account a cui è assegnato il modello. Potresti volerlo fare se il modello non funziona come previsto. Quando si rimuove un modello assegnato da un account, per impostazione predefinita viene ripristinata la versione precedente del modello. Se l'assegnazione rimossa è per la prima o unica versione di un modello, le preferenze delle impostazioni gestite dall'azienda nell'account figlio vengono rimosse.

Per rimuovere un incarico, segui questi passaggi:

  1. Elenca gli incarichi nell'account e annota l'ID dell'incarico che desideri rimuovere.
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. Rimuovi l'assegnazione.

La rimozione di un incarico potrebbe rendere attivo un incarico precedente. Per ulteriori informazioni, vedere Lavorare con le versioni modello.

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)

Eliminazione di una versione utilizzando l'API

Prima di poter eliminare una versione del modello di impostazioni, è necessario rimuovere tutte le assegnazioni per quella versione del modello. Eliminare una versione specifica completando i seguenti passaggi:

  1. Elenca i modelli di impostazioni nel tuo account aziendale e annota l'ID del modello di impostazioni e il numero di versione per la versione che desideri eliminare:
   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. Elimina la versione:

Eliminazione di tutte le versioni utilizzando l'API

Assicurati di rimuovere prima le assegnazioni per ogni versione.

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)

Limitazioni del modello di impostazioni

In un'azienda può essere assegnato un solo modello di impostazioni. È possibile assegnare più versioni del modello, ma non modelli diversi.