Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Gestione accessi e identità per Amazon Aurora
AWS Identity and Access Management (IAM) è un programma Servizio AWS che aiuta un amministratore a controllare in modo sicuro l'accesso alle AWS risorse. Gli amministratori IAM controllano chi può essere *autenticato* (accesso effettuato) e *autorizzato* (dispone di autorizzazioni) per utilizzare le risorse Amazon RDS. IAM è un software Servizio AWS che puoi utilizzare senza costi aggiuntivi.
**Topics**
+ [Destinatari](#security_iam_audience)
+ [Autenticazione con identità](#security_iam_authentication)
+ [Gestione dell’accesso tramite policy](#security_iam_access-manage)
+ [Funzionamento di Amazon Aurora con IAM](security_iam_service-with-iam.md)
+ [Esempi di policy di Amazon Aurora basate su identità](security_iam_id-based-policy-examples.md)
+ [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md)
+ [Aggiornamenti di Amazon RDS sulle policy gestite da AWS](rds-manpol-updates.md)
+ [Prevenzione del problema "confused deputy" tra servizi](cross-service-confused-deputy-prevention.md)
+ [Autenticazione del database IAM](UsingWithRDS.IAMDBAuth.md)
+ [Risoluzione dei problemi di identità e accesso in Amazon Aurora](security_iam_troubleshoot.md)
## Destinatari
Il modo in cui utilizzi AWS Identity and Access Management (IAM) varia a seconda del lavoro svolto in Aurora.
**Utente del servizio** –Se utilizzi il servizio Aurora per eseguire il tuo lavoro, l’amministratore fornisce le credenziali e le autorizzazioni necessarie. All’aumentare del numero di funzionalità Aurora utilizzate per il lavoro, potrebbero essere necessarie ulteriori autorizzazioni. La comprensione della gestione dell’accesso consente di richiedere le autorizzazioni corrette all’amministratore. Se non riesci ad accedere a una funzionalità di Aurora, consulta [Risoluzione dei problemi di identità e accesso in Amazon Aurora](security_iam_troubleshoot.md).
**Amministratore del servizio** – Se sei il responsabile delle risorse Aurorapresso la tua azienda, probabilmente disponi dell’accesso completo a Aurora. Il tuo compito è determinare le caratteristiche e le risorse Aurora a cui i dipendenti devono accedere. Devi inviare le richieste all’amministratore per cambiare le autorizzazioni degli utenti del servizio. Esamina le informazioni contenute in questa pagina per comprendere le nozioni di base di IAM. Per ulteriori informazioni su come la tua azienda può utilizzare IAM con Aurora, consulta [Funzionamento di Amazon Aurora con IAM](security_iam_service-with-iam.md).
**Amministratore** – Se sei un amministratore, potresti essere interessato a ottenere informazioni su come puoi scrivere policy per gestire l’accesso a Aurora. Per visualizzare policy basate su identità Aurora di esempio che puoi utilizzare in IAM, consulta [Esempi di policy di Amazon Aurora basate su identità](security_iam_id-based-policy-examples.md).
## Autenticazione con identità
L'autenticazione è il modo in cui accedi AWS utilizzando le tue credenziali di identità. Devi autenticarti come utente IAM o assumendo un ruolo IAM. Utente root dell'account AWS
Puoi accedere come identità federata utilizzando credenziali provenienti da una fonte di identità come AWS IAM Identity Center (IAM Identity Center), autenticazione Single Sign-On o credenziali. Google/Facebook Per maggiori informazioni sull’accesso, consultare la sezione [Come accedere a Account AWS](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) nella *Guida per l’utente di Accedi ad AWS *.
Per l'accesso programmatico, AWS fornisce un SDK e una CLI per firmare crittograficamente le richieste. Per ulteriori informazioni, consulta [AWS Signature Version 4 per le richieste API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) nella *Guida per l’utente IAM*.
### AWS account (utente root)
Quando si crea un Account AWS, si inizia con un'identità di accesso denominata *utente Account AWS root* che ha accesso completo a tutte Servizi AWS le risorse. Si consiglia vivamente di non utilizzare l’utente root per le attività quotidiane. Per le attività che richiedono le credenziali come utente root, consulta [Attività che richiedono le credenziali dell’utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) nella *Guida per l’utente IAM*.
### Identità federata
Come procedura ottimale, richiedi agli utenti umani di utilizzare la federazione con un provider di identità per accedere Servizi AWS utilizzando credenziali temporanee.
Un'*identità federata* è un utente della directory aziendale, del provider di identità Web o Directory Service che accede Servizi AWS utilizzando le credenziali di una fonte di identità. Le identità federate assumono ruoli che forniscono credenziali temporanee.
Per la gestione centralizzata degli accessi, consigliamo di utilizzare AWS IAM Identity Center. Per ulteriori informazioni, consulta [Cos’è IAM Identity Center?](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html) nella *Guida per l’utente di AWS IAM Identity Center *.
### Utenti e gruppi IAM
Un *[utente IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* è un’identità che dispone di autorizzazioni specifiche per una singola persona o applicazione. Ti consigliamo di utilizzare credenziali temporanee invece di utenti IAM con credenziali a lungo termine. *Per ulteriori informazioni, consulta [Richiedere agli utenti umani di utilizzare la federazione con un provider di identità per accedere AWS utilizzando credenziali temporanee](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) nella Guida per l'utente IAM.*
Un [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) specifica una raccolta di utenti IAM e semplifica la gestione delle autorizzazioni per gestire gruppi di utenti di grandi dimensioni. Per ulteriori informazioni, consulta [Casi d’uso per utenti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) nella *Guida per l’utente IAM*.
Puoi eseguire l’autenticazione nel cluster di database tramite l’autenticazione del database IAM.
L’autenticazione del database IAM funziona con Aurora. Per ulteriori informazioni sull’autenticazione al cluster di database tramite IAM, consulta [Autenticazione del database IAM ](UsingWithRDS.IAMDBAuth.md).
### Ruoli IAM
Un *[ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* è un'identità interna all'utente Account AWS che dispone di autorizzazioni specifiche. È simile a un utente, ma non è associato a una persona specifica. Puoi assumere temporaneamente un ruolo IAM in Console di gestione AWS [cambiando ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html). Puoi assumere un ruolo chiamando un'operazione AWS CLI o AWS API o utilizzando un URL personalizzato. Per ulteriori informazioni sui metodi per l’utilizzo dei ruoli, consulta [Utilizzo di ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) nella *Guida per l’utente IAM*.
I ruoli IAM con credenziali temporanee sono utili nelle seguenti situazioni:
+ **Autorizzazioni utente temporanee**: un utente può assumere un ruolo IAM per ottenere temporaneamente autorizzazioni diverse per un’attività specifica.
+ **Accesso utente federato** - Per assegnare le autorizzazioni a una identità federata, è possibile creare un ruolo e definire le autorizzazioni per il ruolo. Quando un’identità federata viene autenticata, l’identità viene associata al ruolo e ottiene le autorizzazioni da esso definite. Per ulteriori informazioni sulla federazione dei ruoli, consulta [Creare un ruolo per un provider di identità di terza parte (federazione)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html) nella *Guida per l’utente IAM*. Se si utilizza IAM Identity Center, configurare un set di autorizzazioni. IAM Identity Center mette in correlazione il set di autorizzazioni con un ruolo in IAM per controllare a cosa possono accedere le identità dopo l’autenticazione. Per informazioni sui set di autorizzazioni, consulta [Set di autorizzazioni](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) nella *Guida per l’utente AWS IAM Identity Center *.
+ **Accesso multi-account**: è possibile utilizzare un ruolo IAM per permettere a un utente (un principale affidabile) con un account diverso di accedere alle risorse nell’account. I ruoli sono lo strumento principale per concedere l’accesso multi-account. Tuttavia, con alcuni Servizi AWS, è possibile allegare una policy direttamente a una risorsa (anziché utilizzare un ruolo come proxy). Per informazioni sulle differenze tra ruoli e policy basate su risorse per l’accesso multi-account, consulta [Differenza tra i ruoli IAM e le policy basate su risorse](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html) nella *Guida per l’utente IAM*.
+ **Accesso a più servizi**: alcuni Servizi AWS utilizzano le funzionalità di altri Servizi AWS. Ad esempio, quando effettui una chiamata in un servizio, è normale che quel servizio esegua applicazioni in Amazon EC2 o archivi oggetti in Amazon S3. Un servizio può eseguire questa operazione utilizzando le autorizzazioni dell’entità chiamante, utilizzando un ruolo di servizio o utilizzando un ruolo collegato al servizio.
+ **Sessioni di accesso inoltrato**: le sessioni di accesso inoltrato (FAS) utilizzano le autorizzazioni del principale chiamante e Servizio AWS, in combinazione con la richiesta, Servizio AWS per effettuare richieste ai servizi downstream. Per i dettagli delle policy relative alle richieste FAS, consultare [Forward access sessions](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html).
+ **Ruolo di servizio** - Un ruolo di servizio è un [ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) che un servizio assume per eseguire operazioni per conto dell’utente. Un amministratore IAM può creare, modificare ed eliminare un ruolo di servizio dall’interno di IAM. Per ulteriori informazioni, consulta la sezione [Create a role to delegate permissions to an Servizio AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) nella *Guida per l’utente IAM*.
+ **Ruolo collegato al servizio: un ruolo collegato** al servizio è un tipo di ruolo di servizio collegato a un. Servizio AWS Il servizio può assumere il ruolo per eseguire un’azione per tuo conto. I ruoli collegati al servizio vengono visualizzati nel tuo account Account AWS e sono di proprietà del servizio. Un amministratore IAM può visualizzare le autorizzazioni per i ruoli collegati al servizio, ma non modificarle.
+ **Applicazioni in esecuzione su Amazon EC2**: puoi utilizzare un ruolo IAM per gestire le credenziali temporanee per le applicazioni in esecuzione su un' EC2 istanza e che AWS CLI effettuano richieste AWS API. Questa soluzione è preferibile alla memorizzazione delle chiavi di accesso all'interno dell' EC2 istanza. Per assegnare un AWS ruolo a un' EC2 istanza e renderlo disponibile per tutte le sue applicazioni, create un profilo di istanza collegato all'istanza. Un profilo di istanza contiene il ruolo e consente ai programmi in esecuzione sull' EC2 istanza di ottenere credenziali temporanee. Per ulteriori informazioni, consulta [Utilizzare un ruolo IAM per concedere le autorizzazioni alle applicazioni in esecuzione su EC2 istanze Amazon](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html) nella *IAM User Guide*.
Per informazioni sull’utilizzo di ruoli IAM, consulta [Quando creare un ruolo IAM invece di un utente](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose_role) nella *Guida per l’utente di IAM*.
## Gestione dell’accesso tramite policy
Puoi controllare l'accesso AWS creando policy e collegandole a identità o risorse IAM. AWS Una policy è un oggetto AWS che, se associato a un'identità o a una risorsa, ne definisce le autorizzazioni. AWS valuta queste politiche quando un'entità (utente root, utente o ruolo IAM) effettua una richiesta. Le autorizzazioni nelle policy determinano l’approvazione o il rifiuto della richiesta. La maggior parte delle politiche viene archiviata AWS come documenti JSON. Per ulteriori informazioni sulla struttura e sui contenuti dei documenti delle policy JSON, consulta [Panoramica delle policy JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) nella *Guida per l’utente IAM*.
Un amministratore può utilizzare le policy per specificare chi ha accesso alle AWS risorse e quali azioni può eseguire su tali risorse. Ogni entità IAM (set di autorizzazioni o ruolo) inizialmente non dispone di autorizzazioni. Ovvero, di default, gli utenti non possono eseguire alcuna operazione, neppure modificare la propria password. Per autorizzare un utente a eseguire operazioni, un amministratore deve allegare una policy di autorizzazioni a tale utente. In alternativa, l’amministratore può aggiungere l’utente a un gruppo che dispone delle autorizzazioni desiderate. Quando un amministratore fornisce le autorizzazioni a un gruppo, le autorizzazioni vengono concesse a tutti gli utenti in tale gruppo.
Le policy IAM definiscono le autorizzazioni relative a un’operazione, indipendentemente dal metodo utilizzato per eseguirla. Ad esempio, supponiamo di disporre di una policy che consente l’operazione `iam:GetRole`. Un utente con tale policy può ottenere informazioni sul ruolo dall' Console di gestione AWS AWS CLI, dall'o dall' AWS API.
### Policy basate sull’identità
Le policy basate su identità sono documenti di policy di autorizzazione JSON che è possibile collegare a un’identità, ad esempio un set di autorizzazioni o un ruolo. Tali policy definiscono le operazioni autorizzate per l’identità, nonché le risorse e le condizioni in cui possono essere eseguite. Per informazioni su come creare una policy basata su identità, consulta [Creazione di policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) nella *Guida per l’utente IAM*.
Le policy basate su identità possono essere ulteriormente classificate come *policy inline* o *policy gestite*. Le policy inline sono incorporate direttamente in un singolo set di autorizzazioni o ruolo. Le politiche gestite sono politiche autonome che puoi allegare a più set di autorizzazioni e ruoli nel tuo AWS account. Le politiche gestite includono politiche AWS gestite e politiche gestite dai clienti. Per informazioni su come scegliere tra una policy gestita o una policy inline, consulta [Scelta fra policy gestite e policy inline](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#choosing-managed-or-inline) nella *Guida per l’utente IAM*.
Per informazioni sulle policy AWS gestite specifiche di Aurora, consulta. [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md)
### Altri tipi di policy
AWS supporta tipi di policy aggiuntivi e meno comuni. Questi tipi di policy possono impostare il numero massimo di autorizzazioni concesse dai più tipi di policy comuni.
+ **Limiti delle autorizzazioni**: un limite delle autorizzazioni è una funzione avanzata nella quale si imposta il numero massimo di autorizzazioni che una policy basata su identità può concedere a un’entità IAM (set di autorizzazioni o ruolo). È possibile impostare un limite delle autorizzazioni per un’entità. Le autorizzazioni risultanti sono l’intersezione delle policy basate su identità dell’entità e i suoi limiti delle autorizzazioni. Le policy basate su risorse che specificano il set di autorizzazioni o il ruolo nel campo `Principal` sono condizionate dal limite delle autorizzazioni. Un rifiuto esplicito in una qualsiasi di queste policy sostituisce l’autorizzazione. Per ulteriori informazioni sui limiti delle autorizzazioni, consulta [Limiti delle autorizzazioni per le entità IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html) nella *Guida per l’utente di IAM*.
+ **Politiche di controllo del servizio (SCPs)**: SCPs sono politiche JSON che specificano le autorizzazioni massime per un'organizzazione o un'unità organizzativa (OU) in. AWS Organizations AWS Organizations è un servizio per il raggruppamento e la gestione centralizzata di più AWS account di proprietà dell'azienda. Se abiliti tutte le funzionalità di un'organizzazione, puoi applicare le politiche di controllo del servizio (SCPs) a uno o tutti i tuoi account. L'SCP limita le autorizzazioni per le entità presenti negli account dei membri, inclusa ciascuna di esse. Utente root dell'account AWS Per ulteriori informazioni su Organizations and SCPs, consulta [How SCPs work](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_about-scps.html) nella *AWS Organizations User Guide*.
+ **Policy di sessione** - Le policy di sessione sono policy avanzate che vengono trasmesse come parametro quando si crea in modo programmatico una sessione temporanea per un ruolo o un utente federato. Le autorizzazioni della sessione risultante sono l’intersezione delle policy basate sull’identità del set di autorizzazioni o del ruolo e le policy di sessione. Le autorizzazioni possono anche provenire da una policy basata su risorse. Un rifiuto esplicito in una qualsiasi di queste policy sostituisce l’autorizzazione. Per ulteriori informazioni, consulta [Policy di sessione](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session) nella *Guida per l’utente IAM*.
### Più tipi di policy
Quando a una richiesta si applicano più tipi di policy, le autorizzazioni risultanti sono più complicate da comprendere. Per scoprire come si AWS determina se consentire o meno una richiesta quando sono coinvolti più tipi di policy, consulta [Logica di valutazione delle policy](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html) nella *IAM User Guide*.
# Funzionamento di Amazon Aurora con IAM
Prima di utilizzare IAM per gestire l'accesso ad Amazon Aurora, è necessario comprendere quali funzionalità IAM sono disponibili per l'uso con Amazon Aurora.
Nella seguente tabella sono elencate le funzionalità di IAM che è possibile utilizzare con Amazon Aurora:
| Funzionalità IAM | Supporto di Amazon Aurora |
| --- | --- |
| [Policy basate sull’identità](#security_iam_service-with-iam-id-based-policies) | Sì |
| [Policy basate su risorse](#security_iam_service-with-iam-resource-based-policies) | No |
| [Operazioni di policy](#security_iam_service-with-iam-id-based-policies-actions) | Sì |
| [Risorse relative alle policy](#security_iam_service-with-iam-id-based-policies-resources) | Sì |
| [Chiavi di condizione della policy (specifica del servizio)](#UsingWithRDS.IAM.Conditions) | Sì |
| [ACLs](#security_iam_service-with-iam-acls) | No |
| [Controllo degli accessi basato su attributi (ABAC) (tag nelle policy)](#security_iam_service-with-iam-tags) | Sì |
| [Credenziali temporanee](#security_iam_service-with-iam-roles-tempcreds) | Sì |
| [Inoltro delle sessioni di accesso](#security_iam_service-with-iam-principal-permissions) | Sì |
| [Ruoli di servizio](#security_iam_service-with-iam-roles-service) | Sì |
| [Ruoli collegati al servizio](#security_iam_service-with-iam-roles-service-linked) | Sì |
*Per avere una visione di alto livello di come Aurora e AWS altri servizi funzionano con IAM, [AWS consulta i servizi che funzionano con](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) IAM nella IAM User Guide.*
**Topics**
+ [Policy basate su identità Aurora](#security_iam_service-with-iam-id-based-policies)
+ [Policy basate su risorse all'interno di Aurora](#security_iam_service-with-iam-resource-based-policies)
+ [Operazioni delle policy per Aurora](#security_iam_service-with-iam-id-based-policies-actions)
+ [Risorse delle policy per Aurora](#security_iam_service-with-iam-id-based-policies-resources)
+ [Chiavi di condizione delle policy per Aurora](#UsingWithRDS.IAM.Conditions)
+ [Elenchi di controllo degli accessi (ACLs) in](#security_iam_service-with-iam-acls)
+ [Controllo degli accessi basato su attributi (ABAC) nelle policy con tag Aurora](#security_iam_service-with-iam-tags)
+ [Utilizzo di credenziali temporanee con Aurora](#security_iam_service-with-iam-roles-tempcreds)
+ [Inoltro delle sessioni di accesso per Aurora](#security_iam_service-with-iam-principal-permissions)
+ [Ruoli di servizio per Aurora](#security_iam_service-with-iam-roles-service)
+ [Ruoli collegati ai servizi per Aurora](#security_iam_service-with-iam-roles-service-linked)
## Policy basate su identità Aurora
**Supporta le policy basate su identità:** sì.
Le policy basate sull'identità sono documenti di policy di autorizzazione JSON che è possibile allegare a un'identità (utente, gruppo di utenti o ruolo IAM). Tali policy definiscono le operazioni che utenti e ruoli possono eseguire, su quali risorse e in quali condizioni. Per informazioni su come creare una policy basata su identità, consulta [Definizione di autorizzazioni personalizzate IAM con policy gestite dal cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) nella *Guida per l’utente di IAM*.
Con le policy basate sull’identità di IAM, è possibile specificare quali operazioni e risorse sono consentite o respinte, nonché le condizioni in base alle quali le operazioni sono consentite o respinte. Per informazioni su tutti gli elementi utilizzabili in una policy JSON, consulta [Guida di riferimento agli elementi delle policy JSON IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) nella *Guida per l’utente IAM*.
### Esempi di policy basate su identità per Aurora
Per visualizzare esempi di policy basate su identità Aurora, consulta [Esempi di policy di Amazon Aurora basate su identità](security_iam_id-based-policy-examples.md).
## Policy basate su risorse all'interno di Aurora
**Supporta le policy basate su risorse:** no.
Le policy basate su risorse sono documenti di policy JSON che è possibile collegare a una risorsa. Esempi di policy basate sulle risorse sono le *policy di attendibilità dei ruoli* IAM e le *policy di bucket* Amazon S3. Nei servizi che supportano policy basate sulle risorse, gli amministratori dei servizi possono utilizzarli per controllare l’accesso a una risorsa specifica. Quando è collegata a una risorsa, una policy definisce le operazioni che un principale può eseguire su tale risorsa e a quali condizioni. In una policy basata sulle risorse è obbligatorio [specificare un’entità principale](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html). I principali possono includere account, utenti, ruoli, utenti federati o. Servizi AWS
Per consentire l’accesso multi-account, è possibile specificare un intero account o entità IAM in un altro account come entità principale in una policy basata sulle risorse. Per ulteriori informazioni, consulta [Accesso a risorse multi-account in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) nella *Guida per l’utente IAM*.
## Operazioni delle policy per Aurora
**Supporta le operazioni di policy:** si
Gli amministratori possono utilizzare le policy AWS JSON per specificare chi ha accesso a cosa. In altre parole, quale **entità principale** può eseguire **operazioni** su quali **risorse** e in quali **condizioni**.
L'elemento `Action` di una policy JSON descrive le operazioni che è possibile utilizzare per consentire o negare l'accesso in una policy. Includere le operazioni in una policy per concedere le autorizzazioni a eseguire l’operazione associata.
Le operazioni delle policy in Aurora utilizzano il seguente prefisso prima dell'operazione: `rds:`. Ad esempio, per concedere a qualcuno l'autorizzazione per descrivere istanze database con l'operazione API Amazon RDS `DescribeDBInstances`, includi l'operazione `rds:DescribeDBInstances` nella policy. Le istruzioni della policy devono includere un elemento `Action` o `NotAction`. Aurora definisce un proprio set di operazioni che descrivono le attività che puoi eseguire con quel servizio.
Per specificare più operazioni in una singola istruzione, separarle con una virgola come mostrato di seguito.
```
"Action": [
"rds:action1",
"rds:action2"
```
Puoi specificare più operazioni tramite caratteri jolly (\$1). Ad esempio, per specificare tutte le operazioni che iniziano con la parola `Describe`, includi la seguente operazione.
```
"Action": "rds:Describe*"
```
Per visualizzare un elenco di operazioni di Aurora, consulta [Operazioni definite da Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions) nella *Service Authorization Reference*.
## Risorse delle policy per Aurora
**Supporta le risorse di policy:** sì.
Gli amministratori possono utilizzare le policy AWS JSON per specificare chi ha accesso a cosa. In altre parole, quale **entità principale** può eseguire **operazioni** su quali **risorse** e in quali **condizioni**.
L’elemento JSON `Resource` della policy specifica l’oggetto o gli oggetti ai quali si applica l’operazione. Come best practice, specifica una risorsa utilizzando il suo [nome della risorsa Amazon (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). Per le azioni che non supportano le autorizzazioni a livello di risorsa, si utilizza un carattere jolly (\$1) per indicare che l’istruzione si applica a tutte le risorse.
```
"Resource": "*"
```
La risorsa di un'istanza database ha il seguente nome della risorsa Amazon (ARN).
```
arn:${Partition}:rds:${Region}:${Account}:{ResourceType}/${Resource}
```
Per ulteriori informazioni sul formato di ARNs, consulta [Amazon Resource Names (ARNs) e AWS service namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
Ad esempio, per specificare l'istanza database `dbtest` nell'istruzione, utilizza l'ARN riportato di seguito.
```
"Resource": "arn:aws:rds:us-west-2:123456789012:db:dbtest"
```
Per specificare tutte le istanze database che appartengono a un account specifico, utilizza il carattere jolly (\$1).
```
"Resource": "arn:aws:rds:us-east-1:123456789012:db:*"
```
Alcune operazioni API RDS, ad esempio quelle per la creazione di risorse, non possono essere eseguite su una risorsa specifica. In questi casi, utilizza il carattere jolly (\$1).
```
"Resource": "*"
```
Molte operazioni API di Amazon RDS coinvolgono più risorse. Ad esempio, `CreateDBInstance` crea un'istanza database. Puoi specificare che un utente deve utilizzare un gruppo specifico di sicurezza e un gruppo di parametri quando crea un’istanza database. Per specificare più risorse in una singola istruzione, separale con virgole. ARNs
```
"Resource": [
"resource1",
"resource2"
```
*Per visualizzare un elenco dei tipi di risorse di Aurora e ARNs relativi, [consulta Resources Defined by Amazon](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-resources-for-iam-policies) RDS nel Service Authorization Reference.* Per informazioni sulle operazioni con cui è possibile specificare l'ARN di ogni risorsa, consulta [Operazioni definite da Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions).
## Chiavi di condizione delle policy per Aurora
**Supporta le chiavi di condizione delle policy specifiche del servizio:** sì.
Gli amministratori possono utilizzare le policy AWS JSON per specificare chi ha accesso a cosa. In altre parole, quale **entità principale** può eseguire **operazioni** su quali **risorse** e in quali **condizioni**.
L’elemento `Condition` specifica quando le istruzioni vengono eseguite in base a criteri definiti. È possibile compilare espressioni condizionali che utilizzano [operatori di condizione](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), ad esempio uguale a o minore di, per soddisfare la condizione nella policy con i valori nella richiesta. Per visualizzare tutte le chiavi di condizione AWS globali, consulta le chiavi di [contesto delle condizioni AWS globali nella Guida](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) per l'*utente IAM*.
Aurora definisce il proprio set di chiavi di condizione e, inoltre, supporta l'uso di alcune chiavi di condizione globali. Per vedere tutte le chiavi di condizione AWS globali, consulta le [chiavi di contesto delle condizioni AWS globali](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) nella *Guida per l'utente IAM*.
Tutte le operazioni API RDS supportano la chiave di condizione `aws:RequestedRegion`.
Per visualizzare un elenco di chiavi di condizione Aurora, consulta [Chiavi di condizione per Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-policy-keys) nella *Service Authorization Reference*. Per informazioni su operazioni e risorse con cui è possibile utilizzare una chiave di condizione, consulta [Operazioni definite da Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions).
## Elenchi di controllo degli accessi (ACLs) in
**Supporta gli elenchi di controllo degli accessi (ACLs)**: No
Le liste di controllo degli accessi (ACLs) controllano quali principali (membri dell'account, utenti o ruoli) dispongono delle autorizzazioni per accedere a una risorsa. ACLs sono simili alle politiche basate sulle risorse, sebbene non utilizzino il formato del documento di policy JSON.
## Controllo degli accessi basato su attributi (ABAC) nelle policy con tag Aurora
**Supporta tag di controllo degli accessi basato su attributi (ABAC) nelle policy:** sì.
Il controllo degli accessi basato su attributi (ABAC) è una strategia di autorizzazione che definisce le autorizzazioni in base ad attributi chiamati tag. È possibile allegare tag a entità e AWS risorse IAM, quindi progettare politiche ABAC per consentire operazioni quando il tag del principale corrisponde al tag sulla risorsa.
Per controllare l’accesso basato su tag, fornire informazioni sui tag nell’[elemento condizione](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) di una policy utilizzando le chiavi di condizione `aws:ResourceTag/key-name`, `aws:RequestTag/key-name` o `aws:TagKeys`.
Se un servizio supporta tutte e tre le chiavi di condizione per ogni tipo di risorsa, il valore per il servizio è **Sì**. Se un servizio supporta tutte e tre le chiavi di condizione solo per alcuni tipi di risorsa, allora il valore sarà **Parziale**.
Per maggiori informazioni su ABAC, consulta [Definizione delle autorizzazioni con autorizzazione ABAC](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) nella *Guida per l’utente di IAM*. Per visualizzare un tutorial con i passaggi per l’impostazione di ABAC, consulta [Utilizzo del controllo degli accessi basato su attributi (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_attribute-based-access-control.html) nella *Guida per l’utente di IAM*.
Per ulteriori informazioni sul tagging delle risorse di Aurora, consulta [Specifica delle condizioni: Utilizzo di tag personalizzati](UsingWithRDS.IAM.SpecifyingCustomTags.md). Per visualizzare una policy basata sulle identità di esempio per limitare l'accesso a una risorsa basata su tag su tale risorsa, consulta [Concedere l'autorizzazione per le operazioni su una risorsa con un tag specifico con due valori diversi](security_iam_id-based-policy-examples-create-and-modify-examples.md#security_iam_id-based-policy-examples-grant-permissions-tags).
## Utilizzo di credenziali temporanee con Aurora
**Supporta le credenziali temporanee:** sì.
Le credenziali temporanee forniscono l'accesso a breve termine alle AWS risorse e vengono create automaticamente quando si utilizza la federazione o si cambia ruolo. AWS consiglia di generare dinamicamente credenziali temporanee anziché utilizzare chiavi di accesso a lungo termine. Per ulteriori informazioni, consulta [Credenziali di sicurezza temporanee in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) e [Servizi AWS compatibili con IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) nella *Guida per l’utente IAM*.
## Inoltro delle sessioni di accesso per Aurora
**Supporta l’inoltro delle sessioni di accesso:** sì.
Le sessioni di accesso inoltrato (FAS) utilizzano le autorizzazioni del principale che chiama e, in combinazione con la richiesta Servizio AWS, Servizio AWS per effettuare richieste ai servizi downstream. Per i dettagli delle policy relative alle richieste FAS, consulta [Forward access sessions](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html).
## Ruoli di servizio per Aurora
**Supporta i ruoli di servizio:** sì.
Un ruolo di servizio è un [ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) che un servizio assume per eseguire operazioni per tuo conto. Un amministratore IAM può creare, modificare ed eliminare un ruolo di servizio dall’interno di IAM. Per ulteriori informazioni, consulta [Create a role to delegate permissions to an Servizio AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) nella *Guida per l’utente IAM*.
**avvertimento**
La modifica delle autorizzazioni per un ruolo di servizio potrebbe compromettere la funzionalità di Aurora. Modificare i ruoli di servizio solo quando Aurora fornisce le indicazioni per farlo.
## Ruoli collegati ai servizi per Aurora
**Supporta i ruoli collegati ai servizi:** sì.
Un ruolo collegato al servizio è un tipo di ruolo di servizio collegato a un. Servizio AWS Il servizio può assumere il ruolo per eseguire un’operazione per tuo conto. I ruoli collegati al servizio vengono visualizzati nel tuo account Account AWS e sono di proprietà del servizio. Un amministratore IAM può visualizzare le autorizzazioni per i ruoli collegati al servizio, ma non modificarle.
Per ulteriori informazioni sull'utilizzo di ruoli collegati ai servizi Aurora, consulta [Utilizzo di ruoli collegati ai servizi per Amazon Aurora](UsingWithRDS.IAM.ServiceLinkedRoles.md).
# Esempi di policy di Amazon Aurora basate su identità
Per impostazione predefinita, i set di autorizzazioni e i ruoli non dispongono dell'autorizzazione per creare o modificare risorse Aurora. Inoltre, non possono eseguire attività utilizzando l' AWS API Console di gestione AWS AWS CLI, o. Un amministratore deve creare policy IAM che concedono a set di autorizzazioni e ruoli l'autorizzazione per eseguire operazioni API specifiche sulle risorse specifiche di cui hanno bisogno. L'amministratore deve quindi collegare queste policy ai set di autorizzazioni o ai ruoli che richiedono tali autorizzazioni.
Per informazioni su come creare una policy basata su identità IAM utilizzando questi documenti di policy JSON di esempio, consultare [Creazione di policy nella scheda JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) nella *Guida per l'utente di IAM*.
**Topics**
+ [Best practice delle policy](#security_iam_service-with-iam-policy-best-practices)
+ [Utilizzo della console di Aurora](#security_iam_id-based-policy-examples-console)
+ [Autorizzazioni necessarie per l'uso della console](#UsingWithRDS.IAM.RequiredPermissions.Console)
+ [Consentire agli utenti di visualizzare le loro autorizzazioni](#security_iam_id-based-policy-examples-view-own-permissions)
+ [Policy di autorizzazione per creare, modificare ed eliminare risorse in Aurora](security_iam_id-based-policy-examples-create-and-modify-examples.md)
+ [Policy di esempio: Utilizzo di chiavi di condizione](UsingWithRDS.IAM.Conditions.Examples.md)
+ [Specifica delle condizioni: Utilizzo di tag personalizzati](UsingWithRDS.IAM.SpecifyingCustomTags.md)
+ [Concessione dell’autorizzazione all’applicazione di tag Aurora per le risorse durante la creazione](security_iam_id-based-policy-examples-grant-permissions-tags-on-create.md)
## Best practice delle policy
Le policy basate su identità determinano se qualcuno può creare, accedere o eliminare risorse Amazon RDS nell'account. Queste azioni possono comportare costi aggiuntivi per l’ Account AWS. Quando si creano o modificano policy basate sull’identità, seguire queste linee guida e raccomandazioni:
+ **Inizia con le policy AWS gestite e passa alle autorizzazioni con privilegi minimi: per iniziare a concedere autorizzazioni** a utenti e carichi di lavoro, utilizza le *politiche AWS gestite* che concedono le autorizzazioni per molti casi d'uso comuni. Sono disponibili nel tuo. Account AWS Ti consigliamo di ridurre ulteriormente le autorizzazioni definendo politiche gestite dai AWS clienti specifiche per i tuoi casi d'uso. Per maggiori informazioni, consulta [Policy gestite da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) o [Policy gestite da AWS per le funzioni dei processi](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) nella *Guida per l’utente di IAM*.
+ **Applicazione delle autorizzazioni con privilegio minimo** - Quando si impostano le autorizzazioni con le policy IAM, concedere solo le autorizzazioni richieste per eseguire un’attività. È possibile farlo definendo le azioni che possono essere intraprese su risorse specifiche in condizioni specifiche, note anche come *autorizzazioni con privilegio minimo*. Per maggiori informazioni sull’utilizzo di IAM per applicare le autorizzazioni, consulta [Policy e autorizzazioni in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) nella *Guida per l’utente di IAM*.
+ **Condizioni d’uso nelle policy IAM per limitare ulteriormente l’accesso** - Per limitare l’accesso ad azioni e risorse è possibile aggiungere una condizione alle policy. Ad esempio, è possibile scrivere una condizione di policy per specificare che tutte le richieste devono essere inviate utilizzando SSL. Puoi anche utilizzare le condizioni per concedere l'accesso alle azioni del servizio se vengono utilizzate tramite uno specifico Servizio AWS, ad esempio CloudFormation. Per maggiori informazioni, consultare la sezione [Elementi delle policy JSON di IAM: condizione](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) nella *Guida per l’utente di IAM*.
+ **Utilizzo dello strumento di analisi degli accessi IAM per convalidare le policy IAM e garantire autorizzazioni sicure e funzionali** - Lo strumento di analisi degli accessi IAM convalida le policy nuove ed esistenti in modo che aderiscano al linguaggio (JSON) della policy IAM e alle best practice di IAM. Lo strumento di analisi degli accessi IAM offre oltre 100 controlli delle policy e consigli utili per creare policy sicure e funzionali. Per maggiori informazioni, consultare [Convalida delle policy per il Sistema di analisi degli accessi IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) nella *Guida per l’utente di IAM*.
+ **Richiedi l'autenticazione a più fattori (MFA**): se hai uno scenario che richiede utenti IAM o un utente root nel Account AWS tuo, attiva l'MFA per una maggiore sicurezza. Per richiedere la MFA quando vengono chiamate le operazioni API, aggiungere le condizioni MFA alle policy. Per maggiori informazioni, consultare [Protezione dell’accesso API con MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) nella *Guida per l’utente di IAM*.
Per maggiori informazioni sulle best practice in IAM, consulta [Best practice di sicurezza in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) nella *Guida per l’utente di IAM*.
## Utilizzo della console di Aurora
Per accedere alla console Amazon Aurora, è necessario disporre di un set di autorizzazioni minimo. Queste autorizzazioni devono consentirti di elencare e visualizzare i dettagli sulle risorse Amazon Aurora presenti nel tuo. Account AWS Se crei una policy basata sull’identità più restrittiva rispetto alle autorizzazioni minime richieste, la console non funzionerà nel modo previsto per le entità (utenti o ruoli) associate a tale policy.
Non è necessario consentire autorizzazioni minime per la console per gli utenti che effettuano chiamate solo verso o l' AWS CLI API. AWS Al contrario, è possibile accedere solo alle operazioni che soddisfano l'operazione API che stai cercando di eseguire.
Per garantire che tali entità possano ancora utilizzare la console Aurora, allega anche la AWS seguente policy gestita alle entità.
```
AmazonRDSReadOnlyAccess
```
Per maggiori informazioni, consulta [Aggiunta di autorizzazioni a un utente](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) nella *Guida per l’utente di IAM*.
## Autorizzazioni necessarie per l'uso della console
Affinché un utente possa utilizzare la console, è necessario che disponga di un set minimo di autorizzazioni. Queste autorizzazioni consentono all'utente di descrivere le risorse Aurora per il AWS proprio account e di fornire altre informazioni correlate, tra cui informazioni sulla sicurezza e sulla rete di Amazon EC2.
Se decidi di creare una policy IAM più restrittiva delle autorizzazioni minime richieste, la console non funzionerà come previsto per gli utenti con tale policy IAM. Per garantire che gli utenti possano continuare a usare la console, collega anche la policy gestita `AmazonRDSReadOnlyAccess` all'utente, come descritto in [Gestione dell’accesso tramite policy](UsingWithRDS.IAM.md#security_iam_access-manage).
Non sono necessarie le autorizzazioni minime della console per gli utenti che effettuano chiamate solo a AWS CLI o all'API di Amazon RDS.
La seguente politica garantisce l'accesso completo a tutte le risorse Amazon Aurora per l'account root: AWS
```
AmazonRDSFullAccess
```
## Consentire agli utenti di visualizzare le loro autorizzazioni
Questo esempio mostra in che modo è possibile creare una policy che consente agli utenti IAM di visualizzare le policy inline e gestite che sono collegate alla relativa identità utente. Questa policy include le autorizzazioni per completare questa azione sulla console o utilizzando programmaticamente l'API o. AWS CLI AWS
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}
```
# Policy di autorizzazione per creare, modificare ed eliminare risorse in Aurora
Le seguenti sezioni presentano esempi di policy di autorizzazione che concedono e limitano l’accesso alle risorse:
## Consenti a un utente di creare istanze DB in un account AWS
Di seguito è riportato un esempio di politica che consente all'account con l'ID di `123456789012` creare istanze DB per il tuo AWS account. La policy richiede che il nome della nuova istanza database inizi con `test`. La nuova istanza database deve anche utilizzare il motore del database MySQL e la classe di istanza database `db.t2.micro`. Inoltre, la nuova istanza database deve utilizzare un gruppo di opzioni e un gruppo di parametri database che inizia con `default`, e deve utilizzare il gruppo di sottoreti `default`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCreateDBInstanceOnly",
"Effect": "Allow",
"Action": [
"rds:CreateDBInstance"
],
"Resource": [
"arn:aws:rds:*:123456789012:db:test*",
"arn:aws:rds:*:123456789012:og:default*",
"arn:aws:rds:*:123456789012:pg:default*",
"arn:aws:rds:*:123456789012:subgrp:default"
],
"Condition": {
"StringEquals": {
"rds:DatabaseEngine": "mysql",
"rds:DatabaseClass": "db.t2.micro"
}
}
}
]
}
```
------
La policy include una singola istruzione che specifica le autorizzazioni seguenti per l'utente :
+ La policy consente all'account di creare un'istanza DB utilizzando l'operazione [Create DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) API (ciò vale anche per il [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) AWS CLI comando e il Console di gestione AWS).
+ L'elemento `Resource` specifica che l'utente può eseguire azioni in o con altre risorse. Specifica le risorse usando Amazon Resource Name (ARN). Questo ARN include il nome del servizio a cui appartiene la risorsa (`rds`), la AWS regione (`*`indica qualsiasi regione in questo esempio), il numero di AWS account (`123456789012`è il numero di account in questo esempio) e il tipo di risorsa. Per ulteriori informazioni sulla creazione ARNs, vedere[Nome della risorsa Amazon (ARN) in Amazon RDS](USER_Tagging.ARN.md).
L'elemento `Resource` nell'esempio specifica i seguenti vincoli della policy sulle risorse per l'utente:
+ L'identificatore istanze DB per la nuova istanza database deve iniziare con `test` (per esempio, `testCustomerData1`, `test-region2-data`).
+ Il gruppo di opzioni per la nuova istanza database deve iniziare con `default`.
+ Il gruppo di parametri database per la nuova istanza database deve iniziare con `default`.
+ Il gruppo di sottoreti per la nuova istanza database deve essere il gruppo di sottoreti `default`.
+ L'elemento `Condition` specifica che il motore database deve essere MySQL e la classe di istanza database deve essere `db.t2.micro`. L'elemento `Condition` specifica le condizioni quando deve essere applicata una policy. È possibile aggiungere permessi o restrizioni aggiuntivi usando l'elemento `Condition`. Per ulteriori informazioni su come specificare le condizioni;, consulta [Chiavi di condizione delle policy per Aurora](security_iam_service-with-iam.md#UsingWithRDS.IAM.Conditions). Questo esempio specifica le condizioni `rds:DatabaseEngine` e `rds:DatabaseClass`. Per informazioni sui valori delle condizioni validi per`rds:DatabaseEngine`, consultate l'elenco sotto il `Engine` parametro in [Create DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). Per informazioni sui valori di condizione validi per `rds:DatabaseClass`, consulta [Motori di database supportati per classi di istanza database](Concepts.DBInstanceClass.SupportAurora.md).
La policy non specifica l'elemento `Principal` poiché in una policy basata su identità l'entità che ottiene l'autorizzazione non viene specificata. Quando si collega una policy a un utente, quest'ultimo è l'entità implicita. Quando si collega una policy di autorizzazione a un ruolo IAM;, l'entità identificata nella policy di attendibilità del ruolo ottiene le autorizzazioni.
Per visualizzare un elenco di operazioni di Aurora, consulta [Operazioni definite da Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions) nella *Service Authorization Reference*.
## Consentire a un utente di eseguire qualsiasi operazione Describe in qualsiasi risorsa RDS
La seguente policy di autorizzazione concede a un utente le autorizzazioni per eseguire tutte le operazioni che iniziano con `Describe`. Queste operazioni riportano informazioni su una risorsa RDS, ad esempio un'istanza database. Il carattere jolly (\$1) nell'elemento `Resource` indica che le operazioni sono permesse per tutte le risorse Amazon Aurora di proprietà dell'account.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRDSDescribe",
"Effect": "Allow",
"Action": "rds:Describe*",
"Resource": "*"
}
]
}
```
------
## Consentire a un utente di creare un'istanza database che utilizza il gruppo parametri del database e il gruppo di sottorete specificati
La seguente policy di autorizzazioni concede le autorizzazioni per consentire a un utente di creare un'istanza database che deve usare il gruppo di parametri database `mydbpg` e il gruppo di sottorete DB `mydbsubnetgroup`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "rds:CreateDBInstance",
"Resource": [
"arn:aws:rds:*:*:pg:mydbpg",
"arn:aws:rds:*:*:subgrp:mydbsubnetgroup"
]
}
]
}
```
------
## Concedere l'autorizzazione per le operazioni su una risorsa con un tag specifico con due valori diversi
Puoi utilizzare le condizioni nella policy basata sulle identità per controllare l'accesso alle risorse di Aurora in base ai tag. La seguente policy concede l'autorizzazione per eseguire l'operazione API `CreateDBSnapshot` sulle istanze database con il tag `stage` impostato su `development` o `test`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowAnySnapshotName",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:snapshot:*"
},
{
"Sid":"AllowDevTestToCreateSnapshot",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
La seguente policy concede l'autorizzazione per eseguire l'operazione API `ModifyDBInstance` sulle istanze database con il tag `stage` impostato su `development` o `test`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowChangingParameterOptionSecurityGroups",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource": [
"arn:aws:rds:*:123456789012:pg:*",
"arn:aws:rds:*:123456789012:secgrp:*",
"arn:aws:rds:*:123456789012:og:*"
]
},
{
"Sid":"AllowDevTestToModifyInstance",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
## Impedire a un utente di eliminare un'istanza database
La seguente policy di autorizzazione assegna le autorizzazioni per impedire a un utente di eliminare un'istanza database specifica. Ad esempio, potresti voler negare la possibilità di eliminare le istanze database di produzione a qualsiasi utente che non sia un amministratore.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyDelete1",
"Effect": "Deny",
"Action": "rds:DeleteDBInstance",
"Resource": "arn:aws:rds:us-west-2:123456789012:db:my-mysql-instance"
}
]
}
```
------
## Negare tutti gli accessi a una risorsa
È anche possibile negare esplicitamente l'accesso a una risorsa. I criteri di negazione hanno la precedenza sui criteri di autorizzazione. La policy seguente nega esplicitamente a un utente la possibilità di gestire una risorsa:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "rds:*",
"Resource": "arn:aws:rds:us-east-1:123456789012:db:mydb"
}
]
}
```
------
# Policy di esempio: Utilizzo di chiavi di condizione
Di seguito sono illustrati esempi di come è possibile utilizzare le chiavi di condizione nelle policy di autorizzazioni IAM di Amazon Aurora.
## Esempio 1: Concessione dell'autorizzazione per creare un'istanza database che utilizza un motore del database specifico e non è Multi-AZ
La policy seguente utilizza una chiave di condizione RDS e permette a un utente di creare solo istanze database che utilizzano il motore del database MySQL e non utilizzano Multi-AZ. L'elemento `Condition` indica il requisito secondo cui il motore del database deve essere MySQL.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowMySQLCreate",
"Effect": "Allow",
"Action": "rds:CreateDBInstance",
"Resource": "*",
"Condition": {
"StringEquals": {
"rds:DatabaseEngine": "mysql"
},
"Bool": {
"rds:MultiAz": false
}
}
}
]
}
```
------
## Esempio 2: Rifiuto esplicito dell'autorizzazione per creare istanze database per determinate classi di istanze database e per creare istanze database che utilizzano Provisioned IOPS
La policy seguente rifiuta in modo esplicito l'autorizzazione per creare istanze database che utilizzano le classi di istanze database `r3.8xlarge` e `m4.10xlarge`, che sono le istanze database di dimensioni maggiori e più costose. Questa policy impedisce anche gli utenti di creare istanze database che utilizzano Provisioned IOPS, che comporta costi aggiuntivi.
Il rifiuto esplicito di un'autorizzazione prevale su qualsiasi altra autorizzazione concessa. In questo modo si evita che le identità ottengano accidentalmente un'autorizzazione che non desideravi concedere.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyLargeCreate",
"Effect": "Deny",
"Action": "rds:CreateDBInstance",
"Resource": "*",
"Condition": {
"StringEquals": {
"rds:DatabaseClass": [
"db.r3.8xlarge",
"db.m4.10xlarge"
]
}
}
},
{
"Sid": "DenyPIOPSCreate",
"Effect": "Deny",
"Action": "rds:CreateDBInstance",
"Resource": "*",
"Condition": {
"NumericNotEquals": {
"rds:Piops": "0"
}
}
}
]
}
```
------
## Esempio 3: limita il set di chiavi di tag e valori che possono essere utilizzati per aggiungere tag a una risorsa
La policy seguente utilizza una chiave di condizione RDS che consente l'aggiunta di un tag con la chiave `stage` per essere aggiunta alla risorsa con i valori `test`, `qa` e `production`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowTagEdits",
"Effect": "Allow",
"Action": [
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource": "arn:aws:rds:us-east-1:123456789012:db:db-123456",
"Condition": {
"StringEquals": {
"rds:req-tag/stage": [
"test",
"qa",
"production"
]
}
}
}
]
}
```
------
# Specifica delle condizioni: Utilizzo di tag personalizzati
Amazon Aurora permette di specificare condizioni in una policy IAM utilizzando tag personalizzati.
Ad esempio, supponi di aggiungere alle istanze database un tag denominato `environment` con valori quali `beta`, `staging`, `production` e così via. In questo modo, puoi creare una policy che limita alcuni utenti alle istanze database in base al valore del tag `environment`.
**Nota**
Per gli identificatori di tag personalizzati viene fatta distinzione tra maiuscole e minuscole.
Nella tabella seguente sono elencati gli identificatori di tag RDS che è possibile utilizzare in un elemento `Condition`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAM.SpecifyingCustomTags.html)
La sintassi per una condizione di un tag personalizzato è la seguente:
`"Condition":{"StringEquals":{"rds:rds-tag-identifier/tag-name": ["value"]} }`
Ad esempio, l'elemento `Condition` seguente si applica alle istanze database con un tag denominato `environment` e un valore di tag corrispondente a `production`.
` "Condition":{"StringEquals":{"rds:db-tag/environment": ["production"]} } `
Per informazioni sulla creazione di tag, consulta [Etichettatura delle risorse Amazon Aurora e Amazon RDS](USER_Tagging.md).
**Importante**
Se gestisci l'accesso alle risorse RDS tramite tagging, è consigliabile proteggere l'accesso ai tag per le risorse RDS. È possibile gestire l'accesso ai tag creando policy per le operazioni `AddTagsToResource` e `RemoveTagsFromResource`. Ad esempio, la policy seguente nega agli utenti la possibilità di aggiungere o rimuovere tag per tutte le risorse. Puoi quindi creare policy per permettere a utenti specifici di aggiungere o rimuovere tag.
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"DenyTagUpdates",
"Effect":"Deny",
"Action":[
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource":"*"
}
]
}
```
Per visualizzare un elenco di operazioni di Aurora, consulta [Operazioni definite da Amazon RDS](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-actions-as-permissions) nella *Service Authorization Reference*.
## Policy di esempio: Utilizzo di tag personalizzati
Di seguito sono illustrati esempi di come è possibile utilizzare i tag personalizzati nelle policy di autorizzazioni IAM di Amazon Aurora. Per ulteriori informazioni sull'aggiunta di tag a una risorsa Amazon Aurora, consulta [Nome della risorsa Amazon (ARN) in Amazon RDS](USER_Tagging.ARN.md).
**Nota**
Tutti gli esempi utilizzano la regione us-west-2 e contengono account fittizi. IDs
### Esempio 1: Concessione dell'autorizzazione per le operazioni su una risorsa con un tag specifico con due valori diversi
La seguente policy concede l'autorizzazione per eseguire l'operazione API `CreateDBSnapshot` sulle istanze database con il tag `stage` impostato su `development` o `test`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowAnySnapshotName",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:snapshot:*"
},
{
"Sid":"AllowDevTestToCreateSnapshot",
"Effect":"Allow",
"Action":[
"rds:CreateDBSnapshot"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
La seguente policy concede l'autorizzazione per eseguire l'operazione API `ModifyDBInstance` sulle istanze database con il tag `stage` impostato su `development` o `test`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowChangingParameterOptionSecurityGroups",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource": [
"arn:aws:rds:*:123456789012:pg:*",
"arn:aws:rds:*:123456789012:secgrp:*",
"arn:aws:rds:*:123456789012:og:*"
]
},
{
"Sid":"AllowDevTestToModifyInstance",
"Effect":"Allow",
"Action":[
"rds:ModifyDBInstance"
],
"Resource":"arn:aws:rds:*:123456789012:db:*",
"Condition":{
"StringEquals":{
"rds:db-tag/stage":[
"development",
"test"
]
}
}
}
]
}
```
------
### Esempio 2: Rifiuto esplicito dell'autorizzazione per creare un'istanza database che utilizza gruppi di parametri database specificati
La policy seguente rifiuta in modo esplicito l'autorizzazione per creare un'istanza database che utilizza gruppi di parametri database con valori di tag specifici. Puoi applicare questa policy se desideri che uno specifico gruppo di parametri database creato dal cliente venga sempre utilizzato nella creazione di istanze database. Le policy che utilizzano `Deny` servono per lo più a limitare l'accesso concesso da una policy più ampia.
Il rifiuto esplicito di un'autorizzazione prevale su qualsiasi altra autorizzazione concessa. In questo modo si evita che le identità ottengano accidentalmente un'autorizzazione che non desideravi concedere.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"DenyProductionCreate",
"Effect":"Deny",
"Action":"rds:CreateDBInstance",
"Resource":"arn:aws:rds:*:123456789012:pg:*",
"Condition":{
"StringEquals":{
"rds:pg-tag/usage":"prod"
}
}
}
]
}
```
------
### Esempio 3: Concessione dell'autorizzazione per le operazioni in un'istanza database con un nome di istanza che ha come prefisso un nome utente
La policy seguente concede l'autorizzazione per chiamare qualsiasi API (ad eccezione di `AddTagsToResource` o `RemoveTagsFromResource`) in un'istanza database con un nome di istanza che ha come prefisso il nome dell'utente e che dispone di un tag denominato `stage` equivalente a `devo` o che non dispone di un tag `stage`.
La riga `Resource` nella policy identifica una risorsa in base al relativo Amazon Resource Name (ARN). Per ulteriori informazioni sull'utilizzo ARNs con le risorse Amazon Aurora, consulta. [Nome della risorsa Amazon (ARN) in Amazon RDS](USER_Tagging.ARN.md)
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowFullDevAccessNoTags",
"Effect":"Allow",
"NotAction":[
"rds:AddTagsToResource",
"rds:RemoveTagsFromResource"
],
"Resource":"arn:aws:rds:*:123456789012:db:${aws:username}*",
"Condition":{
"StringEqualsIfExists":{
"rds:db-tag/stage":"devo"
}
}
}
]
}
```
------
# Concessione dell’autorizzazione all’applicazione di tag Aurora per le risorse durante la creazione
Alcune operazioni dell’API RDS consentono di specificare tag al momento della creazione delle risorse. È possibile utilizzare i tag delle risorse per implementare il controllo basato sugli attributi (ABAC). Per ulteriori informazioni, consulta A [cosa serve ABAC](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html)? AWS e [Controllo dell'accesso alle AWS risorse tramite tag](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html).
Per essere abilitati a taggare le risorse in fase di creazione, gli utenti devono disporre delle autorizzazioni per utilizzare l’azione che crea la risorsa, ad esempio `rds:CreateDBCluster`. Se i tag vengono specificati nell’azione di creazione, RDS implementa autorizzazioni aggiuntive per l’azione `rds:AddTagsToResource` al fine di verificare se gli utenti dispongono delle autorizzazioni per creare tag. Pertanto, gli utenti devono disporre anche di autorizzazioni esplicite a utilizzare l’azione `rds:AddTagsToResource`.
Nella definizione della policy IAM per l’azione `rds:AddTagsToResource`, è possibile utilizzare la chiave di condizione `aws:RequestTag` per richiedere tag in una richiesta di applicare tag a una risorsa.
Ad esempio, la seguente policy consente agli utenti di creare istanze database e applicare tag durante la creazione di un’istanza database, ma solo con chiavi di tag specifiche (`environment` o `project`):
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds:CreateDBInstance"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"rds:AddTagsToResource"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestTag/environment": ["production", "development"],
"aws:RequestTag/project": ["dataanalytics", "webapp"]
},
"ForAllValues:StringEquals": {
"aws:TagKeys": ["environment", "project"]
}
}
}
]
}
```
------
Questa policy respinge qualsiasi richiesta di creazione di istanza database che includa tag diversi dai tag `environment` o `project` oppure che non specifichi nessuno di questi tag. Inoltre, gli utenti devono specificare i valori per i tag che corrispondono ai valori consentiti nella policy.
La seguente policy consente gli utenti di creare cluster di database e applicare tag durante la creazione ad eccezione del tag `environment=prod`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds:CreateDBCluster"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"rds:AddTagsToResource"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:RequestTag/environment": "prod"
}
}
}
]
}
```
------
## Azioni API RDS supportate per l’applicazione di tag in fase di creazione
Le seguenti azioni dell’API RDS supportano l’applicazione di tag durante la creazione di una risorsa. Per queste azioni, puoi specificare i tag al momento della creazione della risorsa:
+ `CreateBlueGreenDeployment`
+ `CreateCustomDBEngineVersion`
+ `CreateDBCluster`
+ `CreateDBClusterEndpoint`
+ `CreateDBClusterParameterGroup`
+ `CreateDBClusterSnapshot`
+ `CreateDBInstance`
+ `CreateDBInstanceReadReplica`
+ `CreateDBParameterGroup`
+ `CreateDBProxy`
+ `CreateDBProxyEndpoint`
+ `CreateDBSecurityGroup`
+ `CreateDBShardGroup`
+ `CreateDBSnapshot`
+ `CreateDBSubnetGroup`
+ `CreateEventSubscription`
+ `CreateGlobalCluster`
+ `CreateIntegration`
+ `CreateOptionGroup`
+ `CreateTenantDatabase`
+ `CopyDBClusterParameterGroup`
+ `CopyDBClusterSnapshot`
+ `CopyDBParameterGroup`
+ `CopyDBSnapshot`
+ `CopyOptionGroup`
+ `RestoreDBClusterFromS3`
+ `RestoreDBClusterFromSnapshot`
+ `RestoreDBClusterToPointInTime`
+ `RestoreDBInstanceFromDBSnapshot`
+ `RestoreDBInstanceFromS3`
+ `RestoreDBInstanceToPointInTime`
+ `PurchaseReservedDBInstancesOffering`
Se si utilizza l'API AWS CLI or per creare una risorsa con tag, il `Tags` parametro viene utilizzato per applicare i tag alle risorse durante la creazione.
Per queste azioni dell’API, se l’applicazione di tag non riesce, la risorsa non viene creata, la richiesta ha esito negativo e viene restituito un errore. Questo garantisce che le risorse vengano create con i tag o che non vengano create affatto, impedendo così la creazione di risorse senza i tag previsti.
# AWS politiche gestite per Amazon RDS
Per aggiungere autorizzazioni ai set di autorizzazioni e ai ruoli, è più facile utilizzare politiche AWS gestite piuttosto che scrivere politiche da soli. La [creazione di policy gestite dai clienti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) che forniscono al team solo le autorizzazioni di cui ha bisogno richiede tempo e competenza. Per iniziare rapidamente, puoi utilizzare le nostre politiche AWS gestite. Queste policy coprono i casi d’uso comuni e sono disponibili nell’account Account AWS. Per ulteriori informazioni sulle policy AWS gestite, consulta le [policy AWS gestite](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) nella *IAM User Guide*.
Servizi AWS mantenere e aggiornare le politiche AWS gestite. Non è possibile modificare le autorizzazioni nelle politiche AWS gestite. I servizi aggiungono occasionalmente autorizzazioni aggiuntive a una policy AWS gestita per supportare nuove funzionalità. Questo tipo di aggiornamento interessa tutte le identità (set di autorizzazioni e ruoli) a cui è collegata la policy. È più probabile che i servizi aggiornino una politica AWS gestita quando viene lanciata una nuova funzionalità o quando diventano disponibili nuove operazioni. I servizi non rimuovono le autorizzazioni da una policy AWS gestita, quindi gli aggiornamenti delle policy non compromettono le autorizzazioni esistenti.
Inoltre, AWS supporta politiche gestite per le funzioni lavorative che si estendono su più servizi. Ad esempio, la policy `ReadOnlyAccess` AWS gestita fornisce l'accesso in sola lettura a tutte le Servizi AWS risorse. Quando un servizio lancia una nuova funzionalità, AWS aggiunge autorizzazioni di sola lettura per nuove operazioni e risorse. Per l’elenco e la descrizione delle policy di funzione dei processi, consultare la sezione [Policy gestite da AWS per funzioni di processi](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) nella *Guida per l’utente di IAM*.
**Topics**
+ [AWS politica gestita: Amazon RDSRead OnlyAccess](#rds-security-iam-awsmanpol-AmazonRDSReadOnlyAccess)
+ [AWS politica gestita: Amazon RDSFull Access](#rds-security-iam-awsmanpol-AmazonRDSFullAccess)
+ [AWS politica gestita: Amazon RDSData FullAccess](#rds-security-iam-awsmanpol-AmazonRDSDataFullAccess)
+ [AWS politica gestita: Amazon RDSEnhanced MonitoringRole](#rds-security-iam-awsmanpol-AmazonRDSEnhancedMonitoringRole)
+ [AWS politica gestita: Amazon RDSPerformance InsightsReadOnly](#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsReadOnly)
+ [AWS politica gestita: Amazon RDSPerformance InsightsFullAccess](#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsFullAccess)
+ [AWS politica gestita: Amazon RDSDirectory ServiceAccess](#rds-security-iam-awsmanpol-AmazonRDSDirectoryServiceAccess)
+ [AWS politica gestita: Amazon RDSService RolePolicy](#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy)
+ [AWS politica gestita: Amazon RDSPreview ServiceRolePolicy](#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy)
+ [AWS politica gestita: Amazon RDSBeta ServiceRolePolicy](#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy)
## AWS politica gestita: Amazon RDSRead OnlyAccess
Questa policy consente l'accesso in sola lettura ad Amazon RDS tramite. Console di gestione AWS
**Dettagli delle autorizzazioni**
Questa policy include le seguenti autorizzazioni:
+ `rds`: consente ai principali di descrivere le risorse Amazon RDS e di elencare i tag per le risorse Amazon RDS.
+ `cloudwatch`— Consente ai mandanti di ottenere statistiche sui CloudWatch parametri di Amazon.
+ `ec2`: consente ai principali di descrivere le zone di disponibilità e le risorse di rete.
+ `logs`— Consente ai responsabili di descrivere CloudWatch Logs, i flussi di log dei gruppi di log e di ottenere gli eventi di log di Logs. CloudWatch
+ `devops-guru`— Consente ai responsabili di descrivere le risorse che hanno una copertura Amazon DevOps Guru, specificata dai nomi degli CloudFormation stack o dai tag delle risorse.
Per ulteriori informazioni su questa politica, incluso il documento sulla politica JSON, consulta [Amazon RDSRead OnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSReadOnlyAccess.html) nella *AWS Managed Policy Reference Guide*.
## AWS politica gestita: Amazon RDSFull Access
Questa policy fornisce l'accesso completo ad Amazon RDS tramite. Console di gestione AWS
**Dettagli delle autorizzazioni**
Questa policy include le seguenti autorizzazioni:
+ `rds`: consente ai principali l'accesso completo ad Amazon RDS.
+ `application-autoscaling`: consente ai principali di descrivere e gestire gli obiettivi e le policy di dimensionamento di Application Auto Scaling.
+ `cloudwatch`— Consente ai responsabili di ottenere statistiche CloudWatch metriche e gestire gli allarmi. CloudWatch
+ `ec2`: consente ai principali di descrivere le zone di disponibilità e le risorse di rete.
+ `logs`— Consente ai responsabili di descrivere CloudWatch Logs, log, flussi di log dei gruppi di log e ottenere gli eventi di log di Logs. CloudWatch
+ `outposts`— Consente ai principali di ottenere i tipi di istanza. AWS Outposts
+ `pi`: consente ai principali di ottenere i parametri di Performance Insights.
+ `sns`: consente ai principali di accedere a iscrizioni e argomenti Amazon Simple Notification Service (Amazon SNS) e di pubblicare messaggi Amazon SNS.
+ `devops-guru`— Consente ai responsabili di descrivere le risorse che hanno una copertura Amazon DevOps Guru, specificata dai nomi degli CloudFormation stack o dai tag delle risorse.
Per ulteriori informazioni su questa politica, incluso il documento sulla politica JSON, consulta [Amazon RDSFull Access](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSFullAccess.html) nella *AWS Managed Policy Reference Guide*.
## AWS politica gestita: Amazon RDSData FullAccess
Questa politica consente l'accesso completo all'utilizzo della Data API e dell'editor di query sui Aurora Serverless cluster in uno specifico Account AWS. Questa politica consente di Account AWS ottenere il valore di un segreto da Gestione dei segreti AWS.
È possibile allegare la policy `AmazonRDSDataFullAccess` alle identità IAM.
**Dettagli delle autorizzazioni**
Questa policy include le seguenti autorizzazioni:
+ `dbqms`: consente ai principali di accedere, creare, eliminare, descrivere e aggiornare le query. Il Database Query Metadata Service (`dbqms`) è un servizio solo interno. Fornisce le tue query recenti e salvate per l'editor di query su Console di gestione AWS for multiple Servizi AWS, incluso Amazon RDS.
+ `rds-data`: consente ai principali di eseguire istruzioni SQL su database Aurora Serverless.
+ `secretsmanager`— Consente ai mandanti di ottenere il valore di un segreto da. Gestione dei segreti AWS
Per ulteriori informazioni su questa politica, incluso il documento sulla politica JSON, consulta [Amazon RDSData FullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSDataFullAccess.html) nella *AWS Managed Policy Reference Guide*.
## AWS politica gestita: Amazon RDSEnhanced MonitoringRole
Questa policy fornisce l'accesso ad Amazon CloudWatch Logs for Amazon RDS Enhanced Monitoring.
**Dettagli delle autorizzazioni**
Questa policy include le seguenti autorizzazioni:
+ `logs`— Consente ai responsabili di creare CloudWatch Logs, gruppi di log e politiche di conservazione e di creare e descrivere i flussi di log CloudWatch Logs dei gruppi di log. Consente inoltre ai responsabili di inserire e ottenere gli eventi di log dei Logs. CloudWatch
Per ulteriori informazioni su questa politica, incluso il documento sulla politica JSON, consulta [Amazon RDSEnhanced MonitoringRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSEnhancedMonitoringRole.html) nella *AWS Managed Policy Reference Guide*.
## AWS politica gestita: Amazon RDSPerformance InsightsReadOnly
Questa policy fornisce accesso in sola lettura alle istanze Amazon RDS Performance Insights per istanze database Amazon RDS e cluster di database Amazon Aurora.
Questa policy ora include `Sid` (ID istruzione) come identificativo per l'istruzione della policy.
**Dettagli delle autorizzazioni**
Questa policy include le seguenti autorizzazioni:
+ `rds`: consente ai principali di descrivere le istanze database Amazon RDS e i cluster di database Amazon Aurora.
+ `pi`: consente ai principali di effettuare chiamate all'API Amazon RDS Performance Insights e accedere ai parametri di Performance Insights.
Per ulteriori informazioni su questa politica, incluso il documento sulla politica JSON, consulta [Amazon RDSPerformance InsightsReadOnly](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPerformanceInsightsReadOnly.html) nella *AWS Managed Policy Reference Guide*.
## AWS politica gestita: Amazon RDSPerformance InsightsFullAccess
Questa policy fornisce l'accesso completo ad Approfondimenti sulle prestazioni di Amazon RDS per istanze database Amazon RDS e cluster database Amazon Aurora.
Questa policy ora include `Sid` (ID istruzione) come identificativo per l'istruzione della policy.
**Dettagli delle autorizzazioni**
Questa policy include le seguenti autorizzazioni:
+ `rds`: consente ai principali di descrivere le istanze database Amazon RDS e i cluster di database Amazon Aurora.
+ `pi`: consente ai principali di effettuare chiamate all'API Approfondimenti sulle prestazioni di Amazon RDS e di creare, visualizzare ed eliminare report di analisi delle prestazioni.
+ `cloudwatch`— Consente ai responsabili di elencare tutte le CloudWatch metriche di Amazon e ottenere dati e statistiche sui parametri.
Per ulteriori informazioni su questa politica, incluso il documento sulla politica JSON, consulta [Amazon RDSPerformance InsightsFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPerformanceInsightsFullAccess.html) nella *AWS Managed Policy Reference Guide*.
## AWS politica gestita: Amazon RDSDirectory ServiceAccess
Questa policy permette ad Amazon RDS di effettuare chiamate alla Directory Service.
**Dettagli delle autorizzazioni**
Questa policy include la seguente autorizzazione:
+ `ds`— Consente ai responsabili di descrivere le Directory Service directory e di controllare l'autorizzazione alle Directory Service directory.
Per ulteriori informazioni su questa politica, incluso il documento sulla politica JSON, consulta [Amazon RDSDirectory ServiceAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSDirectoryServiceAccess.html) nella *AWS Managed Policy Reference Guide*.
## AWS politica gestita: Amazon RDSService RolePolicy
Non è possibile allegare la policy `AmazonRDSServiceRolePolicy` alle entità IAM. Questa policy è allegata a un ruolo collegato ai servizi che consente ad Amazon RDS di eseguire operazioni per conto dell'utente. Per ulteriori informazioni, consulta [Autorizzazioni del ruolo collegato ai servizi per Amazon Aurora](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions).
## AWS politica gestita: Amazon RDSPreview ServiceRolePolicy
Non bisogna collegare `AmazonRDSPreviewServiceRolePolicy` alle entità IAM. Questa policy è associata a un ruolo collegato al servizio che consente ad Amazon RDS di chiamare i AWS servizi per conto delle tue risorse DB RDS. Per ulteriori informazioni, consulta [Ruolo collegato ai servizi per Amazon RDS Preview](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-rdspreview).
**Dettagli delle autorizzazioni**
Questa policy include le seguenti autorizzazioni:
+ `ec2`: consente ai principali di descrivere le zone di disponibilità e le risorse di rete.
+ `secretsmanager`— Consente ai responsabili di ottenere il valore di un segreto da. Gestione dei segreti AWS
+ `cloudwatch`, `logs` ‐ Consente ad Amazon RDS di caricare i parametri e i log delle istanze DB tramite agente. CloudWatch CloudWatch
Per ulteriori informazioni su questa politica, incluso il documento sulla politica JSON, consulta [Amazon RDSPreview ServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSPreviewServiceRolePolicy.html) nella *AWS Managed Policy Reference Guide*.
## AWS politica gestita: Amazon RDSBeta ServiceRolePolicy
Non bisogna collegare `AmazonRDSBetaServiceRolePolicy` alle entità IAM. Questa policy è associata a un ruolo collegato al servizio che consente ad Amazon RDS di chiamare i AWS servizi per conto delle tue risorse DB RDS. Per ulteriori informazioni, consulta [Autorizzazioni del ruolo collegato ai servizi per Amazon RDS Beta](UsingWithRDS.IAM.ServiceLinkedRoles.md#slr-permissions-rdsbeta).
**Dettagli delle autorizzazioni**
Questa policy include le seguenti autorizzazioni:
+ `ec2`‐ Consente ad Amazon RDS di eseguire operazioni di backup sull'istanza DB che fornisce funzionalità di point-in-time ripristino.
+ `secretsmanager`: consente ad Amazon RDS di gestire i segreti specifici delle istanze database creati da Amazon RDS.
+ `cloudwatch`, `logs` ‐ Consente ad Amazon RDS di caricare i parametri e i log delle istanze DB tramite agente. CloudWatch CloudWatch
Per ulteriori informazioni su questa politica, incluso il documento sulla politica JSON, consulta [Amazon RDSBeta ServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSBetaServiceRolePolicy.html) nella *AWS Managed Policy Reference Guide*.
# Aggiornamenti di Amazon RDS sulle policy gestite da AWS
Visualizza i dettagli sugli aggiornamenti alle policy gestite da AWS per Amazon RDS da quando questo servizio ha iniziato a tenere traccia delle modifiche. Per gli avvisi automatici sulle modifiche apportate a questa pagina, sottoscrivere il feed RSS nella pagina di [Cronologia dei documenti](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/WhatsNew.html) di Amazon RDS.
| Modifica | Descrizione | Data |
| --- | --- | --- |
| [AWS politica gestita: Amazon RDSPreview ServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy): aggiornamento a policy esistente | Amazon RDS ha rimosso l’autorizzazione `sns:Publish` dalla policy `AmazonRDSPreviewServiceRolePolicy` del ruolo collegato al servizio `AWSServiceRoleForRDSPreview`. Per ulteriori informazioni, consulta [AWS politica gestita: Amazon RDSPreview ServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPreviewServiceRolePolicy). | 7 agosto 2024 |
| [AWS politica gestita: Amazon RDSBeta ServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy): aggiornamento a policy esistente | Amazon RDS ha rimosso l’autorizzazione `sns:Publish` dalla policy `AmazonRDSBetaServiceRolePolicy` del ruolo collegato al servizio `AWSServiceRoleForRDSBeta`. Per ulteriori informazioni, consulta [AWS politica gestita: Amazon RDSBeta ServiceRolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSBetaServiceRolePolicy). | 7 agosto 2024 |
| [AWS politica gestita: Amazon RDSService RolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy): aggiornamento a policy esistente | Amazon RDS ha rimosso l’autorizzazione `sns:Publish` dalla policy `AmazonRDSServiceRolePolicy` del ruolo collegato al servizio ` AWSServiceRoleForRDS`. Per ulteriori informazioni, consulta [AWS politica gestita: Amazon RDSService RolePolicy](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSServiceRolePolicy). | 2 luglio 2024 |
| [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md): aggiornamento a policy esistente | Amazon RDS ha aggiunto una nuova autorizzazione alla policy `AmazonRDSCustomServiceRolePolicy` del ruolo collegato al servizio `AWSServiceRoleForRDSCustom` per consentire a RDS Custom per SQL Server di modificare il tipo di istanza host del database sottostante. RDS ha inoltre aggiunto l’autorizzazione `ec2:DescribeInstanceTypes` per ottenere informazioni sul tipo di istanza per l’host del database. Per ulteriori informazioni, consulta [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md). | 8 aprile 2024 |
| [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md): nuova policy | Amazon RDS ha aggiunto una nuova policy gestita denominata AmazonRDSCustomInstanceProfileRolePolicy per consentire a RDS Custom di eseguire azioni di automazione e attività di gestione del database tramite un profilo dell’istanza EC2. Per ulteriori informazioni, consulta [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md). | 27 febbraio 2024 |
| [Autorizzazioni del ruolo collegato ai servizi per Amazon Aurora](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): aggiornamento a una policy esistente | Amazon RDS ha aggiunto nuovi ID istruzione alla policy `AmazonRDSServiceRolePolicy` del ruolo collegato al servizio `AWSServiceRoleForRDS`. Per ulteriori informazioni, consulta [Autorizzazioni del ruolo collegato ai servizi per Amazon Aurora](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions). | 19 gennaio 2024 |
| [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md): aggiornamento a policy esistenti | Le policy gestite `AmazonRDSPerformanceInsightsReadOnly` e `AmazonRDSPerformanceInsightsFullAccess` ora includono `Sid` (ID istruzione) come identificativo nell'istruzione della policy. Per ulteriori informazioni, consulta [AWS politica gestita: Amazon RDSPerformance InsightsReadOnly](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsReadOnly) e [AWS politica gestita: Amazon RDSPerformance InsightsFullAccess](rds-security-iam-awsmanpol.md#rds-security-iam-awsmanpol-AmazonRDSPerformanceInsightsFullAccess). | 23 ottobre 2023 |
| [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md): aggiornamento a policy esistente | Amazon RDS ha aggiunto nuove autorizzazioni alla policy gestita `AmazonRDSFullAccess`. Le autorizzazioni consentono di generare, visualizzare ed eliminare il report di analisi delle prestazioni per un periodo di tempo. Per ulteriori informazioni sulla configurazione delle policy di accesso per Performance Insights, consulta [Configurazione delle policy di accesso per Performance Insights](USER_PerfInsights.access-control.md) | 17 agosto 2023 |
| [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md): nuova policy e aggiornamento a una policy esistente | Amazon RDS ha aggiunto nuove autorizzazioni alla policy gestita `AmazonRDSPerformanceInsightsReadOnly`e una nuova policy gestita denominata `AmazonRDSPerformanceInsightsFullAccess`. Queste autorizzazioni consentono di analizzare Performance Insights per un periodo di tempo, visualizzare i risultati dell'analisi insieme ai suggerimenti ed eliminare i report. Per ulteriori informazioni sulla configurazione delle policy di accesso per Performance Insights, consulta [Configurazione delle policy di accesso per Performance Insights](USER_PerfInsights.access-control.md) | 16 agosto 2023 |
| [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md): aggiornamento a una policy esistente | Amazon RDS ha aggiunto un nuovo spazio dei nomi Amazon CloudWatch `ListMetrics` a `AmazonRDSFullAccess` e `AmazonRDSReadOnlyAccess`. Questo spazio dei nomi è necessario affinché Amazon RDS elenchi specifici parametri di utilizzo delle risorse. Per ulteriori informazioni, consulta [Panoramica sulla gestione delle autorizzazioni di accesso alle risorse CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-access-control-overview-cw.html) nella *Guida per l'utente di Amazon CloudWatch*. | 4 aprile 2023 |
| [Autorizzazioni del ruolo collegato ai servizi per Amazon Aurora](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): aggiornamento a una policy esistente | Amazon RDS ha aggiunto nuove autorizzazioni alla `AmazonRDSServiceRolePolicy` del ruolo collegato al servizio `AWSServiceRoleForRDS` per l'integrazione con Gestione dei segreti AWS. RDS richiede l'integrazione con Secrets Manager per la gestione delle password degli utenti master in Secrets Manager. Il segreto utilizza una convenzione di denominazione riservata e limita gli aggiornamenti del cliente. Per ulteriori informazioni, consulta [Gestione delle password con Amazon Aurora e Gestione dei segreti AWS](rds-secrets-manager.md). | 22 dicembre 2022 |
| [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md): aggiornamento a policy esistenti | Amazon RDS ha aggiunto una nuova autorizzazione alle policy gestite `AmazonRDSFullAccess` e `AmazonRDSReadOnlyAccess` per consentire di attivare Amazon DevOps Guru nella console RDS. Questa autorizzazione è necessaria per verificare se DevOps Guru è attivato. Per ulteriori informazioni, consulta [Configurazione delle politiche di accesso IAM per Guru for RDS DevOps](devops-guru-for-rds.md#devops-guru-for-rds.configuring.access). | 19 dicembre 2022 |
| [Autorizzazioni del ruolo collegato ai servizi per Amazon Aurora](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): aggiornamento a una policy esistente | Amazon RDS ha aggiunto un nuovo spazio dei nomi Amazon CloudWatch ad `AmazonRDSPreviewServiceRolePolicy` per `PutMetricData`. Questo spazio dei nomi è necessario affinché Amazon RDS pubblichi i parametri di utilizzo delle risorse. Per ulteriori informazioni, consultare [Utilizzo delle chiavi di condizione per limitare l’accesso agli spazi dei nomi di CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) nella *Guida per l’utente di Amazon CloudWatch*. | 7 luglio 2022 |
| [Autorizzazioni del ruolo collegato ai servizi per Amazon Aurora](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): aggiornamento a una policy esistente | Amazon RDS ha aggiunto un nuovo spazio dei nomi Amazon CloudWatch ad `AmazonRDSBetaServiceRolePolicy` per `PutMetricData`. Questo spazio dei nomi è necessario affinché Amazon RDS pubblichi i parametri di utilizzo delle risorse. Per ulteriori informazioni, consultare [Utilizzo delle chiavi di condizione per limitare l’accesso agli spazi dei nomi di CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) nella *Guida per l’utente di Amazon CloudWatch*. | 7 luglio 2022 |
| [Autorizzazioni del ruolo collegato ai servizi per Amazon Aurora](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): aggiornamento a una policy esistente | Amazon RDS ha aggiunto un nuovo spazio dei nomi Amazon CloudWatch ad `AWSServiceRoleForRDS` per `PutMetricData`. Questo spazio dei nomi è necessario affinché Amazon RDS pubblichi i parametri di utilizzo delle risorse. Per ulteriori informazioni, consultare [Utilizzo delle chiavi di condizione per limitare l’accesso agli spazi dei nomi di CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) nella *Guida per l’utente di Amazon CloudWatch*. | 22 aprile 2022 |
| [AWS politiche gestite per Amazon RDS](rds-security-iam-awsmanpol.md): nuova policy | Amazon RDS ha aggiunto una nuova policy gestita denominata `AmazonRDSPerformanceInsightsReadOnly` per consentire ad Amazon RDS di chiamare i servizi AWS per conto delle istanze database. Per ulteriori informazioni sulla configurazione delle policy di accesso per Performance Insights, consulta [Configurazione delle policy di accesso per Performance Insights](USER_PerfInsights.access-control.md) | 10 marzo 2022 |
| [Autorizzazioni del ruolo collegato ai servizi per Amazon Aurora](UsingWithRDS.IAM.ServiceLinkedRoles.md#service-linked-role-permissions): aggiornamento a una policy esistente | Amazon RDS ha aggiunto nuovi namespace Amazon CloudWatch a `AWSServiceRoleForRDS` per `PutMetricData`. Questi spazi dei nomi servono ad Amazon DocumentDB (con compatibilità MongoDB) e Amazon Neptune per pubblicare i parametri di CloudWatch. Per ulteriori informazioni, consultare [Utilizzo delle chiavi di condizione per limitare l’accesso agli spazi dei nomi di CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/iam-cw-condition-keys-namespace.html) nella *Guida per l’utente di Amazon CloudWatch*. | 4 marzo 2022 |
| Amazon RDS ha iniziato a monitorare le modifiche | Amazon RDS ha iniziato a tenere traccia delle modifiche per le sue policy gestite da AWS. | 26 ottobre 2021 |
# Prevenzione del problema "confused deputy" tra servizi
Il *problema confused deputy* è un problema di sicurezza in cui un’entità che non dispone dell’autorizzazione per eseguire un’azione può costringere un’entità maggiormente privilegiata a eseguire l’azione. InoltreAWS, l'impersonificazione tra diversi servizi può portare alla confusione del vicesceriffo.
La rappresentazione tra servizi può verificarsi quando un servizio (il *servizio chiamante*) effettua una chiamata a un altro servizio (il *servizio chiamato*). Il servizio chiamante può essere manipolato per utilizzare le proprie autorizzazioni e agire sulle risorse di un altro cliente, a cui normalmente non avrebbe accesso. Per evitare che ciò accada, AWS fornisce strumenti che possono aiutarvi a proteggere i vostri dati per tutti i servizi, con responsabili del servizio a cui è stato concesso l'accesso alle risorse del vostro account. Per ulteriori informazioni, consultare [Problema del "confused deputy"](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) nella *Guida per l'utente di IAM*.
Per limitare le autorizzazioni alle risorse che Amazon RDS fornisce a un altro servizio per una risorsa specifica, si consiglia di utilizzare le chiavi di contesto delle condizioni globali [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) e [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) nelle policy delle risorse.
In alcuni casi, il valore `aws:SourceArn` non contiene l'ID dell'account, ad esempio quando utilizzi Amazon Resource Name (ARN) per un bucket Simple Storage Service (Amazon S3). In questi casi, assicurati di utilizzare entrambe le chiavi di contesto delle condizioni globali per limitare le autorizzazioni. In alcuni casi, si utilizzano le chiavi di contesto delle condizioni globali e il valore `aws:SourceArn` contiene l'ID dell'account. In questi casi, assicurati che il valore `aws:SourceAccount` e l'account in `aws:SourceArn` utilizzano lo stesso ID dell'account quando vengono utilizzati nella stessa dichiarazione di policy. Utilizza `aws:SourceArn` se desideri consentire l'associazione di una sola risorsa all'accesso tra servizi. Se desideri consentire l'associazione di qualsiasi risorsa nell'AWSaccount specificato all'utilizzo tra servizi, utilizza. `aws:SourceAccount`
Assicurati che il valore di `aws:SourceArn` sia un ARN per un tipo di risorsa Amazon RDS. Per ulteriori informazioni, consulta [Nome della risorsa Amazon (ARN) in Amazon RDS](USER_Tagging.ARN.md).
Il modo più efficace per proteggersi dal problema "confused deputy" è quello di usare la chiave di contesto della condizione globale `aws:SourceArn` con l'ARN completo della risorsa. In alcuni casi, potresti non conoscere l'ARN completo della risorsa o potresti specificare più risorse. In questi casi, utilizza la chiave di contesto delle condizioni globali `aws:SourceArn` con caratteri jolly (`*`) per le parti sconosciute dell'ARN. Un esempio è `arn:aws:rds:*:123456789012:*`.
L'esempio seguente mostra il modo in cui puoi utilizzare le chiavi di contesto `aws:SourceArn` e `aws:SourceAccount` delle condizioni globali in Amazon RDS per prevenire il problema “confused deputy”.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "ConfusedDeputyPreventionExamplePolicy",
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:rds:us-east-1:123456789012:db:mydbinstance"
},
"StringEquals": {
"aws:SourceAccount": "123456789012"
}
}
}
}
```
------
Per altri esempi di policy che utilizzano le chiavi di contesto delle condizioni globali `aws:SourceArn` e `aws:SourceAccount`, consulta le sezioni seguenti:
+ [Concessione di autorizzazioni per pubblicare le notifiche in un argomento Amazon SNS](USER_Events.GrantingPermissions.md)
+ [Configurazione dell'accesso a un bucket Simple Storage Service (Amazon S3)](USER_PostgreSQL.S3Import.AccessPermission.md) (importazione PostgreSQL)
+ [Configurazione dell'accesso a un bucket Amazon S3](postgresql-s3-export-access-bucket.md) (esportazione PostgreSQL)
# Autenticazione del database IAM
Puoi autenticarti nel tuo cluster di DB utilizzando l'autenticazione del database AWS Identity and Access Management (IAM). L'autenticazione del database IAM funziona con Aurora MySQL e Aurora PostgreSQL. Con questo metodo di autenticazione, non devi utilizzare una password quando esegui la connessione al cluster database. Utilizzi invece un token di autenticazione.
Un *token di autenticazione* è una stringa univoca di caratteri generata da Amazon Aurora su richiesta. I token di autenticazione vengono generati utilizzando la versione 4 di AWS Signature. Ciascun token ha un ciclo di vita di 15 minuti. Non devi archiviare le credenziali dell'utente nel database, perché l'autenticazione è gestita esternamente utilizzando IAM. Puoi anche utilizzare ancora l'autenticazione standard del database. Il token viene utilizzato solo per l'autenticazione e non influisce sulla sessione dopo che è stato stabilito.
L'autenticazione del database IAM fornisce i seguenti vantaggi:
+ Il traffico di rete da e verso il database viene crittografato utilizzando Secure Socket Layer (SSL) o Transport Layer Security (TLS). Per ulteriori informazioni sull'utilizzo SSL/TLS con Aurora, consulta. [Utilizzo SSL/TLS per crittografare una connessione a un'](UsingWithRDS.SSL.md)
+ Puoi usare IAM per gestire in modo centralizzato l'accesso alle risorse del database invece di gestire l'accesso singolarmente in ogni cluster database.
+ Per le applicazioni in esecuzione su Amazon EC2, puoi utilizzare le credenziali specifiche dell'istanza EC2 per accedere al database invece di una password, per maggiore sicurezza.
In generale, prendi in considerazione l'utilizzo dell'autenticazione del database IAM quando le applicazioni creano meno di 200 connessioni al secondo e non desideri gestire nomi utente e password direttamente nel codice dell'applicazione.
Il driver JDBC Amazon Web Services (AWS) supporta l’autenticazione del database IAM. Per ulteriori informazioni, consulta [AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) nel [repository di driver GitHub JDBC di Amazon Web Services (AWS)](https://github.com/aws/aws-advanced-jdbc-wrapper).
Il driver Python Amazon Web Services (AWS) supporta l’autenticazione del database IAM. Per ulteriori informazioni, consulta [AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-python-wrapper/blob/main/docs/using-the-python-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) nel repository [Python Driver GitHub di Amazon Web Services (AWS)](https://github.com/aws/aws-advanced-python-wrapper).
Per apprendere il processo di impostazione di IAM per l’autenticazione del database, consulta i seguenti argomenti:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Connessione al cluster di database tramite l'autenticazione IAM](UsingWithRDS.IAMDBAuth.Connecting.md)
## Disponibilità di regioni e versioni
La disponibilità e il supporto della funzionalità varia a seconda delle versioni specifiche di ciascun motore di database Aurora e in tutte le Regioni AWS. Per ulteriori informazioni sulla disponibilità di versioni e Regioni per l'autenticazione del database Aurora e IAM, consulta [Regioni e motori di database Aurora supportati per l’autenticazione del database IAM](Concepts.Aurora_Fea_Regions_DB-eng.Feature.IAMdbauth.md).
Per Aurora MySQL, tutte le classi di istanza database supportate supportano l'autenticazione del database IAM, ad eccezione di db.t2.small e db.t3.small. Per informazioni sulle classi di istanza database supportate, consulta [Motori di database supportati per classi di istanza database](Concepts.DBInstanceClass.SupportAurora.md).
## Supporto per CLI e SDK
L'autenticazione del database IAM è disponibile per [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/generate-db-auth-token.html)e per i seguenti linguaggi: AWS SDKs
+ [AWS SDK per .NET](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/RDS/TRDSAuthTokenGenerator.html)
+ [AWS SDK per C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/class_aws_1_1_r_d_s_1_1_r_d_s_client.html#ae134ffffed5d7672f6156d324e7bd392)
+ [AWS SDK per Go](https://docs.aws.amazon.com/sdk-for-go/api/service/rds/#pkg-overview)
+ [AWS SDK per Java](https://docs.aws.amazon.com/sdk-for-java/latest/reference/software/amazon/awssdk/services/rds/RdsUtilities.html)
+ [AWS SDK per JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_rds_signer.html)
+ [AWS SDK per PHP](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.Rds.AuthTokenGenerator.html)
+ [AWS SDK per Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.generate_db_auth_token)
+ [AWS SDK per Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/RDS/AuthTokenGenerator.html)
## Limitazioni per l'autenticazione database IAM
Quando utilizzi l'autenticazione database IAM, tieni presenti le seguenti limitazioni:
+ Attualmente, l'autenticazione database IAM non supporta nessuna delle chiavi di contesto delle condizioni globali.
Per ulteriori informazioni sulle chiavi di contesto delle condizioni globali, consulta [Chiavi di contesto delle condizioni globali AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) nella *Guida per l'utente di IAM*.
+ Per PostgreSQL, se il ruolo IAM (`rds_iam`) viene aggiunto a un utente (incluso l'utente principale RDS), l'autenticazione IAM ha la precedenza sull'autenticazione tramite password, quindi l'utente deve accedere come un utente IAM.
+ Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint del cluster di databaseper generare il token di autenticazione.
+ CloudWatch e CloudTrail non registrate l'autenticazione IAM. Questi servizi non tengono traccia delle chiamate API `generate-db-auth-token` che autorizzano il ruolo IAM a consentire la connessione al database.
+ L’autenticazione del database IAM richiede risorse di calcolo sul cluster di database. Per una connettività affidabile è necessario disporre di una memoria aggiuntiva compresa tra 300 e 1000 MiB nel database. Per individuare la memoria necessaria per il carico di lavoro, si confronta la colonna RES per i processi RDS nell’elenco dei processi di monitoraggio avanzato prima e dopo aver abilitato l’autenticazione del database IAM. Per informazioni, consulta [Visualizzazione delle metriche nella console RDS](USER_Monitoring.OS.Viewing.md).
Se si utilizza un’istanza di classe espandibile, evitare di esaurire la memoria riducendo della stessa quantità la memoria utilizzata da altri parametri, come buffer e cache.
+ Per Aurora MySQL, non è possibile utilizzare l'autenticazione basata su password per un utente del database configurato con l'autenticazione IAM.
+ L’autenticazione del database IAM non è supportata per RDS su Outposts per tutti i motori.
## Consigli per l'autenticazione del database IAM
Quando si utilizza l'autenticazione del database IAM, è consigliabile procedere come segue:
+ Utilizzare l'autenticazione del database IAM quando l'applicazione richiede meno di 200 nuove connessioni di autenticazione del database IAM al secondo.
I motori di database che funzionano con Amazon Aurora non prevedono limitazioni per i tentativi di autenticazione al secondo. Tuttavia, quando utilizzi un'autenticazione database IAM, l'applicazione deve generare un token di autenticazione. L'applicazione usa quindi il token per connettersi al cluster database. Se eccedi il limite massimo di nuove connessioni al secondo, la gestione extra dell'autenticazione database IAM può causare throttling della connessione.
Valuta la possibilità di utilizzare il pool di connessioni nelle applicazioni per mitigare la creazione continua di connessioni. Questo può ridurre il sovraccarico derivante dall'autenticazione DB IAM e consentire alle applicazioni di riutilizzare le connessioni esistenti. In alternativa, per questi casi d'uso considera l'utilizzo di Server proxy per RDS. Per Server proxy per RDS sono previsti costi aggiuntivi. Consulta i [prezzi per Server proxy per RDS](https://aws.amazon.com/rds/proxy/pricing/).
+ La dimensione di un token di autenticazione del database IAM dipende da molti fattori, tra cui il numero di tag IAM, le policy di servizio IAM, la lunghezza del nome della risorsa Amazon (ARN) e altre proprietà IAM e del database. La dimensione minima del token è generalmente di circa 1 KB, ma può essere maggiore. Poiché questo token viene utilizzato come password nella stringa di connessione al database mediante l'autenticazione IAM, è necessario assicurarsi che il driver del database (ad esempio ODBC) and/or non limiti o altrimenti tronchi questo token a causa delle sue dimensioni. Un token troncato causa l'esito negativo della convalida dell'autenticazione effettuata dal database e da IAM.
+ Se si utilizzano credenziali temporanee durante la creazione di un token di autenticazione del database IAM, le credenziali temporanee devono essere ancora valide quando si utilizza il token di autenticazione del database IAM per effettuare una richiesta di connessione.
## Chiavi di contesto relative alle condizioni globali non supportate AWS
L'autenticazione del database IAM non supporta il seguente sottoinsieme di chiavi di contesto delle condizioni AWS globali.
+ `aws:Referer`
+ `aws:SourceIp`
+ `aws:SourceVpc`
+ `aws:SourceVpce`
+ `aws:UserAgent`
+ `aws:VpcSourceIp`
Per ulteriori informazioni, consultare [Chiavi di contesto delle condizioni globali AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) nella *Guida per l'utente IAM*.
# Abilitazione e disabilitazione dell’autenticazione database IAM
Per impostazione predefinita, l’autenticazione database IAM è disabilitata nei cluster database. Puoi abilitare o disabilitare l'autenticazione del database IAM utilizzando Console di gestione AWS AWS CLI, o l'API.
Puoi abilitare l’autenticazione database IAM quando esegui una delle seguenti operazioni:
+ Per creare un nuovo cluster di database con l’autenticazione database IAM abilitata, consulta [Creazione di un cluster database Amazon Aurora](Aurora.CreateInstance.md).
+ Per modificare un cluster di database per abilitare l’autenticazione database IAM, consulta [Modifica di un cluster database Amazon Aurora](Aurora.Modifying.md).
+ Per ripristinare un cluster di database da uno snapshot con l’autenticazione del database IAM abilitata, consulta [Ripristino da uno snapshot cluster database](aurora-restore-snapshot.md).
+ Per ripristinare un cluster database a un momento specifico con l’autenticazione del database IAM abilitata, consulta [Ripristino di un cluster di database a un determinato momento](aurora-pitr.md).
## Console
Ogni flusso di lavoro di creazione o modifica include una sezione **Database authentication (Autenticazione database)** in cui puoi abilitare o disabilitare l’autenticazione database IAM. In questa sezione scegli **Password and IAM database authentication (Autenticazione password e database IAM)** per abilitare l’autenticazione database IAM.
**Per abilitare o disabilitare l’autenticazione database IAM per un cluster di database esistente**
1. Aprire la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegliere **Databases (Database)**.
1. Scegliere il cluster database che si vuole modificare.
**Nota**
Puoi abilitare l’autenticazione IAM solo se tutte le istanze database nel cluster di database sono compatibili con IAM. Controllare i requisiti di compatibilità in [Disponibilità di regioni e versioni](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
1. Scegliere **Modify (Modifica)**.
1. Nella sezione **Autenticazione del database**, scegli Autenticazione del **database IAM per abilitare l'**autenticazione del database IAM. Scegli **Autenticazione password** o **Autenticazione di password e Kerberos** per disabilitare l’autenticazione IAM.
1. Puoi anche scegliere di abilitare la pubblicazione dei log di autenticazione IAM DB su Logs. CloudWatch In **Esportazioni di log**, scegli l'opzione **iam-db-auth-error log**. La pubblicazione dei log in CloudWatch Logs consuma spazio di archiviazione e comporta l'addebito di costi per tale archiviazione. Assicurati di eliminare tutti i CloudWatch log che non ti servono più.
1. Scegli **Continue (Continua)**.
1. Per applicare immediatamente le modifiche, scegli **Immediately (Immediatamente)** nella sezione **Scheduling of modifications (Pianificazione delle modifiche)**.
1. Scegliere **Modify cluster (Modifica cluster)**.
## AWS CLI
Per creare un nuovo cluster DB con autenticazione IAM utilizzando il AWS CLI, usa il [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html)comando. Specifica l’opzione `--enable-iam-database-authentication`.
Per aggiornare un cluster di database esistente in modo da abilitare o disabilitare l’autenticazione IAM, utilizzare il comando AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html). Specifica l’opzione `--enable-iam-database-authentication` o `--no-enable-iam-database-authentication`, come appropriato.
**Nota**
Puoi abilitare l’autenticazione IAM solo se tutte le istanze database nel cluster di database sono compatibili con IAM. Controllare i requisiti di compatibilità in [Disponibilità di regioni e versioni](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Per impostazione predefinita, Aurora esegue la modifica durante la finestra di manutenzione successiva. Se desideri sostituire ciò e abilitare l’autenticazione database IAM il prima possibile, utilizza il parametro `--apply-immediately`.
Se stai ripristinando un cluster di DB, usa uno dei seguenti AWS CLI comandi:
+ `[restore-db-cluster-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-to-point-in-time.html)`
+ `[restore-db-cluster-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)`
L’impostazione di autenticazione del database IAM corrisponde a quella della snapshot origine. Per modificare questa impostazione, imposta l’opzione `--enable-iam-database-authentication` or `--no-enable-iam-database-authentication`, come appropriato.
## API RDS
Per creare una nuova istanza database con autenticazione IAM tramite l’API, utilizzare l’operazione API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html). Imposta il parametro `EnableIAMDatabaseAuthentication` su `true`.
Per aggiornare un cluster di database esistente in modo da abilitare l’autenticazione IAM, utilizzare l’operazione API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html). Imposta il parametro `EnableIAMDatabaseAuthentication` su `true` per abilitare l’autenticazione IAM o su `false` per disabilitarla.
**Nota**
Puoi abilitare l’autenticazione IAM solo se tutte le istanze database nel cluster di database sono compatibili con IAM. Controllare i requisiti di compatibilità in [Disponibilità di regioni e versioni](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Se ripristini un cluster database, usa una delle operazioni API seguenti:
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterFromSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterFromSnapshot.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterToPointInTime.html)
L’impostazione di autenticazione del database IAM corrisponde a quella della snapshot origine. Per modificare questa impostazione, imposta il parametro `EnableIAMDatabaseAuthentication` su `true` per abilitare l’autenticazione IAM o su `false` per disabilitarla.
# Creazione e utilizzo di una policy IAM per l'accesso al database IAM
Per permettere a un utente o un ruolo di connettersi al cluster database, devi creare una policy IAM. Dopo questa operazione, collega la policy a un set di autorizzazioni o un ruolo.
**Nota**
Per ulteriori informazioni sulle policy IAM, consulta [Gestione accessi e identità per Amazon Aurora](UsingWithRDS.IAM.md).
La policy nell'esempio seguente permette a un utente di connettersi a un cluster database tramite l'autenticazione database IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:cluster-ABCDEFGHIJKL01234/db_user"
]
}
]
}
```
------
**Importante**
Un utente con le autorizzazioni di amministratore può accedere ai cluster database senza una policy IAM esplicita. Se vuoi limitare l'accesso come amministratore a cluster di , puoi creare un ruolo IAM con le autorizzazioni appropriate, con privilegi minori e assegnarlo all'amministratore.
**Nota**
Non confondere il prefisso `rds-db:` con altri prefissi di operazione API RDS che iniziano con `rds:`. Utilizzi il prefisso `rds-db:` e l'operazione `rds-db:connect` solo per l'autenticazione database IAM. Non sono validi in altri contesti.
La policy di esempio include una singola istruzione con i seguenti elementi:
+ `Effect` – Specifica `Allow` per concedere l'accesso al cluster database. Se non si concede esplicitamente l'accesso, questo viene rifiutato per impostazione predefinita.
+ `Action` – Specifica `rds-db:connect` per consentire le connessioni al cluster database.
+ `Resource` – Specifica un Amazon Resource Name (ARN) che descrive un account database in un cluster database. Di seguito è riportato il formato ARN.
```
arn:aws:rds-db:region:account-id:dbuser:DbClusterResourceId/db-user-name
```
In questo formato, sostituisci quanto segue:
+ `region`è la AWS regione per il cluster di DB. Nella politica di esempio, la AWS regione è`us-east-2`.
+ `account-id`è il numero di AWS account per il cluster di DB. Nella policy di esempio, il numero di account è `1234567890`. L'utente deve essere nello stesso account dell'account del cluster di database.
Per eseguire l'accesso multi-account, crea un ruolo IAM con la policy mostrata in precedenza nell'account per il cluster di database e consenti all'altro account di assumere il ruolo.
+ `DbClusterResourceId` è l'identificatore del cluster database. Questo identificatore è unico per una AWS regione e non cambia mai. Nella policy di esempio, l'identificatore è `cluster-ABCDEFGHIJKL01234`.
Per trovare un ID di risorsa del Console di gestione AWS cluster di DB in Amazon Aurora, scegli il cluster di istanze per visualizzarne i dettagli. Quindi seleziona la scheda **Configuration (Configurazione)**. **Resource ID (ID risorsa)** è visualizzato nella sezione **Configuration (Configurazione)**.
In alternativa, puoi utilizzare il AWS CLI comando per elencare gli identificatori e le risorse IDs per tutto il cluster di DB nella AWS regione corrente, come illustrato di seguito.
```
aws rds describe-db-clusters --query "DBClusters[*].[DBClusterIdentifier,DbClusterResourceId]"
```
**Nota**
Se si sta effettuando la connessione a un database tramite proxy RDS, specificare l'ID risorsa proxy, ad esempio `prx-ABCDEFGHIJKL01234`. Per informazioni sull'utilizzo dell'autenticazione del database IAM con proxy RDS, vedere [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
+ `db-user-name` è il nome dell'account database da associare all'autenticazione IAM. Nella policy di esempio, l'account database è `db_user`.
È possibile crearne altri ARNs per supportare vari modelli di accesso. La policy seguente permette l'accesso a due diversi account database in un cluster database.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:cluster-ABCDEFGHIJKL01234/jane_doe",
"arn:aws:rds-db:us-east-2:123456789012:dbuser:cluster-ABCDEFGHIJKL01234/mary_roe"
]
}
]
}
```
------
La seguente politica utilizza il carattere «\$1» per abbinare tutte le DB, i cluster e gli account di database per un account e una regione particolari AWS . AWS
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:*/*"
]
}
]
}
```
------
La seguente politica corrisponde a tutti i cluster di DB per un account e una regione particolari AWS . AWS Tuttavia, la policy concede l'accesso solo a cluster database che hanno un account database `jane_doe`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:*/jane_doe"
]
}
]
}
```
------
L'utente o il ruolo ha accesso solo a quei database ai quali l'utente ha accesso. Supponiamo, ad esempio, che il cluster database abbia un database denominato *dev* e un altro database denominato *test*. Se l'utente del database `jane_doe` ha accesso solo a *dev*, anche qualsiasi utente o ruolo che accede al cluster database con l'utente `jane_doe` ha accesso solo a *dev*. Questa restrizione dell'accesso è anche valida per altri oggetti database, come tabelle, visualizzazioni e così via.
Un amministratore deve creare policy IAM che concedono alle entità l'autorizzazione per eseguire operazioni API specifiche sulle risorse specificate di cui hanno bisogno. L'amministratore deve quindi collegare queste policy ai set di autorizzazioni o ai ruoli che richiedono tali autorizzazioni. Per esempi di policy, consulta [Esempi di policy di Amazon Aurora basate su identità](security_iam_id-based-policy-examples.md).
## Collegamento di una policy IAM a un set di autorizzazioni o un ruolo
Dopo aver creato una policy IAM per consentire l'autenticazione del database, devi collegare la policy a un set di autorizzazioni o un ruolo. Per un tutorial su questo argomento, consulta [ Creare e collegare la tua prima policy gestita dal cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) nella *Guida per l'utente IAM*.
Durante il tutorial, puoi utilizzare uno degli esempi di policy indicati in questa sezione come punto di partenza e personalizzarli in base alle tue esigenze. Al termine del tutorial, avrai un set di autorizzazioni con una policy collegata che può utilizzare l'operazione `rds-db:connect`.
**Nota**
Puoi mappare più set di autorizzazioni o ruoli allo stesso account utente del database. Ad esempio, supponiamo che la policy IAM abbia specificato la seguente risorsa ARN.
```
arn:aws:rds-db:us-east-2:123456789012:dbuser:cluster-12ABC34DEFG5HIJ6KLMNOP78QR/jane_doe
```
Se colleghi la policy agli utenti *Jane*, *Bob* e *Diego*, ciascuno di quegli utenti potrà connettersi al cluster di database specificato utilizzando l'account di database `jane_doe`.
# Creazione di un account database tramite l’autenticazione IAM
Con l’autenticazione database IAM, non devi assegnare password di database agli account utente che crei. Se rimuovi un utente mappato a un account database, devi anche rimuovere l’account database con l’istruzione `DROP USER`.
**Nota**
Il nome utente utilizzato per l’autenticazione IAM deve avere lo stesso formato maiuscolo/minuscolo del nome utente nel database.
**Topics**
+ [Utilizzo dell’autenticazione IAM con Aurora MySQL](#UsingWithRDS.IAMDBAuth.DBAccounts.MySQL)
+ [Utilizzo dell'autenticazione IAM con Aurora PostgreSQL](#UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL)
## Utilizzo dell’autenticazione IAM con Aurora MySQL
Con per autenticare gli utenti. Connettiti al cluster database come utente master o altro utente che può creare utenti e concedere privilegi. Dopo la connessione, immetti l’istruzione `CREATE USER`, come mostrato nell’esempio seguente.
```
CREATE USER 'jane_doe' IDENTIFIED WITH AWSAuthenticationPlugin AS 'RDS';
```
La clausola `IDENTIFIED WITH` permette a Aurora MySQL di utilizzare `AWSAuthenticationPlugin` per autenticare l’account database (`jane_doe`). La clausola `AS 'RDS'` fa riferimento al metodo di autenticazione. Assicurarsi che il nome utente del database specificato sia lo stesso di una risorsa nella policy IAM per l’accesso al database IAM. Per ulteriori informazioni, consulta [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md).
**Nota**
`ERROR 1524 (HY000): Plugin 'AWSAuthenticationPlugin' is not loaded`
Per correggere questo errore, assicurati di usare una configurazione supportata e di aver abilitato l’autenticazione database IAM nel cluster database. Per ulteriori informazioni, consulta [Disponibilità di regioni e versioni](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) e [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md).
Dopo aver creato un account utilizzando `AWSAuthenticationPlugin`, lo gestisci nello stesso modo di altri account database. Ad esempio, puoi modificare i privilegi di account con le istruzioni `GRANT` e `REVOKE` o modificare vari attributi di account con l’istruzione `ALTER USER`.
Il traffico di rete del database viene SSL/TLS crittografato utilizzando IAM. Per consentire le connessioni SSL, modifica l’account utente con il comando seguente.
```
ALTER USER 'jane_doe'@'%' REQUIRE SSL;
```
## Utilizzo dell'autenticazione IAM con Aurora PostgreSQL
Per utilizzare l’autenticazione IAM con Aurora PostgreSQL, connettiti al cluster database come utente master o altro utente che può creare utenti e concedere privilegi. Dopo la connessione, crea gli utenti di database e autorizza il ruolo `rds_iam`, come mostrato nell’esempio seguente.
```
CREATE USER db_userx;
GRANT rds_iam TO db_userx;
```
Assicurarsi che il nome utente del database specificato sia lo stesso di una risorsa nella policy IAM per l’accesso al database IAM. Per ulteriori informazioni, consulta [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md). È necessario fornire il ruolo `rds_iam` per utilizzare l’autenticazione IAM. È possibile utilizzare anche appartenenze nidificate o concessioni indirette del ruolo.
Tieni presente che un utente del database PostgreSQL può utilizzare l’autenticazione IAM o Kerberos ma non entrambe, quindi questo utente non può avere anche il ruolo `rds_ad`. Questo vale anche per le appartenenze nidificate. Per ulteriori informazioni, consulta [Fase 7: creazione di utenti PostgreSQL per i principali Kerberos](postgresql-kerberos-setting-up.md#postgresql-kerberos-setting-up.create-logins).
# Connessione al cluster di database tramite l'autenticazione IAM
Con l'autenticazione database IAM devi usare un token di autenticazione per la connessione al cluster di database. Un *token di autenticazione* è una stringa unica di caratteri che utilizzi invece di una password. Trascorsi 15 minuti dalla sua creazione, un token di autenticazione scade. Se cerchi di eseguire la connessione utilizzando un token scaduto la richiesta di connessione viene negata.
Ogni token di autenticazione deve essere accompagnato da una firma valida, utilizzando AWS Signature Version 4. Per ulteriori informazioni, consulta [Processo di firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) in *Riferimenti generali di AWS*. La AWS CLI e un SDK AWS, come AWS SDK per Java o AWS SDK per Python (Boto3), possono firmare automaticamente ogni token che viene creato.
Poi usare un token di autenticazione quando ti connetti ad Amazon Aurora da un altro servizio AWS, ad esempio AWS Lambda. Utilizzando un token, eviti di inserire una password nel codice. In alternativa, puoi utilizzare l'SDK AWS per creare e firmare in modo programmatico un token di autenticazione.
Quando hai un token di autenticazione IAM firmato, puoi connetterti a un cluster di database Aurora. Di seguito vengono fornite informazioni su come eseguire questa operazione tramite uno strumento a riga di comando o un SDK AWS, come AWS SDK per Java o AWS SDK per Python (Boto3).
Per ulteriori informazioni, consulta il seguente post sul blog:
+ [Uso dell'autenticazione IAM per la connessione con SQL Workbench/J a Aurora MySQL o Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/).
+ [Utilizzo dell'autenticazione IAM per connettersi con pgAdmin Amazon Aurora PostgreSQL o Amazon RDS for PostgreSQL](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/)
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione alcluster di DB utilizzando l'autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Topics**
+ [Connessione al cluster dell’ database utilizzando l’autenticazione IAM con i driver AWS](IAMDBAuth.Connecting.Drivers.md)
+ [Connessione al cluster di DB utilizzando l'autenticazione IAM dalla riga di comando: AWS CLI e il client mysql](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [Connessione al cluster di DB utilizzando l'autenticazione IAM dalla riga di comando: AWS CLI e il client psql](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL.md)
+ [Connessione al cluster di DB utilizzando l'autenticazione IAM e AWS SDK per .NET](UsingWithRDS.IAMDBAuth.Connecting.NET.md)
+ [Connessione al cluster di DB utilizzando l'autenticazione IAM e AWS SDK per Go](UsingWithRDS.IAMDBAuth.Connecting.Go.md)
+ [Connessione al cluster di DB utilizzando l'autenticazione IAM e il AWS SDK per Java](UsingWithRDS.IAMDBAuth.Connecting.Java.md)
+ [Connessione al cluster di DB utilizzando l'autenticazione IAM e il AWS SDK per Python (Boto3)](UsingWithRDS.IAMDBAuth.Connecting.Python.md)
# Connessione al cluster dell’ database utilizzando l’autenticazione IAM con i driver AWS
La suite di driver AWS è stata progettata per consentire tempi di switchover e failover più rapidi e per eseguire l’autenticazione con Gestione dei segreti AWS, AWS Identity and Access Management (IAM) e l’identità federata. I driver AWS si basano sul monitoraggio dello stato dell’ del cluster di database e conoscono la topologia dell’ del cluster per determinare la nuova istanza di scrittura. Questo approccio riduce i tempi di switchover e failover a meno di dieci secondi, rispetto alle decine di secondi necessari per i driver open source.
Per ulteriori informazioni sui driver AWS, consulta il driver del linguaggio corrispondente per il cluster di database [Aurora MySQL](Aurora.Connecting.md#Aurora.Connecting.JDBCDriverMySQL) o [Aurora PostgreSQL](Aurora.Connecting.md#Aurora.Connecting.AuroraPostgreSQL.Utilities).
# Connessione al cluster di DB utilizzando l'autenticazione IAM dalla riga di comando: AWS CLI e il client mysql
Puoi connetterti dalla riga di comando a un cluster Aurora con AWS CLI lo strumento da riga di comando `mysql` and come descritto di seguito.
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione alcluster di DB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Nota**
Per informazioni sulla connessione al database tramite SQL Workbench/J con autenticazione IAM, consulta il post del blog [Use IAM authentication to connect with SQL Workbench/J to Aurora MySQL o Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/).
**Topics**
+ [Generazione di un token di autenticazione IAM](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken)
+ [Connessione a un cluster database](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect)
## Generazione di un token di autenticazione IAM
L'esempio seguente mostra come ottenere un token di autenticazione firmato utilizzando AWS CLI.
```
aws rds generate-db-auth-token \
--hostname rdsmysql.123456789012.us-west-2.rds.amazonaws.com \
--port 3306 \
--region us-west-2 \
--username jane_doe
```
Nell'esempio, i parametri sono come segue:
+ `--hostname` – Nome host del cluster database cui vuoi accedere.
+ `--port` – Numero di porta usato per la connessione al dell'istanza database
+ `--region`
+ `--username` – L'account database cui vuoi accedere.
I primi caratteri del token hanno il seguente aspetto.
```
rdsmysql.123456789012.us-west-2.rds.amazonaws.com:3306/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint del cluster di databaseper generare il token di autenticazione.
## Connessione a un cluster database
Il formato generale per la connessione è visualizzato di seguito.
```
mysql --host=hostName --port=portNumber --ssl-ca=full_path_to_ssl_certificate --enable-cleartext-plugin --user=userName --password=authToken
```
I parametri sono i seguenti:
+ `--host` – Nome host del cluster database cui vuoi accedere.
+ `--port` – Numero di porta usato per la connessione al dell'istanza database
+ `--ssl-ca` – Il percorso completo del file del certificato SSL che contiene la chiave pubblica
Per ulteriori informazioni, consulta [Connessioni TLS a cluster di database Aurora MySQL](AuroraMySQL.Security.md#AuroraMySQL.Security.SSL).
Per scaricare un certificato SSL consulta [Utilizzo SSL/TLS per crittografare una connessione a un'](UsingWithRDS.SSL.md)
+ `--enable-cleartext-plugin` – Valore che specifica che per la connessione deve essere usato `AWSAuthenticationPlugin`.
Se si utilizza un client MariaDB, l'opzione `--enable-cleartext-plugin` non è richiesta.
+ `--user` – L'account database cui vuoi accedere.
+ `--password` – Token di autenticazione IAM firmato.
Il token di autenticazione consiste in diverse centinaia di caratteri. Può essere macchinoso nella riga di comando. Una soluzione è di salvare il token in una variabile di ambiente e utilizzare quella variabile durante la connessione. L'esempio seguente mostra un modo per eseguire questa soluzione. Nell'esempio, */sample\$1dir/* è il percorso completo del file del certificato SSL che contiene la chiave pubblica.
```
RDSHOST="mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
TOKEN="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 3306 --region us-west-2 --username jane_doe )"
mysql --host=$RDSHOST --port=3306 --ssl-ca=/sample_dir/global-bundle.pem --enable-cleartext-plugin --user=jane_doe --password=$TOKEN
```
Quando si esegue la connessione utilizzando `AWSAuthenticationPlugin`, la connessione viene protetta utilizzando SSL. Per verificare ciò, digita quanto segue al prompt del comando `mysql>`.
```
show status like 'Ssl%';
```
Le righe seguenti nell'output mostrano più dettagli.
```
+---------------+-------------+
| Variable_name | Value |
+---------------+-------------+
| ... | ...
| Ssl_cipher | AES256-SHA |
| ... | ...
| Ssl_version | TLSv1.1 |
| ... | ...
+-----------------------------+
```
Se desideri connetterti a un cluster di database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connessione al cluster di DB utilizzando l'autenticazione IAM dalla riga di comando: AWS CLI e il client psql
Puoi eseguire la connessione dalla riga di comando a un cluster database Aurora PostgreSQL con AWS CLI e lo strumento a riga di comando psql come descritto di seguito.
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione alcluster di DB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Nota**
Per informazioni sulla connessione al database tramite pgAdmin con autenticazione IAM, consulta il post sul blog [Utilizzo dell'autenticazione IAM per connettersi con PGadmin Amazon Aurora PostgreSQL o Amazon RDS for PostgreSQL](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/).
**Topics**
+ [Generazione di un token di autenticazione IAM](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken.PostgreSQL)
+ [Connessione a un cluster Aurora PostgreSQL](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect.PostgreSQL)
## Generazione di un token di autenticazione IAM
Il token di autenticazione è costituito da diverse centinaia di caratteri, quindi può essere complesso nella riga di comando. Una soluzione è di salvare il token in una variabile di ambiente e utilizzare quella variabile durante la connessione. L'esempio seguente mostra come utilizzare il AWS CLI per ottenere un token di autenticazione firmato utilizzando il `generate-db-auth-token` comando e archiviarlo in una variabile di `PGPASSWORD` ambiente.
```
export RDSHOST="mypostgres-cluster.cluster-123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
```
Nell'esempio, i parametri per il comando `generate-db-auth-token` sono i seguenti:
+ `--hostname` – Nome host del cluster (endpoint del cluster) di database cui desideri accedere.
+ `--port` – Numero di porta usato per la connessione al dell'istanza database
+ `--region`— La AWS regione in cui è in esecuzione il cluster di DB
+ `--username` – L'account database cui vuoi accedere.
I primi caratteri del token generato hanno il seguente aspetto.
```
mypostgres-cluster.cluster-123456789012.us-west-2.rds.amazonaws.com:5432/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint del cluster di databaseper generare il token di autenticazione.
## Connessione a un cluster Aurora PostgreSQL
Di seguito è mostrato il formato generale per l'utilizzo di psql per la connessione.
```
psql "host=hostName port=portNumber sslmode=verify-full sslrootcert=full_path_to_ssl_certificate dbname=DBName user=userName password=authToken"
```
I parametri sono i seguenti:
+ `host` – Nome host del cluster (endpoint del cluster) di database cui desideri accedere.
+ `port` – Numero di porta usato per la connessione al dell'istanza database
+ `sslmode` – Modalità SSL da utilizzare.
Quando si utilizza `sslmode=verify-full`, la connessione SSL verifica l'endpoint del cluster database rispetto a quello nel certificato SSL.
+ `sslrootcert` – Il percorso completo del file del certificato SSL che contiene la chiave pubblica
Per ulteriori informazioni, consulta [Sicurezza dei dati Aurora PostgreSQL con SSL/TLS](AuroraPostgreSQL.Security.md#AuroraPostgreSQL.Security.SSL).
Per scaricare un certificato SSL consulta [Utilizzo SSL/TLS per crittografare una connessione a un'](UsingWithRDS.SSL.md)
+ `dbname` – Database a cui accedere.
+ `user` – L'account database cui vuoi accedere.
+ `password` – Token di autenticazione IAM firmato.
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint del cluster di databaseper generare il token di autenticazione.
L'esempio seguente mostra l'utilizzo di psql per la connessione. Nell'esempio, psql utilizza la variabile d'ambiente `RDSHOST` per l'host e la variabile d'ambiente `PGPASSWORD` per il token generato. Inoltre, */sample\$1dir/* è il percorso completo del file del certificato SSL che contiene la chiave pubblica.
```
export RDSHOST="mypostgres-cluster.cluster-123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
psql "host=$RDSHOST port=5432 sslmode=verify-full sslrootcert=/sample_dir/global-bundle.pem dbname=DBName user=jane_doe password=$PGPASSWORD"
```
Se desideri connetterti a un cluster di database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connessione al cluster di DB utilizzando l'autenticazione IAM e AWS SDK per .NET
È possibile connettersi a un cluster come descritto di seguito. AWS SDK per .NET
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione alcluster di DB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Esempi**
Il seguente esempio di codice mostra come generare un token di autenticazione e utilizzarlo per eseguire la connessione a un cluster del database.
Per eseguire questo esempio di codice, è necessario il file, trovato sul sito. [AWS SDK per .NET](https://aws.amazon.com/sdk-for-net/) AWS I pacchetti `AWSSDK.CORE` e `AWSSDK.RDS` sono obbligatori. Per connetterti a un cluster di DB, usa il connettore di database.NET per il motore DB, ad esempio MySqlConnector per MariaDB o MySQL, o Npgsql per PostgreSQL.
Questo codice si connette a un cluster di database Aurora MySQL. Modifica i valori delle variabili seguenti in base alle esigenze.
+ `server`: l'endpoint del cluster database cui vuoi accedere
+ `user` – L'account database cui vuoi accedere.
+ `database` – Database a cui accedere.
+ `port` – Numero di porta usato per la connessione al dell'istanza database
+ `SslMode` – Modalità SSL da utilizzare.
Quando si utilizza `SslMode=Required`, la connessione SSL verifica l'endpoint del cluster database rispetto a quello nel certificato SSL.
+ `SslCa` - Percorso completo del certificato SSL per Amazon Aurora
Per scaricare un certificato, consultare [Utilizzo SSL/TLS per crittografare una connessione a un'](UsingWithRDS.SSL.md).
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint del cluster di databaseper generare il token di autenticazione.
```
using System;
using System.Data;
using MySql.Data;
using MySql.Data.MySqlClient;
using Amazon;
namespace ubuntu
{
class Program
{
static void Main(string[] args)
{
var pwd = Amazon.RDS.Util.RDSAuthTokenGenerator.GenerateAuthToken(RegionEndpoint.USEast1, "mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com", 3306, "jane_doe");
// for debug only Console.Write("{0}\n", pwd); //this verifies the token is generated
MySqlConnection conn = new MySqlConnection($"server=mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com;user=jane_doe;database=mydB;port=3306;password={pwd};SslMode=Required;SslCa=full_path_to_ssl_certificate");
conn.Open();
// Define a query
MySqlCommand sampleCommand = new MySqlCommand("SHOW DATABASES;", conn);
// Execute a query
MySqlDataReader mysqlDataRdr = sampleCommand.ExecuteReader();
// Read all rows and output the first column in each row
while (mysqlDataRdr.Read())
Console.WriteLine(mysqlDataRdr[0]);
mysqlDataRdr.Close();
// Close connection
conn.Close();
}
}
}
```
Questo codice si connette a un cluster di database Aurora PostgreSQL.
Modifica i valori delle variabili seguenti in base alle esigenze.
+ `Server`: l'endpoint del cluster database cui vuoi accedere
+ `User ID` – L'account database cui vuoi accedere.
+ `Database` – Database a cui accedere.
+ `Port` – Numero di porta usato per la connessione al dell'istanza database
+ `SSL Mode` – Modalità SSL da utilizzare.
Quando si utilizza `SSL Mode=Required`, la connessione SSL verifica l'endpoint del cluster database rispetto a quello nel certificato SSL.
+ `Root Certificate` - Percorso completo del certificato SSL per Amazon Aurora
Per scaricare un certificato, consultare [Utilizzo SSL/TLS per crittografare una connessione a un'](UsingWithRDS.SSL.md).
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint del cluster di databaseper generare il token di autenticazione.
```
using System;
using Npgsql;
using Amazon.RDS.Util;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
var pwd = RDSAuthTokenGenerator.GenerateAuthToken("postgresmycluster.cluster-123456789012.us-east-1.rds.amazonaws.com", 5432, "jane_doe");
// for debug only Console.Write("{0}\n", pwd); //this verifies the token is generated
NpgsqlConnection conn = new NpgsqlConnection($"Server=postgresmycluster.cluster-123456789012.us-east-1.rds.amazonaws.com;User Id=jane_doe;Password={pwd};Database=mydb;SSL Mode=Require;Root Certificate=full_path_to_ssl_certificate");
conn.Open();
// Define a query
NpgsqlCommand cmd = new NpgsqlCommand("select count(*) FROM pg_user", conn);
// Execute a query
NpgsqlDataReader dr = cmd.ExecuteReader();
// Read all rows and output the first column in each row
while (dr.Read())
Console.Write("{0}\n", dr[0]);
// Close connection
conn.Close();
}
}
}
```
Se desideri connetterti a un cluster di database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connessione al cluster di DB utilizzando l'autenticazione IAM e AWS SDK per Go
È possibile connettersi a un cluster come descritto di seguito. AWS SDK per Go
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione alcluster di DB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Esempi**
Per eseguire questi esempi di codice, è necessario il file, trovato sul sito. [AWS SDK per Go](https://aws.amazon.com/sdk-for-go/) AWS
Modifica i valori delle variabili seguenti in base alle esigenze.
+ `dbName` – Database a cui accedere.
+ `dbUser` – L'account database cui vuoi accedere.
+ `dbHost`: l'endpoint del cluster database cui vuoi accedere
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint del cluster di databaseper generare il token di autenticazione.
+ `dbPort` – Numero di porta usato per la connessione al dell'istanza database
+ `region`— La AWS regione in cui è in esecuzione il cluster di DB
Inoltre, assicurarsi che le librerie importate nel codice di esempio esistano nel sistema.
**Importante**
Negli esempi riportati in questa sezione viene utilizzato il codice seguente per fornire credenziali che accedono a un database da un ambiente locale:
`creds := credentials.NewEnvCredentials()`
Se accedi a un database da un AWS servizio, come Amazon EC2 o Amazon ECS, puoi sostituire il codice con il seguente codice:
`sess := session.Must(session.NewSession())`
`creds := sess.Config.Credentials`
Se si apporta questa modifica, assicurarsi di aggiungere la seguente importazione:
`"github.com/aws/aws-sdk-go/aws/session"`
**Topics**
+ [Connessione tramite autenticazione IAM e V2 AWS SDK per Go](#UsingWithRDS.IAMDBAuth.Connecting.GoV2)
+ [Connessione tramite autenticazione IAM e AWS SDK per Go V1.](#UsingWithRDS.IAMDBAuth.Connecting.GoV1)
## Connessione tramite autenticazione IAM e V2 AWS SDK per Go
È possibile connettersi a un cluster di DB utilizzando l'autenticazione IAM e la AWS SDK per Go V2.
Il seguente esempio di codice mostra come generare un token di autenticazione e utilizzarlo per eseguire la connessione a un cluster del database.
Questo codice si connette a un cluster di database Aurora MySQL.
```
package main
import (
"context"
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/go-sql-driver/mysql"
)
func main() {
var dbName string = "DatabaseName"
var dbUser string = "DatabaseUser"
var dbHost string = "mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
var dbPort int = 3306
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = "us-east-1"
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authenticationToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Questo codice si connette a un cluster di database Aurora PostgreSQL.
```
package main
import (
"context"
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/lib/pq"
)
func main() {
var dbName string = "DatabaseName"
var dbUser string = "DatabaseUser"
var dbHost string = "postgresmycluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
var dbPort int = 5432
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = "us-east-1"
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
dbHost, dbPort, dbUser, authenticationToken, dbName,
)
db, err := sql.Open("postgres", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Se desideri connetterti a un cluster di database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
## Connessione tramite autenticazione IAM e AWS SDK per Go V1.
È possibile connettersi a un cluster di DB utilizzando l'autenticazione IAM e la AWS SDK per Go V1
Il seguente esempio di codice mostra come generare un token di autenticazione e utilizzarlo per eseguire la connessione a un cluster del database.
Questo codice si connette a un cluster di database Aurora MySQL.
```
package main
import (
"database/sql"
"fmt"
"log"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/service/rds/rdsutils"
_ "github.com/go-sql-driver/mysql"
)
func main() {
dbName := "app"
dbUser := "jane_doe"
dbHost := "mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
dbPort := 3306
dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
region := "us-east-1"
creds := credentials.NewEnvCredentials()
authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
if err != nil {
panic(err)
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Questo codice si connette a un cluster di database Aurora PostgreSQL.
```
package main
import (
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/service/rds/rdsutils"
_ "github.com/lib/pq"
)
func main() {
dbName := "app"
dbUser := "jane_doe"
dbHost := "postgresmycluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
dbPort := 5432
dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
region := "us-east-1"
creds := credentials.NewEnvCredentials()
authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
if err != nil {
panic(err)
}
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
dbHost, dbPort, dbUser, authToken, dbName,
)
db, err := sql.Open("postgres", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Se desideri connetterti a un cluster di database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connessione al cluster di DB utilizzando l'autenticazione IAM e il AWS SDK per Java
È possibile connettersi a un cluster come descritto di seguito. AWS SDK per Java
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione alcluster di DB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Configurare l' AWS SDK per Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html)
Per esempi su come utilizzare l’SDK per Java 2.x, consulta [Esempi per Amazon RDS con SDK per Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html). [Puoi anche usare AWS Advanced JDBC Wrapper, consulta AWS la documentazione di Advanced JDBC Wrapper.](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/Documentation.md)
**Topics**
+ [Generazione di un token di autenticazione IAM](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken)
+ [Creazione manuale di un token di autenticazione IAM](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken2)
+ [Connessione a un cluster database](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken.Connect)
## Generazione di un token di autenticazione IAM
Se state scrivendo programmi utilizzando il AWS SDK per Java, potete ottenere un token di autenticazione firmato utilizzando la classe. `RdsIamAuthTokenGenerator` L'utilizzo di questa classe richiede l'immissione di AWS credenziali. A tale scopo, create un'istanza della `DefaultAWSCredentialsProviderChain` classe. `DefaultAWSCredentialsProviderChain`utilizza la prima chiave di AWS accesso e la chiave segreta che trova nella [catena di provider di credenziali predefinita](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default). Per ulteriori informazioni sulle chiavi di accesso AWS , consulta [Gestione delle chiavi di accesso per gli utenti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint del cluster di databaseper generare il token di autenticazione.
Dopo aver creato un’istanza di `RdsIamAuthTokenGenerator`, puoi chiamare il metodo `getAuthToken` per ottenere un token firmato. Specifica la regione AWS , il nome host, il numero di porta e il nome utente. Il seguente esempio di codice dimostra come eseguire questa operazione.
```
package com.amazonaws.codesamples;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;
public class GenerateRDSAuthToken {
public static void main(String[] args) {
String region = "us-west-2";
String hostname = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
String port = "3306";
String username = "jane_doe";
System.out.println(generateAuthToken(region, hostname, port, username));
}
static String generateAuthToken(String region, String hostName, String port, String username) {
RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
.credentials(new DefaultAWSCredentialsProviderChain())
.region(region)
.build();
String authToken = generator.getAuthToken(
GetIamAuthTokenRequest.builder()
.hostname(hostName)
.port(Integer.parseInt(port))
.userName(username)
.build());
return authToken;
}
}
```
## Creazione manuale di un token di autenticazione IAM
In Java, il modo più semplice di generare un token di autenticazione è di utilizzare `RdsIamAuthTokenGenerator`. Questa classe crea un token di autenticazione per te, quindi lo firma utilizzando la versione 4 AWS della firma. Per ulteriori informazioni, consulta la pagina relativa al [processo di firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) nella *Riferimenti generali di AWS*.
Tuttavia, puoi anche creare e firmare un token di autenticazione manualmente, come visualizzato nel seguente esempio di codice.
```
package com.amazonaws.codesamples;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.SigningAlgorithm;
import com.amazonaws.util.BinaryUtils;
import org.apache.commons.lang3.StringUtils;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.SortedMap;
import java.util.TreeMap;
import static com.amazonaws.auth.internal.SignerConstants.AWS4_TERMINATOR;
import static com.amazonaws.util.StringUtils.UTF8;
public class CreateRDSAuthTokenManually {
public static String httpMethod = "GET";
public static String action = "connect";
public static String canonicalURIParameter = "/";
public static SortedMap canonicalQueryParameters = new TreeMap();
public static String payload = StringUtils.EMPTY;
public static String signedHeader = "host";
public static String algorithm = "AWS4-HMAC-SHA256";
public static String serviceName = "rds-db";
public static String requestWithoutSignature;
public static void main(String[] args) throws Exception {
String region = "us-west-2";
String instanceName = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
String port = "3306";
String username = "jane_doe";
Date now = new Date();
String date = new SimpleDateFormat("yyyyMMdd").format(now);
String dateTimeStamp = new SimpleDateFormat("yyyyMMdd'T'HHmmss'Z'").format(now);
DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
String awsAccessKey = creds.getCredentials().getAWSAccessKeyId();
String awsSecretKey = creds.getCredentials().getAWSSecretKey();
String expiryMinutes = "900";
System.out.println("Step 1: Create a canonical request:");
String canonicalString = createCanonicalString(username, awsAccessKey, date, dateTimeStamp, region, expiryMinutes, instanceName, port);
System.out.println(canonicalString);
System.out.println();
System.out.println("Step 2: Create a string to sign:");
String stringToSign = createStringToSign(dateTimeStamp, canonicalString, awsAccessKey, date, region);
System.out.println(stringToSign);
System.out.println();
System.out.println("Step 3: Calculate the signature:");
String signature = BinaryUtils.toHex(calculateSignature(stringToSign, newSigningKey(awsSecretKey, date, region, serviceName)));
System.out.println(signature);
System.out.println();
System.out.println("Step 4: Add the signing info to the request");
System.out.println(appendSignature(signature));
System.out.println();
}
//Step 1: Create a canonical request date should be in format YYYYMMDD and dateTime should be in format YYYYMMDDTHHMMSSZ
public static String createCanonicalString(String user, String accessKey, String date, String dateTime, String region, String expiryPeriod, String hostName, String port) throws Exception {
canonicalQueryParameters.put("Action", action);
canonicalQueryParameters.put("DBUser", user);
canonicalQueryParameters.put("X-Amz-Algorithm", "AWS4-HMAC-SHA256");
canonicalQueryParameters.put("X-Amz-Credential", accessKey + "%2F" + date + "%2F" + region + "%2F" + serviceName + "%2Faws4_request");
canonicalQueryParameters.put("X-Amz-Date", dateTime);
canonicalQueryParameters.put("X-Amz-Expires", expiryPeriod);
canonicalQueryParameters.put("X-Amz-SignedHeaders", signedHeader);
String canonicalQueryString = "";
while(!canonicalQueryParameters.isEmpty()) {
String currentQueryParameter = canonicalQueryParameters.firstKey();
String currentQueryParameterValue = canonicalQueryParameters.remove(currentQueryParameter);
canonicalQueryString = canonicalQueryString + currentQueryParameter + "=" + currentQueryParameterValue;
if (!currentQueryParameter.equals("X-Amz-SignedHeaders")) {
canonicalQueryString += "&";
}
}
String canonicalHeaders = "host:" + hostName + ":" + port + '\n';
requestWithoutSignature = hostName + ":" + port + "/?" + canonicalQueryString;
String hashedPayload = BinaryUtils.toHex(hash(payload));
return httpMethod + '\n' + canonicalURIParameter + '\n' + canonicalQueryString + '\n' + canonicalHeaders + '\n' + signedHeader + '\n' + hashedPayload;
}
//Step 2: Create a string to sign using sig v4
public static String createStringToSign(String dateTime, String canonicalRequest, String accessKey, String date, String region) throws Exception {
String credentialScope = date + "/" + region + "/" + serviceName + "/aws4_request";
return algorithm + '\n' + dateTime + '\n' + credentialScope + '\n' + BinaryUtils.toHex(hash(canonicalRequest));
}
//Step 3: Calculate signature
/**
* Step 3 of the &AWS; Signature version 4 calculation. It involves deriving
* the signing key and computing the signature. Refer to
* http://docs.aws.amazon
* .com/general/latest/gr/sigv4-calculate-signature.html
*/
public static byte[] calculateSignature(String stringToSign,
byte[] signingKey) {
return sign(stringToSign.getBytes(Charset.forName("UTF-8")), signingKey,
SigningAlgorithm.HmacSHA256);
}
public static byte[] sign(byte[] data, byte[] key,
SigningAlgorithm algorithm) throws SdkClientException {
try {
Mac mac = algorithm.getMac();
mac.init(new SecretKeySpec(key, algorithm.toString()));
return mac.doFinal(data);
} catch (Exception e) {
throw new SdkClientException(
"Unable to calculate a request signature: "
+ e.getMessage(), e);
}
}
public static byte[] newSigningKey(String secretKey,
String dateStamp, String regionName, String serviceName) {
byte[] kSecret = ("AWS4" + secretKey).getBytes(Charset.forName("UTF-8"));
byte[] kDate = sign(dateStamp, kSecret, SigningAlgorithm.HmacSHA256);
byte[] kRegion = sign(regionName, kDate, SigningAlgorithm.HmacSHA256);
byte[] kService = sign(serviceName, kRegion,
SigningAlgorithm.HmacSHA256);
return sign(AWS4_TERMINATOR, kService, SigningAlgorithm.HmacSHA256);
}
public static byte[] sign(String stringData, byte[] key,
SigningAlgorithm algorithm) throws SdkClientException {
try {
byte[] data = stringData.getBytes(UTF8);
return sign(data, key, algorithm);
} catch (Exception e) {
throw new SdkClientException(
"Unable to calculate a request signature: "
+ e.getMessage(), e);
}
}
//Step 4: append the signature
public static String appendSignature(String signature) {
return requestWithoutSignature + "&X-Amz-Signature=" + signature;
}
public static byte[] hash(String s) throws Exception {
try {
MessageDigest md = MessageDigest.getInstance("SHA-256");
md.update(s.getBytes(UTF8));
return md.digest();
} catch (Exception e) {
throw new SdkClientException(
"Unable to compute hash while signing request: "
+ e.getMessage(), e);
}
}
}
```
## Connessione a un cluster database
Il seguente esempio di codice mostra come generare un token di autenticazione e utilizzarlo per eseguire la connessione a un cluster eseguendo Aurora MySQL.
Per eseguire questo esempio di codice, è necessario il [AWS SDK per Java](https://aws.amazon.com/sdk-for-java/)file, trovato sul AWS sito. Inoltre, hai bisogno di quanto segue:
+ MySQL Connector/J. Questo esempio di codice è stato testato con `mysql-connector-java-5.1.33-bin.jar`.
+ Un certificato intermedio per Amazon Aurora specifico per una regione. AWS Per ulteriori informazioni, consulta [Utilizzo SSL/TLS per crittografare una connessione a un'](UsingWithRDS.SSL.md). Durante il runtime, il loader della classe cerca un certificato nella stessa directory di questo esempio di codice Java, per permettere al loader della classe di trovarlo.
+ Modifica i valori delle variabili seguenti in base alle esigenze.
+ `RDS_INSTANCE_HOSTNAME`: il nome host del cluster database cui vuoi accedere.
+ `RDS_INSTANCE_PORT`: il numero di porta usato per la connessione al cluster database PostgreSQL.
+ `REGION_NAME`— La AWS regione in cui è in esecuzione il cluster di DB.
+ `DB_USER`: l’account database cui vuoi accedere.
+ `SSL_CERTIFICATE`— Un certificato SSL per Amazon Aurora specifico per una regione. AWS
Per scaricare un certificato per la regione AWS , consulta [Utilizzo SSL/TLS per crittografare una connessione a un'](UsingWithRDS.SSL.md). Inserisci il certificato SSL nella stessa directory di questo file di programma Java, per permettere al loader di classe di trovare il certificato durante il runtime.
[Questo esempio di codice ottiene AWS le credenziali dalla catena di provider di credenziali predefinita.](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default)
**Nota**
Specifica una password per `DEFAULT_KEY_STORE_PASSWORD` diversa da quella mostrata qui come best practice di sicurezza.
```
package com.amazonaws.samples;
import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.security.KeyStore;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;
import java.net.URL;
public class IAMDatabaseAuthenticationTester {
//&AWS; Credentials of the IAM user with policy enabling IAM Database Authenticated access to the db by the db user.
private static final DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
private static final String AWS_ACCESS_KEY = creds.getCredentials().getAWSAccessKeyId();
private static final String AWS_SECRET_KEY = creds.getCredentials().getAWSSecretKey();
//Configuration parameters for the generation of the IAM Database Authentication token
private static final String RDS_INSTANCE_HOSTNAME = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
private static final int RDS_INSTANCE_PORT = 3306;
private static final String REGION_NAME = "us-west-2";
private static final String DB_USER = "jane_doe";
private static final String JDBC_URL = "jdbc:mysql://" + RDS_INSTANCE_HOSTNAME + ":" + RDS_INSTANCE_PORT;
private static final String SSL_CERTIFICATE = "rds-ca-2019-us-west-2.pem";
private static final String KEY_STORE_TYPE = "JKS";
private static final String KEY_STORE_PROVIDER = "SUN";
private static final String KEY_STORE_FILE_PREFIX = "sys-connect-via-ssl-test-cacerts";
private static final String KEY_STORE_FILE_SUFFIX = ".jks";
private static final String DEFAULT_KEY_STORE_PASSWORD = "changeit";
public static void main(String[] args) throws Exception {
//get the connection
Connection connection = getDBConnectionUsingIam();
//verify the connection is successful
Statement stmt= connection.createStatement();
ResultSet rs=stmt.executeQuery("SELECT 'Success!' FROM DUAL;");
while (rs.next()) {
String id = rs.getString(1);
System.out.println(id); //Should print "Success!"
}
//close the connection
stmt.close();
connection.close();
clearSslProperties();
}
/**
* This method returns a connection to the db instance authenticated using IAM Database Authentication
* @return
* @throws Exception
*/
private static Connection getDBConnectionUsingIam() throws Exception {
setSslProperties();
return DriverManager.getConnection(JDBC_URL, setMySqlConnectionProperties());
}
/**
* This method sets the mysql connection properties which includes the IAM Database Authentication token
* as the password. It also specifies that SSL verification is required.
* @return
*/
private static Properties setMySqlConnectionProperties() {
Properties mysqlConnectionProperties = new Properties();
mysqlConnectionProperties.setProperty("verifyServerCertificate","true");
mysqlConnectionProperties.setProperty("useSSL", "true");
mysqlConnectionProperties.setProperty("user",DB_USER);
mysqlConnectionProperties.setProperty("password",generateAuthToken());
return mysqlConnectionProperties;
}
/**
* This method generates the IAM Auth Token.
* An example IAM Auth Token would look like follows:
* btusi123---cmz7kenwo2ye---rds---cn-north-1.amazonaws.com.rproxy.goskope.com.cn:3306/?Action=connect&DBUser=iamtestuser&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20171003T010726Z&X-Amz-SignedHeaders=host&X-Amz-Expires=899&X-Amz-Credential=AKIAPFXHGVDI5RNFO4AQ%2F20171003%2Fcn-north-1%2Frds-db%2Faws4_request&X-Amz-Signature=f9f45ef96c1f770cdad11a53e33ffa4c3730bc03fdee820cfdf1322eed15483b
* @return
*/
private static String generateAuthToken() {
BasicAWSCredentials awsCredentials = new BasicAWSCredentials(AWS_ACCESS_KEY, AWS_SECRET_KEY);
RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
.credentials(new AWSStaticCredentialsProvider(awsCredentials)).region(REGION_NAME).build();
return generator.getAuthToken(GetIamAuthTokenRequest.builder()
.hostname(RDS_INSTANCE_HOSTNAME).port(RDS_INSTANCE_PORT).userName(DB_USER).build());
}
/**
* This method sets the SSL properties which specify the key store file, its type and password:
* @throws Exception
*/
private static void setSslProperties() throws Exception {
System.setProperty("javax.net.ssl.trustStore", createKeyStoreFile());
System.setProperty("javax.net.ssl.trustStoreType", KEY_STORE_TYPE);
System.setProperty("javax.net.ssl.trustStorePassword", DEFAULT_KEY_STORE_PASSWORD);
}
/**
* This method returns the path of the Key Store File needed for the SSL verification during the IAM Database Authentication to
* the db instance.
* @return
* @throws Exception
*/
private static String createKeyStoreFile() throws Exception {
return createKeyStoreFile(createCertificate()).getPath();
}
/**
* This method generates the SSL certificate
* @return
* @throws Exception
*/
private static X509Certificate createCertificate() throws Exception {
CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
URL url = new File(SSL_CERTIFICATE).toURI().toURL();
if (url == null) {
throw new Exception();
}
try (InputStream certInputStream = url.openStream()) {
return (X509Certificate) certFactory.generateCertificate(certInputStream);
}
}
/**
* This method creates the Key Store File
* @param rootX509Certificate - the SSL certificate to be stored in the KeyStore
* @return
* @throws Exception
*/
private static File createKeyStoreFile(X509Certificate rootX509Certificate) throws Exception {
File keyStoreFile = File.createTempFile(KEY_STORE_FILE_PREFIX, KEY_STORE_FILE_SUFFIX);
try (FileOutputStream fos = new FileOutputStream(keyStoreFile.getPath())) {
KeyStore ks = KeyStore.getInstance(KEY_STORE_TYPE, KEY_STORE_PROVIDER);
ks.load(null);
ks.setCertificateEntry("rootCaCertificate", rootX509Certificate);
ks.store(fos, DEFAULT_KEY_STORE_PASSWORD.toCharArray());
}
return keyStoreFile;
}
/**
* This method clears the SSL properties.
* @throws Exception
*/
private static void clearSslProperties() throws Exception {
System.clearProperty("javax.net.ssl.trustStore");
System.clearProperty("javax.net.ssl.trustStoreType");
System.clearProperty("javax.net.ssl.trustStorePassword");
}
}
```
Se desideri connetterti a un cluster di database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connessione al cluster di DB utilizzando l'autenticazione IAM e il AWS SDK per Python (Boto3)
È possibile connettersi a un cluster come descritto di seguito. AWS SDK per Python (Boto3)
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione alcluster di DB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
Inoltre, assicurarsi che le librerie importate nel codice di esempio esistano nel sistema.
**Esempi**
Gli esempi di codice utilizzano i profili per le credenziali condivise. [Per informazioni sulla specificazione delle credenziali, AWS SDK per Python (Boto3) consulta Credenziali nella documentazione.](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html)
Il seguente esempio di codice mostra come generare un token di autenticazione e utilizzarlo per eseguire la connessione a un cluster del database.
Per eseguire questo esempio di codice, è necessario il file [AWS SDK per Python (Boto3)](https://aws.amazon.com/sdk-for-python/), trovato sul sito. AWS
Modifica i valori delle variabili seguenti in base alle esigenze.
+ `ENDPOINT`: l'endpoint del cluster di database cui vuoi accedere
+ `PORT` – Numero di porta usato per la connessione al dell'istanza database
+ `USER` – L'account database cui vuoi accedere.
+ `REGION`— La AWS regione in cui è in esecuzione il cluster di DB
+ `DBNAME` – Database a cui accedere.
+ `SSLCERTIFICATE` - Percorso completo del certificato SSL per Amazon Aurora
Per `ssl_ca`, specificare un certificato SSL. Per scaricare un certificato SSL consulta [Utilizzo SSL/TLS per crittografare una connessione a un'](UsingWithRDS.SSL.md)
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint del cluster di databaseper generare il token di autenticazione.
Questo codice si connette a un cluster di database Aurora MySQL.
Prima di eseguire questo codice, installa il driver PyMy SQL seguendo le istruzioni nel [Python Package](https://pypi.org/project/PyMySQL/) Index.
```
import pymysql
import sys
import boto3
import os
ENDPOINT="mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
PORT="3306"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"
os.environ['LIBMYSQL_ENABLE_CLEARTEXT_PLUGIN'] = '1'
#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='default')
client = session.client('rds')
token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)
try:
conn = pymysql.connect(auth_plugin_map={'mysql_clear_password':None},host=ENDPOINT, user=USER, password=token, port=PORT, database=DBNAME, ssl_ca='SSLCERTIFICATE', ssl_verify_identity=True, ssl_verify_cert=True)
cur = conn.cursor()
cur.execute("""SELECT now()""")
query_results = cur.fetchall()
print(query_results)
except Exception as e:
print("Database connection failed due to {}".format(e))
```
Questo codice si connette a un cluster di database Aurora PostgreSQL.
Prima di eseguire questo codice, installa`psycopg2`seguendo le istruzioni in [Documentazione di Psycopg](https://pypi.org/project/psycopg2/).
```
import psycopg2
import sys
import boto3
import os
ENDPOINT="postgresmycluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
PORT="5432"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"
#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='RDSCreds')
client = session.client('rds')
token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)
try:
conn = psycopg2.connect(host=ENDPOINT, port=PORT, database=DBNAME, user=USER, password=token, sslrootcert="SSLCERTIFICATE")
cur = conn.cursor()
cur.execute("""SELECT now()""")
query_results = cur.fetchall()
print(query_results)
except Exception as e:
print("Database connection failed due to {}".format(e))
```
Se desideri connetterti a un cluster di database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Risoluzione dei problemi relativi all’autenticazione database IAM
Di seguito, è possibile trovare idee per la risoluzione dei problemi comuni relativi all’autenticazione database IAM e informazioni sui log e sulle metriche di CloudWatch relativi all’autenticazione database IAM.
## Esportazione di log degli errori di autenticazione database IAM su CloudWatch Logs
I log degli errori di autenticazione database IAM sono archiviati sull’host del database e li puoi esportare nel tuo account CloudWatch Logs. Utilizza i log e i metodi di correzione in questa pagina per risolvere i problemi relativi all’autenticazione database IAM.
È possibile abilitare le esportazioni dei log verso CloudWatch Logs dalla console, dalla AWS CLI e dall’API RDS. Per istruzioni relative alla console, consulta [Pubblicazione di log di database su Amazon CloudWatch Logs](USER_LogAccess.Procedural.UploadtoCloudWatch.md).
Per esportare i log degli errori di autenticazione database IAM in CloudWatch Logs durante la modifica di un cluster di database dalla AWS CLI, usa il seguente comando:
```
aws rds create-db-cluster --db-cluster-identifier mydbinstance \
--region us-east-1 \
--engine postgres \
--engine-version 16 \
--master-username master \
--master-user-password password \
--publicly-accessible \
--enable-iam-database-authentication \
--enable-cloudwatch-logs-exports=iam-db-auth-error
```
Per esportare i log degli errori di autenticazione database IAM in CloudWatch Logs durante la modifica di un cluster di database dalla AWS CLI, usa il seguente comando:
```
aws rds modify-db-cluster --db-cluster-identifier mydbcluster \
--region us-east-1 \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["iam-db-auth-error"]}'
```
Per verificare se il cluster di database sta esportando i log di autenticazione database IAM su CloudWatch Logs, controlla se il parametro `EnabledCloudwatchLogsExports` è impostato a `iam-db-auth-error` nell’output del comando `describe-db-instances`.
```
aws rds describe-db-cluster --region us-east-1 --db-cluster-identifier mydbcluster
...
"EnabledCloudwatchLogsExports": [
"iam-db-auth-error"
],
...
```
## Metriche CloudWatch relative all’autenticazione database IAM
Amazon Aurora fornisce metriche quasi in tempo reale sull’autenticazione database IAM al tuo account Amazon CloudWatch. Nella tabella seguente sono elencati le metriche di autenticazione database IAM e le dimensioni disponibili con CloudWatch:
| Parametro | Descrizione |
| --- | --- |
| `IamDbAuthConnectionRequests` | Numero totale di richieste di connessione effettuate con l’autenticazione database IAM. |
| `IamDbAuthConnectionSuccess` | Numero totale di richieste di autenticazione database IAM riuscite. |
| `IamDbAuthConnectionFailure` | Numero totale di richieste di autenticazione database IAM non riuscite. |
| `IamDbAuthConnectionFailureInvalidToken` | Numero totale di richieste di autenticazione database IAM non riuscite a causa di un token non valido. |
| `IamDbAuthConnectionFailureInsufficientPermissions` | Numero totale di richieste di autenticazione database IAM non riuscite a causa di policy o autorizzazioni errate. |
| `IamDbAuthConnectionFailureThrottling` | Numero totale di richieste di autenticazione database IAM non riuscite a causa della limitazione (della larghezza di banda della rete) per l’autenticazione database IAM. |
| `IamDbAuthConnectionFailureServerError` | Numero totale di richieste di autenticazione database IAM non riuscite a causa di un errore interno del server nella funzionalità di autenticazione database IAM. |
## Problemi e soluzioni comuni
È possibile che si verifichino i seguenti problemi durante l’utilizzo dell’autenticazione database IAM. Utilizza i passaggi di correzione indicati nella tabella per risolvere i problemi:
| Errore | Metrica/metriche | Causa | Soluzione |
| --- | --- | --- | --- |
| `[ERROR] Failed to authenticate the connection request for user db_user because the provided token is malformed or otherwise invalid. (Status Code: 400, Error Code: InvalidToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | Il token di autenticazione database IAM nella richiesta di connessione non è un token SigV4a valido o non è formattato correttamente. | Controlla la tua strategia di generazione di token nella tua applicazione. In alcuni casi, assicurati di passare il token con una formattazione valida. La troncatura del token (o la formattazione errata della stringa) renderà il token non valido. |
| `[ERROR] Failed to authenticate the connection request for user db_user because the token age is longer than 15 minutes. (Status Code: 400, Error Code:ExpiredToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | Il token di autenticazione database IAM è scaduto. I token sono validi solo per 15 minuti. | Controlla la logica di memorizzazione nella cache dei token e/o di riutilizzo dei token nell’applicazione. Non riutilizzare token più vecchi di 15 minuti. |
| `[ERROR] Failed to authorize the connection request for user db_user because the IAM policy assumed by the caller 'arn:aws:sts::123456789012:assumed-role/ / ' is not authorized to perform `rds-db:connect` on the DB instance. (Status Code: 403, Error Code:NotAuthorized)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInsufficientPermissions` | Questo errore potrebbe essere dovuto ai seguenti fattori: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.Troubleshooting.html) | Verifica il ruolo e/o la policy IAM che stai assumendo nella tua applicazione. Assicurati di assumere la stessa policy per generare il token utilizzata per la connessione al database. |
| `[ERROR] Failed to authorize the connection request for user db_user due to IAM DB authentication throttling. (Status Code: 429, Error Code: ThrottlingException)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Stai effettuando troppe richieste di connessione al tuo database in un breve lasso di tempo. La limitazione (della larghezza di banda della rete) per l’autenticazione database IAM è di 200 connessioni al secondo. | Riduci la velocità di creazione di nuove connessioni con l’autenticazione IAM. Prendi in considerazione l’implementazione del pool di connessioni utilizzando Server proxy per RDS per riutilizzare le connessioni stabilite nell’applicazione. |
| `[ERROR] Failed to authorize the connection request for user db_user due to an internal IAM DB authentication error. (Status Code: 500, Error Code: InternalError)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Si è verificato un errore interno durante l’autorizzazione della connessione database con l’autenticazione database IAM. | Contatta https://aws.amazon.com/premiumsupport/ per indagare sul problema. |
# Risoluzione dei problemi di identità e accesso in Amazon Aurora
Utilizza le informazioni seguenti per diagnosticare e risolvere i problemi comuni che possono verificarsi durante l'utilizzo di Aurora e IAM.
**Topics**
+ [Non sono autorizzato a eseguire un'operazione in Aurora](#security_iam_troubleshoot-no-permissions)
+ [Non sono autorizzato a eseguire iam: PassRole](#security_iam_troubleshoot-passrole)
+ [Desidero consentire a persone esterne al mio AWS account di accedere alle mie risorse Aurora](#security_iam_troubleshoot-cross-account-access)
## Non sono autorizzato a eseguire un'operazione in Aurora
Se ti Console di gestione AWS dice che non sei autorizzato a eseguire un'azione, devi contattare l'amministratore per ricevere assistenza. L’amministratore è colui che ti ha fornito le credenziali di accesso.
L'errore di esempio seguente si verifica quando l'`mateojackson`utente tenta di utilizzare la console per visualizzare i dettagli su un *widget* ma non dispone `rds:GetWidget` delle autorizzazioni.
```
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: rds:GetWidget on resource: my-example-widget
```
In questo caso, Mateo chiede al suo amministratore di aggiornare le policy per poter accedere alla risorsa `my-example-widget` mediante l'operazione `rds:GetWidget`.
## Non sono autorizzato a eseguire iam: PassRole
Se ricevi un errore che indica che non sei autorizzato a eseguire l'operazione `iam:PassRole`, devi contattare il tuo amministratore per ricevere assistenza. L’amministratore è colui che ti ha fornito le credenziali di accesso. Richiedi a tale persona di aggiornare le tue policy per poter passare un ruolo a Aurora.
Alcuni AWS servizi consentono di trasferire un ruolo esistente a quel servizio, anziché creare un nuovo ruolo di servizio o un ruolo collegato al servizio. Per eseguire questa operazione, è necessario disporre delle autorizzazioni per trasmettere il ruolo al servizio.
L'errore di esempio seguente si verifica quando un utente denominato `marymajor` cerca di utilizzare la console per eseguire un'operazione in Aurora. Tuttavia, l'operazione richiede che il servizio disponga delle autorizzazioni concesse da un ruolo di servizio. Mary non dispone di autorizzazioni per passare il ruolo al servizio.
```
User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole
```
In questo caso, Mary chiede all'amministratore di aggiornare la sue policy per poter eseguire l'operazione `iam:PassRole`.
## Desidero consentire a persone esterne al mio AWS account di accedere alle mie risorse Aurora
È possibile creare un ruolo con il quale utenti in altri account o persone esterne all’organizzazione possono accedere alle tue risorse. È possibile specificare chi è attendibile per l’assunzione del ruolo. Per i servizi che supportano politiche basate sulle risorse o liste di controllo degli accessi (ACLs), puoi utilizzare tali policy per consentire alle persone di accedere alle tue risorse.
Per maggiori informazioni, consulta gli argomenti seguenti:
+ Per capire se Aurora supporta queste funzionalità, consulta [Funzionamento di Amazon Aurora con IAM](security_iam_service-with-iam.md).
+ Per scoprire come fornire l'accesso alle tue risorse su più AWS account di tua proprietà, consulta [Fornire l'accesso a un utente IAM in un altro AWS account di tua proprietà nella Guida](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) per l'utente *IAM*.
+ Per scoprire come fornire l'accesso alle tue risorse ad AWS account di terze parti, consulta [Fornire l'accesso agli AWS account di proprietà di terze parti](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html) nella *Guida per l'utente IAM*.
+ Per informazioni su come fornire l’accesso tramite la federazione delle identità, consulta [Fornire l’accesso a utenti autenticati esternamente (Federazione delle identità)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html) nella *Guida per l’utente IAM*.
+ Per informazioni sulle differenze tra l'utilizzo di ruoli e policy basate su risorse per l'accesso multi-account, consultare [Differenza tra i ruoli IAM e le policy basate su risorse](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html) nella *Guida per l'utente di IAM*.