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à.

# Impostazione delle credenziali del database per RDS Proxy
<a name="rds-proxy-secrets-arns"></a>

Il proxy RDS in Amazon RDS viene utilizzato Gestione dei segreti AWS per archiviare e gestire le credenziali del database in modo sicuro. Anziché essere incorporate nell’applicazione, le credenziali vengono impostate associando un proxy a un segreto Secrets Manager contenente i dettagli di autenticazione necessari. È necessario creare un segreto Secrets Manager separato per ogni account utente del database a cui si connette il proxy sull’istanza database RDS.

In alternativa, puoi configurare RDS Proxy per utilizzare l'autenticazione end-to-end IAM, che elimina la necessità di archiviare le credenziali del database in Secrets Manager. RDS Proxy utilizza l'autenticazione IAM per entrambe client-to-proxy le connessioni. proxy-to-database Ciò fornisce una soluzione di autenticazione basata su IAM completamente integrata che non richiede la gestione di segreti o password. Per informazioni sull'aggiunta di un nuovo utente IAM DB, consulta. [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)

**Topics**
+ [

## Creazione di segreti da utilizzare con Server proxy per RDS
](#rds-proxy-secrets-create)

## Creazione di segreti da utilizzare con Server proxy per RDS
<a name="rds-proxy-secrets-create"></a>

Prima di creare un proxy, devi creare almeno un segreto in cui archiviare le credenziali del database.

### Console
<a name="rds-proxy-secrets-create-console"></a>

**Per creare un segreto**

1. Apri la console Secrets Manager all'indirizzo [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).

1. Scegli **Archivia un nuovo segreto**.

1. Scegli **Credenziali per database Amazon RDS**.

1. Inserisci un nome utente e una password. Le credenziali inserite devono corrispondere a quelle di un utente esistente nel database RDS associato. Server proxy per RDS utilizza queste credenziali per autenticare e stabilire connessioni al database per conto delle applicazioni.

   In caso di mancata corrispondenza, puoi aggiornare il segreto in modo che corrisponda alla password del database. Finché non aggiorni il segreto, i tentativi di connessione effettuati tramite il proxy utilizzando tale segreto avranno esito negativo, ma le connessioni che utilizzano altri segreti validi continueranno a funzionare.
**Nota**  
Per RDS per SQL Server, Server proxy per RDS richiede un segreto con distinzione tra maiuscole e minuscole in Secrets Manager, indipendentemente dalle impostazioni di confronto delle istanze database. Se l’applicazione consente nomi utente con uso di maiuscole e minuscole diverse, come “Admin” e “admin”, è necessario creare segreti separati per ciascuno. Server proxy per RDS non supporta l’autenticazione senza distinzione tra maiuscole e minuscole tra client e proxy.  
Per ulteriori informazioni sul confronto in SQL Server, consulta la documentazione di [Microsoft SQL Server](https://docs.microsoft.com/en-us/sql/relational-databases/collations/collation-and-unicode-support?view=sql-server-ver16).

1. Per **Database**, seleziona il database Amazon RDS a cui accederà il segreto.

1. Inserisci le altre impostazioni per il segreto, quindi scegli **Archivia**. Per le istruzioni complete, consulta [Creazione di un segreto Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) nella *Guida per l’utente di Gestione dei segreti AWS *. 

### AWS CLI
<a name="rds-proxy-secrets-create-cli"></a>

Quando crei un proxy tramite AWS CLI, specifichi gli Amazon Resource Names (ARNs) dei segreti corrispondenti. per tutti gli account utente del database a cui il proxy può accedere. In Console di gestione AWS, scegli i segreti in base ai loro nomi descrittivi.
+ Per creare un segreto Secrets Manager da utilizzare con Server proxy per RDS, utilizza il comando [create-secret](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/create-secret.html):

  ```
  aws secretsmanager create-secret \
    --name "secret_name" \
    --description "secret_description" \
    --region region_name \
    --secret-string '{"username":"db_user","password":"db_user_password"}'
  ```
+ Puoi anche creare una chiave personalizzata per crittografare il segreto Secrets Manager. Il comando seguente crea una chiave di esempio.

  ```
  aws kms create-key --description "test-key" --policy '{
    "Id":"kms-policy",
    "Version": "2012-10-17",		 	 	 
    "Statement":
      [
        {
          "Sid":"Enable IAM User Permissions",
          "Effect":"Allow",
          "Principal":{"AWS":"arn:aws:iam::account_id:root"},
          "Action":"kms:*","Resource":"*"
        },
        {
          "Sid":"Allow access for Key Administrators",
          "Effect":"Allow",
          "Principal":
            {
              "AWS":
                ["$USER_ARN","arn:aws:iam:account_id::role/Admin"]
            },
          "Action":
            [
              "kms:Create*",
              "kms:Describe*",
              "kms:Enable*",
              "kms:List*",
              "kms:Put*",
              "kms:Update*",
              "kms:Revoke*",
              "kms:Disable*",
              "kms:Get*",
              "kms:Delete*",
              "kms:TagResource",
              "kms:UntagResource",
              "kms:ScheduleKeyDeletion",
              "kms:CancelKeyDeletion"
            ],
          "Resource":"*"
        },
        {
          "Sid":"Allow use of the key",
          "Effect":"Allow",
          "Principal":{"AWS":"$ROLE_ARN"},
          "Action":["kms:Decrypt","kms:DescribeKey"],
          "Resource":"*"
        }
      ]
  }'
  ```

 Ad esempio, i comandi seguenti creano segreti Secrets Manager per due utenti di database: 

```
aws secretsmanager create-secret \
  --name secret_name_1 --description "db admin user" \
  --secret-string '{"username":"admin","password":"choose_your_own_password"}'

aws secretsmanager create-secret \
  --name secret_name_2 --description "application user" \
  --secret-string '{"username":"app-user","password":"choose_your_own_password"}'
```

Per creare questi segreti crittografati con la tua AWS KMS chiave personalizzata, usa i seguenti comandi:

```
aws secretsmanager create-secret \
  --name secret_name_1 --description "db admin user" \
  --secret-string '{"username":"admin","password":"choose_your_own_password"}' \
  --kms-key-id arn:aws:kms:us-east-2:account_id:key/key_id

aws secretsmanager create-secret \
  --name secret_name_2 --description "application user" \
  --secret-string '{"username":"app-user","password":"choose_your_own_password"}' \
  --kms-key-id arn:aws:kms:us-east-2:account_id:key/key_id
```

Per vedere i segreti di proprietà del tuo AWS account, usa il comando [list-secrets](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/list-secrets.html):

```
aws secretsmanager list-secrets
```

Quando crei un proxy utilizzando la CLI, passi gli Amazon Resource Names (ARNs) di uno o più segreti al `--auth` parametro. L’esempio seguente mostra come preparare un report con solo il nome e l’ARN di ogni segreto di proprietà del tuo account AWS . Questo esempio utilizza il `--output table` parametro disponibile nella AWS CLI versione 2. Se stai usando la AWS CLI versione 1, usa `--output text` invece. 

```
aws secretsmanager list-secrets --query '*[].[Name,ARN]' --output table
```

Per confermare che il segreto contenga le credenziali corrette nel formato corretto, utilizzate il [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html)comando. Sostituisci `your_secret_name` con il nome breve o l’ARN del segreto.

```
aws secretsmanager get-secret-value --secret-id your_secret_name
```

L’output contiene una riga con un valore con codifica JSON simile al seguente:

```
...
"SecretString": "{\"username\":\"your_username\",\"password\":\"your_password\"}",
...
```