Informazioni sui cookie del presente sito Per il corretto funzionamento, i nostri siti Web richiedono alcuni cookie (richiesto). Inoltre, con il suo consenso, potrebbero essere utilizzati altri cookie per l'analisi dell'utilizzo del sito, per migliorare l'esperienza utente e per scopi pubblicitari. Per ulteriori informazioni, consultare le. Visitando il nostro sito web, accettate il trattamento delle informazioni da parte nostra come descritto nelladichiarazione sulla privacy di IBM. Per consentire una corretta navigazione, le preferenze per i cookie dell'utente verranno condivise sui domini Web IBM qui elencati.
Gestione dell'accesso per IBM Cloudant
IBM Cloud® Identity and Access Management fornisce un approccio unificato alla gestione di identità utente, servizi e controllo dell'accesso.
Il seguente testo descrive l'integrazione di IBM® Cloudant® for IBM Cloud® con IBM Cloud Identity and Access Management. Vengono discussi i seguenti argomenti:
- Differenze tra i controlli di accesso legacy IBM Cloudant e i controlli di accesso IAM IBM Cloud.
- Vantaggi e svantaggi di ciascuno per aiutarti a decidere quale utilizzare.
- Come utilizzare IAM all'interno delle librerie client di IBM Cloudant utilizzando le chiamate HTTP.
- Descrizione dei ruoli e delle azioni IAM disponibili in IBM Cloudant.
Per ulteriori informazioni, vedi una panoramica di IAM che include i seguenti argomenti:
- Gestire ID utente e servizio.
- Gestire le credenziali disponibili.
- Utilizzare le politiche di accesso IAM che consentono e revocano l'accesso alle istanze del servizio IBM Cloudant.
Differenze tra i controlli di accesso legacy IBM Cloudant e i controlli di accesso IAM
La seguente sezione fornisce una breve panoramica delle differenze tra IBM Cloudant Controlli dell'accesso legacy e meccanismi di controllo dell'accesso di IBM Cloud IAM.
IBM Cloud Identity and Access Management
- Gestione dell'accesso gestita centralmente in tutto IBM Cloud.
- Consentire a un utente o a un servizio di accedere a molte risorse diverse utilizzando lo stesso set di credenziali (ad esempio, stesso nome utente e password o chiave API IAM).
- Alle chiavi API IAM è possibile concedere l'accesso alle funzioni di gestione dell'account, come la creazione di nuovi database.
Controlli di accesso legacy IBM Cloudant
- Unico per IBM Cloudant.
- L'accesso a ogni istanza del servizio richiede una sua serie di credenziali.
- Utilizza l'autenticazione di base HTTP con credenziali che non sono associate a un singolo utente o servizio.
- IBM Cloudant Le chiavi API possono concedere autorizzazioni solo a livello di database.
Note sulle chiavi API
In questo documento, ovunque siano menzionate le chiavi API, ci si riferisce alle chiavi API IAM. Anche i controlli di accesso legacy IBM Cloudant hanno un concetto di chiavi API e qualsiasi discussione sulle credenziali legacy o sulle combinazioni di nome utente e password IBM Cloudant include anche le chiavi API IBM Cloudant.
Abilitazione di IAM con IBM Cloudant
Per tutte le istanze del servizio IBM Cloudant di cui è stato eseguito il provisioning a luglio del 2018 o successivamente. il provisioning viene eseguito in gruppi di risorse e sono abilitate con IBM Cloud IAM. Facoltativamente, puoi scegliere di abilitare anche il meccanismo di autenticazione legacy IBM Cloudant. Quando esegui il provisioning di una nuova istanza IBM Cloudant dal catalogo IBM Cloud, seleziona uno dei seguenti metodi di autenticazione.
- Utilizza sia le credenziali legacy che IAM
- Questa modalità significa che è possibile utilizzare le credenziali IAM e legacy per accedere all'account. In particolare, entrambe le serie di credenziali IAM e Legacy sono fornite a tutte le applicazioni associate alle credenziali di account e servizio generate.
- Utilizza solo IAM
- Questa modalità significa che vengono fornite solo credenziali IAM utilizzando il binding del servizio e la generazione delle credenziali.
Quando utilizzi ruoli IAM diversi da Manager
, come ad esempio Reader
, Writer
, Monitor
o Checkpointer
, devi utilizzare Utilizza solo IAM per evitare di
fornire agli utenti le credenziali legacy che includono maggiori autorizzazioni di accesso.
Implementazione delle politiche
I criteri IAM vengono applicati in modo gerarchico, dal livello di accesso più ampio a quello più limitato, con i criteri più permissivi che prevalgono su quelli meno permissivi. Ad esempio, se un utente ha sia il ruolo di accesso al servizio
Writer
che Reader
su un database, la policy che concede il ruolo Reader
viene ignorata.
Ciò vale anche per le istanze di servizio e le politiche a livello di database.
- Se un utente ha una policy che gli garantisce il ruolo di
Writer
su un'istanza di servizio e il ruolo diReader
su un singolo database, la policy a livello di database viene ignorata. - Se un utente ha una policy che gli garantisce il ruolo di
Reader
su un'istanza di servizio e il ruolo diWriter
su un singolo database, entrambe le policy vengono applicate e il ruolo diWriter
, più permissivo, avrà la precedenza per il singolo database.
Se è necessario limitare l'accesso a un singolo database (o a un insieme di database), assicurarsi che l'ID utente o di servizio non abbia altre policy a livello di istanza utilizzando la console o la CLI.
Per saperne di più, consultate le Migliori pratiche per l'organizzazione delle risorse e l'assegnazione dell'accesso.
IBM Cloudant Chiavi API e utilizzo solo IAM
L'utilizzo di chiavi API IBM Cloudant insieme a IAM è possibile ma non è consigliato. Questo consiglio è fatto perché IBM Cloudant Le autorizzazioni e le chiavi API non sono visibili o gestibili utilizzando l'interfaccia della politica IAM, rendendo impossibile la gestione dell'accesso olistico.
La scelta tra Usa solo IAM o Usa sia credenziali legacy che IAM influisce sui seguenti fattori:
- Se le credenziali a livello di account IBM Cloudant legacy sono disponibili per gestire i database e altre azioni a livello di account.
- Lo stile delle credenziali fornite durante la generazione delle credenziali del servizio.
In particolare, è ancora possibile utilizzare le chiavi API IBM Cloudant per gestire l'accesso al database. Queste credenziali devono essere generate e configurate utilizzando l'API HTTP.
Provisioning utilizzando la riga di comando
Quando si esegue il provisioning di una nuova istanza di IBM Cloudant dalla riga di comando, fornire un'opzione allo strumento ibmcloud
utilizzando il parametro -p
per abilitare o disabilitare le credenziali legacy
per un account L'opzione viene passata in formato JSON ed è denominata legacyCredentials
.
Per impostare un'istanza come Usa solo IAM (consigliato), eseguire il seguente comando:
ibmcloud resource service-instance-create "Instance Name" \
cloudantnosqldb Standard us-south \
-p {"legacyCredentials": false}
Quando utilizzi ruoli IAM diversi da Manager
, come ad esempio Reader
, Writer
, Monitor
o Checkpointer
, devi utilizzare Utilizza solo IAM per evitare
di fornire agli utenti le credenziali legacy che includono maggiori autorizzazioni di accesso.
Per creare un'istanza come Usa sia le credenziali legacy che IAM, eseguire il seguente comando:
ibmcloud resource service-instance-create "Instance Name" \
cloudantnosqldb Standard us-south \
-p {"legacyCredentials": true}
Esempi JSON di credenziali del servizio per ogni opzione
La scelta tra Utilizza solo IAM e Utilizza sia credenziali legacy che controllo di accesso IAM influisce sul modo in cui le credenziali vengono distribuite all'applicazione quando si associano e si generano le credenziali del servizio. Quando generi le credenziali all'interno del IBM Cloud Interfaccia IAM, le chiavi API vengono visualizzate in tale interfaccia quando vengono generate.
Puoi anche generare le credenziali dalla sezione Credenziali del servizio di una istanza del servizio. Generare le credenziali del servizio in questo modo crea un blob JSON di credenziali del servizio che può essere incollato nelle applicazioni con tutti i dettagli necessari per accedere all'istanza del servizio.
Successivamente, puoi vedere come appare la credenziale di servizio JSON e cosa significa ogni valore.
Quando si seleziona Usa solo IAM, le credenziali di servizio generate contengono solo valori IAM e hanno l'aspetto dell'esempio seguente.
{
"apikey": "MxVp86XHkU82Wc97tdvDF8qM8B0Xdit2RqR1mGfVXPWz",
"iam_apikey_description": "Auto generated apikey during resource-key [...]",
"iam_apikey_name": "auto-generated-apikey-050d21b5-5f[...]",
"iam_role_crn": "crn:v1:bluemix:public:iam::::serviceRole:Manager",
"iam_serviceid_crn": "crn:v1:staging:public:iam-identity::[...]",
"url": "https://76838001-b883-444d-90d0-46f89e942a15-bluemix.cloudant.com",
"username": "76838001-b883-444d-90d0-46f89e942a15-bluemix"
}
Ogni valore nell'esempio JSON precedente deve essere interpretato utilizzando le seguenti definizioni:
apikey
- Chiave API IAM.
iam_apikey_description
- Descrizione della chiave API IAM.
iam_apikey_name
- ID della chiave API IAM.
iam_role_crn
- Il ruolo IAM che ha la chiave API IAM.
iam_serviceid_crn
- Il CRN dell'ID servizio.
url
- IBM Cloudant URL del servizio.
username
- Il nome account interno IBM Cloudant.
Quando si seleziona Usa sia credenziali legacy che IAM, le credenziali di servizio generate contengono sia credenziali IAM che legacy e assomigliano ai valori dell'esempio seguente.
{
"apikey": "MxVp86XHkU82Wc97tdvDF8qM8B0Xdit2RqR1mGfVXPWz",
"host": "76838001-b883-444d-90d0-46f89e942a15-bluemix.cloudant.com",
"iam_apikey_description": "Auto generated apikey during resource-key [...]",
"iam_apikey_name": "auto-generated-apikey-050d21b5-5f[...]",
"iam_role_crn": "crn:v1:bluemix:public:iam::::serviceRole:Manager",
"iam_serviceid_crn": "crn:v1:staging:public:iam-identity::[...]",
"password": "8fb6a16b48903e87b769e7f4968521e85c2394ed8f0e69b2769e56dcb27d2e76",
"port": 443,
"url": "https://<username>:<password>@76838001-b883-444d-90d0-46f89e942a15-bluemix.cloudant.com",
"username": "apikey-v2-58B528DF5397465BB6673E1B79482A8C"
}
Ogni valore nell'esempio JSON precedente deve essere interpretato utilizzando le seguenti definizioni:
apikey
- Chiave API IAM.
host
- Nome host del servizio IBM Cloudant.
iam_apikey_description
- Descrizione della chiave API IAM.
iam_apikey_name
- ID della chiave API IAM.
iam_role_crn
- Il ruolo IAM che ha la chiave API IAM.
iam_serviceid_crn
- Il CRN dell'ID servizio.
password
- La password della credenziale legacy IBM Cloudant.
port
- Porta del servizio IBM Cloudant.
url
- IBM Cloudant URL, incluso l' IBM Cloudant embedded credenziali legacy.
username
- Il nome utente della credenziale legacy IBM Cloudant.
Tieni presente che username
e password
inclusi sono sempre equivalenti alle credenziali di IAM Manager. Pertanto, l'utilizzo di Utilizza sia le credenziali legacy che IAM non è sicuro quando viene utilizzato
con i ruoli Reader
, Writer
, Monitor
o Checkpointer
IAM.
Devo usare Usa solo IAM o Usa sia le credenziali legacy che IAM?
Se possibile, è preferibile utilizzare solo IAM. I principali vantaggi per l'utilizzo IBM Cloud IAM vengono mostrati nel seguente elenco:
- gestione dell'accesso a IBM Cloudant con gli strumenti standard di IBM Cloud piuttosto che una combinazione di IBM Cloud e IBM Cloudant-gestione delle credenziali specifiche.
- Le credenziali possono essere facilmente revocate e ruotate quando utilizzi IBM Cloud IAM.
Di seguito è riportata un'ulteriore descrizione dei vantaggi e degli svantaggi di ciascun approccio.
Quando utilizzi ruoli IAM diversi da Manager
, come ad esempio Reader
, Writer
, Monitor
o Checkpointer
, devi utilizzare Utilizza solo IAM per evitare di
fornire agli utenti le credenziali legacy che includono maggiori autorizzazioni di accesso.
Vantaggi e svantaggi dei due meccanismi di controllo dell'accesso
Complessivamente, IBM Cloud IAM è il modello di autenticazione consigliato. Tuttavia, gli svantaggi principali di questo approccio sono se si dispone di un'applicazione esistente o non si è in grado di utilizzare una libreria client supportata da IBM Cloudant.
Vantaggi della modalità IAM
- Gestisci l'accesso per molti servizi utilizzando un'unica interfaccia.
- Revoca l'accesso a un utente globalmente.
- Chiavi API a livello di account che utilizzano gli ID servizio.
- Credenziali facili da ruotare.
- I log Activity Tracker acquisiscono singoli utenti e servizi.
- IAM si federa con altri sistemi di identità, come i repository LDAP aziendali.
- Autorizzazioni dettagliate (ad esempio,
Reader
,Writer
,Monitor
oCheckpointer
).
Svantaggi della modalità IAM
- Se non si utilizzano le librerie supportate da IBM Cloudant, potrebbero essere necessarie modifiche all'applicazione per utilizzare le chiavi API e i token di accesso di IAM.
- Alcuni endpoint non sono disponibili. Per ulteriori informazioni, vedi Endpoint non disponibili.
- Non è possibile specificare un database come "pubblico", ovvero che non richiede l'accesso da parte di un utente autorizzato.
Vantaggi della modalità legacy
- Nessun bisogno di modificare le applicazioni o le dipendenze di libreria client esistenti.
Svantaggi della modalità legacy
- Gestione separata delle credenziali dell' IBM Cloudant, quindi impossibile ottenere una panoramica completa di tutti gli accessi all'interno dell'interfaccia centralizzata.
Criteri IAM a livello di database
Le politiche IAM possono essere definite per limitare l'accesso a singoli database o a quelli che corrispondono a uno schema jolly.
Per puntare a un database, impostare l'attributo Tipo di risorsa su 'database
. Sono disponibili due operatori disponibili:
Operatore | Descrizione |
---|---|
string equals |
corrisponde esattamente a un nome di database codificato tramite URL. |
string matches |
corrispondenza utilizzando un carattere jolly multiplo (*), che corrisponde a qualsiasi sequenza di zero o più caratteri, un carattere jolly singolo (?), che corrisponde a qualsiasi singolo carattere, o entrambi. |
I nomi dei database devono essere codificati come URL nel campo ID risorsa del criterio, ad eccezione delle barre in avanti /
. Questo non si applica ai caratteri jolly presenti nel criterio.
Si noti che lasciando vuoti i campi Tipo di risorsa o ID risorsa si creerà una politica a livello di istanza.
Esempi
Descrizione | Attributo | Operatore | Valore |
---|---|---|---|
database denominati 'movies |
Tipo di risorsa | string equals |
database |
ID risorsa | string equals |
movies |
|
database che iniziano con 'movies |
Tipo di risorsa | string equals |
database |
ID risorsa | string matches |
movies* |
|
database denominati 'movies+new |
Tipo di risorsa | string equals |
database |
ID risorsa | string equals |
movies%2Bnew |
|
database che iniziano con 'movies+* |
Tipo di risorsa | string equals |
database |
ID risorsa | string matches |
movies%2B* |
|
database denominati 'movies/new |
Tipo di risorsa | string equals |
database |
ID risorsa | string equals |
movies/new |
Crea un lavoro di replica utilizzando solo le credenziali IAM
Segui queste istruzioni per generare chiavi API IAM, generare il token di connessione, creare il database _replicator
e creare il lavoro di replica.
Generazione delle chiavi API IAM per origine e destinazione e una per l'accesso API IBM Cloudant
In questo esercizio, vengono create le prime due chiavi API in modo che le due istanze possano comunicare tra loro durante il processo di replica. La terza chiave API è per l'utente per accedere all'API IBM Cloudant, creare il database _replicator
e quindi aggiungere il documento di replica.
Attieniti alla seguente procedura per generare chiavi API IAM e accesso API per IBM Cloudant. È necessario annotare le credenziali richieste nei seguenti passi per continuare con l'esempio.
Assicurarsi di selezionare l'istanza specificata, l'origine o la destinazione.
-
Accedi a
cloud.ibm.com
. -
Dall'elenco Risorsa, seleziona Servizi e la tua istanza di origine.
-
Fare clic su Credenziali di servizio e quindi su Nuova credenziale.
-
Denominare la nuova credenziale
replicator-source
e selezionare il ruolo Gestore. -
Fai clic su Aggiungi e prendi nota del suo
apikey
, che si trova in Visualizza credenziali nella colonna Azioni.
-
-
Ripetere i passi da 2 a 2.c. per l'istanza di destinazione.
-
Creare una credenziale denominata
replicator-target
con il ruolo Gestore. -
Prendi nota della sua chiave API IAM, che si trova in Visualizza credenziali nella colonna Azioni.
-
-
Seleziona l'istanza di origine e fai clic su Credenziali del servizio e Nuova credenziale.
-
Denominare la nuova credenziale
apiaccess
e selezionare il ruolo Gestore. -
Prendi nota della chiave API IAM effettiva in Visualizza credenziali nella colonna Azioni.
-
-
Prendere nota degli URL dell'istanza di origine e di destinazione.
A seconda del tuo flusso di lavoro, invece di creare una credenziale a livello di servizio (passo 4), puoi utilizzare una chiave API IAM personale, come descritto in Creazione di una chiave API.
Puoi anche completare questa procedura sulla riga di comando utilizzando la catena di strumenti CLIIBM Cloud.
Generazione di un token di connessione per l'autenticazione rispetto all'API di IBM Cloudant
Nel passo 4.b, hai scritto la chiave apiaccess
. Utilizzare ora tale chiave:
curl -k -X POST \
--header "Content-Type: application/x-www-form-urlencoded" \
--header "Accept: application/json" \
--data-urlencode "grant_type=urn:ibm:params:oauth:grant-type:apikey" \
--data-urlencode "apikey=aSCsx4...2lN97h_2Ts" \
"https://iam.cloud.ibm.com/identity/token"
La chiave apiaccess
restituisce le seguenti informazioni (abbreviate):
{
"access_token": "eyJraWQiOiIyMDE5MD...tIwkCO9A",
"refresh_token": "ReVbNrHo3UA38...mq67g",
"token_type": "Bearer",
"expires_in": 3600,
"expiration": 1566313064,
"scope": "ibm openid"
}
Creare una variabile di ambiente per salvare alcuni tipi utilizzando il valore sotto la chiave access_token
nei dati di risposta:
export TOK="Bearer eyJraWQiOiIyMDE5MD...tIwkCO9A"
Creazione del database _replicator
sul lato origine
L' URL è l' URL dell'istanza sorgente scritto in precedenza al punto 4.b
curl -k -X PUT \
-H"Content-type: application/json" \
-H'Authorization: '"$TOK"'' \
'https://d43caf1b-e2c8-4d3e-9b85-1d04839fa68f-bluemix.cloudant.com/_replicator'
Vedere i risultati nel seguente esempio:
{"ok": "true"}
Creazione del lavoro di replica
Creare un file denominato data.json
che contenga le seguenti informazioni. Le due chiavi sono le chiavi API di origine e di destinazione create all'inizio e gli URL delle istanze di origine e di destinazione, con i nomi database
aggiunti.
{
"source": {
"url": "https://d43caf1b-e2c8-4d3e-9b85-1d04839fa68f-bluemix.cloudant.com/source",
"auth": {
"iam": {
"api_key": "xju1...TxuS"
}
}
},
"target": {
"url": "https://dbc68dd8-f69f-4083-97dd-bf0a3e1a467a-bluemix.cloudant.com/target",
"auth": {
"iam": {
"api_key": "UElc7...QIaL01Bjn"
}
}
},
"create_target": true,
"continuous": true
}
Scrivere ora un documento di replica denominato source_dest
nel database _replicator
sull'istanza di origine.
curl -k -X PUT \
-H"Content-type: application/json" \
-H'Authorization: '"$TOK"'' \
'https://d43caf1b-e2c8-4d3e-9b85-1d04839fa68f-bluemix.cloudant.com/_replicator/source_dest' -d@data.json
Vedere i risultati nel seguente esempio:
{"ok":true,"id":"source_dest","rev":"1-89b01e42968acd5944ed657b87c49f0c"}
Rimozione delle credenziali legacy IBM Cloudant da un'istanza
IBM Cloud IAM è il modello di autenticazione consigliato. Per scopi di sicurezza, puoi richiedere di rimuovere le credenziali legacy IBM Cloudant in modo che per l'istanza possa essere utilizzata solo l'autenticazione IAM. Il processo corretto per rimuovere credenziali legacy viene mostrato nei seguenti passi:
-
Assicurarsi che l'istanza IBM Cloudant abbia l'autenticazione IAM abilitata.
-
Aggiorna la tua applicazione per utilizzare l'autenticazione IAM invece dell'autenticazione legacy IBM Cloudant.
-
Genera le nuove credenziali del servizio come necessario.
-
Apri un nuovo caso di supporto IBM Cloud che richiede la rimozione di credenziali legacy IBM Cloudant per la tua istanza. Includere il nome utente dell'istanza come mostrato nelle credenziali del servizio. Per ulteriori informazioni, vedi Individuazione delle tue credenziali del servizio.
-
Dopo che il supporto ha risposto che le credenziali legacy sono state rimosse, tutte le credenziali del servizio che sono state create prima della rimozione contengono i dettagli di nome utente e password legacy che non funzionano più. Ti consigliamo di rimuovere tali voci di credenziali del servizio.
Effettuazione di richieste alle istanze utilizzando le credenziali IAM
Ora, la seguente sezione descrive come utilizzare IBM Cloudant con istanze del servizio tramite l'autenticazione IAM. Utilizza i dettagli dagli esempi JSON delle credenziali del servizio per ogni opzione.
IBM Cloud IAM richiede che una chiave API IAM venga scambiata con un token di accesso a tempo limitato prima di effettuare una richiesta a una risorsa o a un servizio. Il token di accesso viene quindi incluso nell'intestazione HTTP Authorization
al servizio. Quando il token di accesso scade, l'applicazione che lo utilizza deve gestire l'ottenimento di un nuovo token dal servizio token IAM. Per ulteriori informazioni, consultare la documentazione Ottenere un token IAM(IBM Cloud)utilizzando una chiave API per maggiori dettagli.
Le librerie client ufficiali di IBM Cloudant gestiscono l'ottenimento di un token da una chiave API per tuo conto. È possibile accedere a IBM Cloudant direttamente utilizzando un client HTTP anziché una libreria client IBM Cloudant. Tuttavia,
devi gestire lo scambio e l'aggiornamento di un token di accesso limitato nel tempo utilizzando una chiave API IAM con il servizio token IAM. Dopo che un token scade, IBM Cloudant restituisce un codice di stato HTTP 401
.
Versioni della libreria client richieste
La connettività IAM è disponibile nell'ultima release di tutte le librerie client supportate. Per ulteriori informazioni, consultare Librerie client.
Java
Il seguente link fornisce la versione supportata più recente della libreria IBM Cloudant Java™:
Per un esempio che utilizza IBM Cloudant SDK for Java Java, consulta la documentazione API e SDK.
Node.js
Il seguente link fornisce l'ultima versione supportata della libreria IBM Cloudant Node.js:
Per un esempio che utilizza l'SDK IBM Cloudant per Node, consulta la documentazione di API e SDK.
Python
Il seguente link fornisce la versione supportata più recente della libreria IBM Cloudant Python:
Per un esempio che utilizza l'SDK IBM Cloudant per Python, consulta API and SDK documentation.
Vai
Il seguente link fornisce la versione supportata più recente della libreria Go IBM Cloudant:
Per un esempio che utilizza l'SDK for Go IBM Cloudant, consultare la documentazione API e SDK.
Accesso utilizzando il client HTTP
IBM Cloud IAM richiede che una chiave API IAM venga scambiata con un token di accesso a tempo limitato prima di effettuare una richiesta a una risorsa o a un servizio. Il token di accesso viene quindi incluso nell'intestazione HTTP Authorization
al servizio. Quando il token di accesso scade, il cliente deve gestire l'ottenimento di un nuovo token dal servizio token IAM.
Come indicato in precedenza, se utilizzi IBM Cloud IAM, devi prima scambiare una chiave API IBM per un token di accesso a tempo limitato. Successivamente, utilizzi il token per l'autenticazione rispetto all'API IBM Cloudant.
In Python, un esempio potrebbe presentarsi così:
import time
import requests
API_KEY = "MxVp86XHkU82Wc97tdvDF8qM8B0Xdit2RqR1mGfVXPWz"
ACCOUNT = "76838001-b883-444d-90d0-46f89e942a15-bluemix"
def get_access_token(api_key):
"""Retrieve an access token from the IAM token service."""
token_response = requests.post(
"https://iam.cloud.ibm.com/identity/token",
data={
"grant_type": "urn:ibm:params:oauth:grant-type:apikey",
"response_type": "cloud_iam",
"apikey": api_key
},
headers={
"Accept": "application/json"
}
)
if token_response.status_code == 200:
print "Got access token from IAM"
return token_response.json()['access_token']
else:
print token_response.status_code, token_response.json()
return None
def main(api_key, account):
access_token = None
while True:
if not access_token:
access_token = get_access_token(api_key)
if access_token:
response = requests.get(
"https://{0}.cloudant.com/_all_dbs".format(account),
headers={
"Accept": "application/json",
"Authorization": "Bearer {0}".format(access_token)
}
)
print "Got Cloudant response, status code", response.status_code
if response.status_code == 401:
print "Token has expired."
access_token = None
time.sleep(1)
if __name__ == "__main__":
main(API_KEY, ACCOUNT)
Utilizzo di IAM IP allowlisting con Cloudant
Puoi abilitare le limitazioni di accesso agli indirizzi IP IAM quando stai utilizzando IBM Cloudant.
Per abilitare le restrizioni di accesso all'indirizzo IP IAM, devi assicurarti che il servizio Cloud Identity and Access Management (IAM) IP allowlist sia configurato in modo tale che il servizio IBM Cloudant possa ancora funzionare. IAM viene utilizzato da IBM Cloudant quando si autenticano richieste all'API IBM Cloudant che passano le credenziali IAM e quando si eseguono le repliche configurate per l'autenticazione utilizzando le chiavi API IAM.
I token IAM possono essere validi per fino a 60 minuti. Ciò significa che le modifiche all'IP IAM allowlisting potrebbero non avere effetto completo fino a quando questo periodo di convalida non è scaduto, poiché allowlisting viene applicato solo al momento della creazione del token.
Creazione di una zona di rete
Per aggiungere IBM Cloudant all'elenco di accesso IAM, devi prima creare una zona di rete che includa il servizio IBM Cloudant.
Per creare una zona di rete, completare i seguenti passaggi.
- Nella console IBM Cloud, fai clic su Gestisci > Limitazioni basate sul contesto e seleziona Network zones.
- Fai clic su Crea.
- Immettere un nome univoco (ad esempio,
cloudant-network
) e, facoltativamente, una descrizione. - In
Reference a service
, selezionare il tipo di servizioIAM Services
e il servizioIBM Cloudant
. Fare clic su Aggiungi per associare gli indirizzi IPIBM Cloudant
alla propria area di rete. - Fare clic su Avanti per esaminare la zona di rete.
- Fai clic su Crea.
Riferimento alla zona di rete nell'elenco IP IAM consentiti
La Zona di rete creata in precedenza, denominata cloudant-network
, può ora essere utilizzata nel tuo
IAM IP allowlist.
- Nella console IBM Cloud, fai clic su Gestisci > Accesso (IAM) e seleziona Impostazioni.
- Dalla sezione Account, abilitare l'impostazione Accesso indirizzo IP.
- Nel campo
Allowed IP addresses
, aggiungere il nome della zona di rete creata in precedenza (ad esempiocloudant-network
). - Fare clic su Salva.
Ruoli e azioni
Le seguenti tabelle includono un elenco completo delle azioni e dei ruoli IAM di IBM Cloudante un'associazione di quali azioni sono consentite per ogni ruolo di sistema IAM.
Ruoli IBM Cloudant
La seguente tabella elenca i ruoli del servizio IAM disponibili per IBM Cloudant e una breve descrizione di ciascuno.
Ruolo | Descrizione |
---|---|
Manager |
Include la possibilità di accedere a tutti gli endpoint ed eseguire tutte le funzioni amministrative su un'istanza, ad esempio la creazione di database, la modifica della capacità, la lettura e la scrittura di dati e indici e l'accesso al dashboard. |
Writer |
Include la possibilità di leggere e scrivere in tutti i database e documenti, ma non è possibile creare indici. |
Reader |
Include la possibilità di leggere tutti i database e i documenti, ma non di scrivere nuovi documenti o creare indici. |
Monitor |
Include la possibilità di leggere gli endpoint di monitoraggio, come gli endpoint _active_tasks e di replica _scheduler . |
Checkpointer |
Include la possibilità di scrivere documenti checkpointer _local di replica. Richiesto sui database di origine durante la replica. |
Il Gestore è comprensivo di tutte le azioni di Lettore e Scrittore e il Scrittore è comprensivo di tutte le azioni di Lettore.
Azioni di IBM Cloudant
La tabella seguente descrive le azioni e i ruoli IAM disponibili. Per l'autorizzazione dettagliata, è possibile utilizzare i ruoli di Manager
, Reader
, Writer
, Monitor
o Checkpointer
.
Quando utilizzi ruoli IAM diversi da Manager
, come ad esempio Reader
, Writer
, Monitor
o Checkpointer
, devi utilizzare Utilizza solo IAM per evitare
di fornire agli utenti le credenziali legacy che includono maggiori autorizzazioni di accesso.
Metodo | Endpoint | Nome azione |
---|---|---|
GET/PUT |
/_api/v2/db/<path:db>/_security |
cloudantnosqldb.sapi.db-security |
GET |
/_api/v2/user/capacity/throughput |
cloudantnosqldb.capacity-throughput.read |
PUT |
/_api/v2/user/capacity/throughput |
cloudantnosqldb.capacity-throughput.write |
GET |
/_api/v2/user/current/throughput |
cloudantnosqldb.current-throughput.read |
GET |
/_api/v2/user/capacity/databases |
cloudantnosqldb.account-capacity-dbs.read |
GET |
/_api/v2/user/current/databases |
cloudantnosqldb.account-current-dbs.read |
GET |
/_api/v2/user/activity_tracker/events |
cloudantnosqldb.activity-tracker-event-types.read |
POST |
/_api/v2/user/activity_tracker/events |
cloudantnosqldb.activity-tracker-event-types.write |
POST |
/_api/v2/api_keys |
cloudantnosqldb.sapi.apikeys |
GET/POST |
/_api/v2/user/config/cors/ |
cloudantnosqldb.sapi.usercors |
GET/PUT |
/_api/v2/user/plan |
cloudantnosqldb.sapi.userplan |
GET |
/_api/v2/user/ccm_diagnostics |
cloudantnosqldb.sapi.userccmdiagnostics |
GET |
/_api/v2/user/last_activity |
cloudantnosqldb.sapi.lastactivity |
GET |
/_api/v2/support/tickets/$CASEID/files/$ATTACHMENTID |
cloudantnosqldb.sapi.supportattachments |
GET/POST |
/_api/v2/support/tickets |
cloudantnosqldb.sapi.supporttickets |
GET/PUT/DELETE |
/_api/v2/support/tickets/$CASEID |
cloudantnosqldb.sapi.supporttickets |
GET |
/_api/v2/user |
cloudantnosqldb.sapi.userinfo |
GET |
/_api/v2/usage/data_volume e /_api/v2/usage/$YEAR/$MONTH |
cloudantnosqldb.sapi.usage-data-volume |
GET/HEAD |
/ | cloudantnosqldb.account-meta-info.read |
GET/HEAD |
/_active_tasks |
cloudantnosqldb.account-active-tasks.read |
GET/HEAD |
/_replicator |
cloudantnosqldb.replicator-database-info.read |
GET/HEAD |
/_replicator/$DOCUMENT |
cloudantnosqldb.replication.read |
GET/HEAD |
/_scheduler/jobs |
cloudantnosqldb.replication-scheduler.read |
GET/HEAD |
/_scheduler/docs |
cloudantnosqldb.replication-scheduler.read |
POST |
/_replicate |
cloudantnosqldb.replication.write |
POST |
/_replicator |
cloudantnosqldb.replication.write |
PUT/DELETE |
/_replicator |
cloudantnosqldb.replicator-database.create |
PUT/DELETE |
/_replicator/$DOCUMENT |
cloudantnosqldb.replication.write |
GET/HEAD |
/_up |
cloudantnosqldb.account-up.read |
PUT |
/$DATABASE/ |
cloudantnosqldb.database.create |
DELETE |
/$DATABASE |
cloudantnosqldb.database.delete |
POST |
/$DATABASE/_design_docs/queries |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/_design/$DOCUMENT_ID/_geo_info |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/_design/$DOCUMENT_ID/_info/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
GET |
/$DATABASE/_design/$DOCUMENT_ID/_search_disk_size/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
GET |
/$DATABASE/_design/$DOCUMENT_ID/_search_info/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/_index/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
GET |
/$DATABASE/_design_docs |
cloudantnosqldb.any-document.read |
GET |
/$DATABASE/_design/$DOCUMENT_ID |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/_design/$DOCUMENT_ID/$ATTACHMENT |
cloudantnosqldb.any-document.read |
PUT |
/$DATABASE/_design/$DOCUMENT_ID |
cloudantnosqldb.design-document.write |
COPY |
/$DATABASE/_design/$DOCUMENT_ID |
cloudantnosqldb.design-document.write |
DELETE |
/$DATABASE/_design/$DOCUMENT_ID |
cloudantnosqldb.design-document.write |
PUT |
/$DATABASE/_design/$DOCUMENT_ID/$ATTACHMENT |
cloudantnosqldb.design-document.write |
DELETE |
/$DATABASE/_design/$DOCUMENT_ID/$ATTACHMENT |
cloudantnosqldb.design-document.write |
POST/DELETE |
/$DATABASE/_index/$FURTHER_PATH_PARTS |
cloudantnosqldb.design-document.write |
GET/HEAD |
/$DATABASE/_security |
cloudantnosqldb.database-security.read |
PUT |
/$DATABASE/_security |
cloudantnosqldb.database-security.write |
GET/HEAD |
/$DATABASE/_shards |
cloudantnosqldb.database-shards.read |
COPY (Dipende dal tipo di documento di scrittura.) |
/$DATABASE/$DOCUMENT_ID |
cloudantnosqldb.any-document.read + cloudantnosqldb.design-document.write uno o entrambi cloudantnosqldb.local-document.write o entrambi cloudantnosqldb.data-document.write |
GET |
/_membership |
cloudantnosqldb.cluster-membership.read |
POST |
/$DATABASE/_ensure_full_commit |
cloudantnosqldb.database-ensure-full-commit.execute |
PUT |
/_users |
cloudantnosqldb.users-database.create |
GET/HEAD |
/_users |
cloudantnosqldb.users-database-info.read |
DELETE |
/_users |
cloudantnosqldb.users-database.delete |
GET/HEAD |
/_users/$DOCUMENT |
cloudantnosqldb.users.read |
GET/POST |
/_users/_all_docs |
cloudantnosqldb.users.read |
GET/POST |
/_users/_changes |
cloudantnosqldb.users.read |
POST |
/_users/_missing_revs |
cloudantnosqldb.users.read |
POST |
/_users/_revs_diff |
cloudantnosqldb.users.read |
POST |
/_users/_bulk_get |
cloudantnosqldb.users.read |
PUT/DELETE |
/_users/$DOCUMENT |
cloudantnosqldb.users.write |
POST |
/_users/_bulk_docs |
cloudantnosqldb.users.write |
POST |
/_users/ |
cloudantnosqldb.users.write |
GET/HEAD |
/_uuids |
cloudantnosqldb.cluster-uuids.execute |
POST |
/$DATABASE/ |
cloudantnosqldb.data-document.write o cloudantnosqldb.design-document.write o cloudantnosqldb.local-document.write |
POST |
/$DATABASE/_bulk_docs |
cloudantnosqldb.data-document.write uno o entrambi cloudantnosqldb.design-document.write uno o entrambi cloudantnosqldb.local-document.write |
PUT |
/$DATABASE/$DOCUMENT_ID |
cloudantnosqldb.data-document.write |
DELETE |
/$DATABASE/$DOCUMENT_ID |
cloudantnosqldb.data-document.write |
PUT |
/$DATABASE/$DOCUMENT_ID/$ATTACHMENT |
cloudantnosqldb.data-document.write |
DELETE |
/$DATABASE/$DOCUMENT_ID/$ATTACHMENT |
cloudantnosqldb.data-document.write |
PUT/DELETE |
/$DATABASE/_local/$DOCUMENT_ID |
cloudantnosqldb.local-document.write |
COPY (Dipende dal tipo di documento di scrittura.) |
/$DATABASE/_local/$DOCUMENT_ID |
cloudantnosqldb.any-document.read + cloudantnosqldb.design-document.write uno o entrambi cloudantnosqldb.local-document.write o entrambi cloudantnosqldb.data-document.write |
GET/HEAD |
/_iam_session |
cloudantnosqldb.iam-session.read |
POST |
/_iam_session |
cloudantnosqldb.iam-session.write |
DELETE |
/_iam_session |
cloudantnosqldb.iam-session.delete |
GET/HEAD |
/_session |
cloudantnosqldb.session.read |
POST |
/_session |
cloudantnosqldb.session.write |
DELETE |
/_session |
cloudantnosqldb.session.delete |
GET/HEAD |
/_all_dbs |
cloudantnosqldb.account-all-dbs.read |
POST |
/_dbs_info |
cloudantnosqldb.account-dbs-info.read |
GET |
/$DATABASE/ |
cloudantnosqldb.database-info.read |
GET/POST |
/$DATABASE/_all_docs |
cloudantnosqldb.any-document.read |
GET/POST |
/$DATABASE/_changes |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/$DOCUMENT_ID |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/$DOCUMENT_ID/$ATTACHMENT |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_bulk_get |
cloudantnosqldb.any-document.read |
GET/POST |
/_search_analyze |
cloudantnosqldb.account-search-analyze.execute |
POST |
/$DATABASE/_all_docs/queries |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/_design/$DOCUMENT_ID/_geo/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
GET/POST |
/$DATABASE/_design/$DOCUMENT_ID/_search/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_design/$DOCUMENT_ID/_view/$VIEW/queries |
cloudantnosqldb.any-document.read |
GET/POST |
/$DATABASE/_design/$DOCUMENT_ID/_view/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_explain/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_find/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
GET |
/$DATABASE/_local/$DOCUMENT_ID |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_missing_revs |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_revs_diff |
cloudantnosqldb.any-document.read |
Metodo | Endpoint | Nome azione |
---|---|---|
GET |
/_api/v2/user/activity_tracker/events |
cloudantnosqldb.activity-tracker-event-types.read |
GET |
/_api/v2/user/capacity/databases |
cloudantnosqldb.account-capacity-dbs.read |
GET |
/_api/v2/user/current/databases |
cloudantnosqldb.account-current-dbs.read |
GET/HEAD |
/_uuids |
cloudantnosqldb.cluster-uuids.execute |
POST |
/$DATABASE/ |
cloudantnosqldb.data-document.write o cloudantnosqldb.design-document.write o cloudantnosqldb.local-document.write |
POST |
/$DATABASE/_bulk_docs |
cloudantnosqldb.data-document.write uno o entrambi cloudantnosqldb.design-document.write uno o entrambi cloudantnosqldb.local-document.write |
PUT |
/$DATABASE/$DOCUMENT_ID |
cloudantnosqldb.data-document.write |
DELETE |
/$DATABASE/$DOCUMENT_ID |
cloudantnosqldb.data-document.write |
PUT |
/$DATABASE/$DOCUMENT_ID/$ATTACHMENT |
cloudantnosqldb.data-document.write |
DELETE |
/$DATABASE/$DOCUMENT_ID/$ATTACHMENT |
cloudantnosqldb.data-document.write |
PUT/DELETE |
/$DATABASE/_local/$DOCUMENT_ID |
cloudantnosqldb.local-document.write |
GET/HEAD |
/_iam_session |
cloudantnosqldb.iam-session.read |
POST |
/_iam_session |
cloudantnosqldb.iam-session.write |
DELETE |
/_iam_session |
cloudantnosqldb.iam-session.delete |
GET/HEAD |
/_session |
cloudantnosqldb.session.read |
POST |
/_session |
cloudantnosqldb.session.write |
DELETE |
/_session |
cloudantnosqldb.session.delete |
GET/HEAD |
/_all_dbs |
cloudantnosqldb.account-all-dbs.read |
POST |
/_dbs_info |
cloudantnosqldb.account-dbs-info.read |
GET |
/$DATABASE/ |
cloudantnosqldb.database-info.read |
GET/POST |
/$DATABASE/_all_docs |
cloudantnosqldb.any-document.read |
GET/POST |
/$DATABASE/_changes |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/$DOCUMENT_ID |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/$DOCUMENT_ID/$ATTACHMENT |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_bulk_get |
cloudantnosqldb.any-document.read |
GET/POST |
/_search_analyze |
cloudantnosqldb.account-search-analyze.execute |
POST |
/$DATABASE/_all_docs/queries |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/_design/$DOCUMENT_ID/_geo/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
GET/POST |
/$DATABASE/_design/$DOCUMENT_ID/_search/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_design/$DOCUMENT_ID/_view/$VIEW/queries |
cloudantnosqldb.any-document.read |
GET/POST |
/$DATABASE/_design/$DOCUMENT_ID/_view/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_explain/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_find/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
GET |
/$DATABASE/_local/$DOCUMENT_ID |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_missing_revs |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_revs_diff |
cloudantnosqldb.any-document.read |
GET/HEAD |
/ | cloudantnosqldb.account-meta-info.read |
POST |
/$DATABASE/_ensure_full_commit |
cloudantnosqldb.database-ensure-full-commit.execute |
Metodo | Endpoint | Nome azione |
---|---|---|
GET |
/_api/v2/user/activity_tracker/events |
cloudantnosqldb.activity-tracker-event-types.read |
GET |
/_api/v2/user/capacity/databases |
cloudantnosqldb.account-capacity-dbs.read |
GET |
/_api/v2/user/current/databases |
cloudantnosqldb.account-current-dbs.read |
GET/HEAD |
/_iam_session |
cloudantnosqldb.iam-session.read |
POST |
/_iam_session |
cloudantnosqldb.iam-session.write |
DELETE |
/_iam_session |
cloudantnosqldb.iam-session.delete |
GET/HEAD |
/_session |
cloudantnosqldb.session.read |
POST |
/_session |
cloudantnosqldb.session.write |
DELETE |
/_session |
cloudantnosqldb.session.delete |
GET/HEAD |
/_all_dbs |
cloudantnosqldb.account-all-dbs.read |
POST |
/_dbs_info |
cloudantnosqldb.account-dbs-info.read |
GET |
/$DATABASE/ |
cloudantnosqldb.database-info.read |
GET/POST |
/$DATABASE/_all_docs |
cloudantnosqldb.any-document.read |
GET/POST |
/$DATABASE/_changes |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/$DOCUMENT_ID |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/$DOCUMENT_ID/$ATTACHMENT |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_bulk_get |
cloudantnosqldb.any-document.read |
GET/POST |
/_search_analyze |
cloudantnosqldb.account-search-analyze.execute |
POST |
/$DATABASE/_all_docs/queries |
cloudantnosqldb.any-document.read |
GET/HEAD |
/$DATABASE/_design/$DOCUMENT_ID/_geo/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
GET/POST |
/$DATABASE/_design/$DOCUMENT_ID/_search/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_design/$DOCUMENT_ID/_view/$VIEW/queries |
cloudantnosqldb.any-document.read |
GET/POST |
/$DATABASE/_design/$DOCUMENT_ID/_view/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_explain/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_find/$FURTHER_PATH_PARTS |
cloudantnosqldb.any-document.read |
GET |
/$DATABASE/_local/$DOCUMENT_ID |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_missing_revs |
cloudantnosqldb.any-document.read |
POST |
/$DATABASE/_revs_diff |
cloudantnosqldb.any-document.read |
GET/HEAD |
/ | cloudantnosqldb.account-meta-info.read |
Metodo | Endpoint | Nome azione |
---|---|---|
GET |
/_api/v2/usage/data_volume e /_api/v2/usage/$YEAR/$MONTH |
cloudantnosqldb.sapi.usage-data-volume |
GET |
/_api/v2/user/capacity/throughput |
cloudantnosqldb.capacity-throughput.read |
GET |
/_api/v2/user/current/throughput |
cloudantnosqldb.current-throughput.read |
GET |
/_api/v2/user/capacity/databases |
cloudantnosqldb.account-capacity-dbs.read |
GET |
/_api/v2/user/current/databases |
cloudantnosqldb.account-current-dbs.read |
GET/HEAD |
/ | cloudantnosqldb.account-meta-info.read |
GET/HEAD |
/_active_tasks |
cloudantnosqldb.account-active-tasks.read |
GET/HEAD |
/_scheduler/jobs |
cloudantnosqldb.replication-scheduler.read |
GET/HEAD |
/_scheduler/docs |
cloudantnosqldb.replication-scheduler.read |
GET/HEAD |
/_up |
cloudantnosqldb.account-up.read |
GET/HEAD |
/$DATABASE/_shards |
cloudantnosqldb.database-shards.read |
PUT/DELETE |
/$DATABASE/_local/$DOCUMENT_ID |
cloudantnosqldb.local-document.write |
POST |
/_dbs_info |
cloudantnosqldb.account-dbs-info.read |
GET |
/$DATABASE/ |
cloudantnosqldb.database-info.read |
Metodo | Endpoint | Nome azione |
---|---|---|
PUT/DELETE |
/$DATABASE/_local/$DOCUMENT_ID |
cloudantnosqldb.local-document.write |
Risoluzione dei problemi
Se non puoi utilizzare IAM per eseguire l'autenticazione quando effettui richieste alla tua istanza del servizio IBM Cloudant, verifica il tuo account come mostrato nella sezione successiva.
Assicurati che il tuo account sia abilitato per IAM
Nella sezione Panoramica della dashboard dell' IBM Cloudant, il "metodo di autenticazione" è elencato sotto i dettagli di distribuzione. I tuoi metodi di autenticazione disponibili sono elencati lì.