

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Démarrage avec le proxy RDS
<a name="rds-proxy-setup"></a>

Utilisez les informations des pages suivantes pour configurer, gérer le [Proxy Amazon RDS ](rds-proxy.md) et définir les options de sécurité associées. Les options de sécurité contrôlent les accès à chaque proxy et la connexion de ces derniers aux instances de base de données.

Si vous utilisez le proxy RDS pour la première fois, nous vous recommandons de suivre les pages dans l’ordre dans lequel nous les présentons. 

**Topics**
+ [Configuration des prérequis réseau pour un proxy RDS](rds-proxy-network-prereqs.md)
+ [Configuration des informations d'identification de base de données pour le proxy RDS](rds-proxy-secrets-arns.md)
+ [Configuration de l’authentification IAM pour RDS Proxy](rds-proxy-iam-setup.md)
+ [Création d’un proxy pour Amazon RDS](rds-proxy-creating.md)
+ [Affichage d’un proxy](rds-proxy-viewing.md)
+ [Connexion à une base de données via RDS Proxy](rds-proxy-connecting.md)

# Configuration des prérequis réseau pour un proxy RDS
<a name="rds-proxy-network-prereqs"></a>

 L’utilisation de RDS Proxy nécessite un cloud privé virtuel (VPC) commun entre votre instance de base de données RDS et RDS Proxy. Ce VPC doit avoir au moins deux sous-réseaux situés dans des zones de disponibilité différentes. Votre compte peut posséder ces sous-réseaux ou les partager avec d’autres comptes. Pour plus d'informations sur le partage VPC, consultez la section [Travailler avec](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-sharing.html) le partage. VPCs 

Pour le IPv6 support, une configuration réseau supplémentaire est requise :
+ **IPv6 types de réseaux de points de terminaison** : votre VPC et vos sous-réseaux doivent être configurés pour prendre en charge. IPv6 Cela inclut l'attribution de blocs IPv6 CIDR à votre VPC et à vos sous-réseaux.
+ **Types de réseaux de points de terminaison à double pile** : votre VPC et vos sous-réseaux doivent prendre en charge IPv4 les deux types et l'adressage. IPv6 
+ **IPv6 types de réseaux de connexion cibles** : votre base de données doit être configurée pour le mode double pile afin de prendre en charge IPv6 les connexions depuis le proxy.

Les ressources de vos applications client telles qu’Amazon EC2, Lambda ou Amazon ECS peuvent se trouver dans le même VPC que le proxy. Elles peuvent également se trouver dans un VPC distinct du proxy. Si vous êtes bien connecté à des instances de base de données RDS , vous disposez déjà des ressources réseau requises. 

**Topics**
+ [Obtention d’informations sur vos sous-réseaux](#rds-proxy-network-prereqs.subnet-info)
+ [Planification de la capacité des adresses IP](#rds-proxy-network-prereqs.plan-ip-address)

## Obtention d’informations sur vos sous-réseaux
<a name="rds-proxy-network-prereqs.subnet-info"></a>

Pour créer un proxy, vous devez fournir les sous-réseaux et le VPC au sein desquels le proxy fonctionne. L'exemple Linux suivant montre des AWS CLI commandes qui examinent les sous-réseaux VPCs et appartenant à votre Compte AWS. En particulier, vous transmettez le sous-réseau IDs en tant que paramètres lorsque vous créez un proxy à l'aide de la CLI. 

```
aws ec2 describe-vpcs
aws ec2 describe-internet-gateways
aws ec2 describe-subnets --query '*[].[VpcId,SubnetId]' --output text | sort
```

L'exemple Linux suivant montre des AWS CLI commandes permettant de déterminer le sous-réseau IDs correspondant à un cluster de base de données de base de données RDS spécifique. Recherchez l’ID du VPC de l’instance de base de données. Examinez le VPC pour rechercher ses sous-réseaux. Pour ce faire, examinez l’exemple Linux suivant.

```
$ #From the DB instance, trace through the DBSubnetGroup and Subnets to find the subnet IDs.
$ aws rds describe-db-instances --db-instance-identifier my_instance_id --query '*[].[DBSubnetGroup]|[0]|[0]|[Subnets]|[0]|[*].SubnetIdentifier' --output text
```

```
subnet_id_1
subnet_id_2
subnet_id_3
...
```

```
$ #From the DB instance, find the VPC.
$ aws rds describe-db-instances --db-instance-identifier my_instance_id --query '*[].[DBSubnetGroup]|[0]|[0].VpcId' --output text
```

```
my_vpc_id
```

```
$ aws ec2 describe-subnets --filters Name=vpc-id,Values=my_vpc_id --query '*[].[SubnetId]' --output text
```

```
subnet_id_1
subnet_id_2
subnet_id_3
subnet_id_4
subnet_id_5
subnet_id_6
```

## Planification de la capacité des adresses IP
<a name="rds-proxy-network-prereqs.plan-ip-address"></a>

Un proxy RDS ajuste automatiquement sa capacité selon les besoins en fonction de la taille et du nombre d’instances de base de données enregistrées auprès de lui. Certaines opérations peuvent également nécessiter de la capacité de proxy supplémentaire, par exemple, une augmentation de la taille d’une base de données enregistrée ou des opérations de maintenance des proxy RDS internes. Au cours de ces opérations, votre proxy peut avoir besoin de plus d’adresses IP pour fournir de la capacité supplémentaire. Ces adresses supplémentaires permettent à votre proxy d’évoluer sans affecter votre charge de travail. L’absence d’adresses IP libres dans vos sous-réseaux empêche d’augmenter un proxy. Cela peut entraîner des latences de requêtes plus élevées ou des échecs de connexion client. RDS vous avertit par le biais de l’événement `RDS-EVENT-0243` lorsqu’il n’y a pas suffisamment d’adresses IP libres dans vos sous-réseaux. Pour plus d’informations sur cet événement, consultez [Utilisation des des événements RDS ProxyUtilisation des des événements RDS Proxy](rds-proxy.events.md).

**Note**  
Le proxy RDS ne consomme pas plus de 215 adresses IP pour chaque proxy d'un VPC.

Réservez le nombre minimal suivant d’adresses IP libres dans vos sous-réseaux pour votre proxy, en fonction des tailles de classes d’instance de base de données.


|  Classe d’instance de base de données  |  Nombre minimal d’adresses IP libres  | 
| --- | --- | 
|  db.\$1.xlarge ou moins   |  10  | 
|  db.\$1.2xlarge   |  15  | 
|  db.\$1.4xlarge   |  25  | 
|  db.\$1.8xlarge   |  45  | 
|  db.\$1.12xlarge   |  60  | 
|  db.\$1.16xlarge   |  75  | 
|  db.\$1.24xlarge   |  110  | 

Ces nombres recommandés d’adresses IP sont des estimations pour un proxy avec uniquement le point de terminaison par défaut. Un proxy avec des points de terminaison supplémentaires ou des réplicas en lecture peut avoir besoin d’un plus grand nombre d’adresses IP libres. Pour chaque point de terminaison supplémentaire, nous vous recommandons de réserver trois adresses IP supplémentaires. Pour chaque réplica en lecture, nous vous recommandons de réserver des adresses IP supplémentaires, comme indiqué dans le tableau, en fonction de la taille de ce réplica en lecture.

# Configuration des informations d'identification de base de données pour le proxy RDS
<a name="rds-proxy-secrets-arns"></a>

Le proxy RDS dans Amazon RDS est utilisé AWS Secrets Manager pour stocker et gérer les informations d'identification de base de données en toute sécurité. Au lieu d’intégrer des informations d’identification dans votre application, vous associez un proxy à un secret Secrets Manager contenant les informations d’authentification nécessaires. Vous créez un secret Secrets Manager distinct pour chaque compte d’utilisateur de base de données auquel le proxy se connecte sur l’instance de base de données RDS.

Vous pouvez également configurer le proxy RDS pour utiliser l'authentification end-to-end IAM, ce qui élimine le besoin de stocker les informations d'identification de la base de données dans Secrets Manager. Le proxy RDS utilise l'authentification IAM pour les connexions à la fois client-to-proxy. proxy-to-database Cela fournit une solution d'authentification basée sur IAM entièrement intégrée qui ne nécessite pas de gérer des secrets ou des mots de passe. Pour plus d'informations sur l'ajout d'un nouvel utilisateur de base de données IAM, consultez[Création d’un compte de base de données à l’aide de l’authentification IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md).

**Topics**
+ [Création de secrets à utiliser avec le proxy RDS](#rds-proxy-secrets-create)

## Création de secrets à utiliser avec le proxy RDS
<a name="rds-proxy-secrets-create"></a>

Avant de créer un proxy, vous devez d’abord créer au moins un secret qui stocke les informations d’identification de votre base de données.

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

**Pour créer un secret**

1. Ouvrez la console Secrets Manager à l'adresse [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).

1. Choisissez **Store a new secret** (Stocker un nouveau secret).

1. Choisissez **Informations d’identification pour une base de données Amazon RDS**.

1. Entrez un nom d’utilisateur et un mot de passe. Les informations d’identification que vous entrez doivent correspondre aux informations d’identification d’un utilisateur de base de données existant dans la base de données RDS associée. Le proxy RDS utilise ces informations d’identification pour authentifier et établir des connexions à la base de données pour le compte des applications.

   En cas d’incompatibilité, vous pouvez mettre à jour le secret pour qu’il corresponde à celui de la base de données. Tant que vous ne mettez pas à jour le secret, les tentatives de connexion via le proxy utilisant ce secret échouent, mais les connexions utilisant d’autres secrets valides fonctionnent toujours.
**Note**  
Pour RDS for SQL Server, le proxy RDS nécessite un secret sensible aux majuscules et minuscules dans Secrets Manager, quels que soient les paramètres de classement des instances de base de données. Si votre application autorise des noms d’utilisateur avec des capitalisations différentes, tels que « Admin » et « admin », vous devez créer des secrets distincts pour chacun. Le proxy RDS ne prend pas en charge l’authentification insensible à la casse entre le client et le proxy.  
Pour plus d’informations sur le classement SQL Server, consultez la documentation [Microsoft SQL Server](https://docs.microsoft.com/en-us/sql/relational-databases/collations/collation-and-unicode-support?view=sql-server-ver16).

1. Pour **Base de données**, sélectionnez la base de données Amazon RDS à laquelle le secret doit accéder.

1. Renseignez les autres paramètres pour le secret, puis choisissez **Stockage**. Pour obtenir des instructions complètes, consultez [Création d’un secret AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) dans le *AWS Secrets Manager Guide de l’utilisateur*. 

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

Lorsque vous créez un proxy via le AWS CLI, vous spécifiez les Amazon Resource Names (ARNs) des secrets correspondants. Vous le faites pour tous les comptes utilisateur de base de données auxquels le proxy peut accéder. Dans le AWS Management Console, vous choisissez les secrets par leurs noms descriptifs.
+ Pour créer un secret Secrets Manager à utiliser avec le proxy RDS, utilisez la commande [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"}'
  ```
+ Vous pouvez également créer une clé personnalisée pour chiffrer votre secret Secrets Manager. La commande suivante crée un exemple de clé.

  ```
  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":"*"
        }
      ]
  }'
  ```

 Par exemple, les commandes suivantes créent des secrets Secrets Manager pour deux utilisateurs de base de données. 

```
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"}'
```

Pour créer ces secrets chiffrés avec votre AWS KMS clé personnalisée, utilisez les commandes suivantes :

```
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
```

Pour voir les secrets détenus par votre AWS compte, utilisez la commande [list-secrets](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/list-secrets.html) :

```
aws secretsmanager list-secrets
```

Lorsque vous créez un proxy à l'aide de la CLI, vous transmettez les Amazon Resource Names (ARNs) d'un ou de plusieurs secrets au `--auth` paramètre. L’exemple suivant montre comment préparer un rapport avec uniquement le nom et l’ARN de chacun des secrets détenus par votre compte AWS . Cet exemple utilise le `--output table` paramètre disponible dans la AWS CLI version 2. Si vous utilisez AWS CLI la version 1, utilisez `--output text` plutôt. 

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

Pour vérifier que le secret contient les informations d'identification correctes au format approprié, utilisez la [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html)commande. Remplacez `your_secret_name` par le nom abrégé ou l’ARN du secret.

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

La sortie contient une ligne avec une valeur codée en JSON semblable à la suivante :

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

# Configuration de l’authentification IAM pour RDS Proxy
<a name="rds-proxy-iam-setup"></a>

Pour configurer l'authentification Gestion des identités et des accès AWS (IAM) pour le proxy RDS dans Amazon RDS, créez et configurez une politique IAM qui accorde les autorisations nécessaires. 

Cette rubrique décrit les étapes de configuration de l’authentification IAM pour RDS Proxy, notamment la création de la politique IAM requise et son association à un rôle IAM. 

**Astuce**  
Cette procédure n’est nécessaire que si vous souhaitez créer votre propre rôle IAM. Dans le cas contraire, RDS peut créer automatiquement le rôle requis lorsque vous configurez le proxy. Vous pouvez donc ignorer ces étapes.

## Conditions préalables
<a name="rds-proxy-iam-setup-prereqs"></a>

Avant de configurer l’authentification IAM pour RDS Proxy, assurez-vous de disposer des éléments suivants :
+ **AWS Secrets Manager** : au moins un secret stocké contenant les informations d’identification de la base de données. Pour obtenir des instructions sur la création des secrets, consultez [Configuration des informations d'identification de base de données pour le proxy RDS](rds-proxy-secrets-arns.md).

  Cela n'est pas obligatoire si vous utilisez l'authentification end-to-end IAM.
+ **Autorisations IAM** : rôle ou utilisateur IAM autorisé à créer et à gérer des politiques, des rôles et des secrets IAM dans AWS Secrets Manager.

## Création d'une politique IAM pour l'authentification end-to-end IAM
<a name="rds-proxy-iam-setup-e2e-steps"></a>

Lorsque vous utilisez l'authentification end-to-end IAM, le proxy RDS se connecte à votre base de données à l'aide de l'authentification IAM au lieu de récupérer les informations d'identification auprès de Secrets Manager. Cela nécessite de configurer votre rôle IAM avec des `rds-db:connect` autorisations pour les comptes de base de données que vous souhaitez utiliser avec le proxy.

Pour authentifier votre proxy RDS auprès de la base de données à l'aide d'IAM, créez un rôle IAM avec une politique qui accorde les autorisations de connexion à la base de données nécessaires.

### Console
<a name="rds-proxy-iam-e2e-console"></a>

**Pour créer un rôle pour l'authentification end-to-end IAM avec votre proxy**

1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.

1. Créez une stratégie d’autorisation pour le rôle. Pour connaître les étapes générales, consultez [Créer des politiques IAM (console).](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html)

   Collez cette politique dans l’éditeur JSON et effectuez les modifications suivantes :
   + Indiquez votre propre ID de compte.
   + Remplacez `us-east-2` par le lieu où le mandataire doit résider.
   + Remplacez les noms d'utilisateur IDs et de ressource de base de données par ceux que vous souhaitez utiliser. Le format de l'ID de ressource diffère entre les instances RDS etAurora clusters.

   ```
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "rds-db:connect",
               "Resource": [
                   "arn:aws:rds-db:us-east-2:account_id:dbuser:db_instance_resource_id/db_user_name_1",
                   "arn:aws:rds-db:us-east-2:account_id:dbuser:db_instance_resource_id/db_user_name_2"
               ]
           }
       ]
   }
   ```

1. Créez le rôle et associez-le à une stratégie d’autorisations. Pour les étapes générales, voir [Créer un rôle pour déléguer des autorisations à un AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html). 

   Choisissez **Service AWS ** pour **Type d’entité de confiance**. Sous **Cas d’utilisation**, sélectionnez **RDS** et choisissez **RDS : ajouter un rôle à la base de données** pour le cas d’utilisation.

1. Sous **Stratégies d’autorisation**, choisissez la stratégie que vous avez créée.

1. Pour **Sélectionner les entités de confiance**, entrez la stratégie d’approbation suivante pour le rôle :

   ```
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "",
         "Effect": "Allow",
         "Principal": {
           "Service": "rds.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   ```

### AWS CLI
<a name="rds-proxy-iam-e2e-cli"></a>

Pour créer le rôle à l'aide du AWS CLI, envoyez la demande suivante :

```
aws iam create-role \
  --role-name my_e2e_iam_role_name \

  --assume-role-policy-document '{"Version":"2012-10-17",		 	 	 "Statement":[{"Effect":"Allow","Principal":{"Service":["rds.amazonaws.com"]},"Action":"sts:AssumeRole"}]}'
```

Associez ensuite cette stratégie au rôle :

```
aws iam put-role-policy \
  --role-name my_e2e_iam_role_name \
  --policy-name e2e_iam_db_connect_policy \
  --policy-document '{

    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "rds-db:connect",
            "Resource": [
                "arn:aws:rds-db:us-east-2:account_id:dbuser:db_instance_resource_id/db_user_name_1",
                "arn:aws:rds-db:us-east-2:account_id:dbuser:db_instance_resource_id/db_user_name_2"
            ]
        }
    ]
}'
```

Le rôle et les autorisations IAM étant configurés pour l'authentification end-to-end IAM, vous pouvez désormais créer un proxy `DefaultAuthScheme` défini sur. `IAM_AUTH` Ce proxy s'authentifie directement auprès de la base de données à l'aide d'IAM sans avoir besoin des secrets de Secrets Manager. Pour obtenir des instructions, veuillez consulter [Création d’un proxy pour Amazon RDS](rds-proxy-creating.md).

Lorsque vous utilisez l'authentification end-to-end IAM, assurez-vous que les utilisateurs de votre base de données sont configurés pour l'authentification IAM, comme décrit dans. [Création d’un compte de base de données à l’aide de l’authentification IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)

## Création d’une Politique IAM pour accéder à Secrets Manager
<a name="rds-proxy-iam-setup-steps"></a>

Pour permettre à RDS Proxy de récupérer les informations d’identification de la base de données de Secrets Manager, créez un rôle IAM avec une politique qui accorde les autorisations nécessaires.

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

**Pour créer un rôle permettant d’accéder aux secrets qui seront utilisés avec votre proxy**

1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.

1. Créez une stratégie d’autorisation pour le rôle. Pour connaître les étapes générales, consultez [Créer des politiques IAM (console).](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html)

   Collez cette politique dans l’éditeur JSON et effectuez les modifications suivantes :
   + Indiquez votre propre ID de compte.
   + Remplacez `us-east-2` par la région où résidera le proxy.
   + Remplacez les noms secrets par ceux que vous avez créés. Pour plus d’informations, consultez [Spécification de clés KMS dans les instructions de politique IAM](https://docs.aws.amazon.com/kms/latest/developerguide/cmks-in-iam-policies.html).
   + Remplacez l’ID de clé KMS par celui que vous avez utilisé pour chiffrer les secrets de Secrets Manager, qu’il s’agisse de la clé par défaut ou de votre propre clé.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "secretsmanager:GetSecretValue",
               "Resource": [
                   "arn:aws:secretsmanager:us-east-2:111122223333:secret:secret_name_1",
                   "arn:aws:secretsmanager:us-east-2:111122223333:secret:secret_name_2"
               ]
           },
           {
               "Effect": "Allow",
               "Action": "kms:Decrypt",
               "Resource": "arn:aws:kms:us-east-2:111122223333:key/key_id",
               "Condition": {
                   "StringEquals": {
                       "kms:ViaService": "secretsmanager.us-east-2.amazonaws.com"
                   }
               }
           }
       ]
   }
   ```

------

1. Créez le rôle et associez-le à une stratégie d’autorisations. Pour les étapes générales, voir [Créer un rôle pour déléguer des autorisations à un AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html). 

   Choisissez **Service AWS ** pour **Type d’entité de confiance**. Sous **Cas d’utilisation**, sélectionnez **RDS** et choisissez **RDS : ajouter un rôle à la base de données** pour le cas d’utilisation.

1. Sous **Stratégies d’autorisation**, choisissez la stratégie que vous avez créée.

1. Pour **Sélectionner les entités de confiance**, entrez la stratégie d’approbation suivante pour le rôle :

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "",
         "Effect": "Allow",
         "Principal": {
           "Service": "rds.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   ```

------

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

Pour créer le rôle à l'aide du AWS CLI, envoyez la demande suivante :

```
aws iam create-role \
  --role-name my_role_name \
  --assume-role-policy-document '{"Version": "2012-10-17",		 	 	 "Statement":[{"Effect":"Allow","Principal":{"Service":["rds.amazonaws.com"]},"Action":"sts:AssumeRole"}]}'
```

Associez ensuite cette stratégie au rôle :

```
aws iam put-role-policy \
  --role-name my_role_name \
  --policy-name secret_reader_policy \
  --policy-document '{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": "secretsmanager:GetSecretValue",
            "Resource": [
                "arn:aws:secretsmanager:us-east-2:account_id:secret:secret_name_1",
                "arn:aws:secretsmanager:us-east-2:account_id:secret:secret_name_2"
            ]
        },
        {
            "Sid": "VisualEditor1",
            "Effect": "Allow",
            "Action": "kms:Decrypt",
            "Resource": "arn:aws:kms:us-east-2:account_id:key/key_id",
            "Condition": {
                "StringEquals": {
                    "kms:ViaService": "secretsmanager.us-east-2.amazonaws.com"
                }
            }
        }
    ]
}'
```

Une fois le rôle et les autorisations IAM configurés, vous pouvez créer un proxy et l’associer à ce rôle. Cela permet au proxy de récupérer les informations d'identification de la base de données en toute sécurité AWS Secrets Manager et d'activer l'authentification IAM pour vos applications. Pour obtenir des instructions, veuillez consulter [Création d’un proxy pour Amazon RDS](rds-proxy-creating.md).

# Création d’un proxy pour Amazon RDS
<a name="rds-proxy-creating"></a>

Vous pouvez employer un proxy avec une instance de base de données RDS for MariaDB, RDS for Microsoft SQL Server, RDS for MySQL ou RDS pour PostgreSQL. 

## Console
<a name="rds-proxy-creating.console"></a>

**Pour créer un proxy**

1. Connectez-vous à la console Amazon RDS AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)l'adresse.

1. Dans le panneau de navigation, sélectionnez **Proxies**. 

1. Choisissez **Création d’un proxy**. 

1. Configurez les paramètres suivants pour votre proxy.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/rds-proxy-creating.html)

1.  Choisissez **Création d’un proxy**. 

## AWS CLI
<a name="rds-proxy-creating.CLI"></a>

 Pour créer un proxy à l'aide de AWS CLI, appelez la [create-db-proxy](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-proxy.html)commande avec les paramètres obligatoires suivants : 
+ `--db-proxy-name`
+ `--engine-family`
+ `--role-arn`
+ `--vpc-subnet-ids`

La valeur `--engine-family` est sensible à la casse.

**Example**  
Pour Linux, macOS ou Unix :  

```
aws rds create-db-proxy \
    --db-proxy-name proxy_name \
    --engine-family { MYSQL | POSTGRESQL | SQLSERVER } \
    --role-arn iam_role \
    --vpc-subnet-ids space_separated_list \
    [--default-auth-scheme { NONE | IAM_AUTH }] \
    [--auth ProxyAuthenticationConfig_JSON_string] \
    [--vpc-security-group-ids space_separated_list] \
    [--require-tls | --no-require-tls] \
    [--idle-client-timeout value] \
    [--debug-logging | --no-debug-logging] \
    [--endpoint-network-type { IPV4 | IPV6 | DUAL }] \
    [--target-connection-network-type { IPV4 | IPV6 }] \
    [--tags comma_separated_list]
```
Pour Windows :  

```
aws rds create-db-proxy ^
    --db-proxy-name proxy_name ^
    --engine-family { MYSQL | POSTGRESQL | SQLSERVER } ^
    --role-arn iam_role ^
    --vpc-subnet-ids space_separated_list ^
    [--default-auth-scheme { NONE | IAM_AUTH }] ^
    [--auth ProxyAuthenticationConfig_JSON_string] ^
    [--vpc-security-group-ids space_separated_list] ^
    [--require-tls | --no-require-tls] ^
    [--idle-client-timeout value] ^
    [--debug-logging | --no-debug-logging] ^
    [--endpoint-network-type { IPV4 | IPV6 | DUAL }] ^
    [--target-connection-network-type { IPV4 | IPV6 }] ^
    [--tags comma_separated_list]
```

Voici un exemple de valeur JSON pour l’option `--auth`. Cet exemple applique un type d’authentification client différent à chaque secret.

```
[
  {
    "Description": "proxy description 1",
    "AuthScheme": "SECRETS",
    "SecretArn": "arn:aws:secretsmanager:us-west-2:123456789123:secret/1234abcd-12ab-34cd-56ef-1234567890ab",
    "IAMAuth": "DISABLED",
    "ClientPasswordAuthType": "POSTGRES_SCRAM_SHA_256"
  },
  
  {
    "Description": "proxy description 2",
    "AuthScheme": "SECRETS",
    "SecretArn": "arn:aws:secretsmanager:us-west-2:111122223333:secret/1234abcd-12ab-34cd-56ef-1234567890cd",
    "IAMAuth": "DISABLED",
    "ClientPasswordAuthType": "POSTGRES_MD5"
    
  },
  
  {
    "Description": "proxy description 3",
    "AuthScheme": "SECRETS",
    "SecretArn": "arn:aws:secretsmanager:us-west-2:111122221111:secret/1234abcd-12ab-34cd-56ef-1234567890ef",
    "IAMAuth": "REQUIRED"
  }
  
]
```

Le paramètre `--endpoint-network-type` indique la version IP du point de terminaison de proxy que les clients utilisent pour se connecter au proxy. Les valeurs valides sont :
+ `IPV4`— Le point de terminaison du proxy utilise uniquement IPv4 des adresses (par défaut).
+ `IPV6`— Le point de terminaison du proxy utilise uniquement IPv6 des adresses.
+ `DUAL`— Le point de terminaison du proxy prend en charge IPv4 les deux IPv6 adresses.

Le paramètre `--target-connection-network-type` indique la version IP utilisée par le proxy pour se connecter à la base de données cible. Les valeurs valides sont :
+ `IPV4`— Le proxy se connecte à la base de données à l'aide d' IPv4 adresses (par défaut).
+ `IPV6`— Le proxy se connecte à la base de données à l'aide d' IPv6 adresses.

Pour utiliser IPv6 ou doubler les types de réseaux de points de terminaison, votre VPC et vos sous-réseaux doivent être configurés pour prendre en charge le type de réseau sélectionné. Pour utiliser le type de réseau de connexion IPv6 cible, votre base de données doit prendre en charge le mode double pile.

**Astuce**  
 Si vous ne connaissez pas encore le sous-réseau IDs à utiliser pour le `--vpc-subnet-ids` paramètre, consultez des exemples [Configuration des prérequis réseau pour un proxy RDS](rds-proxy-network-prereqs.md) pour les trouver. 

**Note**  
Le groupe de sécurité doit autoriser l’accès à la base de données à laquelle le proxy se connecte. Le même groupe de sécurité est utilisé pour l’entrée de vos applications vers le proxy, et pour la sortie du proxy vers la base de données. Par exemple, supposons que vous utilisiez le même groupe de sécurité pour votre base de données et votre proxy. Dans ce cas, assurez-vous de spécifier que les ressources de ce groupe de sécurité peuvent communiquer avec d’autres ressources du même groupe de sécurité.  
Lorsque vous utilisez un VPC partagé, vous ne pouvez pas utiliser le groupe de sécurité par défaut pour le VPC ni un groupe appartenant à un autre compte. Choisissez un groupe de sécurité qui appartient à votre compte. S’il n’en existe aucun, créez-en un. Pour plus d'informations sur cette limitation, voir [Travailler avec le partage VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-sharing.html#vpc-share-limitations). 

 Pour créer les associations appropriées pour le proxy, vous devez également utiliser la [register-db-proxy-targets](https://docs.aws.amazon.com/cli/latest/reference/rds/register-db-proxy-targets.html)commande. Spécifiez le nom du groupe cible `default`. RDS Proxy crée automatiquement un groupe cible portant ce nom au moment de la création de chaque proxy. 

```
aws rds register-db-proxy-targets
    --db-proxy-name value
    [--target-group-name target_group_name]
    [--db-instance-identifiers space_separated_list]  # rds db instances, or
    [--db-cluster-identifiers cluster_id]        # rds db cluster (all instances)
```

## API RDS
<a name="rds-proxy-creating.API"></a>

 [Pour créer un proxy RDS, appelez l'opération Create de l'API Amazon RDS. DBProxy](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBProxy.html) Vous transmettez un paramètre avec la structure [AuthConfig](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_AuthConfig.html)de données. 

 RDS Proxy crée automatiquement un groupe cible nommé `default` au moment de la création de chaque proxy. Vous associez un de données RDS au groupe cible en appelant la fonction [Register DBProxy Targets](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RegisterDBProxyTargets.html). 

**Important**  
Lorsque vous sélectionnez l'**authentification IAM comme** schéma d'authentification par défaut :  
Vous devez activer l'authentification de base de données IAM sur vos instances ou clusters de base de données cibles pour que le proxy puisse se connecter correctement.
Si vous choisissez **Créer un rôle IAM**, le champ **Comptes de base de données pour l'authentification IAM** est obligatoire.
Si vous sélectionnez un rôle IAM existant, la console ne met pas automatiquement à jour le rôle avec les autorisations de connexion à la base de données. Vérifiez que le rôle dispose des `rds-db:connect` autorisations nécessaires.

# Affichage d’un proxy
<a name="rds-proxy-viewing"></a>

 Après avoir créé un ou plusieurs proxys RDS, vous pouvez les afficher et les gérer dans la AWS Management Console, l’AWS CLI ou l’API RDS. Vous pouvez consulter les détails de leur configuration, surveiller les performances et déterminer les proxys à modifier ou à supprimer selon les besoins.

Pour permettre aux applications de base de données d’acheminer le trafic via un proxy, vous devez spécifier le point de terminaison du proxy dans la chaîne de connexion.

## Console
<a name="rds-proxy-viewing.console"></a>

**Pour afficher un proxy dans la console**

1. Connectez-vous à la AWS Management Console et ouvrez la console Amazon RDS à l’adresse [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. Dans le panneau de navigation, sélectionnez **Proxies**. 

1. Sélectionnez le nom du proxy pour en afficher les détails. 

1. Sur la page de détails, la section **Groupes cibles** montre comment le proxy est lié à une instance de base de données RDS spécifique. Vous pouvez accéder à la page du groupe cible par défaut pour obtenir une vue plus approfondie de cette association, notamment des paramètres de configuration définis lors de la création du proxy. Cela inclut le pourcentage maximal de connexion, le délai d’emprunt de connexion, la famille de moteurs et les filtres d’épinglage de session.

## Interface de ligne de commande (CLI)
<a name="rds-proxy-viewing.cli"></a>

 Pour afficher votre proxy à l'aide de l'interface de ligne de commande, utilisez la commande [describe-db-proxies](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-proxies.html). Par défaut, la demande renvoie tous les proxy appartenant à votre compte AWS. Pour afficher les détails d'un proxy, spécifiez son nom avec le paramètre `--db-proxy-name`. 

```
aws rds describe-db-proxies [--db-proxy-name proxy_name]
```

 Pour afficher les autres informations associées au proxy, utilisez les commandes suivantes. 

```
aws rds describe-db-proxy-target-groups  --db-proxy-name proxy_name

aws rds describe-db-proxy-targets --db-proxy-name proxy_name
```

 Utilisez la séquence de commandes suivante pour afficher plus de détails sur les éléments associés au proxy : 

1.  Pour obtenir une liste des proxies, exécutez [describe-db-proxies](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-proxies.html). 

1.  Pour afficher les paramètres de connexion tels que le pourcentage maximal de connexions que le proxy peut utiliser, exécutez [describe-db-proxy-target-groups](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-proxy-target-groups.html) `--db-proxy-name`. Utilisez le nom du proxy comme valeur de paramètre. 

1.  Pour afficher les détails de l’instance de base de données RDS associée au groupe cible renvoyé, exécutez [describe-db-proxy-targets](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-proxy-targets.html). 

## API RDS
<a name="rds-proxy-viewing.api"></a>

 Pour afficher vos proxies à l'aide de l'API RDS, utilisez l'opération [DescribeDBProxies](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBProxies.html). Elle renvoie les valeurs du type de données [DBProxy](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DBProxy.html). 

 Pour afficher les détails des paramètres de connexion du proxy, utilisez les identifiants de proxy à partir de la valeur renvoyée à l'aide de l'opération [DescribeDBProxyTargetGroups](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBProxyTargetGroups.html). Elle renvoie les valeurs du type de données [DBProxyTargetGroup](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DBProxyTargetGroup.html). 

 Pour voir l'instance RDS ou le cluster de base de données Aurora associé au proxy, utilisez l'opération [DescribeDBProxyTargets](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBProxyTargets.html). Elle renvoie les valeurs du type de données [DBProxyTarget](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DBProxyTarget.html). 

# Connexion à une base de données via RDS Proxy
<a name="rds-proxy-connecting"></a>

La méthode pour se connecter à une instance RDS, que ce soit par un proxy ou en se connectant directement à la base de données, est globalement identique. Pour plus d’informations, consultez [Présentation des points de terminaison proxy](rds-proxy-endpoints.md#rds-proxy-endpoints-overview). 

**Topics**
+ [Connexion à une base de données à l'aide des informations d'identification](#rds-proxy-connecting-native)
+ [Connexion à une base de données à l'aide de l'authentification IAM](#rds-proxy-connecting-iam)
+ [Considérations relatives à la connexion à Microsoft SQL Server](#rds-proxy-connecting-sqlserver)
+ [Considérations relatives à la connexion à PostgreSQL](#rds-proxy-connecting-postgresql)

## Connexion à une base de données à l'aide des informations d'identification
<a name="rds-proxy-connecting-native"></a>

 Procédez comme suit pour vous connecter à un proxy à l'aide des informations d'identification de base de données : 

1.  Recherchez le point de terminaison du proxy. Dans le AWS Management Console, vous pouvez trouver le point de terminaison sur la page de détails du proxy correspondant. Avec le AWS CLI, vous pouvez utiliser la [describe-db-proxies](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-proxies.html)commande. L’exemple suivant montre comment procéder. 

   ```
   # Add --output text to get output as a simple tab-separated list.
   $ aws rds describe-db-proxies --query '*[*].{DBProxyName:DBProxyName,Endpoint:Endpoint}'
   [
       [
           {
               "Endpoint": "the-proxy.proxy-demo.us-east-1.rds.amazonaws.com",
               "DBProxyName": "the-proxy"
           },
           {
               "Endpoint": "the-proxy-other-secret.proxy-demo.us-east-1.rds.amazonaws.com",
               "DBProxyName": "the-proxy-other-secret"
           },
           {
               "Endpoint": "the-proxy-rds-secret.proxy-demo.us-east-1.rds.amazonaws.com",
               "DBProxyName": "the-proxy-rds-secret"
           },
           {
               "Endpoint": "the-proxy-t3.proxy-demo.us-east-1.rds.amazonaws.com",
               "DBProxyName": "the-proxy-t3"
           }
       ]
   ]
   ```

1.  Spécifier le point de terminaison comme paramètre hôte dans la chaîne de connexion de votre application cliente. Par exemple, spécifiez le point de terminaison du proxy comme valeur pour l’option `mysql -h` ou `psql -h`. 

1.  Fournissez le nom d’utilisateur et le mot de passe de base de données que vous utilisez habituellement. 

## Connexion à une base de données à l'aide de l'authentification IAM
<a name="rds-proxy-connecting-iam"></a>

 Lorsque vous utilisez l'authentification IAM avec RDS Proxy, vous disposez de deux options d'authentification entre votre client et votre proxy :
+ Configurez les utilisateurs de votre base de données pour qu'ils s'authentifient à l'aide de noms d'utilisateur et de mots de passe habituels. RDS Proxy récupère le nom d'utilisateur et les informations d'identification du mot de passe auprès de Secrets Manager. La connexion depuis RDS Proxy à la base de données sous-jacente ne passe pas par IAM.
+ Vous pouvez également utiliser l'authentification end-to-end IAM, qui se connecte à votre base de données via le proxy à l'aide d'IAM sans avoir besoin d'informations d'identification de base de données.

 Pour vous connecter à RDS Proxy à l’aide de l’authentification IAM, suivez la même procédure de connexion générale que pour vous connecter avec une authentification IAM à une instance de base de données RDS. Pour obtenir des informations générales sur l’utilisation d’IAM, consultez [Sécurité dans Amazon RDS ( Aurora)](UsingWithRDS.md). Si vous utilisez l'authentification end-to-end IAM, fournissez le plug-in d'authentification IAM à votre utilisateur de base de données. Consultez [Création d’un compte de base de données à l’aide de l’authentification IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md).

 Les principales différences dans l’utilisation d’IAM pour RDS Proxy sont les suivantes : 
+ Avec l'authentification IAM standard, les utilisateurs de la base de données disposent d'informations d'identification régulières dans la base de données. Vous configurez des secrets Secrets Manager contenant ces noms et mots de passe d’utilisateur, et autorisez RDS Proxy à récupérer les informations d’identification à partir d’Secrets Manager. L’authentification IAM s’applique à la connexion entre votre programme client et le proxy. Le proxy s’authentifie ensuite à la base de données à l’aide des informations d’identification (nom d’utilisateur et mot de passe) extraites via Secrets Manager.
+ Avec l'authentification end-to-end IAM, vous n'avez pas besoin de configurer les secrets de Secrets Manager pour les informations d'identification de base de données. L'authentification IAM s'applique à la connexion entre le client et le proxy et la base de données.
+ Spécifiez le point de terminaison du proxy plutôt que celui de l’instance, du cluster ou du lecteur. Pour plus d’informations sur le point de terminaison du proxy, consultez [Connexion à votre instance de base de données à l'aide de l'authentification IAM.](UsingWithRDS.IAMDBAuth.Connecting.md).
+ Veillez à utiliser le protocole TLS (Transport Layer Security)/SSL (Secure Sockets Layer) lorsque vous vous connectez à un proxy avec l’authentification IAM.

Vous pouvez accorder l’accès au proxy à un utilisateur spécifique en modifiant la politique IAM. Un exemple suit.

```
"Resource": "arn:aws:rds-db:us-east-2:1234567890:dbuser:prx-ABCDEFGHIJKL01234/db_user"
```

**Astuce**  
Lorsque vous configurez l'authentification IAM pour les connexions au proxy RDS, suivez ces directives importantes pour éviter les problèmes de connexion :  
N'accordez pas le `rds_iam` rôle tout en conservant l'authentification générale par mot de passe pour le même utilisateur ou le même rôle de base de données.
N'oubliez pas que lorsque les clients se connectent au proxy RDS à l'aide de l'authentification IAM, le proxy RDS se connecte toujours à la base de données à l'aide de l'authentification par mot de passe via Secrets Manager.
Si vous rencontrez fréquemment des interruptions et des reconnexions de connexion, supprimez toutes les autorisations existantes `rds_iam` accordées à l'utilisateur ou au rôle et utilisez uniquement l'authentification par mot de passe.
Assurez-vous que votre politique de mot de passe répond aux exigences du protocole SCRAM-SHA-256 en matière de caractères sûrs.
La combinaison de méthodes d'authentification IAM et par mot de passe pour le même utilisateur de base de données peut entraîner une instabilité de connexion.

## Considérations relatives à la connexion à Microsoft SQL Server
<a name="rds-proxy-connecting-sqlserver"></a>

Pour vous connecter à un proxy à l’aide de l’authentification IAM, vous n’utilisez pas le champ du mot de passe. Vous devez plutôt fournir la propriété de jeton appropriée pour chaque type de pilote de base de données dans le champ du jeton. Par exemple, utilisez la propriété `accessToken` pour JDBC ou la propriété `sql_copt_ss_access_token` pour ODBC. Vous pouvez également utiliser la `AccessToken` propriété du SqlClient pilote .NET. Vous ne pouvez pas utiliser l’authentification IAM avec des clients qui ne prennent pas en charge les propriétés des jetons.

Dans certaines conditions, un proxy ne peut pas partager une connexion à une base de données et épingle la connexion entre votre application cliente et le proxy vers une connexion de base de données dédiée. Pour plus d’informations sur ces conditions, consultez [Contournement de l’épinglage d’un proxy RDS](rds-proxy-pinning.md).

## Considérations relatives à la connexion à PostgreSQL
<a name="rds-proxy-connecting-postgresql"></a>

Si vous créez un nouvel utilisateur de base de données PostgreSQL pour vous connecter au proxy RDS, veillez à lui accorder `CONNECT` sur la base de données. À défaut de ce privilège, l’utilisateur ne sera pas en mesure de se connecter. Pour plus d’informations, consultez [Ajout d’un nouvel utilisateur de base de données à une base de données PostgreSQL lors de l’utilisation du proxy RDS](rds-proxy-new-db-user.md#rds-proxy-new-db-user-pg).

Lorsqu’un client démarre une connexion à une base de données PostgreSQL, il envoie un message de démarrage. Ce message inclut des paires de chaînes de noms de paramètres et de valeurs. Pour plus de détails, consultez `StartupMessage` dans la section relative aux [formats de message PostgreSQL](https://www.postgresql.org/docs/current/protocol-message-formats.html) de la documentation PostgreSQL. 

Lors de la connexion via un proxy RDS, le message de démarrage peut inclure les paramètres actuellement reconnus suivants : 
+  `user` 
+  `database`

 Le message de démarrage peut également inclure les paramètres d’exécution supplémentaires suivants : 
+ `[application\$1name](https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-APPLICATION-NAME) `
+ `[client\$1encoding](https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-CLIENT-ENCODING) `
+ `[DateStyle](https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-DATESTYLE) `
+ `[TimeZone](https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-TIMEZONE) `
+  `[extra\$1float\$1digits](https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-EXTRA-FLOAT-DIGITS) `
+  `[ search\$1path ](https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-SEARCH-PATH)` 

 Pour plus d’informations sur la messagerie PostgreSQL, consultez [protocole frontend/backend](https://www.postgresql.org/docs/current/protocol.html) dans la documentation PostgreSQL.

 Pour PostgreSQL, si vous utilisez JDBC, nous vous recommandons ce qui suit pour éviter l’épinglage :
+ Définissez le paramètre de connexion JDBC `assumeMinServerVersion` sur `9.0` au minimum afin d’éviter l’épinglage. Cela empêche le pilote JDBC d’effectuer un aller-retour supplémentaire au démarrage de la connexion lorsqu’il exécute `SET extra_float_digits = 3`. 
+ Définissez le paramètre de connexion JDBC `ApplicationName` sur `any/your-application-name` afin d’éviter l’épinglage. Cela empêche le pilote JDBC d’effectuer un aller-retour supplémentaire au démarrage de la connexion lorsqu’il exécute `SET application_name = "PostgreSQL JDBC Driver"`. Notez que le paramètre JDBC est `ApplicationName`, mais que le paramètre PostgreSQL `StartupMessage` est `application_name`.

Pour plus d’informations, consultez [Contournement de l’épinglage d’un proxy RDS](rds-proxy-pinning.md). Pour plus d’informations sur la connexion à l’aide de JDBC, consultez [Connexion à la base de données](https://jdbc.postgresql.org/documentation/setup/) dans la documentation PostgreSQL.