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à.
# Esempi di utilizzo di Amazon RDS AWS CLI
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando Amazon RDS. AWS Command Line Interface
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `add-option-to-option-group`
Il seguente esempio di codice mostra come usare`add-option-to-option-group`.
**AWS CLI**
**Come aggiungere un’opzione a un gruppo di opzioni**
L’esempio `add-option-to-option-group` seguente aggiunge un’opzione al gruppo di opzioni specificato.
```
aws rds add-option-to-option-group \
--option-group-name myoptiongroup \
--options OptionName=OEM,Port=5500,DBSecurityGroupMemberships=default \
--apply-immediately
```
Output:
```
{
"OptionGroup": {
"OptionGroupName": "myoptiongroup",
"OptionGroupDescription": "Test Option Group",
"EngineName": "oracle-ee",
"MajorEngineVersion": "12.1",
"Options": [
{
"OptionName": "Timezone",
"OptionDescription": "Change time zone",
"Persistent": true,
"Permanent": false,
"OptionSettings": [
{
"Name": "TIME_ZONE",
"Value": "Australia/Sydney",
"DefaultValue": "UTC",
"Description": "Specifies the timezone the user wants to change the system time to",
"ApplyType": "DYNAMIC",
"DataType": "STRING",
"AllowedValues": "Africa/Cairo,Africa/Casablanca,Africa/Harare,Africa/Lagos,Africa/Luanda,Africa/Monrovia,Africa/Nairobi,Africa/Tripoli,Africa/Windhoek,America/Araguaina,America/Argentina/Buenos_Aires,America/Asuncion,America/Bogota,America/Caracas,America/Chicago,America/Chihuahua,America/Cuiaba,America/Denver,America/Detroit,America/Fortaleza,America/Godthab,America/Guatemala,America/Halifax,America/Lima,America/Los_Angeles,America/Manaus,America/Matamoros,America/Mexico_City,America/Monterrey,America/Montevideo,America/New_York,America/Phoenix,America/Santiago,America/Sao_Paulo,America/Tijuana,America/Toronto,Asia/Amman,Asia/Ashgabat,Asia/Baghdad,Asia/Baku,Asia/Bangkok,Asia/Beirut,Asia/Calcutta,Asia/Damascus,Asia/Dhaka,Asia/Hong_Kong,Asia/Irkutsk,Asia/Jakarta,Asia/Jerusalem,Asia/Kabul,Asia/Karachi,Asia/Kathmandu,Asia/Kolkata,Asia/Krasnoyarsk,Asia/Magadan,Asia/Manila,Asia/Muscat,Asia/Novosibirsk,Asia/Rangoon,Asia/Riyadh,Asia/Seoul,Asia/Shanghai,Asia/Singapore,Asia/Taipei,Asia/Tehran,Asia/Tokyo,Asia/Ulaanbaatar,Asia/Vladivostok,Asia/Yakutsk,Asia/Yerevan,Atlantic/Azores,Atlantic/Cape_Verde,Australia/Adelaide,Australia/Brisbane,Australia/Darwin,Australia/Eucla,Australia/Hobart,Australia/Lord_Howe,Australia/Perth,Australia/Sydney,Brazil/DeNoronha,Brazil/East,Canada/Newfoundland,Canada/Saskatchewan,Etc/GMT-3,Europe/Amsterdam,Europe/Athens,Europe/Berlin,Europe/Dublin,Europe/Helsinki,Europe/Kaliningrad,Europe/London,Europe/Madrid,Europe/Moscow,Europe/Paris,Europe/Prague,Europe/Rome,Europe/Sarajevo,Pacific/Apia,Pacific/Auckland,Pacific/Chatham,Pacific/Fiji,Pacific/Guam,Pacific/Honolulu,Pacific/Kiritimati,Pacific/Marquesas,Pacific/Samoa,Pacific/Tongatapu,Pacific/Wake,US/Alaska,US/Central,US/East-Indiana,US/Eastern,US/Pacific,UTC",
"IsModifiable": true,
"IsCollection": false
}
],
"DBSecurityGroupMemberships": [],
"VpcSecurityGroupMemberships": []
},
{
"OptionName": "OEM",
"OptionDescription": "Oracle 12c EM Express",
"Persistent": false,
"Permanent": false,
"Port": 5500,
"OptionSettings": [],
"DBSecurityGroupMemberships": [
{
"DBSecurityGroupName": "default",
"Status": "authorized"
}
],
"VpcSecurityGroupMemberships": []
}
],
"AllowsVpcAndNonVpcInstanceMemberships": false,
"OptionGroupArn": "arn:aws:rds:us-east-1:123456789012:og:myoptiongroup"
}
}
```
Per ulteriori informazioni, consulta [Aggiunta di un’opzione a un gruppo di opzioni](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithOptionGroups.html#USER_WorkingWithOptionGroups.AddOption) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [AddOptionToOptionGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/add-option-to-option-group.html)*Command Reference*.
### `add-role-to-db-cluster`
Il seguente esempio di codice mostra come utilizzare`add-role-to-db-cluster`.
**AWS CLI**
**Per associare un ruolo AWS Identity and Access Management (IAM) a un cluster DB**
L’esempio `add-role-to-db-cluster` seguente associa un ruolo a un cluster di database.
```
aws rds add-role-to-db-cluster \
--db-cluster-identifier mydbcluster \
--role-arn arn:aws:iam::123456789012:role/RDSLoadFromS3
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Associazione di un ruolo IAM a un cluster DB Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Integrating.Authorizing.IAM.AddRoleToDBCluster.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [AddRoleToDbCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/add-role-to-db-cluster.html)*Command Reference*.
### `add-role-to-db-instance`
Il seguente esempio di codice mostra come utilizzare`add-role-to-db-instance`.
**AWS CLI**
**Per associare un ruolo AWS Identity and Access Management (IAM) a un'istanza DB**
L’esempio `add-role-to-db-instance` seguente aggiunge il ruolo a un’istanza database Oracle denominata `test-instance`.
```
aws rds add-role-to-db-instance \
--db-instance-identifier test-instance \
--feature-name S3_INTEGRATION \
--role-arn arn:aws:iam::111122223333:role/rds-s3-integration-role
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Prerequisiti per l’integrazione di Amazon RDS per Oracle con Amazon S3](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/oracle-s3-integration.html#oracle-s3-integration.preparing) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [AddRoleToDbInstance AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/add-role-to-db-instance.html)*Command Reference*.
### `add-source-identifier-to-subscription`
Il seguente esempio di codice mostra come utilizzare`add-source-identifier-to-subscription`.
**AWS CLI**
**Come aggiungere un identificatore di origine a un’abbonamento**
L’esempio `add-source-identifier` seguente aggiunge l’identificatore di origine all’abbonamento esistente.
```
aws rds add-source-identifier-to-subscription \
--subscription-name my-instance-events \
--source-identifier test-instance-repl
```
Output:
```
{
"EventSubscription": {
"SubscriptionCreationTime": "Tue Jul 31 23:22:01 UTC 2018",
"CustSubscriptionId": "my-instance-events",
"EventSubscriptionArn": "arn:aws:rds:us-east-1:123456789012:es:my-instance-events",
"Enabled": false,
"Status": "modifying",
"EventCategoriesList": [
"backup",
"recovery"
],
"CustomerAwsId": "123456789012",
"SnsTopicArn": "arn:aws:sns:us-east-1:123456789012:interesting-events",
"SourceType": "db-instance",
"SourceIdsList": [
"test-instance",
"test-instance-repl"
]
}
}
```
+ Per i dettagli sull'API, consulta [AddSourceIdentifierToSubscription AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/add-source-identifier-to-subscription.html)*Command Reference*.
### `add-tags-to-resource`
Il seguente esempio di codice mostra come utilizzare`add-tags-to-resource`.
**AWS CLI**
**Come aggiungere tag a una risorsa**
L’esempio `add-tags-to-resource` seguente aggiunge tag a un database RDS.
```
aws rds add-tags-to-resource \
--resource-name arn:aws:rds:us-east-1:123456789012:db:database-mysql \
--tags "[{\"Key\": \"Name\",\"Value\": \"MyDatabase\"},{\"Key\": \"Environment\",\"Value\": \"test\"}]"
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta la pagina [Tagging delle risorse Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [AddTagsToResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/add-tags-to-resource.html)*Command Reference*.
### `apply-pending-maintenance-action`
Il seguente esempio di codice mostra come utilizzare`apply-pending-maintenance-action`.
**AWS CLI**
**Esecuzione di azioni di manutenzione in attesa**
L’esempio `apply-pending-maintenance-action` seguente applica le azioni di manutenzione in sospeso per i cluster di database.
```
aws rds apply-pending-maintenance-action \
--resource-identifier arn:aws:rds:us-east-1:123456789012:cluster:my-db-cluster \
--apply-action system-update \
--opt-in-type immediate
```
Output:
```
{
"ResourcePendingMaintenanceActions": {
"ResourceIdentifier": "arn:aws:rds:us-east-1:123456789012:cluster:my-db-cluster",
"PendingMaintenanceActionDetails": [
{
"Action": "system-update",
"OptInStatus": "immediate",
"CurrentApplyDate": "2021-01-23T01:07:36.100Z",
"Description": "Upgrade to Aurora PostgreSQL 3.3.2"
}
]
}
}
```
Per ulteriori informazioni, consulta [Manutenzione di un’istanza database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_UpgradeDBInstance.Maintenance.html) nella *Guida per l’utente di Amazon RDS* e [Manutenzione di un cluster database Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_UpgradeDBInstance.Maintenance.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [ApplyPendingMaintenanceAction AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/apply-pending-maintenance-action.html)*Command Reference*.
### `authorize-db-security-group-ingress`
Il seguente esempio di codice mostra come utilizzare`authorize-db-security-group-ingress`.
**AWS CLI**
**Per associare un ruolo AWS Identity and Access Management (IAM) a un'istanza DB**
L’esempio `authorize-db-security-group-ingress` seguente configura il gruppo di sicurezza predefinito con una regola di ingresso per l’intervallo CIDR IP 192.0.2.0/24.
```
aws rds authorize-db-security-group-ingress \
--db-security-group-name default \
--cidrip 192.0.2.0/24
```
Output:
```
{
"DBSecurityGroup": {
"OwnerId": "123456789012",
"DBSecurityGroupName": "default",
"DBSecurityGroupDescription": "default",
"EC2SecurityGroups": [],
"IPRanges": [
{
"Status": "authorizing",
"CIDRIP": "192.0.2.0/24"
}
],
"DBSecurityGroupArn": "arn:aws:rds:us-east-1:111122223333:secgrp:default"
}
}
```
Per ulteriori informazioni, consulta [Autorizzazione dell’accesso a un gruppo di sicurezza database da un intervallo IP](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithSecurityGroups.html#USER_WorkingWithSecurityGroups.Authorizing) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [AuthorizeDbSecurityGroupIngress AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/authorize-db-security-group-ingress.html)*Command Reference*.
### `backtrack-db-cluster`
Il seguente esempio di codice mostra come utilizzare`backtrack-db-cluster`.
**AWS CLI**
**Come eseguire il backtrack di un cluster di database Aurora**
L’esempio `backtrack-db-cluster` seguente esegue il backtrack del sample-cluster del cluster di database con il timestamp 19 marzo 2018, ore 10:00.
```
aws rds backtrack-db-cluster --db-cluster-identifier sample-cluster --backtrack-to 2018-03-19T10:00:00+00:00
```
Questo comando genera un blocco JSON che riconosce la modifica alla risorsa RDS.
+ Per i dettagli sull'API, consulta [BacktrackDbCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/backtrack-db-cluster.html)*Command Reference*.
### `cancel-export-task`
Il seguente esempio di codice mostra come utilizzare`cancel-export-task`.
**AWS CLI**
**Come annullare l’esportazione di uno snapshot in Amazon S3**
L’esempio `cancel-export-task` seguente annulla un’attività di esportazione in corso che sta esportando uno snapshot in Amazon S3.
```
aws rds cancel-export-task \
--export-task-identifier my-s3-export-1
```
Output:
```
{
"ExportTaskIdentifier": "my-s3-export-1",
"SourceArn": "arn:aws:rds:us-east-1:123456789012:snapshot:publisher-final-snapshot",
"SnapshotTime": "2019-03-24T20:01:09.815Z",
"S3Bucket": "amzn-s3-demo-bucket",
"S3Prefix": "",
"IamRoleArn": "arn:aws:iam::123456789012:role/service-role/export-snap-S3-role",
"KmsKeyId": "arn:aws:kms:us-east-1:123456789012:key/abcd0000-7bfd-4594-af38-aabbccddeeff",
"Status": "CANCELING",
"PercentProgress": 0,
"TotalExtractedDataInGB": 0
}
```
Per ulteriori informazioni, consulta [Annullamento di un’attività di esportazione di snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ExportSnapshot.html#USER_ExportSnapshot.Canceling) nella *Guida per l’utente di Amazon RDS* o [Annullamento di un’attività di esportazione di snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_ExportSnapshot.html#USER_ExportSnapshot.Canceling) nella *Guida per l’utente di Amazon Aurora.*
+ Per i dettagli sull'API, consulta [CancelExportTask AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/cancel-export-task.html)*Command Reference*.
### `copy-db-cluster-parameter-group`
Il seguente esempio di codice mostra come utilizzare`copy-db-cluster-parameter-group`.
**AWS CLI**
**Come copiare un gruppo di parametri del cluster di database**
L’esempio `copy-db-cluster-parameter-group` seguente crea una copia di un gruppo di parametri del cluster di database.
```
aws rds copy-db-cluster-parameter-group \
--source-db-cluster-parameter-group-identifier mydbclusterpg \
--target-db-cluster-parameter-group-identifier mydbclusterpgcopy \
--target-db-cluster-parameter-group-description "Copy of mydbclusterpg parameter group"
```
Output:
```
{
"DBClusterParameterGroup": {
"DBClusterParameterGroupName": "mydbclusterpgcopy",
"DBClusterParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:cluster-pg:mydbclusterpgcopy",
"DBParameterGroupFamily": "aurora-mysql5.7",
"Description": "Copy of mydbclusterpg parameter group"
}
}
```
Per ulteriori informazioni, consulta [Copia di un gruppo di parametri cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.html#USER_WorkingWithParamGroups.CopyingCluster) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [CopyDbClusterParameterGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/copy-db-cluster-parameter-group.html)*Command Reference*.
### `copy-db-cluster-snapshot`
Il seguente esempio di codice mostra come utilizzare`copy-db-cluster-snapshot`.
**AWS CLI**
**Come copiare uno snapshot del cluster di database**
L’esempio `copy-db-cluster-snapshot` seguente crea una copia di uno snapshot del cluster di database, inclusi i relativi tag.
```
aws rds copy-db-cluster-snapshot \
--source-db-cluster-snapshot-identifier arn:aws:rds:us-east-1:123456789012:cluster-snapshot:rds:myaurora-2019-06-04-09-16
--target-db-cluster-snapshot-identifier myclustersnapshotcopy \
--copy-tags
```
Output:
```
{
"DBClusterSnapshot": {
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1e"
],
"DBClusterSnapshotIdentifier": "myclustersnapshotcopy",
"DBClusterIdentifier": "myaurora",
"SnapshotCreateTime": "2019-06-04T09:16:42.649Z",
"Engine": "aurora-mysql",
"AllocatedStorage": 0,
"Status": "available",
"Port": 0,
"VpcId": "vpc-6594f31c",
"ClusterCreateTime": "2019-04-15T14:18:42.785Z",
"MasterUsername": "myadmin",
"EngineVersion": "5.7.mysql_aurora.2.04.2",
"LicenseModel": "aurora-mysql",
"SnapshotType": "manual",
"PercentProgress": 100,
"StorageEncrypted": true,
"KmsKeyId": "arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE",
"DBClusterSnapshotArn": "arn:aws:rds:us-east-1:123456789012:cluster-snapshot:myclustersnapshotcopy",
"IAMDatabaseAuthenticationEnabled": false
}
}
```
Per ulteriori informazioni, consulta [Copia di uno snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_CopySnapshot.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [CopyDbClusterSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/copy-db-cluster-snapshot.html)*Command Reference*.
### `copy-db-parameter-group`
Il seguente esempio di codice mostra come utilizzare`copy-db-parameter-group`.
**AWS CLI**
**Come copiare un gruppo di parametri del cluster di database**
L’esempio `copy-db-parameter-group` seguente crea una copia di un gruppo di parametri del database.
```
aws rds copy-db-parameter-group \
--source-db-parameter-group-identifier mydbpg \
--target-db-parameter-group-identifier mydbpgcopy \
--target-db-parameter-group-description "Copy of mydbpg parameter group"
```
Output:
```
{
"DBParameterGroup": {
"DBParameterGroupName": "mydbpgcopy",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:814387698303:pg:mydbpgcopy",
"DBParameterGroupFamily": "mysql5.7",
"Description": "Copy of mydbpg parameter group"
}
}
```
Per ulteriori informazioni, consulta [Copia di un gruppo di parametri database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html#USER_WorkingWithParamGroups.Copying) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [CopyDbParameterGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/copy-db-parameter-group.html)*Command Reference*.
### `copy-db-snapshot`
Il seguente esempio di codice mostra come utilizzare`copy-db-snapshot`.
**AWS CLI**
**Come copiare uno snapshot database**
L’esempio `copy-db-snapshot` seguente crea una copia di uno snapshot database.
```
aws rds copy-db-snapshot \
--source-db-snapshot-identifier rds:database-mysql-2019-06-06-08-38
--target-db-snapshot-identifier mydbsnapshotcopy
```
Output:
```
{
"DBSnapshot": {
"VpcId": "vpc-6594f31c",
"Status": "creating",
"Encrypted": true,
"SourceDBSnapshotIdentifier": "arn:aws:rds:us-east-1:123456789012:snapshot:rds:database-mysql-2019-06-06-08-38",
"MasterUsername": "admin",
"Iops": 1000,
"Port": 3306,
"LicenseModel": "general-public-license",
"DBSnapshotArn": "arn:aws:rds:us-east-1:123456789012:snapshot:mydbsnapshotcopy",
"EngineVersion": "5.6.40",
"OptionGroupName": "default:mysql-5-6",
"ProcessorFeatures": [],
"Engine": "mysql",
"StorageType": "io1",
"DbiResourceId": "db-ZI7UJ5BLKMBYFGX7FDENCKADC4",
"KmsKeyId": "arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE",
"SnapshotType": "manual",
"IAMDatabaseAuthenticationEnabled": false,
"SourceRegion": "us-east-1",
"DBInstanceIdentifier": "database-mysql",
"InstanceCreateTime": "2019-04-30T15:45:53.663Z",
"AvailabilityZone": "us-east-1f",
"PercentProgress": 0,
"AllocatedStorage": 100,
"DBSnapshotIdentifier": "mydbsnapshotcopy"
}
}
```
Per ulteriori informazioni, consulta [Copia di uno snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CopySnapshot.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [CopyDbSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/copy-db-snapshot.html)*Command Reference*.
### `copy-option-group`
Il seguente esempio di codice mostra come utilizzare`copy-option-group`.
**AWS CLI**
**Come copiare un gruppo di opzioni**
L’esempio `copy-option-group` seguente crea una copia di un gruppo di opzioni.
```
aws rds copy-option-group \
--source-option-group-identifier myoptiongroup \
--target-option-group-identifier new-option-group \
--target-option-group-description "My option group copy"
```
Output:
```
{
"OptionGroup": {
"Options": [],
"OptionGroupName": "new-option-group",
"MajorEngineVersion": "11.2",
"OptionGroupDescription": "My option group copy",
"AllowsVpcAndNonVpcInstanceMemberships": true,
"EngineName": "oracle-ee",
"OptionGroupArn": "arn:aws:rds:us-east-1:123456789012:og:new-option-group"
}
}
```
Per ulteriori informazioni, consulta [Esecuzione di una copia di un gruppo di opzioni](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithOptionGroups.html#USER_WorkingWithOptionGroups.Copy) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [CopyOptionGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/copy-option-group.html)*Command Reference*.
### `create-blue-green-deployment`
Il seguente esempio di codice mostra come utilizzare`create-blue-green-deployment`.
**AWS CLI**
**Esempio 1: creare una blue/green distribuzione per un'istanza DB RDS for MySQL**
L'`create-blue-green-deployment`esempio seguente crea una blue/green distribuzione per un'istanza DB MySQL.
```
aws rds create-blue-green-deployment \
--blue-green-deployment-name bgd-cli-test-instance \
--source arn:aws:rds:us-east-1:123456789012:db:my-db-instance \
--target-engine-version 8.0 \
--target-db-parameter-group-name mysql-80-group
```
Output:
```
{
"BlueGreenDeployment": {
"BlueGreenDeploymentIdentifier": "bgd-v53303651eexfake",
"BlueGreenDeploymentName": "bgd-cli-test-instance",
"Source": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance",
"SwitchoverDetails": [
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-1"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-2"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-3"
}
],
"Tasks": [
{
"Name": "CREATING_READ_REPLICA_OF_SOURCE",
"Status": "PENDING"
},
{
"Name": "DB_ENGINE_VERSION_UPGRADE",
"Status": "PENDING"
},
{
"Name": "CONFIGURE_BACKUPS",
"Status": "PENDING"
},
{
"Name": "CREATING_TOPOLOGY_OF_SOURCE",
"Status": "PENDING"
}
],
"Status": "PROVISIONING",
"CreateTime": "2022-02-25T21:18:51.183000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Creare una blue/green distribuzione](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/blue-green-deployments-creating.html) nella *Amazon RDS User Guide*.
**Esempio 2: creare una blue/green distribuzione per un cluster Aurora MySQL DB**
L'`create-blue-green-deployment`esempio seguente crea una blue/green distribuzione per un cluster Aurora MySQL DB.
```
aws rds create-blue-green-deployment \
--blue-green-deployment-name my-blue-green-deployment \
--source arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster \
--target-engine-version 8.0 \
--target-db-cluster-parameter-group-name ams-80-binlog-enabled \
--target-db-parameter-group-name mysql-80-cluster-group
```
Output:
```
{
"BlueGreenDeployment": {
"BlueGreenDeploymentIdentifier": "bgd-wi89nwzglccsfake",
"BlueGreenDeploymentName": "my-blue-green-deployment",
"Source": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"SwitchoverDetails": [
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"Status": "PROVISIONING"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-1",
"Status": "PROVISIONING"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-2",
"Status": "PROVISIONING"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-3",
"Status": "PROVISIONING"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-excluded-member-endpoint",
"Status": "PROVISIONING"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-reader-endpoint",
"Status": "PROVISIONING"
}
],
"Tasks": [
{
"Name": "CREATING_READ_REPLICA_OF_SOURCE",
"Status": "PENDING"
},
{
"Name": "DB_ENGINE_VERSION_UPGRADE",
"Status": "PENDING"
},
{
"Name": "CREATE_DB_INSTANCES_FOR_CLUSTER",
"Status": "PENDING"
},
{
"Name": "CREATE_CUSTOM_ENDPOINTS",
"Status": "PENDING"
}
],
"Status": "PROVISIONING",
"CreateTime": "2022-02-25T21:12:00.288000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Creare una blue/green distribuzione](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-creating.html) nella Guida per l'*utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [CreateBlueGreenDeployment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-blue-green-deployment.html)*Command Reference.*
### `create-db-cluster-endpoint`
Il seguente esempio di codice mostra come utilizzare`create-db-cluster-endpoint`.
**AWS CLI**
**Come creare un endpoint del cluster di database personalizzato**
L’esempio `create-db-cluster-endpoint` seguente crea un endpoint del cluster di database personalizzato e lo associa al cluster Aurora DB specificato.
```
aws rds create-db-cluster-endpoint \
--db-cluster-endpoint-identifier mycustomendpoint \
--endpoint-type reader \
--db-cluster-identifier mydbcluster \
--static-members dbinstance1 dbinstance2
```
Output:
```
{
"DBClusterEndpointIdentifier": "mycustomendpoint",
"DBClusterIdentifier": "mydbcluster",
"DBClusterEndpointResourceIdentifier": "cluster-endpoint-ANPAJ4AE5446DAEXAMPLE",
"Endpoint": "mycustomendpoint.cluster-custom-cnpexample.us-east-1.rds.amazonaws.com",
"Status": "creating",
"EndpointType": "CUSTOM",
"CustomEndpointType": "READER",
"StaticMembers": [
"dbinstance1",
"dbinstance2"
],
"ExcludedMembers": [],
"DBClusterEndpointArn": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:mycustomendpoint"
}
```
Per ulteriori informazioni, consulta [Gestione delle connessioni Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Overview.Endpoints.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [CreateDbClusterEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-cluster-endpoint.html)*Command Reference*.
### `create-db-cluster-parameter-group`
Il seguente esempio di codice mostra come utilizzare`create-db-cluster-parameter-group`.
**AWS CLI**
**Come creare un gruppo di parametri del cluster di database**
L’esempio `create-db-cluster-parameter-group` seguente crea un gruppo di parametri del cluster di database.
```
aws rds create-db-cluster-parameter-group \
--db-cluster-parameter-group-name mydbclusterparametergroup \
--db-parameter-group-family aurora5.6 \
--description "My new cluster parameter group"
```
Output:
```
{
"DBClusterParameterGroup": {
"DBClusterParameterGroupName": "mydbclusterparametergroup",
"DBParameterGroupFamily": "aurora5.6",
"Description": "My new cluster parameter group",
"DBClusterParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:cluster-pg:mydbclusterparametergroup"
}
}
```
Per ulteriori informazioni, consulta [Creazione di un gruppo di parametri cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.html#USER_WorkingWithParamGroups.CreatingCluster) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [CreateDbClusterParameterGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-cluster-parameter-group.html)*Command Reference*.
### `create-db-cluster-snapshot`
Il seguente esempio di codice mostra come utilizzare`create-db-cluster-snapshot`.
**AWS CLI**
**Come creare uno snapshot del cluster di database**
L’esempio `create-db-cluster-snapshot` seguente crea uno snapshot del cluster di database.
```
aws rds create-db-cluster-snapshot \
--db-cluster-identifier mydbcluster \
--db-cluster-snapshot-identifier mydbclustersnapshot
```
Output:
```
{
"DBClusterSnapshot": {
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1e"
],
"DBClusterSnapshotIdentifier": "mydbclustersnapshot",
"DBClusterIdentifier": "mydbcluster",
"SnapshotCreateTime": "2019-06-18T21:21:00.469Z",
"Engine": "aurora-mysql",
"AllocatedStorage": 1,
"Status": "creating",
"Port": 0,
"VpcId": "vpc-6594f31c",
"ClusterCreateTime": "2019-04-15T14:18:42.785Z",
"MasterUsername": "myadmin",
"EngineVersion": "5.7.mysql_aurora.2.04.2",
"LicenseModel": "aurora-mysql",
"SnapshotType": "manual",
"PercentProgress": 0,
"StorageEncrypted": true,
"KmsKeyId": "arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE",
"DBClusterSnapshotArn": "arn:aws:rds:us-east-1:123456789012:cluster-snapshot:mydbclustersnapshot",
"IAMDatabaseAuthenticationEnabled": false
}
}
```
Per ulteriori informazioni, consulta [Creazione di una snapshot di cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_CreateSnapshotCluster.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [CreateDbClusterSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-cluster-snapshot.html)*Command Reference*.
### `create-db-cluster`
Il seguente esempio di codice mostra come utilizzare`create-db-cluster`.
**AWS CLI**
**Esempio 1: come creare un cluster di database compatibile con MySQL**
L’esempio `create-db-cluster` seguente crea un cluster di database compatibile con MySQL 5.7 utilizzando la versione del motore predefinita. Sostituisci la password di esempio `secret99` con una password sicura. Se utilizzi la console per creare un cluster di database, Amazon RDS crea automaticamente l’istanza di database core di scrittura per il cluster di database. Tuttavia, quando si utilizza la AWS CLI per creare un cluster DB, è necessario creare in modo esplicito l'istanza Writer DB per il cluster DB utilizzando il comando `create-db-instance` AWS CLI.
```
aws rds create-db-cluster \
--db-cluster-identifier sample-cluster \
--engine aurora-mysql \
--engine-version 5.7 \
--master-username admin \
--master-user-password secret99 \
--db-subnet-group-name default \
--vpc-security-group-ids sg-0b9130572daf3dc16
```
Output:
```
{
"DBCluster": {
"DBSubnetGroup": "default",
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-0b9130572daf3dc16",
"Status": "active"
}
],
"AllocatedStorage": 1,
"AssociatedRoles": [],
"PreferredBackupWindow": "09:12-09:42",
"ClusterCreateTime": "2023-02-27T23:21:33.048Z",
"DeletionProtection": false,
"IAMDatabaseAuthenticationEnabled": false,
"ReadReplicaIdentifiers": [],
"EngineMode": "provisioned",
"Engine": "aurora-mysql",
"StorageEncrypted": false,
"MultiAZ": false,
"PreferredMaintenanceWindow": "mon:04:31-mon:05:01",
"HttpEndpointEnabled": false,
"BackupRetentionPeriod": 1,
"DbClusterResourceId": "cluster-ANPAJ4AE5446DAEXAMPLE",
"DBClusterIdentifier": "sample-cluster",
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1e"
],
"MasterUsername": "master",
"EngineVersion": "5.7.mysql_aurora.2.11.1",
"DBClusterArn": "arn:aws:rds:us-east-1:123456789012:cluster:sample-cluster",
"DBClusterMembers": [],
"Port": 3306,
"Status": "creating",
"Endpoint": "sample-cluster.cluster-cnpexample.us-east-1.rds.amazonaws.com",
"DBClusterParameterGroup": "default.aurora-mysql5.7",
"HostedZoneId": "Z2R2ITUGPM61AM",
"ReaderEndpoint": "sample-cluster.cluster-ro-cnpexample.us-east-1.rds.amazonaws.com",
"CopyTagsToSnapshot": false
}
}
```
**Esempio 2: come creare un cluster di database compatibile con PostgreSQL**
L’esempio `create-db-cluster` seguente crea un cluster di database compatibile con PostgreSQL utilizzando la versione del motore predefinita. Sostituisci la password `secret99` di esempio con una password sicura. Se utilizzi la console per creare un cluster di database, Amazon RDS crea automaticamente l’istanza di database core di scrittura per il cluster di database. Tuttavia, quando si utilizza la AWS CLI per creare un cluster DB, è necessario creare in modo esplicito l'istanza Writer DB per il cluster DB utilizzando il comando `create-db-instance` AWS CLI.
```
aws rds create-db-cluster \
--db-cluster-identifier sample-pg-cluster \
--engine aurora-postgresql \
--master-username master \
--master-user-password secret99 \
--db-subnet-group-name default \
--vpc-security-group-ids sg-0b9130572daf3dc16
```
Output:
```
{
"DBCluster": {
"Endpoint": "sample-pg-cluster.cluster-cnpexample.us-east-1.rds.amazonaws.com",
"HttpEndpointEnabled": false,
"DBClusterMembers": [],
"EngineMode": "provisioned",
"CopyTagsToSnapshot": false,
"HostedZoneId": "Z2R2ITUGPM61AM",
"IAMDatabaseAuthenticationEnabled": false,
"AllocatedStorage": 1,
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-0b9130572daf3dc16",
"Status": "active"
}
],
"DeletionProtection": false,
"StorageEncrypted": false,
"BackupRetentionPeriod": 1,
"PreferredBackupWindow": "09:56-10:26",
"ClusterCreateTime": "2023-02-27T23:26:08.371Z",
"DBClusterParameterGroup": "default.aurora-postgresql13",
"EngineVersion": "13.7",
"Engine": "aurora-postgresql",
"Status": "creating",
"DBClusterIdentifier": "sample-pg-cluster",
"MultiAZ": false,
"Port": 5432,
"DBClusterArn": "arn:aws:rds:us-east-1:123456789012:cluster:sample-pg-cluster",
"AssociatedRoles": [],
"DbClusterResourceId": "cluster-ANPAJ4AE5446DAEXAMPLE",
"PreferredMaintenanceWindow": "wed:03:33-wed:04:03",
"ReaderEndpoint": "sample-pg-cluster.cluster-ro-cnpexample.us-east-1.rds.amazonaws.com",
"MasterUsername": "master",
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1c"
],
"ReadReplicaIdentifiers": [],
"DBSubnetGroup": "default"
}
}
```
Per ulteriori informazioni, consulta [Creazione di un cluster database Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.CreateInstance.html) nella *Guida per l’utente di Amazon Aurora*.
+ *Per i dettagli sull'API, consulta Command [CreateDbCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-cluster.html)Reference AWS CLI .*
### `create-db-instance-read-replica`
Il seguente esempio di codice mostra come utilizzare`create-db-instance-read-replica`.
**AWS CLI**
**Come creare una replica di lettura dell’istanza database**
Questo esempio crea una replica di lettura di un’istanza database esistente denominata `test-instance`. La replica di lettura è denominata `test-instance-repl`.
```
aws rds create-db-instance-read-replica \
--db-instance-identifier test-instance-repl \
--source-db-instance-identifier test-instance
```
Output:
```
{
"DBInstance": {
"IAMDatabaseAuthenticationEnabled": false,
"MonitoringInterval": 0,
"DBInstanceArn": "arn:aws:rds:us-east-1:123456789012:db:test-instance-repl",
"ReadReplicaSourceDBInstanceIdentifier": "test-instance",
"DBInstanceIdentifier": "test-instance-repl",
...some output truncated...
}
}
```
+ Per i dettagli sull'API, consulta [CreateDbInstanceReadReplica AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-instance-read-replica.html)*Command Reference*.
### `create-db-instance`
Il seguente esempio di codice mostra come utilizzare`create-db-instance`.
**AWS CLI**
**Come creare un’istanza database**
L’esempio `create-db-instance` seguente utilizza le opzioni richieste per avviare una nuova istanza database.
```
aws rds create-db-instance \
--db-instance-identifier test-mysql-instance \
--db-instance-class db.t3.micro \
--engine mysql \
--master-username admin \
--master-user-password secret99 \
--allocated-storage 20
```
Output:
```
{
"DBInstance": {
"DBInstanceIdentifier": "test-mysql-instance",
"DBInstanceClass": "db.t3.micro",
"Engine": "mysql",
"DBInstanceStatus": "creating",
"MasterUsername": "admin",
"AllocatedStorage": 20,
"PreferredBackupWindow": "12:55-13:25",
"BackupRetentionPeriod": 1,
"DBSecurityGroups": [],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-12345abc",
"Status": "active"
}
],
"DBParameterGroups": [
{
"DBParameterGroupName": "default.mysql5.7",
"ParameterApplyStatus": "in-sync"
}
],
"DBSubnetGroup": {
"DBSubnetGroupName": "default",
"DBSubnetGroupDescription": "default",
"VpcId": "vpc-2ff2ff2f",
"SubnetGroupStatus": "Complete",
"Subnets": [
{
"SubnetIdentifier": "subnet-########",
"SubnetAvailabilityZone": {
"Name": "us-west-2c"
},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-########",
"SubnetAvailabilityZone": {
"Name": "us-west-2d"
},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-########",
"SubnetAvailabilityZone": {
"Name": "us-west-2a"
},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-########",
"SubnetAvailabilityZone": {
"Name": "us-west-2b"
},
"SubnetStatus": "Active"
}
]
},
"PreferredMaintenanceWindow": "sun:08:07-sun:08:37",
"PendingModifiedValues": {
"MasterUserPassword": "****"
},
"MultiAZ": false,
"EngineVersion": "5.7.22",
"AutoMinorVersionUpgrade": true,
"ReadReplicaDBInstanceIdentifiers": [],
"LicenseModel": "general-public-license",
"OptionGroupMemberships": [
{
"OptionGroupName": "default:mysql-5-7",
"Status": "in-sync"
}
],
"PubliclyAccessible": true,
"StorageType": "gp2",
"DbInstancePort": 0,
"StorageEncrypted": false,
"DbiResourceId": "db-5555EXAMPLE44444444EXAMPLE",
"CACertificateIdentifier": "rds-ca-2019",
"DomainMemberships": [],
"CopyTagsToSnapshot": false,
"MonitoringInterval": 0,
"DBInstanceArn": "arn:aws:rds:us-west-2:123456789012:db:test-mysql-instance",
"IAMDatabaseAuthenticationEnabled": false,
"PerformanceInsightsEnabled": false,
"DeletionProtection": false,
"AssociatedRoles": []
}
}
```
Per ulteriori informazioni, consulta la pagina [Creazione di un’istanza database Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [Create DBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-instance.html) in *AWS CLI Command Reference*.
### `create-db-parameter-group`
Il seguente esempio di codice mostra come utilizzare`create-db-parameter-group`.
**AWS CLI**
**Come creare un gruppo di parametri del database**
L’esempio `create-db-parameter-group` seguente crea un gruppo di parametri database.
```
aws rds create-db-parameter-group \
--db-parameter-group-name mydbparametergroup \
--db-parameter-group-family MySQL5.6 \
--description "My new parameter group"
```
Output:
```
{
"DBParameterGroup": {
"DBParameterGroupName": "mydbparametergroup",
"DBParameterGroupFamily": "mysql5.6",
"Description": "My new parameter group",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:mydbparametergroup"
}
}
```
Per ulteriori informazioni, consulta [Creazione di un gruppo di parametri database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html#USER_WorkingWithParamGroups.Creating) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [Create DBParameter Group](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-parameter-group.html) in *AWS CLI Command Reference*.
### `create-db-proxy-endpoint`
Il seguente esempio di codice mostra come utilizzare`create-db-proxy-endpoint`.
**AWS CLI**
**Come creare un endpoint proxy database per un database RDS**
L’esempio `create-db-proxy-endpoint` seguente crea un endpoint proxy database personalizzato.
```
aws rds create-db-proxy-endpoint \
--db-proxy-name proxyExample \
--db-proxy-endpoint-name "proxyep1" \
--vpc-subnet-ids subnetgroup1 subnetgroup2
```
Output:
```
{
"DBProxyEndpoint": {
"DBProxyEndpointName": "proxyep1",
"DBProxyEndpointArn": "arn:aws:rds:us-east-1:123456789012:db-proxy-endpoint:prx-endpoint-0123a01b12345c0ab",
"DBProxyName": "proxyExample",
"Status": "creating",
"VpcId": "vpc-1234567",
"VpcSecurityGroupIds": [
"sg-1234",
"sg-5678"
],
"VpcSubnetIds": [
"subnetgroup1",
"subnetgroup2"
],
"Endpoint": "proxyep1.endpoint.proxy-ab0cd1efghij.us-east-1.rds.amazonaws.com",
"CreatedDate": "2023-04-05T16:09:33.452000+00:00",
"TargetRole": "READ_WRITE",
"IsDefault": false
}
}
```
Per ulteriori informazioni, consulta [Creazione di un endpoint proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-endpoints.html#rds-proxy-endpoints.CreatingEndpoint) nella *Guida per l’utente di Amazon RDS* e [Creazione di un endpoint proxy](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-endpoints.html#rds-proxy-endpoints.CreatingEndpoint) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [CreateDbProxyEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-proxy-endpoint.html)*Command Reference*.
### `create-db-proxy`
Il seguente esempio di codice mostra come utilizzare`create-db-proxy`.
**AWS CLI**
**Come creare un proxy database per un database RDS**
L’esempio `create-db-proxy` seguente crea un proxy database.
```
aws rds create-db-proxy \
--db-proxy-name proxyExample \
--engine-family MYSQL \
--auth Description="proxydescription1",AuthScheme="SECRETS",SecretArn="arn:aws:secretsmanager:us-west-2:123456789123:secret:secretName-1234f",IAMAuth="DISABLED",ClientPasswordAuthType="MYSQL_NATIVE_PASSWORD" \
--role-arn arn:aws:iam::123456789123:role/ProxyRole \
--vpc-subnet-ids subnetgroup1 subnetgroup2
```
Output:
```
{
"DBProxy": {
"DBProxyName": "proxyExample",
"DBProxyArn": "arn:aws:rds:us-east-1:123456789012:db-proxy:prx-0123a01b12345c0ab",
"EngineFamily": "MYSQL",
"VpcId": "vpc-1234567",
"VpcSecuritytGroupIds": [
"sg-1234",
"sg-5678",
"sg-9101"
],
"VpcSubnetIds": [
"subnetgroup1",
"subnetgroup2"
],
"Auth": "[
{
"Description": "proxydescription1",
"AuthScheme": "SECRETS",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789123:secret:proxysecret1-Abcd1e",
"IAMAuth": "DISABLED"
}
]",
"RoleArn": "arn:aws:iam::12345678912:role/ProxyRole",
"Endpoint": "proxyExample.proxy-ab0cd1efghij.us-east-1.rds.amazonaws.com",
"RequireTLS": false,
"IdleClientTimeout": 1800,
"DebuggingLogging": false,
"CreatedDate": "2023-04-05T16:09:33.452000+00:00",
"UpdatedDate": "2023-04-13T01:49:38.568000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Creazione di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-setup.html#rds-proxy-creating) nella *Guida per l’utente di Amazon RDS* e [Creazione di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-setup.html#rds-proxy-creating) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [CreateDbProxy AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-proxy.html)*Command Reference*.
### `create-db-security-group`
Il seguente esempio di codice mostra come utilizzare`create-db-security-group`.
**AWS CLI**
**Come creare un gruppo di sicurezza database Amazon RDS**
Il comando `create-db-security-group` seguente crea un nuovo gruppo di sicurezza del database Amazon RDS:
```
aws rds create-db-security-group --db-security-group-name mysecgroup --db-security-group-description "My Test Security Group"
```
Nell’esempio il nuovo gruppo di sicurezza database è denominato `mysecgroup` e ha una descrizione.
Output:
```
{
"DBSecurityGroup": {
"OwnerId": "123456789012",
"DBSecurityGroupName": "mysecgroup",
"DBSecurityGroupDescription": "My Test Security Group",
"VpcId": "vpc-a1b2c3d4",
"EC2SecurityGroups": [],
"IPRanges": [],
"DBSecurityGroupArn": "arn:aws:rds:us-west-2:123456789012:secgrp:mysecgroup"
}
}
```
+ Per i dettagli sull'API, consulta [CreateDbSecurityGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-security-group.html)*Command Reference*.
### `create-db-shard-group`
Il seguente esempio di codice mostra come utilizzare`create-db-shard-group`.
**AWS CLI**
**Esempio 1: come creare un cluster di database primario Aurora PostgreSQL**
L’esempio `create-db-cluster` seguente crea un cluster di database primario Aurora PostgreSQL SQL compatibile con Aurora Serverless v2 e Aurora Limitless Database.
```
aws rds create-db-cluster \
--db-cluster-identifier my-sv2-cluster \
--engine aurora-postgresql \
--engine-version 15.2-limitless \
--storage-type aurora-iopt1 \
--serverless-v2-scaling-configuration MinCapacity=2,MaxCapacity=16 \
--enable-limitless-database \
--master-username myuser \
--master-user-password mypassword \
--enable-cloudwatch-logs-exports postgresql
```
Output:
```
{
"DBCluster": {
"AllocatedStorage": 1,
"AvailabilityZones": [
"us-east-2b",
"us-east-2c",
"us-east-2a"
],
"BackupRetentionPeriod": 1,
"DBClusterIdentifier": "my-sv2-cluster",
"DBClusterParameterGroup": "default.aurora-postgresql15",
"DBSubnetGroup": "default",
"Status": "creating",
"Endpoint": "my-sv2-cluster.cluster-cekycexample.us-east-2.rds.amazonaws.com",
"ReaderEndpoint": "my-sv2-cluster.cluster-ro-cekycexample.us-east-2.rds.amazonaws.com",
"MultiAZ": false,
"Engine": "aurora-postgresql",
"EngineVersion": "15.2-limitless",
"Port": 5432,
"MasterUsername": "myuser",
"PreferredBackupWindow": "06:05-06:35",
"PreferredMaintenanceWindow": "mon:08:25-mon:08:55",
"ReadReplicaIdentifiers": [],
"DBClusterMembers": [],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-########",
"Status": "active"
}
],
"HostedZoneId": "Z2XHWR1EXAMPLE",
"StorageEncrypted": false,
"DbClusterResourceId": "cluster-XYEDT6ML6FHIXH4Q2J1EXAMPLE",
"DBClusterArn": "arn:aws:rds:us-east-2:123456789012:cluster:my-sv2-cluster",
"AssociatedRoles": [],
"IAMDatabaseAuthenticationEnabled": false,
"ClusterCreateTime": "2024-02-19T16:24:07.771000+00:00",
"EnabledCloudwatchLogsExports": [
"postgresql"
],
"EngineMode": "provisioned",
"DeletionProtection": false,
"HttpEndpointEnabled": false,
"CopyTagsToSnapshot": false,
"CrossAccountClone": false,
"DomainMemberships": [],
"TagList": [],
"StorageType": "aurora-iopt1",
"AutoMinorVersionUpgrade": true,
"ServerlessV2ScalingConfiguration": {
"MinCapacity": 2.0,
"MaxCapacity": 16.0
},
"NetworkType": "IPV4",
"IOOptimizedNextAllowedModificationTime": "2024-03-21T16:24:07.781000+00:00",
"LimitlessDatabase": {
"Status": "not-in-use",
"MinRequiredACU": 96.0
}
}
}
```
**Esempio 2: come creare l’istanza database primaria (istanza di scrittura)**
L’esempio `create-db-instance` seguente crea un’istanza database primaria (di scrittura) Aurora Serverless v2. Se utilizzi la console per creare un cluster di database, Amazon RDS crea automaticamente l’istanza di database core di scrittura per il cluster di database. Tuttavia, quando si utilizza la AWS CLI per creare un cluster DB, è necessario creare in modo esplicito l'istanza Writer DB per il cluster DB utilizzando il comando `create-db-instance` AWS CLI.
```
aws rds create-db-instance \
--db-instance-identifier my-sv2-instance \
--db-cluster-identifier my-sv2-cluster \
--engine aurora-postgresql \
--db-instance-class db.serverless
```
Output:
```
{
"DBInstance": {
"DBInstanceIdentifier": "my-sv2-instance",
"DBInstanceClass": "db.serverless",
"Engine": "aurora-postgresql",
"DBInstanceStatus": "creating",
"MasterUsername": "myuser",
"AllocatedStorage": 1,
"PreferredBackupWindow": "06:05-06:35",
"BackupRetentionPeriod": 1,
"DBSecurityGroups": [],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-########",
"Status": "active"
}
],
"DBParameterGroups": [
{
"DBParameterGroupName": "default.aurora-postgresql15",
"ParameterApplyStatus": "in-sync"
}
],
"DBSubnetGroup": {
"DBSubnetGroupName": "default",
"DBSubnetGroupDescription": "default",
"VpcId": "vpc-########",
"SubnetGroupStatus": "Complete",
"Subnets": [
{
"SubnetIdentifier": "subnet-########",
"SubnetAvailabilityZone": {
"Name": "us-east-2c"
},
"SubnetOutpost": {},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-########",
"SubnetAvailabilityZone": {
"Name": "us-east-2a"
},
"SubnetOutpost": {},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-########",
"SubnetAvailabilityZone": {
"Name": "us-east-2b"
},
"SubnetOutpost": {},
"SubnetStatus": "Active"
}
]
},
"PreferredMaintenanceWindow": "fri:09:01-fri:09:31",
"PendingModifiedValues": {
"PendingCloudwatchLogsExports": {
"LogTypesToEnable": [
"postgresql"
]
}
},
"MultiAZ": false,
"EngineVersion": "15.2-limitless",
"AutoMinorVersionUpgrade": true,
"ReadReplicaDBInstanceIdentifiers": [],
"LicenseModel": "postgresql-license",
"OptionGroupMemberships": [
{
"OptionGroupName": "default:aurora-postgresql-15",
"Status": "in-sync"
}
],
"PubliclyAccessible": false,
"StorageType": "aurora-iopt1",
"DbInstancePort": 0,
"DBClusterIdentifier": "my-sv2-cluster",
"StorageEncrypted": false,
"DbiResourceId": "db-BIQTE3B3K3RM7M74SK5EXAMPLE",
"CACertificateIdentifier": "rds-ca-rsa2048-g1",
"DomainMemberships": [],
"CopyTagsToSnapshot": false,
"MonitoringInterval": 0,
"PromotionTier": 1,
"DBInstanceArn": "arn:aws:rds:us-east-2:123456789012:db:my-sv2-instance",
"IAMDatabaseAuthenticationEnabled": false,
"PerformanceInsightsEnabled": false,
"DeletionProtection": false,
"AssociatedRoles": [],
"TagList": [],
"CustomerOwnedIpEnabled": false,
"BackupTarget": "region",
"NetworkType": "IPV4",
"StorageThroughput": 0,
"CertificateDetails": {
"CAIdentifier": "rds-ca-rsa2048-g1"
},
"DedicatedLogVolume": false
}
}
```
**Esempio 3: come creare il gruppo di shard di database**
L’esempio `create-db-shard-group` seguente crea un gruppo shard del database nel cluster database primario Aurora PostgreSQL.
```
aws rds create-db-shard-group \
--db-shard-group-identifier my-db-shard-group \
--db-cluster-identifier my-sv2-cluster \
--max-acu 768
```
Output:
```
{
"DBShardGroupResourceId": "shardgroup-a6e3a0226aa243e2ac6c7a1234567890",
"DBShardGroupIdentifier": "my-db-shard-group",
"DBClusterIdentifier": "my-sv2-cluster",
"MaxACU": 768.0,
"ComputeRedundancy": 0,
"Status": "creating",
"PubliclyAccessible": false,
"Endpoint": "my-sv2-cluster.limitless-cekycexample.us-east-2.rds.amazonaws.com"
}
```
Per ulteriori informazioni, consulta [Utilizzo di Amazon Aurora serverless v2](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless-v2.html) nella *Guida per l’utente di Amazon Aurora*.
+ *Per i dettagli sull'API, consulta Command [CreateDbShardGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-shard-group.html)Reference AWS CLI .*
### `create-db-snapshot`
Il seguente esempio di codice mostra come utilizzare`create-db-snapshot`.
**AWS CLI**
**Come creare uno snapshot del database**
L’esempio `create-db-snapshot` seguente crea uno snapshot del database.
```
aws rds create-db-snapshot \
--db-instance-identifier database-mysql \
--db-snapshot-identifier mydbsnapshot
```
Output:
```
{
"DBSnapshot": {
"DBSnapshotIdentifier": "mydbsnapshot",
"DBInstanceIdentifier": "database-mysql",
"Engine": "mysql",
"AllocatedStorage": 100,
"Status": "creating",
"Port": 3306,
"AvailabilityZone": "us-east-1b",
"VpcId": "vpc-6594f31c",
"InstanceCreateTime": "2019-04-30T15:45:53.663Z",
"MasterUsername": "admin",
"EngineVersion": "5.6.40",
"LicenseModel": "general-public-license",
"SnapshotType": "manual",
"Iops": 1000,
"OptionGroupName": "default:mysql-5-6",
"PercentProgress": 0,
"StorageType": "io1",
"Encrypted": true,
"KmsKeyId": "arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE",
"DBSnapshotArn": "arn:aws:rds:us-east-1:123456789012:snapshot:mydbsnapshot",
"IAMDatabaseAuthenticationEnabled": false,
"ProcessorFeatures": [],
"DbiResourceId": "db-AKIAIOSFODNN7EXAMPLE"
}
}
```
Per ulteriori informazioni, consulta [Creazione di uno snapshot di database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [Create DBSnapshot](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-snapshot.html) in *AWS CLI Command Reference*.
### `create-db-subnet-group`
Il seguente esempio di codice mostra come utilizzare`create-db-subnet-group`.
**AWS CLI**
**Come creare un gruppo di sottoreti database**
L’esempio `create-db-subnet-group` seguente crea un gruppo di sottoreti database denominato `mysubnetgroup` utilizzando sottoreti esistenti.
```
aws rds create-db-subnet-group \
--db-subnet-group-name mysubnetgroup \
--db-subnet-group-description "test DB subnet group" \
--subnet-ids '["subnet-0a1dc4e1a6f123456","subnet-070dd7ecb3aaaaaaa","subnet-00f5b198bc0abcdef"]'
```
Output:
```
{
"DBSubnetGroup": {
"DBSubnetGroupName": "mysubnetgroup",
"DBSubnetGroupDescription": "test DB subnet group",
"VpcId": "vpc-0f08e7610a1b2c3d4",
"SubnetGroupStatus": "Complete",
"Subnets": [
{
"SubnetIdentifier": "subnet-070dd7ecb3aaaaaaa",
"SubnetAvailabilityZone": {
"Name": "us-west-2b"
},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-00f5b198bc0abcdef",
"SubnetAvailabilityZone": {
"Name": "us-west-2d"
},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-0a1dc4e1a6f123456",
"SubnetAvailabilityZone": {
"Name": "us-west-2b"
},
"SubnetStatus": "Active"
}
],
"DBSubnetGroupArn": "arn:aws:rds:us-west-2:0123456789012:subgrp:mysubnetgroup"
}
}
```
Per ulteriori informazioni, consulta [Creazione di un’istanza database in un VPC](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_VPC.WorkingWithRDSInstanceinaVPC.html#USER_VPC.InstanceInVPC) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [CreateDbSubnetGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-db-subnet-group.html)*Command Reference*.
### `create-event-subscription`
Il seguente esempio di codice mostra come utilizzare`create-event-subscription`.
**AWS CLI**
**Come creare una sottoscrizione a un evento**
L'`create-event-subscription`esempio seguente crea una sottoscrizione per gli eventi di backup e ripristino per le istanze DB nell' AWS account corrente. Le notifiche vengono inviate a un argomento Amazon Simple Notification Service specificato da `--sns-topic-arn`.
```
aws rds create-event-subscription \
--subscription-name my-instance-events \
--source-type db-instance \
--event-categories '["backup","recovery"]' \
--sns-topic-arn arn:aws:sns:us-east-1:123456789012:interesting-events
```
Output:
```
{
"EventSubscription": {
"Status": "creating",
"CustSubscriptionId": "my-instance-events",
"SubscriptionCreationTime": "Tue Jul 31 23:22:01 UTC 2018",
"EventCategoriesList": [
"backup",
"recovery"
],
"SnsTopicArn": "arn:aws:sns:us-east-1:123456789012:interesting-events",
"CustomerAwsId": "123456789012",
"EventSubscriptionArn": "arn:aws:rds:us-east-1:123456789012:es:my-instance-events",
"SourceType": "db-instance",
"Enabled": true
}
}
```
+ Per i dettagli sull'API, consulta [CreateEventSubscription AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-event-subscription.html)*Command Reference.*
### `create-global-cluster`
Il seguente esempio di codice mostra come utilizzare`create-global-cluster`.
**AWS CLI**
**Come creare un nuovo cluster di database globale**
L’esempio `create-global-cluster` seguente crea un nuovo cluster di database globale compatibile con Aurora MySQL.
```
aws rds create-global-cluster \
--global-cluster-identifier myglobalcluster \
--engine aurora-mysql
```
Output:
```
{
"GlobalCluster": {
"GlobalClusterIdentifier": "myglobalcluster",
"GlobalClusterResourceId": "cluster-f0e523bfe07aabb",
"GlobalClusterArn": "arn:aws:rds::123456789012:global-cluster:myglobalcluster",
"Status": "available",
"Engine": "aurora-mysql",
"EngineVersion": "5.7.mysql_aurora.2.07.2",
"StorageEncrypted": false,
"DeletionProtection": false,
"GlobalClusterMembers": []
}
}
```
Per ulteriori informazioni, consulta [Creazione di un database globale Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database-creating) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [CreateGlobalCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-global-cluster.html)*Command Reference*.
### `create-option-group`
Il seguente esempio di codice mostra come utilizzare`create-option-group`.
**AWS CLI**
**Come creare un gruppo di opzioni Amazon RDS**
Il comando `create-option-group` seguente crea un nuovo gruppo di opzioni Amazon RDS per la versione `Oracle Enterprise Edition` `11.2`, is named ``MyOptionGroup` e include una descrizione.
```
aws rds create-option-group \
--option-group-name MyOptionGroup \
--engine-name oracle-ee \
--major-engine-version 11.2 \
--option-group-description "Oracle Database Manager Database Control"
```
Output:
```
{
"OptionGroup": {
"OptionGroupName": "myoptiongroup",
"OptionGroupDescription": "Oracle Database Manager Database Control",
"EngineName": "oracle-ee",
"MajorEngineVersion": "11.2",
"Options": [],
"AllowsVpcAndNonVpcInstanceMemberships": true,
"OptionGroupArn": "arn:aws:rds:us-west-2:123456789012:og:myoptiongroup"
}
}
```
+ Per i dettagli sull'API, consulta [CreateOptionGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/create-option-group.html)*Command Reference*.
### `delete-blue-green-deployment`
Il seguente esempio di codice mostra come utilizzare`delete-blue-green-deployment`.
**AWS CLI**
**Esempio 1: come eliminare le risorse in ambiente verde per un’istanza database RDS per MySQL**
L’esempio `delete-blue-green-deployment` seguente elimina le risorse in un ambiente verde per un’istanza database RDS per MySQL.
```
aws rds delete-blue-green-deployment \
--blue-green-deployment-identifier bgd-v53303651eexfake \
--delete-target
```
Output:
```
{
"BlueGreenDeployment": {
"BlueGreenDeploymentIdentifier": "bgd-v53303651eexfake",
"BlueGreenDeploymentName": "bgd-cli-test-instance",
"Source": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance",
"Target": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-green-rkfbpe",
"SwitchoverDetails": [
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-green-rkfbpe",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-1-green-j382ha",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-2",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-2-green-ejv4ao",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-3",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-3-green-vlpz3t",
"Status": "AVAILABLE"
}
],
"Tasks": [
{
"Name": "CREATING_READ_REPLICA_OF_SOURCE",
"Status": "COMPLETED"
},
{
"Name": "DB_ENGINE_VERSION_UPGRADE",
"Status": "COMPLETED"
},
{
"Name": "CONFIGURE_BACKUPS",
"Status": "COMPLETED"
},
{
"Name": "CREATING_TOPOLOGY_OF_SOURCE",
"Status": "COMPLETED"
}
],
"Status": "DELETING",
"CreateTime": "2022-02-25T21:18:51.183000+00:00",
"DeleteTime": "2022-02-25T22:25:31.331000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Eliminazione di una blue/green distribuzione](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/blue-green-deployments-deleting.html) nella *Amazon RDS User* Guide.
**Esempio 2: come eliminare le risorse in ambiente verde per un cluster di database Aurora MySQL**
L’esempio `delete-blue-green-deployment` seguente elimina le risorse in un ambiente verde per un cluster di database Aurora MySQL.
```
aws rds delete-blue-green-deployment \
--blue-green-deployment-identifier bgd-wi89nwzglccsfake \
--delete-target
```
Output:
```
{
"BlueGreenDeployment": {
"BlueGreenDeploymentIdentifier": "bgd-wi89nwzglccsfake",
"BlueGreenDeploymentName": "my-blue-green-deployment",
"Source": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"Target": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster-green-3rnukl",
"SwitchoverDetails": [
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster-green-3rnukl",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-1-green-gpmaxf",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-2",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-2-green-j2oajq",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-3",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-3-green-mkxies",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-excluded-member-endpoint",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-excluded-member-endpoint-green-4sqjrq",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-reader-endpoint",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-reader-endpoint-green-gwwzlg",
"Status": "AVAILABLE"
}
],
"Tasks": [
{
"Name": "CREATING_READ_REPLICA_OF_SOURCE",
"Status": "COMPLETED"
},
{
"Name": "DB_ENGINE_VERSION_UPGRADE",
"Status": "COMPLETED"
},
{
"Name": "CREATE_DB_INSTANCES_FOR_CLUSTER",
"Status": "COMPLETED"
},
{
"Name": "CREATE_CUSTOM_ENDPOINTS",
"Status": "COMPLETED"
}
],
"Status": "DELETING",
"CreateTime": "2022-02-25T21:12:00.288000+00:00",
"DeleteTime": "2022-02-25T22:29:11.336000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Eliminazione di una blue/green distribuzione nella Guida](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-deleting.html) per l'utente di *Amazon Aurora*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [DeleteBlueGreenDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-blue-green-deployment.html)Reference*.
### `delete-db-cluster-endpoint`
Il seguente esempio di codice mostra come utilizzare`delete-db-cluster-endpoint`.
**AWS CLI**
**Come eliminare un endpoint del cluster di database personalizzato**
L’esempio `delete-db-cluster-endpoint` seguente elimina l’endpoint del cluster di database personalizzato specificato.
```
aws rds delete-db-cluster-endpoint \
--db-cluster-endpoint-identifier mycustomendpoint
```
Output:
```
{
"DBClusterEndpointIdentifier": "mycustomendpoint",
"DBClusterIdentifier": "mydbcluster",
"DBClusterEndpointResourceIdentifier": "cluster-endpoint-ANPAJ4AE5446DAEXAMPLE",
"Endpoint": "mycustomendpoint.cluster-custom-cnpexample.us-east-1.rds.amazonaws.com",
"Status": "deleting",
"EndpointType": "CUSTOM",
"CustomEndpointType": "READER",
"StaticMembers": [
"dbinstance1",
"dbinstance2",
"dbinstance3"
],
"ExcludedMembers": [],
"DBClusterEndpointArn": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:mycustomendpoint"
}
```
Per ulteriori informazioni, consulta [Gestione delle connessioni Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Overview.Endpoints.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DeleteDbClusterEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-cluster-endpoint.html)*Command Reference*.
### `delete-db-cluster-parameter-group`
Il seguente esempio di codice mostra come utilizzare`delete-db-cluster-parameter-group`.
**AWS CLI**
**Come eliminare un gruppo di parametri del cluster di database**
L’esempio `delete-db-cluster-parameter-group` seguente elimina il gruppo di parametri del cluster di database specificato.
```
aws rds delete-db-cluster-parameter-group \
--db-cluster-parameter-group-name mydbclusterparametergroup
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Uso di gruppi di parametri database e gruppi di parametri cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DeleteDbClusterParameterGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-cluster-parameter-group.html)*Command Reference*.
### `delete-db-cluster-snapshot`
Il seguente esempio di codice mostra come utilizzare`delete-db-cluster-snapshot`.
**AWS CLI**
**Come eliminare uno snapshot del cluster di database**
L’esempio `delete-db-cluster-snapshot` seguente elimina lo snapshot del cluster di database specificato.
```
aws rds delete-db-cluster-snapshot \
--db-cluster-snapshot-identifier mydbclustersnapshot
```
Output:
```
{
"DBClusterSnapshot": {
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1e"
],
"DBClusterSnapshotIdentifier": "mydbclustersnapshot",
"DBClusterIdentifier": "mydbcluster",
"SnapshotCreateTime": "2019-06-18T21:21:00.469Z",
"Engine": "aurora-mysql",
"AllocatedStorage": 0,
"Status": "available",
"Port": 0,
"VpcId": "vpc-6594f31c",
"ClusterCreateTime": "2019-04-15T14:18:42.785Z",
"MasterUsername": "myadmin",
"EngineVersion": "5.7.mysql_aurora.2.04.2",
"LicenseModel": "aurora-mysql",
"SnapshotType": "manual",
"PercentProgress": 100,
"StorageEncrypted": true,
"KmsKeyId": "arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE",
"DBClusterSnapshotArn": "arn:aws:rds:us-east-1:123456789012:cluster-snapshot:mydbclustersnapshot",
"IAMDatabaseAuthenticationEnabled": false
}
}
```
Per ulteriori informazioni, consulta [Eliminazione di uno snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_DeleteSnapshot.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DeleteDbClusterSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-cluster-snapshot.html)*Command Reference*.
### `delete-db-cluster`
Il seguente esempio di codice mostra come utilizzare`delete-db-cluster`.
**AWS CLI**
**Esempio 1: come eliminare un’istanza database in un cluster di database**
L’esempio `delete-db-instance` seguente elimina l’istanza database finale in un cluster di database. Non è possibile eliminare un cluster di database se questo contiene istanze database che non sono in stato di **eliminazione**. Non è possibile scattare uno snapshot finale quando si elimina un’istanza database in un cluster di database.
```
aws rds delete-db-instance \
--db-instance-identifier database-3
```
Output:
```
{
"DBInstance": {
"DBInstanceIdentifier": "database-3",
"DBInstanceClass": "db.r4.large",
"Engine": "aurora-postgresql",
"DBInstanceStatus": "deleting",
...output omitted...
}
}
```
Per ulteriori informazioni, consulta [Eliminazione di un’istanza database da un cluster database Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_DeleteInstance.html) nella *Guida per l’utente di Amazon Aurora*.
**Esempio 2: come eliminare un cluster di database**
L’esempio `delete-db-cluster` seguente elimina il cluster di database denominato `mycluster` e crea uno snapshot finale denominato `mycluster-final-snapshot`. Lo stato del cluster di database è **disponibile** durante l’acquisizione dello snapshot. Per seguire lo stato di avanzamento dell’eliminazione, utilizza il comando dell’`describe-db-clusters` CLI.
```
aws rds delete-db-cluster \
--db-cluster-identifier mycluster \
--no-skip-final-snapshot \
--final-db-snapshot-identifier mycluster-final-snapshot
```
Output:
```
{
"DBCluster": {
"AllocatedStorage": 20,
"AvailabilityZones": [
"eu-central-1b",
"eu-central-1c",
"eu-central-1a"
],
"BackupRetentionPeriod": 7,
"DBClusterIdentifier": "mycluster",
"DBClusterParameterGroup": "default.aurora-postgresql10",
"DBSubnetGroup": "default-vpc-aa11bb22",
"Status": "available",
...output omitted...
}
}
```
Per ulteriori informazioni, consulta [Cluster Aurora con un’istanza database singola](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_DeleteInstance.html#USER_DeleteInstance.LastInstance) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DeleteDbCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-cluster.html)*Command Reference*.
### `delete-db-instance-automated-backup`
Il seguente esempio di codice mostra come utilizzare`delete-db-instance-automated-backup`.
**AWS CLI**
**Come eliminare un backup automatico replicato da una Regione**
L’esempio `delete-db-instance-automated-backup` seguente elimina il backup automatico con il nome della risorsa Amazon (ARN) specificato.
```
aws rds delete-db-instance-automated-backup \
--db-instance-automated-backups-arn "arn:aws:rds:us-west-2:123456789012:auto-backup:ab-jkib2gfq5rv7replzadausbrktni2bn4example"
```
Output:
```
{
"DBInstanceAutomatedBackup": {
"DBInstanceArn": "arn:aws:rds:us-east-1:123456789012:db:new-orcl-db",
"DbiResourceId": "db-JKIB2GFQ5RV7REPLZA4EXAMPLE",
"Region": "us-east-1",
"DBInstanceIdentifier": "new-orcl-db",
"RestoreWindow": {},
"AllocatedStorage": 20,
"Status": "deleting",
"Port": 1521,
"AvailabilityZone": "us-east-1b",
"VpcId": "vpc-########",
"InstanceCreateTime": "2020-12-04T15:28:31Z",
"MasterUsername": "admin",
"Engine": "oracle-se2",
"EngineVersion": "12.1.0.2.v21",
"LicenseModel": "bring-your-own-license",
"OptionGroupName": "default:oracle-se2-12-1",
"Encrypted": false,
"StorageType": "gp2",
"IAMDatabaseAuthenticationEnabled": false,
"BackupRetentionPeriod": 7,
"DBInstanceAutomatedBackupsArn": "arn:aws:rds:us-west-2:123456789012:auto-backup:ab-jkib2gfq5rv7replzadausbrktni2bn4example"
}
}
```
Per ulteriori informazioni, consulta [Eliminazione dei backup replicati](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReplicateBackups.html#AutomatedBackups.Delete) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DeleteDbInstanceAutomatedBackup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-instance-automated-backup.html)*Command Reference*.
### `delete-db-instance`
Il seguente esempio di codice mostra come utilizzare`delete-db-instance`.
**AWS CLI**
**Come eliminare un’istanza database**
L’esempio `delete-db-instance` seguente elimina l’istanza database specificata dopo aver creato uno snapshot database finale denominato `test-instance-final-snap`.
```
aws rds delete-db-instance \
--db-instance-identifier test-instance \
--final-db-snapshot-identifier test-instance-final-snap
```
Output:
```
{
"DBInstance": {
"DBInstanceIdentifier": "test-instance",
"DBInstanceStatus": "deleting",
...some output truncated...
}
}
```
+ Per i dettagli sull'API, consulta [Delete DBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-instance.html) in *AWS CLI Command Reference*.
### `delete-db-parameter-group`
Il seguente esempio di codice mostra come utilizzare`delete-db-parameter-group`.
**AWS CLI**
**Come eliminare un gruppo di parametri del database**
L’esempio `command` seguente elimina un gruppo di parametri database.
```
aws rds delete-db-parameter-group \
--db-parameter-group-name mydbparametergroup
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Utilizzo di gruppi di parametri di database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [Delete DBParameter Group](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-parameter-group.html) in *AWS CLI Command Reference*.
### `delete-db-proxy-endpoint`
Il seguente esempio di codice mostra come utilizzare`delete-db-proxy-endpoint`.
**AWS CLI**
**Come eliminare un endpoint proxy database per un database RDS**
L’esempio `delete-db-proxy-endpoint` seguente elimina un endpoint proxy database per il database di destinazione.
```
aws rds delete-db-proxy-endpoint \
--db-proxy-endpoint-name proxyEP1
```
Output:
```
{
"DBProxyEndpoint":
{
"DBProxyEndpointName": "proxyEP1",
"DBProxyEndpointArn": "arn:aws:rds:us-east-1:123456789012:db-proxy-endpoint:prx-endpoint-0123a01b12345c0ab",
"DBProxyName": "proxyExample",
"Status": "deleting",
"VpcId": "vpc-1234567",
"VpcSecurityGroupIds": [
"sg-1234",
"sg-5678"
],
"VpcSubnetIds": [
"subnetgroup1",
"subnetgroup2"
],
"Endpoint": "proxyEP1.endpoint.proxy-ab0cd1efghij.us-east-1.rds.amazonaws.com",
"CreatedDate": "2023-04-13T01:49:38.568000+00:00",
"TargetRole": "READ_ONLY",
"IsDefault": false
}
}
```
Per ulteriori informazioni, consulta [Eliminazione di un endpoint proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-endpoints.html#rds-proxy-endpoints.DeletingEndpoint) nella *Guida per l’utente di Amazon RDS* ed [Eliminazione di un endpoint proxy](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-endpoints.html#rds-proxy-endpoints.DeletingEndpoint) nella *Guida per l’utente di Amazon Aurora.*
+ Per i dettagli sull'API, consulta [DeleteDbProxyEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-proxy-endpoint.html)*Command Reference*.
### `delete-db-proxy`
Il seguente esempio di codice mostra come utilizzare`delete-db-proxy`.
**AWS CLI**
**Come eliminare un proxy database per un database RDS**
L’esempio `delete-db-proxy` seguente elimina un proxy database.
```
aws rds delete-db-proxy \
--db-proxy-name proxyExample
```
Output:
```
{
"DBProxy":
{
"DBProxyName": "proxyExample",
"DBProxyArn": "arn:aws:rds:us-east-1:123456789012:db-proxy:prx-0123a01b12345c0ab",
"Status": "deleting",
"EngineFamily": "PostgreSQL",
"VpcId": "vpc-1234567",
"VpcSecurityGroupIds": [
"sg-1234",
"sg-5678"
],
"VpcSubnetIds": [
"subnetgroup1",
"subnetgroup2"
],
"Auth": "[
{
"Description": "proxydescription`"
"AuthScheme": "SECRETS",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789123:secret:proxysecret1-Abcd1e",
"IAMAuth": "DISABLED"
} ],
"RoleArn": "arn:aws:iam::12345678912:role/ProxyPostgreSQLRole",
"Endpoint": "proxyExample.proxy-ab0cd1efghij.us-east-1.rds.amazonaws.com",
"RequireTLS": false,
"IdleClientTimeout": 1800,
"DebuggingLogging": false,
"CreatedDate": "2023-04-05T16:09:33.452000+00:00",
"UpdatedDate": "2023-04-13T01:49:38.568000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Eliminazione di un proxy RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-managing.html#rds-proxy-deleting) nella *Guida per l’utente di Amazon RDS* e [Eliminazione di un proxy RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-managing.html#rds-proxy-deleting) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DeleteDbProxy AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-proxy.html)*Command Reference*.
### `delete-db-security-group`
Il seguente esempio di codice mostra come utilizzare`delete-db-security-group`.
**AWS CLI**
**Come eliminare un gruppo di sicurezza del database**
L’esempio `delete-db-security-group` seguente elimina un gruppo di sicurezza database denominato `mysecuritygroup`.
```
aws rds delete-db-security-group \
--db-security-group-name mysecuritygroup
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Utilizzo dei gruppi di sicurezza database (EC2-Piattaforma classica)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithSecurityGroups.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DeleteDbSecurityGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-security-group.html)*Command Reference*.
### `delete-db-shard-group`
Il seguente esempio di codice mostra come utilizzare`delete-db-shard-group`.
**AWS CLI**
**Esempio 1: come eliminare in modo non corretto un gruppo di shard del database**
L’esempio `delete-db-shard-group` seguente mostra l’errore che si verifica quando si tenta di eliminare un gruppo di shard del database prima di eliminare tutti i database e gli schemi.
```
aws rds delete-db-shard-group \
--db-shard-group-identifier limitless-test-shard-grp
```
Output:
```
An error occurred (InvalidDBShardGroupState) when calling the DeleteDBShardGroup operation: Unable to delete the DB shard group limitless-test-db-shard-group.
Delete all of your Limitless Database databases and schemas, then try again.
```
**Esempio 2: come eliminare in modo corretto un gruppo di shard del database**
L’esempio `delete-db-shard-group` seguente elimina un gruppo di shard del database dopo aver eliminato tutti i database e gli schemi, incluso lo schema `public`.
```
aws rds delete-db-shard-group \
--db-shard-group-identifier limitless-test-shard-grp
```
Output:
```
{
"DBShardGroupResourceId": "shardgroup-7bb446329da94788b3f957746example",
"DBShardGroupIdentifier": "limitless-test-shard-grp",
"DBClusterIdentifier": "limitless-test-cluster",
"MaxACU": 768.0,
"ComputeRedundancy": 0,
"Status": "deleting",
"PubliclyAccessible": true,
"Endpoint": "limitless-test-cluster.limitless-cekycexample.us-east-2.rds.amazonaws.com"
}
```
Per ulteriori informazioni, consulta [Eliminazione di cluster e istanze database di Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_DeleteCluster.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DeleteDbShardGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-shard-group.html)*Command Reference*.
### `delete-db-snapshot`
Il seguente esempio di codice mostra come utilizzare`delete-db-snapshot`.
**AWS CLI**
**Come eliminare uno snapshot del database**
L’esempio `delete-db-snapshot` seguente elimina lo snapshot database specificato.
```
aws rds delete-db-snapshot \
--db-snapshot-identifier mydbsnapshot
```
Output:
```
{
"DBSnapshot": {
"DBSnapshotIdentifier": "mydbsnapshot",
"DBInstanceIdentifier": "database-mysql",
"SnapshotCreateTime": "2019-06-18T22:08:40.702Z",
"Engine": "mysql",
"AllocatedStorage": 100,
"Status": "deleted",
"Port": 3306,
"AvailabilityZone": "us-east-1b",
"VpcId": "vpc-6594f31c",
"InstanceCreateTime": "2019-04-30T15:45:53.663Z",
"MasterUsername": "admin",
"EngineVersion": "5.6.40",
"LicenseModel": "general-public-license",
"SnapshotType": "manual",
"Iops": 1000,
"OptionGroupName": "default:mysql-5-6",
"PercentProgress": 100,
"StorageType": "io1",
"Encrypted": true,
"KmsKeyId": "arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE",
"DBSnapshotArn": "arn:aws:rds:us-east-1:123456789012:snapshot:mydbsnapshot",
"IAMDatabaseAuthenticationEnabled": false,
"ProcessorFeatures": [],
"DbiResourceId": "db-AKIAIOSFODNN7EXAMPLE"
}
}
```
Per ulteriori informazioni, consulta [Eliminazione di uno snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_DeleteSnapshot.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DeleteDbSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-snapshot.html)*Command Reference*.
### `delete-db-subnet-group`
Il seguente esempio di codice mostra come utilizzare`delete-db-subnet-group`.
**AWS CLI**
**Come eliminare un gruppo di sottoreti di database**
L’esempio `delete-db-subnet-group` seguente elimina il gruppo di sottoreti database denominato `mysubnetgroup`.
```
aws rds delete-db-subnet-group --db-subnet-group-name mysubnetgroup
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Uso di un’istanza database in un VPC](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_VPC.WorkingWithRDSInstanceinaVPC.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DeleteDbSubnetGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-db-subnet-group.html)*Command Reference*.
### `delete-event-subscription`
Il seguente esempio di codice mostra come utilizzare`delete-event-subscription`.
**AWS CLI**
**Come eliminare un abbonamento all’evento**
L’esempio `delete-event-subscription` seguente elimina l’abbonamento all’evento specificato.
```
aws rds delete-event-subscription --subscription-name my-instance-events
```
Output:
```
{
"EventSubscription": {
"EventSubscriptionArn": "arn:aws:rds:us-east-1:123456789012:es:my-instance-events",
"CustomerAwsId": "123456789012",
"Enabled": false,
"SourceIdsList": [
"test-instance"
],
"SourceType": "db-instance",
"EventCategoriesList": [
"backup",
"recovery"
],
"SubscriptionCreationTime": "2018-07-31 23:22:01.893",
"CustSubscriptionId": "my-instance-events",
"SnsTopicArn": "arn:aws:sns:us-east-1:123456789012:interesting-events",
"Status": "deleting"
}
}
```
+ Per i dettagli sull'API, consulta [DeleteEventSubscription AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-event-subscription.html)*Command Reference*.
### `delete-global-cluster`
Il seguente esempio di codice mostra come utilizzare`delete-global-cluster`.
**AWS CLI**
**Come eliminare un cluster di database globale**
L’esempio `delete-global-cluster` seguente elimina un cluster di database globale compatibile con Aurora MySQL. L’output mostra il cluster che stai eliminando, ma i comandi `describe-global-clusters` successivi non elencano tale cluster di database.
```
aws rds delete-global-cluster \
--global-cluster-identifier myglobalcluster
```
Output:
```
{
"GlobalCluster": {
"GlobalClusterIdentifier": "myglobalcluster",
"GlobalClusterResourceId": "cluster-f0e523bfe07aabb",
"GlobalClusterArn": "arn:aws:rds::123456789012:global-cluster:myglobalcluster",
"Status": "available",
"Engine": "aurora-mysql",
"EngineVersion": "5.7.mysql_aurora.2.07.2",
"StorageEncrypted": false,
"DeletionProtection": false,
"GlobalClusterMembers": []
}
}
```
Per ulteriori informazioni, consulta [Eliminazione di un database globale Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-managing.html#aurora-global-database-deleting) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DeleteGlobalCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-global-cluster.html)*Command Reference*.
### `delete-option-group`
Il seguente esempio di codice mostra come utilizzare`delete-option-group`.
**AWS CLI**
**Come eliminare un gruppo di opzioni**
L’esempio `delete-option-group` seguente elimina il gruppo di opzioni specificato.
```
aws rds delete-option-group \
--option-group-name myoptiongroup
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Eliminazione di un gruppo di utenti IAM](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithOptionGroups.html#USER_WorkingWithOptionGroups.Delete) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DeleteOptionGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/delete-option-group.html)*Command Reference*.
### `deregister-db-proxy-targets`
Il seguente esempio di codice mostra come utilizzare`deregister-db-proxy-targets`.
**AWS CLI**
**Come annullare la registrazione di una destinazione del proxy database dal gruppo di destinazioni del database**
L’esempio `deregister-db-proxy-targets` seguente rimuove l’associazione tra il proxy `proxyExample` e la sua destinazione.
```
aws rds deregister-db-proxy-targets \
--db-proxy-name proxyExample \
--db-instance-identifiers database-1
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Eliminazione di un proxy RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-managing.html#rds-proxy-deleting) nella *Guida per l’utente di Amazon RDS* e [Eliminazione di un proxy RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-managing.html#rds-proxy-deleting) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DeregisterDbProxyTargets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/deregister-db-proxy-targets.html)*Command Reference*.
### `describe-account-attributes`
Il seguente esempio di codice mostra come utilizzare`describe-account-attributes`.
**AWS CLI**
**Come descrivere gli attributi dell’account**
L'`describe-account-attributes`esempio seguente recupera gli attributi per l' AWS account corrente.
```
aws rds describe-account-attributes
```
Output:
```
{
"AccountQuotas": [
{
"Max": 40,
"Used": 4,
"AccountQuotaName": "DBInstances"
},
{
"Max": 40,
"Used": 0,
"AccountQuotaName": "ReservedDBInstances"
},
{
"Max": 100000,
"Used": 40,
"AccountQuotaName": "AllocatedStorage"
},
{
"Max": 25,
"Used": 0,
"AccountQuotaName": "DBSecurityGroups"
},
{
"Max": 20,
"Used": 0,
"AccountQuotaName": "AuthorizationsPerDBSecurityGroup"
},
{
"Max": 50,
"Used": 1,
"AccountQuotaName": "DBParameterGroups"
},
{
"Max": 100,
"Used": 3,
"AccountQuotaName": "ManualSnapshots"
},
{
"Max": 20,
"Used": 0,
"AccountQuotaName": "EventSubscriptions"
},
{
"Max": 50,
"Used": 1,
"AccountQuotaName": "DBSubnetGroups"
},
{
"Max": 20,
"Used": 1,
"AccountQuotaName": "OptionGroups"
},
{
"Max": 20,
"Used": 6,
"AccountQuotaName": "SubnetsPerDBSubnetGroup"
},
{
"Max": 5,
"Used": 0,
"AccountQuotaName": "ReadReplicasPerMaster"
},
{
"Max": 40,
"Used": 1,
"AccountQuotaName": "DBClusters"
},
{
"Max": 50,
"Used": 0,
"AccountQuotaName": "DBClusterParameterGroups"
},
{
"Max": 5,
"Used": 0,
"AccountQuotaName": "DBClusterRoles"
}
]
}
```
+ Per i dettagli sull'API, vedere [DescribeAccountAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-account-attributes.html)in *AWS CLI Command Reference.*
### `describe-blue-green-deployments`
Il seguente esempio di codice mostra come utilizzare`describe-blue-green-deployments`.
**AWS CLI**
**Esempio 1: descrivere una blue/green distribuzione di un'istanza DB RDS dopo il completamento della creazione**
L'`describe-blue-green-deployment`esempio seguente recupera i dettagli di una blue/green distribuzione dopo il completamento della creazione.
```
aws rds describe-blue-green-deployments \
--blue-green-deployment-identifier bgd-v53303651eexfake
```
Output:
```
{
"BlueGreenDeployments": [
{
"BlueGreenDeploymentIdentifier": "bgd-v53303651eexfake",
"BlueGreenDeploymentName": "bgd-cli-test-instance",
"Source": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance",
"Target": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-green-rkfbpe",
"SwitchoverDetails": [
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-green-rkfbpe",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-1-green-j382ha",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-2",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-2-green-ejv4ao",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-3",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-3-green-vlpz3t",
"Status": "AVAILABLE"
}
],
"Tasks": [
{
"Name": "CREATING_READ_REPLICA_OF_SOURCE",
"Status": "COMPLETED"
},
{
"Name": "DB_ENGINE_VERSION_UPGRADE",
"Status": "COMPLETED"
},
{
"Name": "CONFIGURE_BACKUPS",
"Status": "COMPLETED"
},
{
"Name": "CREATING_TOPOLOGY_OF_SOURCE",
"Status": "COMPLETED"
}
],
"Status": "AVAILABLE",
"CreateTime": "2022-02-25T21:18:51.183000+00:00"
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione di una blue/green distribuzione](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/blue-green-deployments-viewing.html) nella *Amazon RDS User Guide*.
**Esempio 2: Per descrivere una blue/green distribuzione per un cluster Aurora MySQL DB**
L'`describe-blue-green-deployment`esempio seguente recupera i dettagli di una distribuzione. blue/green
```
aws rds describe-blue-green-deployments \
--blue-green-deployment-identifier bgd-wi89nwzglccsfake
```
Output:
```
{
"BlueGreenDeployments": [
{
"BlueGreenDeploymentIdentifier": "bgd-wi89nwzglccsfake",
"BlueGreenDeploymentName": "my-blue-green-deployment",
"Source": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"Target": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster-green-3rnukl",
"SwitchoverDetails": [
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster-green-3rnukl",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-1-green-gpmaxf",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-2",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-2-green-j2oajq",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-3",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-3-green-mkxies",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-excluded-member-endpoint",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-excluded-member-endpoint-green-4sqjrq",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-reader-endpoint",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-reader-endpoint-green-gwwzlg",
"Status": "AVAILABLE"
}
],
"Tasks": [
{
"Name": "CREATING_READ_REPLICA_OF_SOURCE",
"Status": "COMPLETED"
},
{
"Name": "DB_ENGINE_VERSION_UPGRADE",
"Status": "COMPLETED"
},
{
"Name": "CREATE_DB_INSTANCES_FOR_CLUSTER",
"Status": "COMPLETED"
},
{
"Name": "CREATE_CUSTOM_ENDPOINTS",
"Status": "COMPLETED"
}
],
"Status": "AVAILABLE",
"CreateTime": "2022-02-25T21:12:00.288000+00:00"
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione di una blue/green distribuzione](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-viewing.html) nella Guida per l'*utente di Amazon Aurora*.
**Esempio 3: Per descrivere una blue/green distribuzione per un cluster Aurora MySQL dopo lo switchover**
L'`describe-blue-green-deployment`esempio seguente recupera i dettagli su una blue/green distribuzione dopo che l'ambiente verde è stato promosso a ambiente di produzione.
```
aws rds describe-blue-green-deployments \
--blue-green-deployment-identifier bgd-wi89nwzglccsfake
```
Output:
```
{
"BlueGreenDeployments": [
{
"BlueGreenDeploymentIdentifier": "bgd-wi89nwzglccsfake",
"BlueGreenDeploymentName": "my-blue-green-deployment",
"Source": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster-old1",
"Target": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"SwitchoverDetails": [
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster-old1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"Status": "SWITCHOVER_COMPLETED"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-1-old1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-1",
"Status": "SWITCHOVER_COMPLETED"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-2-old1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-2",
"Status": "SWITCHOVER_COMPLETED"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-3-old1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-3",
"Status": "SWITCHOVER_COMPLETED"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-excluded-member-endpoint-old1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-excluded-member-endpoint",
"Status": "SWITCHOVER_COMPLETED"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-reader-endpoint-old1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-reader-endpoint",
"Status": "SWITCHOVER_COMPLETED"
}
],
"Tasks": [
{
"Name": "CREATING_READ_REPLICA_OF_SOURCE",
"Status": "COMPLETED"
},
{
"Name": "DB_ENGINE_VERSION_UPGRADE",
"Status": "COMPLETED"
},
{
"Name": "CREATE_DB_INSTANCES_FOR_CLUSTER",
"Status": "COMPLETED"
},
{
"Name": "CREATE_CUSTOM_ENDPOINTS",
"Status": "COMPLETED"
}
],
"Status": "SWITCHOVER_COMPLETED",
"CreateTime": "2022-02-25T22:38:49.522000+00:00"
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione di una blue/green distribuzione](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-viewing.html) nella Guida per l'*utente di Amazon Aurora*.
**Esempio 4: Per descrivere una distribuzione combinata blue/green **
L'`describe-blue-green-deployment`esempio seguente recupera i dettagli di una blue/green distribuzione combinata.
```
aws rds describe-blue-green-deployments
```
Output:
```
{
"BlueGreenDeployments": [
{
"BlueGreenDeploymentIdentifier": "bgd-wi89nwzgfakelccs",
"BlueGreenDeploymentName": "my-blue-green-deployment",
"Source": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"Target": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster-green-3rnukl",
"SwitchoverDetails": [
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster-green-3rnukl",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-1-green-gpmaxf",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-2",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-2-green-j2oajq",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-3",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-3-green-mkxies",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-excluded-member-endpoint",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-excluded-member-endpoint-green-4sqjrq",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-reader-endpoint",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-reader-endpoint-green-gwwzlg",
"Status": "AVAILABLE"
}
],
"Tasks": [
{
"Name": "CREATING_READ_REPLICA_OF_SOURCE",
"Status": "COMPLETED"
},
{
"Name": "DB_ENGINE_VERSION_UPGRADE",
"Status": "COMPLETED"
},
{
"Name": "CREATE_DB_INSTANCES_FOR_CLUSTER",
"Status": "COMPLETED"
},
{
"Name": "CREATE_CUSTOM_ENDPOINTS",
"Status": "COMPLETED"
}
],
"Status": "AVAILABLE",
"CreateTime": "2022-02-25T21:12:00.288000+00:00"
},
{
"BlueGreenDeploymentIdentifier": "bgd-v5330365fake1eex",
"BlueGreenDeploymentName": "bgd-cli-test-instance",
"Source": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-old1",
"Target": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance",
"SwitchoverDetails": [
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-old1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance",
"Status": "SWITCHOVER_COMPLETED"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-1-old1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-1",
"Status": "SWITCHOVER_COMPLETED"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-2-old1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-2",
"Status": "SWITCHOVER_COMPLETED"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-3-old1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-3",
"Status": "SWITCHOVER_COMPLETED"
}
],
"Tasks": [
{
"Name": "CREATING_READ_REPLICA_OF_SOURCE",
"Status": "COMPLETED"
},
{
"Name": "DB_ENGINE_VERSION_UPGRADE",
"Status": "COMPLETED"
},
{
"Name": "CONFIGURE_BACKUPS",
"Status": "COMPLETED"
},
{
"Name": "CREATING_TOPOLOGY_OF_SOURCE",
"Status": "COMPLETED"
}
],
"Status": "SWITCHOVER_COMPLETED",
"CreateTime": "2022-02-25T22:33:22.225000+00:00"
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione di una blue/green distribuzione](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/blue-green-deployments-viewing.html) nella Guida per l'*utente di Amazon RDS e [Visualizzazione di una blue/green distribuzione](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-viewing.html) nella Guida* per l'utente di *Amazon Aurora*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeBlueGreenDeployments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-blue-green-deployments.html)Reference*.
### `describe-certificates`
Il seguente esempio di codice mostra come utilizzare`describe-certificates`.
**AWS CLI**
**Come descrivere i certificati**
L’esempio `describe-certificates` seguente recupera i dettagli del certificato associato alla Regione predefinita dell’utente.
```
aws rds describe-certificates
```
Output:
```
{
"Certificates": [
{
"CertificateIdentifier": "rds-ca-ecc384-g1",
"CertificateType": "CA",
"Thumbprint": "2ee3dcc06e50192559b13929e73484354f23387d",
"ValidFrom": "2021-05-24T22:06:59+00:00",
"ValidTill": "2121-05-24T23:06:59+00:00",
"CertificateArn": "arn:aws:rds:us-west-2::cert:rds-ca-ecc384-g1",
"CustomerOverride": false
},
{
"CertificateIdentifier": "rds-ca-rsa4096-g1",
"CertificateType": "CA",
"Thumbprint": "19da4f2af579a8ae1f6a0fa77aa5befd874b4cab",
"ValidFrom": "2021-05-24T22:03:20+00:00",
"ValidTill": "2121-05-24T23:03:20+00:00",
"CertificateArn": "arn:aws:rds:us-west-2::cert:rds-ca-rsa4096-g1",
"CustomerOverride": false
},
{
"CertificateIdentifier": "rds-ca-rsa2048-g1",
"CertificateType": "CA",
"Thumbprint": "7c40cb42714b6fdb2b296f9bbd0e8bb364436a76",
"ValidFrom": "2021-05-24T21:59:00+00:00",
"ValidTill": "2061-05-24T22:59:00+00:00",
"CertificateArn": "arn:aws:rds:us-west-2::cert:rds-ca-rsa2048-g1",
"CustomerOverride": true,
"CustomerOverrideValidTill": "2061-05-24T22:59:00+00:00"
},
{
"CertificateIdentifier": "rds-ca-2019",
"CertificateType": "CA",
"Thumbprint": "d40ddb29e3750dffa671c3140bbf5f478d1c8096",
"ValidFrom": "2019-08-22T17:08:50+00:00",
"ValidTill": "2024-08-22T17:08:50+00:00",
"CertificateArn": "arn:aws:rds:us-west-2::cert:rds-ca-2019",
"CustomerOverride": false
}
],
"DefaultCertificateForNewLaunches": "rds-ca-rsa2048-g1"
}
```
Per ulteriori informazioni, consulta [Utilizzo per SSL/TLS crittografare una connessione a un'istanza DB](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html) nella *Guida per l'utente di Amazon RDS* e [Utilizzo SSL/TLS per crittografare una connessione a un cluster DB](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.SSL.html) nella Guida per l'utente di *Amazon* Aurora.
+ *Per i dettagli sull'API, consulta [DescribeCertificates](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-certificates.html)Command Reference.AWS CLI *
### `describe-db-cluster-backtracks`
Il seguente esempio di codice mostra come utilizzare`describe-db-cluster-backtracks`.
**AWS CLI**
**Come descrivere i backtrack per un cluster di database**
L’esempio `describe-db-cluster-backtracks` seguente recupera i dettagli del cluster di database specificato.
```
aws rds describe-db-cluster-backtracks \
--db-cluster-identifier mydbcluster
```
Output:
```
{
"DBClusterBacktracks": [
{
"DBClusterIdentifier": "mydbcluster",
"BacktrackIdentifier": "2f5f5294-0dd2-44c9-9f50-EXAMPLE",
"BacktrackTo": "2021-02-12T04:59:22Z",
"BacktrackedFrom": "2021-02-12T14:37:31.640Z",
"BacktrackRequestCreationTime": "2021-02-12T14:36:18.819Z",
"Status": "COMPLETED"
},
{
"DBClusterIdentifier": "mydbcluster",
"BacktrackIdentifier": "3c7a6421-af2a-4ea3-ae95-EXAMPLE",
"BacktrackTo": "2021-02-11T22:53:46Z",
"BacktrackedFrom": "2021-02-12T00:09:27.006Z",
"BacktrackRequestCreationTime": "2021-02-12T00:07:53.487Z",
"Status": "COMPLETED"
}
]
}
```
Per ulteriori informazioni, consulta [Backtracking di un cluster di database Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Managing.Backtrack.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeDbClusterBacktracks AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-cluster-backtracks.html)*Command Reference*.
### `describe-db-cluster-endpoints`
Il seguente esempio di codice mostra come utilizzare`describe-db-cluster-endpoints`.
**AWS CLI**
**Esempio 1: come descrivere gli endpoint del cluster di database**
L’esempio `describe-db-cluster-endpoints` seguente recupera i dettagli degli endpoint del cluster di database. I tipi più comuni di cluster Aurora hanno due endpoint. Un endpoint ha il tipo `WRITER`. Puoi utilizzare questo endpoint per tutte le istruzioni SQL. L’altro endpoint ha il tipo `READER`. Puoi utilizzare questo endpoint solo per SELECT e altre istruzioni SQL di sola lettura.
```
aws rds describe-db-cluster-endpoints
```
Output:
```
{
"DBClusterEndpoints": [
{
"DBClusterIdentifier": "my-database-1",
"Endpoint": "my-database-1.cluster-cnpexample.us-east-1.rds.amazonaws.com",
"Status": "creating",
"EndpointType": "WRITER"
},
{
"DBClusterIdentifier": "my-database-1",
"Endpoint": "my-database-1.cluster-ro-cnpexample.us-east-1.rds.amazonaws.com",
"Status": "creating",
"EndpointType": "READER"
},
{
"DBClusterIdentifier": "mydbcluster",
"Endpoint": "mydbcluster.cluster-cnpexamle.us-east-1.rds.amazonaws.com",
"Status": "available",
"EndpointType": "WRITER"
},
{
"DBClusterIdentifier": "mydbcluster",
"Endpoint": "mydbcluster.cluster-ro-cnpexample.us-east-1.rds.amazonaws.com",
"Status": "available",
"EndpointType": "READER"
}
]
}
```
**Esempio 2: come descrivere gli endpoint del cluster di database di un singolo cluster di database**
L’esempio `describe-db-cluster-endpoints` seguente recupera i dettagli degli endpoint del cluster di database di un singolo cluster di database specificato. I cluster Aurora Serverless hanno un solo endpoint con un tipo `WRITER`.
```
aws rds describe-db-cluster-endpoints \
--db-cluster-identifier serverless-cluster
```
Output:
```
{
"DBClusterEndpoints": [
{
"Status": "available",
"Endpoint": "serverless-cluster.cluster-cnpexample.us-east-1.rds.amazonaws.com",
"DBClusterIdentifier": "serverless-cluster",
"EndpointType": "WRITER"
}
]
}
```
Per ulteriori informazioni, consulta [Gestione delle connessioni Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Overview.Endpoints.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeDbClusterEndpoints AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-cluster-endpoints.html)*Command Reference*.
### `describe-db-cluster-parameter-groups`
Il seguente esempio di codice mostra come utilizzare`describe-db-cluster-parameter-groups`.
**AWS CLI**
**Come descrivere i gruppi di parametri del cluster di database**
L’esempio `describe-db-cluster-parameter-groups` seguente recupera i dettagli per i gruppi di parametri del cluster di database.
```
aws rds describe-db-cluster-parameter-groups
```
Output:
```
{
"DBClusterParameterGroups": [
{
"DBClusterParameterGroupName": "default.aurora-mysql5.7",
"DBParameterGroupFamily": "aurora-mysql5.7",
"Description": "Default cluster parameter group for aurora-mysql5.7",
"DBClusterParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:cluster-pg:default.aurora-mysql5.7"
},
{
"DBClusterParameterGroupName": "default.aurora-postgresql9.6",
"DBParameterGroupFamily": "aurora-postgresql9.6",
"Description": "Default cluster parameter group for aurora-postgresql9.6",
"DBClusterParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:cluster-pg:default.aurora-postgresql9.6"
},
{
"DBClusterParameterGroupName": "default.aurora5.6",
"DBParameterGroupFamily": "aurora5.6",
"Description": "Default cluster parameter group for aurora5.6",
"DBClusterParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:cluster-pg:default.aurora5.6"
},
{
"DBClusterParameterGroupName": "mydbclusterpg",
"DBParameterGroupFamily": "aurora-mysql5.7",
"Description": "My DB cluster parameter group",
"DBClusterParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:cluster-pg:mydbclusterpg"
},
{
"DBClusterParameterGroupName": "mydbclusterpgcopy",
"DBParameterGroupFamily": "aurora-mysql5.7",
"Description": "Copy of mydbclusterpg parameter group",
"DBClusterParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:cluster-pg:mydbclusterpgcopy"
}
]
}
```
Per ulteriori informazioni, consulta [Uso di gruppi di parametri database e gruppi di parametri cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeDbClusterParameterGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-cluster-parameter-groups.html)*Command Reference*.
### `describe-db-cluster-parameters`
Il seguente esempio di codice mostra come utilizzare`describe-db-cluster-parameters`.
**AWS CLI**
**Esempio 1: come descrivere i parametri in un gruppo di parametri del cluster di database**
L’esempio `describe-db-cluster-parameters` seguente recupera i dettagli dei parametri in un gruppo di parametri del cluster di database.
```
aws rds describe-db-cluster-parameters \
--db-cluster-parameter-group-name mydbclusterpg
```
Output:
```
{
"Parameters": [
{
"ParameterName": "allow-suspicious-udfs",
"Description": "Controls whether user-defined functions that have only an xxx symbol for the main function can be loaded",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": false,
"ApplyMethod": "pending-reboot",
"SupportedEngineModes": [
"provisioned"
]
},
{
"ParameterName": "aurora_lab_mode",
"ParameterValue": "0",
"Description": "Enables new features in the Aurora engine.",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": true,
"ApplyMethod": "pending-reboot",
"SupportedEngineModes": [
"provisioned"
]
},
...some output truncated...
]
}
```
**Esempio 2: come elencare solo i nomi dei parametri in un gruppo di parametri del cluster di database**
L’esempio `describe-db-cluster-parameters` seguente recupera solo i nomi dei parametri in un gruppo di parametri del cluster di database.
```
aws rds describe-db-cluster-parameters \
--db-cluster-parameter-group-name default.aurora-mysql5.7 \
--query 'Parameters[].{ParameterName:ParameterName}'
```
Output:
```
[
{
"ParameterName": "allow-suspicious-udfs"
},
{
"ParameterName": "aurora_binlog_read_buffer_size"
},
{
"ParameterName": "aurora_binlog_replication_max_yield_seconds"
},
{
"ParameterName": "aurora_binlog_use_large_read_buffer"
},
{
"ParameterName": "aurora_lab_mode"
},
...some output truncated...
}
]
```
**Esempio 3: come descrivere solo i parametri modificabili in un gruppo di parametri del cluster di database**
L’esempio `describe-db-cluster-parameters` seguente recupera solo i nomi dei parametri che è possibile modificare in un gruppo di parametri del cluster di database.
```
aws rds describe-db-cluster-parameters \
--db-cluster-parameter-group-name default.aurora-mysql5.7 \
--query 'Parameters[].{ParameterName:ParameterName,IsModifiable:IsModifiable} | [?IsModifiable == `true`]'
```
Output:
```
[
{
"ParameterName": "aurora_binlog_read_buffer_size",
"IsModifiable": true
},
{
"ParameterName": "aurora_binlog_replication_max_yield_seconds",
"IsModifiable": true
},
{
"ParameterName": "aurora_binlog_use_large_read_buffer",
"IsModifiable": true
},
{
"ParameterName": "aurora_lab_mode",
"IsModifiable": true
},
...some output truncated...
}
]
```
**Esempio 4: Per descrivere solo i parametri booleani modificabili in un gruppo di parametri del cluster DB**
L’esempio `describe-db-cluster-parameters` seguente recupera solo i nomi dei parametri che è possibile modificare in un gruppo di parametri del cluster di database e che hanno un tipo di dati booleano.
```
aws rds describe-db-cluster-parameters \
--db-cluster-parameter-group-name default.aurora-mysql5.7 \
--query 'Parameters[].{ParameterName:ParameterName,DataType:DataType,IsModifiable:IsModifiable} | [?DataType == `boolean`] | [?IsModifiable == `true`]'
```
Output:
```
[
{
"DataType": "boolean",
"ParameterName": "aurora_binlog_use_large_read_buffer",
"IsModifiable": true
},
{
"DataType": "boolean",
"ParameterName": "aurora_lab_mode",
"IsModifiable": true
},
{
"DataType": "boolean",
"ParameterName": "autocommit",
"IsModifiable": true
},
{
"DataType": "boolean",
"ParameterName": "automatic_sp_privileges",
"IsModifiable": true
},
...some output truncated...
}
]
```
Per ulteriori informazioni, consulta [Uso di gruppi di parametri database e gruppi di parametri cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon Aurora*.
+ *Per i dettagli sull'API, vedere [DescribeDbClusterParameters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-cluster-parameters.html)in Command Reference.AWS CLI *
### `describe-db-cluster-snapshot-attributes`
Il seguente esempio di codice mostra come utilizzare`describe-db-cluster-snapshot-attributes`.
**AWS CLI**
**Come descrivere i nomi e i valori degli attributi per uno snapshot del cluster di database**
L’esempio `describe-db-cluster-snapshot-attributes` seguente recupera i dettagli dei nomi e dei valori degli attributi per lo snapshot del cluster di database specificato.
```
aws rds describe-db-cluster-snapshot-attributes \
--db-cluster-snapshot-identifier myclustersnapshot
```
Output:
```
{
"DBClusterSnapshotAttributesResult": {
"DBClusterSnapshotIdentifier": "myclustersnapshot",
"DBClusterSnapshotAttributes": [
{
"AttributeName": "restore",
"AttributeValues": [
"123456789012"
]
}
]
}
}
```
Per ulteriori informazioni, consulta [Condivisione di uno snapshot cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_ShareSnapshot.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeDbClusterSnapshotAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-cluster-snapshot-attributes.html)*Command Reference*.
### `describe-db-cluster-snapshots`
Il seguente esempio di codice mostra come utilizzare`describe-db-cluster-snapshots`.
**AWS CLI**
**Come descrivere uno snapshot del cluster di database per un cluster di database**
L’esempio `describe-db-cluster-snapshots` seguente recupera i dettagli per gli snapshot del cluster di database per il cluster di database specificato.
```
aws rds describe-db-cluster-snapshots \
--db-cluster-identifier mydbcluster
```
Output:
```
{
"DBClusterSnapshots": [
{
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1e"
],
"DBClusterSnapshotIdentifier": "myclustersnapshotcopy",
"DBClusterIdentifier": "mydbcluster",
"SnapshotCreateTime": "2019-06-04T09:16:42.649Z",
"Engine": "aurora-mysql",
"AllocatedStorage": 0,
"Status": "available",
"Port": 0,
"VpcId": "vpc-6594f31c",
"ClusterCreateTime": "2019-04-15T14:18:42.785Z",
"MasterUsername": "myadmin",
"EngineVersion": "5.7.mysql_aurora.2.04.2",
"LicenseModel": "aurora-mysql",
"SnapshotType": "manual",
"PercentProgress": 100,
"StorageEncrypted": true,
"KmsKeyId": "arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE",
"DBClusterSnapshotArn": "arn:aws:rds:us-east-1:814387698303:cluster-snapshot:myclustersnapshotcopy",
"IAMDatabaseAuthenticationEnabled": false
},
{
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1e"
],
"DBClusterSnapshotIdentifier": "rds:mydbcluster-2019-06-20-09-16",
"DBClusterIdentifier": "mydbcluster",
"SnapshotCreateTime": "2019-06-20T09:16:26.569Z",
"Engine": "aurora-mysql",
"AllocatedStorage": 0,
"Status": "available",
"Port": 0,
"VpcId": "vpc-6594f31c",
"ClusterCreateTime": "2019-04-15T14:18:42.785Z",
"MasterUsername": "myadmin",
"EngineVersion": "5.7.mysql_aurora.2.04.2",
"LicenseModel": "aurora-mysql",
"SnapshotType": "automated",
"PercentProgress": 100,
"StorageEncrypted": true,
"KmsKeyId": "arn:aws:kms:us-east-1:814387698303:key/AKIAIOSFODNN7EXAMPLE",
"DBClusterSnapshotArn": "arn:aws:rds:us-east-1:123456789012:cluster-snapshot:rds:mydbcluster-2019-06-20-09-16",
"IAMDatabaseAuthenticationEnabled": false
}
]
}
```
Per ulteriori informazioni, consulta [Creazione di una snapshot di cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_CreateSnapshotCluster.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeDbClusterSnapshots AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-cluster-snapshots.html)*Command Reference*.
### `describe-db-clusters`
Il seguente esempio di codice mostra come utilizzare`describe-db-clusters`.
**AWS CLI**
**Esempio 1: come descrivere un cluster di database**
L’esempio `describe-db-clusters` seguente recupera i dettagli del cluster di database specificato.
```
aws rds describe-db-clusters \
--db-cluster-identifier mydbcluster
```
Output:
```
{
"DBClusters": [
{
"AllocatedStorage": 1,
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1e"
],
"BackupRetentionPeriod": 1,
"DatabaseName": "mydbcluster",
"DBClusterIdentifier": "mydbcluster",
"DBClusterParameterGroup": "default.aurora-mysql5.7",
"DBSubnetGroup": "default",
"Status": "available",
"EarliestRestorableTime": "2019-06-19T09:16:28.210Z",
"Endpoint": "mydbcluster.cluster-cnpexample.us-east-1.rds.amazonaws.com",
"ReaderEndpoint": "mydbcluster.cluster-ro-cnpexample.us-east-1.rds.amazonaws.com",
"MultiAZ": true,
"Engine": "aurora-mysql",
"EngineVersion": "5.7.mysql_aurora.2.04.2",
"LatestRestorableTime": "2019-06-20T22:38:14.908Z",
"Port": 3306,
"MasterUsername": "myadmin",
"PreferredBackupWindow": "09:09-09:39",
"PreferredMaintenanceWindow": "sat:04:09-sat:04:39",
"ReadReplicaIdentifiers": [],
"DBClusterMembers": [
{
"DBInstanceIdentifier": "dbinstance3",
"IsClusterWriter": false,
"DBClusterParameterGroupStatus": "in-sync",
"PromotionTier": 1
},
{
"DBInstanceIdentifier": "dbinstance1",
"IsClusterWriter": false,
"DBClusterParameterGroupStatus": "in-sync",
"PromotionTier": 1
},
{
"DBInstanceIdentifier": "dbinstance2",
"IsClusterWriter": false,
"DBClusterParameterGroupStatus": "in-sync",
"PromotionTier": 1
},
{
"DBInstanceIdentifier": "mydbcluster",
"IsClusterWriter": false,
"DBClusterParameterGroupStatus": "in-sync",
"PromotionTier": 1
},
{
"DBInstanceIdentifier": "mydbcluster-us-east-1b",
"IsClusterWriter": false,
"DBClusterParameterGroupStatus": "in-sync",
"PromotionTier": 1
},
{
"DBInstanceIdentifier": "mydbcluster",
"IsClusterWriter": true,
"DBClusterParameterGroupStatus": "in-sync",
"PromotionTier": 1
}
],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-0b9130572daf3dc16",
"Status": "active"
}
],
"HostedZoneId": "Z2R2ITUGPM61AM",
"StorageEncrypted": true,
"KmsKeyId": "arn:aws:kms:us-east-1:814387698303:key/AKIAIOSFODNN7EXAMPLE",
"DbClusterResourceId": "cluster-AKIAIOSFODNN7EXAMPLE",
"DBClusterArn": "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster",
"AssociatedRoles": [],
"IAMDatabaseAuthenticationEnabled": false,
"ClusterCreateTime": "2019-04-15T14:18:42.785Z",
"EngineMode": "provisioned",
"DeletionProtection": false,
"HttpEndpointEnabled": false
}
]
}
```
**Esempio 2: come elencare determinati attributi di tutti i cluster di database**
L'`describe-db-clusters`esempio seguente recupera solo gli `ReaderEndpoint` attributi `DBClusterIdentifier``Endpoint`, e di tutti i cluster DB nella regione corrente AWS .
```
aws rds describe-db-clusters \
--query 'DBClusters[].{DBClusterIdentifier:DBClusterIdentifier,Endpoint:Endpoint,ReaderEndpoint:ReaderEndpoint}'
```
Output:
```
[
{
"Endpoint": "cluster-57-2020-05-01-2270.cluster-cnpexample.us-east-1.rds.amazonaws.com",
"ReaderEndpoint": "cluster-57-2020-05-01-2270.cluster-ro-cnpexample.us-east-1.rds.amazonaws.com",
"DBClusterIdentifier": "cluster-57-2020-05-01-2270"
},
{
"Endpoint": "cluster-57-2020-05-01-4615.cluster-cnpexample.us-east-1.rds.amazonaws.com",
"ReaderEndpoint": "cluster-57-2020-05-01-4615.cluster-ro-cnpexample.us-east-1.rds.amazonaws.com",
"DBClusterIdentifier": "cluster-57-2020-05-01-4615"
},
{
"Endpoint": "pg2-cluster.cluster-cnpexample.us-east-1.rds.amazonaws.com",
"ReaderEndpoint": "pg2-cluster.cluster-ro-cnpexample.us-east-1.rds.amazonaws.com",
"DBClusterIdentifier": "pg2-cluster"
},
...output omitted...
}
]
```
**Esempio 3: come elencare i cluster di database con un attributo specifico**
L’esempio `describe-db-clusters` seguente recupera solo gli attributi `DBClusterIdentifier` e `Engine` dei cluster di database che utilizzano il motore database `aurora-postgresql`.
```
aws rds describe-db-clusters \
--query 'DBClusters[].{DBClusterIdentifier:DBClusterIdentifier,Engine:Engine} | [?Engine == `aurora-postgresql`]'
```
Output:
```
[
{
"Engine": "aurora-postgresql",
"DBClusterIdentifier": "pg2-cluster"
}
]
```
Per ulteriori informazioni, consulta [Cluster database Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Overview.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, vedere [DescribeDbClusters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-clusters.html)in *AWS CLI Command Reference*.
### `describe-db-engine-versions`
Il seguente esempio di codice mostra come utilizzare`describe-db-engine-versions`.
**AWS CLI**
**Come descrivere le versioni del motore di database per il motore MySQL DB**
L’esempio `describe-db-engine-versions` seguente mostra i dettagli di ciascuna versione del motore di database specificato.
```
aws rds describe-db-engine-versions \
--engine mysql
```
Output:
```
{
"DBEngineVersions": [
{
"Engine": "mysql",
"EngineVersion": "5.5.46",
"DBParameterGroupFamily": "mysql5.5",
"DBEngineDescription": "MySQL Community Edition",
"DBEngineVersionDescription": "MySQL 5.5.46",
"ValidUpgradeTarget": [
{
"Engine": "mysql",
"EngineVersion": "5.5.53",
"Description": "MySQL 5.5.53",
"AutoUpgrade": false,
"IsMajorVersionUpgrade": false
},
{
"Engine": "mysql",
"EngineVersion": "5.5.54",
"Description": "MySQL 5.5.54",
"AutoUpgrade": false,
"IsMajorVersionUpgrade": false
},
{
"Engine": "mysql",
"EngineVersion": "5.5.57",
"Description": "MySQL 5.5.57",
"AutoUpgrade": false,
"IsMajorVersionUpgrade": false
},
...some output truncated...
]
}
```
Per ulteriori informazioni, consulta [Cos’è Amazon Relational Database Service (Amazon RDS)?](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [Descrivi DBEngine le versioni](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-engine-versions.html) in *AWS CLI Command Reference*.
### `describe-db-instance-automated-backups`
Il seguente esempio di codice mostra come utilizzare`describe-db-instance-automated-backups`.
**AWS CLI**
**Come descrivere i backup automatici per un’istanza database**
L’esempio `describe-db-instance-automated-backups` seguente visualizza i dettagli relativi ai backup automatici per l’istanza di database specificata. I dettagli includono backup automatici replicati in altre AWS regioni.
```
aws rds describe-db-instance-automated-backups \
--db-instance-identifier new-orcl-db
```
Output:
```
{
"DBInstanceAutomatedBackups": [
{
"DBInstanceArn": "arn:aws:rds:us-east-1:123456789012:db:new-orcl-db",
"DbiResourceId": "db-JKIB2GFQ5RV7REPLZA4EXAMPLE",
"Region": "us-east-1",
"DBInstanceIdentifier": "new-orcl-db",
"RestoreWindow": {
"EarliestTime": "2020-12-07T21:05:20.939Z",
"LatestTime": "2020-12-07T21:05:20.939Z"
},
"AllocatedStorage": 20,
"Status": "replicating",
"Port": 1521,
"InstanceCreateTime": "2020-12-04T15:28:31Z",
"MasterUsername": "admin",
"Engine": "oracle-se2",
"EngineVersion": "12.1.0.2.v21",
"LicenseModel": "bring-your-own-license",
"OptionGroupName": "default:oracle-se2-12-1",
"Encrypted": false,
"StorageType": "gp2",
"IAMDatabaseAuthenticationEnabled": false,
"BackupRetentionPeriod": 14,
"DBInstanceAutomatedBackupsArn": "arn:aws:rds:us-west-2:123456789012:auto-backup:ab-jkib2gfq5rv7replzadausbrktni2bn4example"
}
]
}
```
Per ulteriori informazioni, consulta [Ricerca di informazioni sui backup replicati](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReplicateBackups.html#AutomatedBackups.Replicating.Describe) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeDbInstanceAutomatedBackups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-instance-automated-backups.html)Reference*.
### `describe-db-instances`
Il seguente esempio di codice mostra come utilizzare`describe-db-instances`.
**AWS CLI**
**Come descrivere un’istanza database**
L’esempio `describe-db-instances` seguente recupera i dettagli dell’istanza database specificata.
```
aws rds describe-db-instances \
--db-instance-identifier mydbinstancecf
```
Output:
```
{
"DBInstances": [
{
"DBInstanceIdentifier": "mydbinstancecf",
"DBInstanceClass": "db.t3.small",
"Engine": "mysql",
"DBInstanceStatus": "available",
"MasterUsername": "masterawsuser",
"Endpoint": {
"Address": "mydbinstancecf.abcexample.us-east-1.rds.amazonaws.com",
"Port": 3306,
"HostedZoneId": "Z2R2ITUGPM61AM"
},
...some output truncated...
}
]
}
```
+ Per i dettagli sull'API, consulta [Descrivi DBInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-instances.html) in *AWS CLI Command Reference*.
### `describe-db-log-files`
Il seguente esempio di codice mostra come utilizzare`describe-db-log-files`.
**AWS CLI**
**Come descrivere i file di log per un’istanza database**
L’esempio `describe-db-log-files` seguente recupera i dettagli dei file di log per l’istanza database specificata.
```
aws rds describe-db-log-files -\
-db-instance-identifier test-instance
```
Output:
```
{
"DescribeDBLogFiles": [
{
"Size": 0,
"LastWritten": 1533060000000,
"LogFileName": "error/mysql-error-running.log"
},
{
"Size": 2683,
"LastWritten": 1532994300000,
"LogFileName": "error/mysql-error-running.log.0"
},
{
"Size": 107,
"LastWritten": 1533057300000,
"LogFileName": "error/mysql-error-running.log.18"
},
{
"Size": 13105,
"LastWritten": 1532991000000,
"LogFileName": "error/mysql-error-running.log.23"
},
{
"Size": 0,
"LastWritten": 1533061200000,
"LogFileName": "error/mysql-error.log"
},
{
"Size": 3519,
"LastWritten": 1532989252000,
"LogFileName": "mysqlUpgrade"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeDbLogFiles AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-log-files.html)*Command Reference*.
### `describe-db-parameter-groups`
Il seguente esempio di codice mostra come utilizzare`describe-db-parameter-groups`.
**AWS CLI**
**Come descrivere il gruppo di parametri del database**
L’esempio `describe-db-parameter-groups` seguente recupera i dettagli di tutti i gruppi di parametri del database.
```
aws rds describe-db-parameter-groups
```
Output:
```
{
"DBParameterGroups": [
{
"DBParameterGroupName": "default.aurora-mysql5.7",
"DBParameterGroupFamily": "aurora-mysql5.7",
"Description": "Default parameter group for aurora-mysql5.7",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.aurora-mysql5.7"
},
{
"DBParameterGroupName": "default.aurora-postgresql9.6",
"DBParameterGroupFamily": "aurora-postgresql9.6",
"Description": "Default parameter group for aurora-postgresql9.6",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.aurora-postgresql9.6"
},
{
"DBParameterGroupName": "default.aurora5.6",
"DBParameterGroupFamily": "aurora5.6",
"Description": "Default parameter group for aurora5.6",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.aurora5.6"
},
{
"DBParameterGroupName": "default.mariadb10.1",
"DBParameterGroupFamily": "mariadb10.1",
"Description": "Default parameter group for mariadb10.1",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.mariadb10.1"
},
...some output truncated...
]
}
```
Per ulteriori informazioni, consulta [Utilizzo di gruppi di parametri di database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [Descrivi DBParameter i gruppi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-parameter-groups.html) in *AWS CLI Command Reference*.
### `describe-db-parameters`
Il seguente esempio di codice mostra come utilizzare`describe-db-parameters`.
**AWS CLI**
**Come descrivere i parametri in un gruppo di parametri del database**
L’esempio `describe-db-parameters` seguente recupera i dettagli del gruppo di parametri database specificato.
```
aws rds describe-db-parameters \
--db-parameter-group-name mydbpg
```
Output:
```
{
"Parameters": [
{
"ParameterName": "allow-suspicious-udfs",
"Description": "Controls whether user-defined functions that have only an xxx symbol for the main function can be loaded",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": false,
"ApplyMethod": "pending-reboot"
},
{
"ParameterName": "auto_generate_certs",
"Description": "Controls whether the server autogenerates SSL key and certificate files in the data directory, if they do not already exist.",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": false,
"ApplyMethod": "pending-reboot"
},
...some output truncated...
]
}
```
Per ulteriori informazioni, consulta [Utilizzo di gruppi di parametri di database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [Descrivi DBParameters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-parameters.html) in *AWS CLI Command Reference*.
### `describe-db-proxies`
Il seguente esempio di codice mostra come utilizzare`describe-db-proxies`.
**AWS CLI**
**Come descrivere un proxy database per un database RDS**
L’esempio `describe-db-proxies` seguente restituisce le informazioni relative ai proxy database.
```
aws rds describe-db-proxies
```
Output:
```
{
"DBProxies": [
{
"DBProxyName": "proxyExample1",
"DBProxyArn": "arn:aws:rds:us-east-1:123456789012:db-proxy:prx-0123a01b12345c0ab",
"Status": "available",
"EngineFamily": "PostgreSQL",
"VpcId": "vpc-1234567",
"VpcSecurityGroupIds": [
"sg-1234"
],
"VpcSubnetIds": [
"subnetgroup1",
"subnetgroup2"
],
"Auth": "[
{
"Description": "proxydescription1"
"AuthScheme": "SECRETS",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789123:secret:secretName-1234f",
"IAMAuth": "DISABLED"
}
]",
"RoleArn": "arn:aws:iam::12345678912??:role/ProxyPostgreSQLRole",
"Endpoint": "proxyExample1.proxy-ab0cd1efghij.us-east-1.rds.amazonaws.com",
"RequireTLS": false,
"IdleClientTimeout": 1800,
"DebuggingLogging": false,
"CreatedDate": "2023-04-05T16:09:33.452000+00:00",
"UpdatedDate": "2023-04-13T01:49:38.568000+00:00"
},
{
"DBProxyName": "proxyExample2",
"DBProxyArn": "arn:aws:rds:us-east-1:123456789012:db-proxy:prx-1234a12b23456c1ab",
"Status": "available",
"EngineFamily": "PostgreSQL",
"VpcId": "sg-1234567",
"VpcSecurityGroupIds": [
"sg-1234"
],
"VpcSubnetIds": [
"subnetgroup1",
"subnetgroup2"
],
"Auth": "[
{
"Description": "proxydescription2"
"AuthScheme": "SECRETS",
"SecretArn": "aarn:aws:secretsmanager:us-west-2:123456789123:secret:secretName-1234f",
"IAMAuth": "DISABLED"
}
]",
"RoleArn": "arn:aws:iam::12345678912:role/ProxyPostgreSQLRole",
"Endpoint": "proxyExample2.proxy-ab0cd1efghij.us-east-1.rds.amazonaws.com",
"RequireTLS": false,
"IdleClientTimeout": 1800,
"DebuggingLogging": false,
"CreatedDate": "2022-01-05T16:19:33.452000+00:00",
"UpdatedDate": "2023-04-13T01:49:38.568000+00:00"
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-setup.html#rds-proxy-viewing) nella *Guida per l’utente di Amazon RDS* e [Visualizzazione di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-setup.html#rds-proxy-viewing) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeDbProxies AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-proxies.html)*Command Reference*.
### `describe-db-proxy-endpoints`
Il seguente esempio di codice mostra come utilizzare`describe-db-proxy-endpoints`.
**AWS CLI**
**Come descrivere gli endpoint di un proxy database**
L’esempio `describe-db-proxy-endpoints` seguente restituisce informazioni sugli endpoint di un proxy database.
```
aws rds describe-db-proxy-endpoints
```
Output:
```
{
"DBProxyEndpoints": [
{
"DBProxyEndpointName": "proxyEndpoint1",
"DBProxyEndpointArn": "arn:aws:rds:us-east-1:123456789012:db-proxy-endpoint:prx-endpoint-0123a01b12345c0ab",
"DBProxyName": "proxyExample",
"Status": "available",
"VpcId": "vpc-1234567",
"VpcSecurityGroupIds": [
"sg-1234"
],
"VpcSubnetIds": [
"subnetgroup1",
"subnetgroup2"
],
"Endpoint": "proxyEndpoint1.endpoint.proxy-ab0cd1efghij.us-east-1.rds.amazonaws.com",
"CreatedDate": "2023-04-05T16:09:33.452000+00:00",
"TargetRole": "READ_WRITE",
"IsDefault": false
},
{
"DBProxyEndpointName": "proxyEndpoint2",
"DBProxyEndpointArn": "arn:aws:rds:us-east-1:123456789012:db-proxy-endpoint:prx-endpoint-4567a01b12345c0ab",
"DBProxyName": "proxyExample2",
"Status": "available",
"VpcId": "vpc1234567",
"VpcSecurityGroupIds": [
"sg-5678"
],
"VpcSubnetIds": [
"subnetgroup1",
"subnetgroup2"
],
"Endpoint": "proxyEndpoint2.endpoint.proxy-cd1ef2klmnop.us-east-1.rds.amazonaws.com",
"CreatedDate": "2023-04-05T16:09:33.452000+00:00",
"TargetRole": "READ_WRITE",
"IsDefault": false
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione di un endpoint proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-endpoints.html#rds-proxy-endpoints.DescribingEndpoint) nella *Guida per l’utente di Amazon RDS* e [Creazione di un endpoint proxy](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-endpoints.html#rds-proxy-endpoints.DescribingEndpoint) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeDbProxyEndpoints AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-proxy-endpoints.html)*Command Reference*.
### `describe-db-proxy-target-groups`
Il seguente esempio di codice mostra come utilizzare`describe-db-proxy-target-groups`.
**AWS CLI**
**Come descrivere gli endpoint di un proxy database**
L’esempio `describe-db-proxy-target-groups` seguente restituisce informazioni sui gruppi di destinazioni del proxy database.
```
aws rds describe-db-proxy-target-groups \
--db-proxy-name proxyExample
```
Output:
```
{
"TargetGroups":
{
"DBProxyName": "proxyExample",
"TargetGroupName": "default",
"TargetGroupArn": "arn:aws:rds:us-east-1:123456789012:target-group:prx-tg-0123a01b12345c0ab",
"IsDefault": true,
"Status": "available",
"ConnectionPoolConfig": {
"MaxConnectionsPercent": 100,
"MaxIdleConnectionsPercent": 50,
"ConnectionBorrowTimeout": 120,
"SessionPinningFilters": []
},
"CreatedDate": "2023-05-02T18:41:19.495000+00:00",
"UpdatedDate": "2023-05-02T18:41:21.762000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Visualizzazione di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-setup.html#rds-proxy-viewing) nella *Guida per l’utente di Amazon RDS* e [Visualizzazione di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-setup.html#rds-proxy-viewing) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeDbProxyTargetGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-proxy-target-groups.html)*Command Reference*.
### `describe-db-proxy-targets`
Il seguente esempio di codice mostra come utilizzare`describe-db-proxy-targets`.
**AWS CLI**
**Come descrivere le destinazioni del proxy database**
L’esempio `describe-db-proxy-targets` seguente restituisce informazioni sulle destinazioni del proxy database.
```
aws rds describe-db-proxy-targets \
--db-proxy-name proxyExample
```
Output:
```
{
"Targets": [
{
"Endpoint": "database1.ab0cd1efghij.us-east-1.rds.amazonaws.com",
"TrackedClusterId": "database1",
"RdsResourceId": "database1-instance-1",
"Port": 3306,
"Type": "RDS_INSTANCE",
"Role": "READ_WRITE",
"TargetHealth": {
"State": "UNAVAILABLE",
"Reason": "PENDING_PROXY_CAPACITY",
"Description": "DBProxy Target is waiting for proxy to scale to desired capacity"
}
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-setup.html#rds-proxy-viewing) nella *Guida per l’utente di Amazon RDS* e [Visualizzazione di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-setup.html#rds-proxy-viewing) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeDbProxyTargets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-proxy-targets.html)*Command Reference*.
### `describe-db-recommendations`
Il seguente esempio di codice mostra come utilizzare`describe-db-recommendations`.
**AWS CLI**
**Esempio 1: come elencare tutte le raccomandazioni database**
L'`describe-db-recommendations`esempio seguente elenca tutti i consigli DB presenti nel tuo AWS account.
```
aws rds describe-db-recommendations
```
Output:
```
{
"DBRecommendations": [
{
"RecommendationId": "12ab3cde-f456-7g8h-9012-i3j45678k9lm",
"TypeId": "config_recommendation::old_minor_version",
"Severity": "informational",
"ResourceArn": "arn:aws:rds:us-west-2:111122223333:db:database-1",
"Status": "active",
"CreatedTime": "2024-02-21T23:14:19.292000+00:00",
"UpdatedTime": "2024-02-21T23:14:19+00:00",
"Detection": "**[resource-name]** is not running the latest minor DB engine version",
"Recommendation": "Upgrade to latest engine version",
"Description": "Your database resources aren't running the latest minor DB engine version. The latest minor version contains the latest security fixes and other improvements.",
"RecommendedActions": [
{
"ActionId": "12ab34c5de6fg7h89i0jk1lm234n5678",
"Operation": "modifyDbInstance",
"Parameters": [
{
"Key": "EngineVersion",
"Value": "5.7.44"
},
{
"Key": "DBInstanceIdentifier",
"Value": "database-1"
}
],
"ApplyModes": [
"immediately",
"next-maintenance-window"
],
"Status": "ready",
"ContextAttributes": [
{
"Key": "Recommended value",
"Value": "5.7.44"
},
{
"Key": "Current engine version",
"Value": "5.7.42"
}
]
}
],
"Category": "security",
"Source": "RDS",
"TypeDetection": "**[resource-count] resources** are not running the latest minor DB engine version",
"TypeRecommendation": "Upgrade to latest engine version",
"Impact": "Reduced database performance and data security at risk",
"AdditionalInfo": "We recommend that you maintain your database with the latest DB engine minor version as this version includes the latest security and functionality fixes. The DB engine minor version upgrades contain only the changes which are backward-compatible with earlier minor versions of the same major version of the DB engine.",
"Links": [
{
"Text": "Upgrading an RDS DB instance engine version",
"Url": "https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_UpgradeDBInstance.Upgrading.html"
},
{
"Text": "Using Amazon RDS Blue/Green Deployments for database updates for Amazon Aurora",
"Url": "https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments.html"
},
{
"Text": "Using Amazon RDS Blue/Green Deployments for database updates for Amazon RDS",
"Url": "https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/blue-green-deployments.html"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione e risposta di suggerimenti Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/monitoring-recommendations.html) nella *Guida per l’utente di Amazon RDS* e [Visualizzazione e risposta a suggerimenti Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/monitoring-recommendations.html) nella *Guida per l’utente di Amazon Aurora*.
**Esempio 2: come elencare le raccomandazioni database di elevata gravità**
L'`describe-db-recommendations`esempio seguente elenca i consigli DB ad alta severità nel tuo AWS account.
```
aws rds describe-db-recommendations \
--filters Name=severity,Values=high
```
Output:
```
{
"DBRecommendations": [
{
"RecommendationId": "12ab3cde-f456-7g8h-9012-i3j45678k9lm",
"TypeId": "config_recommendation::rds_extended_support",
"Severity": "high",
"ResourceArn": "arn:aws:rds:us-west-2:111122223333:db:database-1",
"Status": "active",
"CreatedTime": "2024-02-21T23:14:19.392000+00:00",
"UpdatedTime": "2024-02-21T23:14:19+00:00",
"Detection": "Your databases will be auto-enrolled to RDS Extended Support on February 29",
"Recommendation": "Upgrade your major version before February 29, 2024 to avoid additional charges",
"Description": "Your PostgreSQL 11 and MySQL 5.7 databases will be automatically enrolled into RDS Extended Support on February 29, 2024. To avoid the increase in charges due to RDS Extended Support, we recommend upgrading your databases to a newer major engine version before February 29, 2024.\nTo learn more about the RDS Extended Support pricing, refer to the pricing page.",
"RecommendedActions": [
{
"ActionId": "12ab34c5de6fg7h89i0jk1lm234n5678",
"Parameters": [],
"ApplyModes": [
"manual"
],
"Status": "ready",
"ContextAttributes": []
}
],
"Category": "cost optimization",
"Source": "RDS",
"TypeDetection": "Your database will be auto-enrolled to RDS Extended Support on February 29",
"TypeRecommendation": "Upgrade your major version before February 29, 2024 to avoid additional charges",
"Impact": "Increase in charges due to RDS Extended Support",
"AdditionalInfo": "With Amazon RDS Extended Support, you can continue running your database on a major engine version past the RDS end of standard support date for an additional cost. This paid feature gives you more time to upgrade to a supported major engine version.\nDuring Extended Support, Amazon RDS will supply critical CVE patches and bug fixes.",
"Links": [
{
"Text": "Amazon RDS Extended Support pricing for RDS for MySQL",
"Url": "https://aws.amazon.com/rds/mysql/pricing/"
},
{
"Text": "Amazon RDS Extended Support for RDS for MySQL and PostgreSQL databases",
"Url": "https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/extended-support.html"
},
{
"Text": "Amazon RDS Extended Support pricing for Amazon Aurora PostgreSQL",
"Url": "https://aws.amazon.com/rds/aurora/pricing/"
},
{
"Text": "Amazon RDS Extended Support for Aurora PostgreSQL databases",
"Url": "https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/extended-support.html"
},
{
"Text": "Amazon RDS Extended Support pricing for RDS for PostgreSQL",
"Url": "https://aws.amazon.com/rds/postgresql/pricing/"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione e risposta di suggerimenti Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/monitoring-recommendations.html) nella *Guida per l’utente di Amazon RDS* e [Visualizzazione e risposta a suggerimenti Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/monitoring-recommendations.html) nella *Guida per l’utente di Amazon Aurora*.
**Esempio 3: come elencare le raccomandazioni database per un’istanza database specificata**
L’esempio `describe-db-recommendations` seguente elenca tutti le raccomandazioni database per un’istanza database specificata.
```
aws rds describe-db-recommendations \
--filters Name=dbi-resource-id,Values=database-1
```
Output:
```
{
"DBRecommendations": [
{
"RecommendationId": "12ab3cde-f456-7g8h-9012-i3j45678k9lm",
"TypeId": "config_recommendation::old_minor_version",
"Severity": "informational",
"ResourceArn": "arn:aws:rds:us-west-2:111122223333:db:database-1",
"Status": "active",
"CreatedTime": "2024-02-21T23:14:19.292000+00:00",
"UpdatedTime": "2024-02-21T23:14:19+00:00",
"Detection": "**[resource-name]** is not running the latest minor DB engine version",
"Recommendation": "Upgrade to latest engine version",
"Description": "Your database resources aren't running the latest minor DB engine version. The latest minor version contains the latest security fixes and other improvements.",
"RecommendedActions": [
{
"ActionId": "12ab34c5de6fg7h89i0jk1lm234n5678",
"Operation": "modifyDbInstance",
"Parameters": [
{
"Key": "EngineVersion",
"Value": "5.7.44"
},
{
"Key": "DBInstanceIdentifier",
"Value": "database-1"
}
],
"ApplyModes": [
"immediately",
"next-maintenance-window"
],
"Status": "ready",
"ContextAttributes": [
{
"Key": "Recommended value",
"Value": "5.7.44"
},
{
"Key": "Current engine version",
"Value": "5.7.42"
}
]
}
],
"Category": "security",
"Source": "RDS",
"TypeDetection": "**[resource-count] resources** are not running the latest minor DB engine version",
"TypeRecommendation": "Upgrade to latest engine version",
"Impact": "Reduced database performance and data security at risk",
"AdditionalInfo": "We recommend that you maintain your database with the latest DB engine minor version as this version includes the latest security and functionality fixes. The DB engine minor version upgrades contain only the changes which are backward-compatible with earlier minor versions of the same major version of the DB engine.",
"Links": [
{
"Text": "Upgrading an RDS DB instance engine version",
"Url": "https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_UpgradeDBInstance.Upgrading.html"
},
{
"Text": "Using Amazon RDS Blue/Green Deployments for database updates for Amazon Aurora",
"Url": "https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments.html"
},
{
"Text": "Using Amazon RDS Blue/Green Deployments for database updates for Amazon RDS",
"Url": "https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/blue-green-deployments.html"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione e risposta di suggerimenti Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/monitoring-recommendations.html) nella *Guida per l’utente di Amazon RDS* e [Visualizzazione e risposta a suggerimenti Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/monitoring-recommendations.html) nella *Guida per l’utente di Amazon Aurora*.
**Esempio 4: come elencare tutti le raccomandazioni database attive**
L'`describe-db-recommendations`esempio seguente elenca tutti i consigli DB attivi nel tuo AWS account.
```
aws rds describe-db-recommendations \
--filters Name=status,Values=active
```
Output:
```
{
"DBRecommendations": [
{
"RecommendationId": "12ab3cde-f456-7g8h-9012-i3j45678k9lm",
"TypeId": "config_recommendation::old_minor_version",
"Severity": "informational",
"ResourceArn": "arn:aws:rds:us-west-2:111122223333:db:database-1",
"Status": "active",
"CreatedTime": "2024-02-21T23:14:19.292000+00:00",
"UpdatedTime": "2024-02-21T23:14:19+00:00",
"Detection": "**[resource-name]** is not running the latest minor DB engine version",
"Recommendation": "Upgrade to latest engine version",
"Description": "Your database resources aren't running the latest minor DB engine version. The latest minor version contains the latest security fixes and other improvements.",
"RecommendedActions": [
{
"ActionId": "12ab34c5de6fg7h89i0jk1lm234n5678",
"Operation": "modifyDbInstance",
"Parameters": [
{
"Key": "EngineVersion",
"Value": "5.7.44"
},
{
"Key": "DBInstanceIdentifier",
"Value": "database-1"
}
],
"ApplyModes": [
"immediately",
"next-maintenance-window"
],
"Status": "ready",
"ContextAttributes": [
{
"Key": "Recommended value",
"Value": "5.7.44"
},
{
"Key": "Current engine version",
"Value": "5.7.42"
}
]
}
],
"Category": "security",
"Source": "RDS",
"TypeDetection": "**[resource-count] resources** are not running the latest minor DB engine version",
"TypeRecommendation": "Upgrade to latest engine version",
"Impact": "Reduced database performance and data security at risk",
"AdditionalInfo": "We recommend that you maintain your database with the latest DB engine minor version as this version includes the latest security and functionality fixes. The DB engine minor version upgrades contain only the changes which are backward-compatible with earlier minor versions of the same major version of the DB engine.",
"Links": [
{
"Text": "Upgrading an RDS DB instance engine version",
"Url": "https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_UpgradeDBInstance.Upgrading.html"
},
{
"Text": "Using Amazon RDS Blue/Green Deployments for database updates for Amazon Aurora",
"Url": "https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments.html"
},
{
"Text": "Using Amazon RDS Blue/Green Deployments for database updates for Amazon RDS",
"Url": "https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/blue-green-deployments.html"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Visualizzazione e risposta di suggerimenti Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/monitoring-recommendations.html) nella *Guida per l’utente di Amazon RDS* e [Visualizzazione e risposta a suggerimenti Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/monitoring-recommendations.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeDbRecommendations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-recommendations.html)*Command Reference*.
### `describe-db-security-groups`
Il seguente esempio di codice mostra come utilizzare`describe-db-security-groups`.
**AWS CLI**
**Come elencare i gruppi di sicurezza del database**
L’esempio `describe-db-security-groups` seguente elenca i gruppi di sicurezza database.
```
aws rds describe-db-security-groups
```
Output:
```
{
"DBSecurityGroups": [
{
"OwnerId": "123456789012",
"DBSecurityGroupName": "default",
"DBSecurityGroupDescription": "default",
"EC2SecurityGroups": [],
"IPRanges": [],
"DBSecurityGroupArn": "arn:aws:rds:us-west-1:111122223333:secgrp:default"
},
{
"OwnerId": "123456789012",
"DBSecurityGroupName": "mysecgroup",
"DBSecurityGroupDescription": "My Test Security Group",
"VpcId": "vpc-1234567f",
"EC2SecurityGroups": [],
"IPRanges": [],
"DBSecurityGroupArn": "arn:aws:rds:us-west-1:111122223333:secgrp:mysecgroup"
}
]
}
```
Per ulteriori informazioni, consulta [Elenco dei gruppi di sicurezza database disponibili](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithSecurityGroups.html#USER_WorkingWithSecurityGroups.Listing) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DescribeDbSecurityGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-security-groups.html)*Command Reference*.
### `describe-db-shard-groups`
Il seguente esempio di codice mostra come utilizzare`describe-db-shard-groups`.
**AWS CLI**
**Esempio 1: come descrivere i gruppi di shard del database**
L’esempio `describe-db-shard-groups` seguente recupera i dettagli dei gruppi di shard database.
```
aws rds describe-db-shard-groups
```
Output:
```
{
"DBShardGroups": [
{
"DBShardGroupResourceId": "shardgroup-7bb446329da94788b3f957746example",
"DBShardGroupIdentifier": "limitless-test-shard-grp",
"DBClusterIdentifier": "limitless-test-cluster",
"MaxACU": 768.0,
"ComputeRedundancy": 0,
"Status": "available",
"PubliclyAccessible": true,
"Endpoint": "limitless-test-cluster.limitless-cekycexample.us-east-2.rds.amazonaws.com"
},
{
"DBShardGroupResourceId": "shardgroup-a6e3a0226aa243e2ac6c7a1234567890",
"DBShardGroupIdentifier": "my-db-shard-group",
"DBClusterIdentifier": "my-sv2-cluster",
"MaxACU": 768.0,
"ComputeRedundancy": 0,
"Status": "available",
"PubliclyAccessible": false,
"Endpoint": "my-sv2-cluster.limitless-cekycexample.us-east-2.rds.amazonaws.com"
}
]
}
```
Per ulteriori informazioni, consulta [Cluster database Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Overview.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeDbShardGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-shard-groups.html)*Command Reference*.
### `describe-db-snapshot-attributes`
Il seguente esempio di codice mostra come utilizzare`describe-db-snapshot-attributes`.
**AWS CLI**
**Come descrivere i nomi e i valori degli attributi per uno snapshot database**
L’esempio `describe-db-snapshot-attributes` seguente descrive i nomi e i valori degli attributi per uno snapshot database.
```
aws rds describe-db-snapshot-attributes \
--db-snapshot-identifier mydbsnapshot
```
Output:
```
{
"DBSnapshotAttributesResult": {
"DBSnapshotIdentifier": "mydbsnapshot",
"DBSnapshotAttributes": [
{
"AttributeName": "restore",
"AttributeValues": [
"123456789012",
"210987654321"
]
}
]
}
}
```
Per ulteriori informazioni, consulta [Condivisione di uno snapshot di database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ShareSnapshot.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DescribeDbSnapshotAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-snapshot-attributes.html)*Command Reference*.
### `describe-db-snapshots`
Il seguente esempio di codice mostra come utilizzare`describe-db-snapshots`.
**AWS CLI**
**Esempio 1: come descrivere uno snapshot di database per un’istanza database**
L’esempio `describe-db-snapshots` seguente recupera i dettagli di uno snapshot database per un’istanza database.
```
aws rds describe-db-snapshots \
--db-snapshot-identifier mydbsnapshot
```
Output:
```
{
"DBSnapshots": [
{
"DBSnapshotIdentifier": "mydbsnapshot",
"DBInstanceIdentifier": "mysqldb",
"SnapshotCreateTime": "2018-02-08T22:28:08.598Z",
"Engine": "mysql",
"AllocatedStorage": 20,
"Status": "available",
"Port": 3306,
"AvailabilityZone": "us-east-1f",
"VpcId": "vpc-6594f31c",
"InstanceCreateTime": "2018-02-08T22:24:55.973Z",
"MasterUsername": "mysqladmin",
"EngineVersion": "5.6.37",
"LicenseModel": "general-public-license",
"SnapshotType": "manual",
"OptionGroupName": "default:mysql-5-6",
"PercentProgress": 100,
"StorageType": "gp2",
"Encrypted": false,
"DBSnapshotArn": "arn:aws:rds:us-east-1:123456789012:snapshot:mydbsnapshot",
"IAMDatabaseAuthenticationEnabled": false,
"ProcessorFeatures": [],
"DbiResourceId": "db-AKIAIOSFODNN7EXAMPLE"
}
]
}
```
Per ulteriori informazioni, consulta [Creazione di uno snapshot di database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) nella *Guida per l’utente di Amazon RDS*.
**Esempio 2: come trovare il numero di snapshot manuali effettuati**
L'`describe-db-snapshots`esempio seguente utilizza l'`length`operatore nell'`--query`opzione per restituire il numero di istantanee manuali che sono state scattate in una particolare AWS regione.
```
aws rds describe-db-snapshots \
--snapshot-type manual \
--query "length(*[].{DBSnapshots:SnapshotType})" \
--region eu-central-1
```
Output:
```
35
```
Per ulteriori informazioni, consulta [Creazione di uno snapshot di database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [Descrivi DBSnapshots](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-snapshots.html) in *AWS CLI Command Reference.*
### `describe-db-subnet-groups`
Il seguente esempio di codice mostra come utilizzare`describe-db-subnet-groups`.
**AWS CLI**
**Come descrivere un gruppo di sottoreti database**
L’esempio `describe-db-subnet-groups` seguente recupera i dettagli del gruppo di sottoreti database specificato.
```
aws rds describe-db-subnet-groups
```
Output:
```
{
"DBSubnetGroups": [
{
"DBSubnetGroupName": "mydbsubnetgroup",
"DBSubnetGroupDescription": "My DB Subnet Group",
"VpcId": "vpc-971c12ee",
"SubnetGroupStatus": "Complete",
"Subnets": [
{
"SubnetIdentifier": "subnet-d8c8e7f4",
"SubnetAvailabilityZone": {
"Name": "us-east-1a"
},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-718fdc7d",
"SubnetAvailabilityZone": {
"Name": "us-east-1f"
},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-cbc8e7e7",
"SubnetAvailabilityZone": {
"Name": "us-east-1a"
},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-0ccde220",
"SubnetAvailabilityZone": {
"Name": "us-east-1a"
},
"SubnetStatus": "Active"
}
],
"DBSubnetGroupArn": "arn:aws:rds:us-east-1:123456789012:subgrp:mydbsubnetgroup"
}
]
}
```
Per ulteriori informazioni, consulta [Amazon Virtual Private Cloud VPCs e Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_VPC.html) nella *Amazon RDS User* Guide.
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeDbSubnetGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-subnet-groups.html)Reference*.
### `describe-engine-default-cluster-parameters`
Il seguente esempio di codice mostra come utilizzare`describe-engine-default-cluster-parameters`.
**AWS CLI**
**Come descrivere il motore predefinito e le informazioni del parametro di sistema per il motore di database Aurora**
L’esempio `describe-engine-default-cluster-parameters` seguente recupera i dettagli del motore predefinito e delle informazioni sui parametri di sistema per i cluster Aurora DB con compatibilità MySQL 5.7.
```
aws rds describe-engine-default-cluster-parameters \
--db-parameter-group-family aurora-mysql5.7
```
Output:
```
{
"EngineDefaults": {
"Parameters": [
{
"ParameterName": "aurora_load_from_s3_role",
"Description": "IAM role ARN used to load data from AWS S3",
"Source": "engine-default",
"ApplyType": "dynamic",
"DataType": "string",
"IsModifiable": true,
"SupportedEngineModes": [
"provisioned"
]
},
...some output truncated...
]
}
}
```
Per ulteriori informazioni, consulta [Uso di gruppi di parametri database e gruppi di parametri cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [DescribeEngineDefaultClusterParameters AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-engine-default-cluster-parameters.html)*Command Reference*.
### `describe-engine-default-parameters`
Il seguente esempio di codice mostra come utilizzare`describe-engine-default-parameters`.
**AWS CLI**
**Come descrivere il motore predefinito e le informazioni sui parametri di sistema per il motore di database**
L’esempio `describe-engine-default-parameters` seguente recupera i dettagli del motore predefinito e delle informazioni sui parametri di sistema per le istanze database MySQL 5.7.
```
aws rds describe-engine-default-parameters \
--db-parameter-group-family mysql5.7
```
Output:
```
{
"EngineDefaults": {
"Parameters": [
{
"ParameterName": "allow-suspicious-udfs",
"Description": "Controls whether user-defined functions that have only an xxx symbol for the main function can be loaded",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": false
},
...some output truncated...
]
}
}
```
Per ulteriori informazioni, consulta [Utilizzo di gruppi di parametri di database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DescribeEngineDefaultParameters AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-engine-default-parameters.html)*Command Reference*.
### `describe-event-categories`
Il seguente esempio di codice mostra come utilizzare`describe-event-categories`.
**AWS CLI**
**Come descrivere le categorie di eventi**
L’esempio `describe-event-categories` seguente recupera i dettagli sulle categorie di eventi per tutte le origini di eventi disponibili.
```
aws rds describe-event-categories
```
Output:
```
{
"EventCategoriesMapList": [
{
"SourceType": "db-instance",
"EventCategories": [
"deletion",
"read replica",
"failover",
"restoration",
"maintenance",
"low storage",
"configuration change",
"backup",
"creation",
"availability",
"recovery",
"failure",
"backtrack",
"notification"
]
},
{
"SourceType": "db-security-group",
"EventCategories": [
"configuration change",
"failure"
]
},
{
"SourceType": "db-parameter-group",
"EventCategories": [
"configuration change"
]
},
{
"SourceType": "db-snapshot",
"EventCategories": [
"deletion",
"creation",
"restoration",
"notification"
]
},
{
"SourceType": "db-cluster",
"EventCategories": [
"failover",
"failure",
"notification"
]
},
{
"SourceType": "db-cluster-snapshot",
"EventCategories": [
"backup"
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeEventCategories AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-event-categories.html)*Command Reference*.
### `describe-event-subscriptions`
Il seguente esempio di codice mostra come utilizzare`describe-event-subscriptions`.
**AWS CLI**
**Come descrivere le sottoscrizioni a eventi**
Questo esempio descrive tutti gli abbonamenti agli eventi Amazon RDS per l'account corrente AWS .
```
aws rds describe-event-subscriptions
```
Output:
```
{
"EventSubscriptionsList": [
{
"EventCategoriesList": [
"backup",
"recovery"
],
"Enabled": true,
"EventSubscriptionArn": "arn:aws:rds:us-east-1:123456789012:es:my-instance-events",
"Status": "creating",
"SourceType": "db-instance",
"CustomerAwsId": "123456789012",
"SubscriptionCreationTime": "2018-07-31 23:22:01.893",
"CustSubscriptionId": "my-instance-events",
"SnsTopicArn": "arn:aws:sns:us-east-1:123456789012:interesting-events"
},
...some output truncated...
]
}
```
+ Per i dettagli sulle API, consulta *AWS CLI Command [DescribeEventSubscriptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-event-subscriptions.html)Reference*.
### `describe-events`
Il seguente esempio di codice mostra come utilizzare`describe-events`.
**AWS CLI**
**Come descrivere gli eventi**
L’esempio `describe-events` seguente recupera i dettagli per gli eventi che si sono verificati per l’istanza database specificata.
```
aws rds describe-events \
--source-identifier test-instance \
--source-type db-instance
```
Output:
```
{
"Events": [
{
"SourceType": "db-instance",
"SourceIdentifier": "test-instance",
"EventCategories": [
"backup"
],
"Message": "Backing up DB instance",
"Date": "2018-07-31T23:09:23.983Z",
"SourceArn": "arn:aws:rds:us-east-1:123456789012:db:test-instance"
},
{
"SourceType": "db-instance",
"SourceIdentifier": "test-instance",
"EventCategories": [
"backup"
],
"Message": "Finished DB Instance backup",
"Date": "2018-07-31T23:15:13.049Z",
"SourceArn": "arn:aws:rds:us-east-1:123456789012:db:test-instance"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeEvents AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-events.html)*Command Reference*.
### `describe-export-tasks`
Il seguente esempio di codice mostra come utilizzare`describe-export-tasks`.
**AWS CLI**
**Come descrivere le attività di esportazione degli snapshot**
L’esempio `describe-export-tasks` seguente restituisce informazioni sulle esportazioni di snapshot in Amazon S3.
```
aws rds describe-export-tasks
```
Output:
```
{
"ExportTasks": [
{
"ExportTaskIdentifier": "test-snapshot-export",
"SourceArn": "arn:aws:rds:us-west-2:123456789012:snapshot:test-snapshot",
"SnapshotTime": "2020-03-02T18:26:28.163Z",
"TaskStartTime": "2020-03-02T18:57:56.896Z",
"TaskEndTime": "2020-03-02T19:10:31.985Z",
"S3Bucket": "amzn-s3-demo-bucket",
"S3Prefix": "",
"IamRoleArn": "arn:aws:iam::123456789012:role/service-role/ExportRole",
"KmsKeyId": "arn:aws:kms:us-west-2:123456789012:key/abcd0000-7fca-4128-82f2-aabbccddeeff",
"Status": "COMPLETE",
"PercentProgress": 100,
"TotalExtractedDataInGB": 0
},
{
"ExportTaskIdentifier": "my-s3-export",
"SourceArn": "arn:aws:rds:us-west-2:123456789012:snapshot:db5-snapshot-test",
"SnapshotTime": "2020-03-27T20:48:42.023Z",
"S3Bucket": "amzn-s3-demo-bucket",
"S3Prefix": "",
"IamRoleArn": "arn:aws:iam::123456789012:role/service-role/ExportRole",
"KmsKeyId": "arn:aws:kms:us-west-2:123456789012:key/abcd0000-7fca-4128-82f2-aabbccddeeff",
"Status": "STARTING",
"PercentProgress": 0,
"TotalExtractedDataInGB": 0
}
]
}
```
Per ulteriori informazioni, consulta [Monitoraggio delle esportazioni di snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ExportSnapshot.html#USER_ExportSnapshot.Monitoring) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DescribeExportTasks AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-export-tasks.html)*Command Reference*.
### `describe-global-clusters`
Il seguente esempio di codice mostra come utilizzare`describe-global-clusters`.
**AWS CLI**
**Come descrivere i cluster di database globali**
L'`describe-global-clusters`esempio seguente elenca i cluster DB globali Aurora nella regione corrente. AWS
```
aws rds describe-global-clusters
```
Output:
```
{
"GlobalClusters": [
{
"GlobalClusterIdentifier": "myglobalcluster",
"GlobalClusterResourceId": "cluster-f5982077e3b5aabb",
"GlobalClusterArn": "arn:aws:rds::123456789012:global-cluster:myglobalcluster",
"Status": "available",
"Engine": "aurora-mysql",
"EngineVersion": "5.7.mysql_aurora.2.07.2",
"StorageEncrypted": false,
"DeletionProtection": false,
"GlobalClusterMembers": []
}
]
}
```
Per ulteriori informazioni, consulta [Utilizzo dei database globali Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-managing.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeGlobalClusters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-global-clusters.html)Reference*.
### `describe-option-group-options`
Il seguente esempio di codice mostra come utilizzare`describe-option-group-options`.
**AWS CLI**
**Come descrivere tutte le opzioni disponibili**
L’esempio `describe-option-group-options` seguente elenca due opzioni per un’istanza di Oracle Database 19c.
```
aws rds describe-option-group-options \
--engine-name oracle-ee \
--major-engine-version 19 \
--max-items 2
```
Output:
```
{
"OptionGroupOptions": [
{
"Name": "APEX",
"Description": "Oracle Application Express Runtime Environment",
"EngineName": "oracle-ee",
"MajorEngineVersion": "19",
"MinimumRequiredMinorEngineVersion": "0.0.0.ru-2019-07.rur-2019-07.r1",
"PortRequired": false,
"OptionsDependedOn": [],
"OptionsConflictsWith": [],
"Persistent": false,
"Permanent": false,
"RequiresAutoMinorEngineVersionUpgrade": false,
"VpcOnly": false,
"SupportsOptionVersionDowngrade": false,
"OptionGroupOptionSettings": [],
"OptionGroupOptionVersions": [
{
"Version": "19.1.v1",
"IsDefault": true
},
{
"Version": "19.2.v1",
"IsDefault": false
}
]
},
{
"Name": "APEX-DEV",
"Description": "Oracle Application Express Development Environment",
"EngineName": "oracle-ee",
"MajorEngineVersion": "19",
"MinimumRequiredMinorEngineVersion": "0.0.0.ru-2019-07.rur-2019-07.r1",
"PortRequired": false,
"OptionsDependedOn": [
"APEX"
],
"OptionsConflictsWith": [],
"Persistent": false,
"Permanent": false,
"RequiresAutoMinorEngineVersionUpgrade": false,
"VpcOnly": false,
"OptionGroupOptionSettings": []
}
],
"NextToken": "eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAyfQ=="
}
```
Per ulteriori informazioni, consulta [Generazione di un elenco delle opzioni e delle impostazioni delle opzioni per un gruppo di opzioni](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithOptionGroups.html#USER_WorkingWithOptionGroups.ListOption) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DescribeOptionGroupOptions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-option-group-options.html)*Command Reference*.
### `describe-option-groups`
Il seguente esempio di codice mostra come utilizzare`describe-option-groups`.
**AWS CLI**
**Come descrivere i gruppi di opzioni disponibili**
L’esempio `describe-option-groups` seguente elenca i gruppi di opzioni per un’istanza di Oracle Database 19c.
```
aws rds describe-option-groups \
--engine-name oracle-ee \
--major-engine-version 19
```
Output:
```
{
"OptionGroupsList": [
{
"OptionGroupName": "default:oracle-ee-19",
"OptionGroupDescription": "Default option group for oracle-ee 19",
"EngineName": "oracle-ee",
"MajorEngineVersion": "19",
"Options": [],
"AllowsVpcAndNonVpcInstanceMemberships": true,
"OptionGroupArn": "arn:aws:rds:us-west-1:111122223333:og:default:oracle-ee-19"
}
]
}
```
Per ulteriori informazioni, consulta [Generazione di un elenco delle opzioni e delle impostazioni delle opzioni per un gruppo di opzioni](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithOptionGroups.html#USER_WorkingWithOptionGroups.ListOption) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DescribeOptionGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-option-groups.html)*Command Reference*.
### `describe-orderable-db-instance-options`
Il seguente esempio di codice mostra come utilizzare`describe-orderable-db-instance-options`.
**AWS CLI**
**Come descrivere le opzioni ordinabili delle istanze database**
L’esempio `describe-orderable-db-instance-options` seguente recupera i dettagli delle opzioni ordinabili per le istanze database che eseguono il motore di database MySQL.
```
aws rds describe-orderable-db-instance-options \
--engine mysql
```
Output:
```
{
"OrderableDBInstanceOptions": [
{
"MinStorageSize": 5,
"ReadReplicaCapable": true,
"MaxStorageSize": 6144,
"AvailabilityZones": [
{
"Name": "us-east-1a"
},
{
"Name": "us-east-1b"
},
{
"Name": "us-east-1c"
},
{
"Name": "us-east-1d"
}
],
"SupportsIops": false,
"AvailableProcessorFeatures": [],
"MultiAZCapable": true,
"DBInstanceClass": "db.m1.large",
"Vpc": true,
"StorageType": "gp2",
"LicenseModel": "general-public-license",
"EngineVersion": "5.5.46",
"SupportsStorageEncryption": false,
"SupportsEnhancedMonitoring": true,
"Engine": "mysql",
"SupportsIAMDatabaseAuthentication": false,
"SupportsPerformanceInsights": false
}
]
...some output truncated...
}
```
+ Per i dettagli sull'API, consulta [DescribeOrderableDBInstanceOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-orderable-db-instance-options.html) in *AWS CLI Command Reference*.
### `describe-pending-maintenance-actions`
Il seguente esempio di codice mostra come utilizzare`describe-pending-maintenance-actions`.
**AWS CLI**
**Come elencare le risorse con almeno un’azione di manutenzione in sospeso**
L'`describe-pending-maintenance-actions`esempio seguente elenca l'azione di manutenzione in sospeso per un'istanza DB.
```
aws rds describe-pending-maintenance-actions
```
Output:
```
{
"PendingMaintenanceActions": [
{
"ResourceIdentifier": "arn:aws:rds:us-west-2:123456789012:cluster:global-db1-cl1",
"PendingMaintenanceActionDetails": [
{
"Action": "system-update",
"Description": "Upgrade to Aurora PostgreSQL 2.4.2"
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Manutenzione di un’istanza database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_UpgradeDBInstance.Maintenance.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [DescribePendingMaintenanceActions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-pending-maintenance-actions.html)*Command Reference.*
### `describe-reserved-db-instances-offerings`
Il seguente esempio di codice mostra come utilizzare`describe-reserved-db-instances-offerings`.
**AWS CLI**
**Come descrivere le offerte di istanze database riservate**
L’esempio `describe-reserved-db-instances-offerings` seguente recupera i dettagli sulle opzioni di istanze database riservate per `oracle`.
```
aws rds describe-reserved-db-instances-offerings \
--product-description oracle
```
Output:
```
{
"ReservedDBInstancesOfferings": [
{
"CurrencyCode": "USD",
"UsagePrice": 0.0,
"ProductDescription": "oracle-se2(li)",
"ReservedDBInstancesOfferingId": "005bdee3-9ef4-4182-aa0c-58ef7cb6c2f8",
"MultiAZ": true,
"DBInstanceClass": "db.m4.xlarge",
"OfferingType": "Partial Upfront",
"RecurringCharges": [
{
"RecurringChargeAmount": 0.594,
"RecurringChargeFrequency": "Hourly"
}
],
"FixedPrice": 4089.0,
"Duration": 31536000
},
...some output truncated...
}
```
+ Per i dettagli sull'API, consulta [DescribeReservedDbInstancesOfferings AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-reserved-db-instances-offerings.html)*Command Reference*.
### `describe-reserved-db-instances`
Il seguente esempio di codice mostra come utilizzare`describe-reserved-db-instances`.
**AWS CLI**
**Come descrivere le istanze database riservate**
L'`describe-reserved-db-instances`esempio seguente recupera i dettagli su tutte le istanze DB riservate nell'account corrente AWS .
```
aws rds describe-reserved-db-instances
```
Output:
```
{
"ReservedDBInstances": [
{
"ReservedDBInstanceId": "myreservedinstance",
"ReservedDBInstancesOfferingId": "12ab34cd-59af-4b2c-a660-1abcdef23456",
"DBInstanceClass": "db.t3.micro",
"StartTime": "2020-06-01T13:44:21.436Z",
"Duration": 31536000,
"FixedPrice": 0.0,
"UsagePrice": 0.0,
"CurrencyCode": "USD",
"DBInstanceCount": 1,
"ProductDescription": "sqlserver-ex(li)",
"OfferingType": "No Upfront",
"MultiAZ": false,
"State": "payment-pending",
"RecurringCharges": [
{
"RecurringChargeAmount": 0.014,
"RecurringChargeFrequency": "Hourly"
}
],
"ReservedDBInstanceArn": "arn:aws:rds:us-west-2:123456789012:ri:myreservedinstance",
"LeaseId": "a1b2c3d4-6b69-4a59-be89-5e11aa446666"
}
]
}
```
Per ulteriori informazioni, consulta [Istanze database riservate per Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithReservedDBInstances.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeReservedDbInstances](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-reserved-db-instances.html)Reference*.
### `describe-source-regions`
Il seguente esempio di codice mostra come utilizzare`describe-source-regions`.
**AWS CLI**
**Come descrivere le Regioni di origine**
L'`describe-source-regions`esempio seguente recupera i dettagli su tutte le AWS regioni di origine. Mostra inoltre che i backup automatici possono essere replicati solo dagli Stati Uniti occidentali (Oregon) alla AWS regione di destinazione, Stati Uniti orientali (Virginia settentrionale).
```
aws rds describe-source-regions \
--region us-east-1
```
Output:
```
{
"SourceRegions": [
{
"RegionName": "af-south-1",
"Endpoint": "https://rds.af-south-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": false
},
{
"RegionName": "ap-east-1",
"Endpoint": "https://rds.ap-east-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": false
},
{
"RegionName": "ap-northeast-1",
"Endpoint": "https://rds.ap-northeast-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "ap-northeast-2",
"Endpoint": "https://rds.ap-northeast-2.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "ap-northeast-3",
"Endpoint": "https://rds.ap-northeast-3.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": false
},
{
"RegionName": "ap-south-1",
"Endpoint": "https://rds.ap-south-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "ap-southeast-1",
"Endpoint": "https://rds.ap-southeast-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "ap-southeast-2",
"Endpoint": "https://rds.ap-southeast-2.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "ap-southeast-3",
"Endpoint": "https://rds.ap-southeast-3.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": false
},
{
"RegionName": "ca-central-1",
"Endpoint": "https://rds.ca-central-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "eu-north-1",
"Endpoint": "https://rds.eu-north-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "eu-south-1",
"Endpoint": "https://rds.eu-south-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": false
},
{
"RegionName": "eu-west-1",
"Endpoint": "https://rds.eu-west-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "eu-west-2",
"Endpoint": "https://rds.eu-west-2.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "eu-west-3",
"Endpoint": "https://rds.eu-west-3.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "me-central-1",
"Endpoint": "https://rds.me-central-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": false
},
{
"RegionName": "me-south-1",
"Endpoint": "https://rds.me-south-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": false
},
{
"RegionName": "sa-east-1",
"Endpoint": "https://rds.sa-east-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "us-east-2",
"Endpoint": "https://rds.us-east-2.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "us-west-1",
"Endpoint": "https://rds.us-west-1.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
},
{
"RegionName": "us-west-2",
"Endpoint": "https://rds.us-west-2.amazonaws.com",
"Status": "available",
"SupportsDBInstanceAutomatedBackupsReplication": true
}
]
}
```
Per ulteriori informazioni, consulta [Ricerca di informazioni sui backup replicati](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReplicateBackups.html#AutomatedBackups.Replicating.Describe) nella *Guida per l’utente di Amazon RDS*.
+ *Per i dettagli sull'API, consulta [DescribeSourceRegions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-source-regions.html)Command Reference.AWS CLI *
### `describe-valid-db-instance-modifications`
Il seguente esempio di codice mostra come utilizzare`describe-valid-db-instance-modifications`.
**AWS CLI**
**Come descrivere le modifiche valide per un’istanza database**
L’esempio `describe-valid-db-instance-modifications` seguente recupera i dettagli delle modifiche valide per l’istanza database specificata.
```
aws rds describe-valid-db-instance-modifications \
--db-instance-identifier test-instance
```
Output:
```
{
"ValidDBInstanceModificationsMessage": {
"ValidProcessorFeatures": [],
"Storage": [
{
"StorageSize": [
{
"Step": 1,
"To": 20,
"From": 20
},
{
"Step": 1,
"To": 6144,
"From": 22
}
],
"ProvisionedIops": [
{
"Step": 1,
"To": 0,
"From": 0
}
],
"IopsToStorageRatio": [
{
"To": 0.0,
"From": 0.0
}
],
"StorageType": "gp2"
},
{
"StorageSize": [
{
"Step": 1,
"To": 6144,
"From": 100
}
],
"ProvisionedIops": [
{
"Step": 1,
"To": 40000,
"From": 1000
}
],
"IopsToStorageRatio": [
{
"To": 50.0,
"From": 1.0
}
],
"StorageType": "io1"
},
{
"StorageSize": [
{
"Step": 1,
"To": 20,
"From": 20
},
{
"Step": 1,
"To": 3072,
"From": 22
}
],
"ProvisionedIops": [
{
"Step": 1,
"To": 0,
"From": 0
}
],
"IopsToStorageRatio": [
{
"To": 0.0,
"From": 0.0
}
],
"StorageType": "magnetic"
}
]
}
}
```
+ Per i dettagli sull'API, consulta [DescribeValidDbInstanceModifications AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-valid-db-instance-modifications.html)*Command Reference*.
### `download-db-log-file-portion`
Il seguente esempio di codice mostra come utilizzare`download-db-log-file-portion`.
**AWS CLI**
**Esempio 1: come scaricare la parte più recente di un file di log database**
L’esempio `download-db-log-file-portion` seguente scarica solo la parte più recente del file di log e la salva in un file locale denominato `tail.txt`.
```
aws rds download-db-log-file-portion \
--db-instance-identifier test-instance \
--log-file-name log.txt \
--output text > tail.txt
```
Il file salvato potrebbe contenere righe vuote. Appaiono alla fine di ogni parte del file di log durante il download.
**Esempio 2: come scaricare un intero file di log database**
L’esempio `download-db-log-file-portion` seguente scarica l’intero file di log utilizzando il parametro `--starting-token 0` e salva l’output in un file locale denominato `full.txt`.
```
aws rds download-db-log-file-portion \
--db-instance-identifier test-instance \
--log-file-name log.txt \
--starting-token 0 \
--output text > full.txt
```
Il file salvato potrebbe contenere righe vuote. Appaiono alla fine di ogni parte del file di log durante il download.
+ Per i dettagli sull'API, consulta [DownloadDbLogFilePortion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/download-db-log-file-portion.html)*Command Reference*.
### `generate-auth-token`
Il seguente esempio di codice mostra come utilizzare`generate-auth-token`.
**AWS CLI**
**Come generare un token di autenticazione**
L’esempio `generate-db-auth-token` seguente genera un token di autenticazione da utilizzare con l’autenticazione del database IAM.
```
aws rds generate-db-auth-token \
--hostname aurmysql-test.cdgmuqiadpid.us-west-2.rds.amazonaws.com \
--port 3306 \
--region us-east-1 \
--username jane_doe
```
Output:
```
aurmysql-test.cdgmuqiadpid.us-west-2.rds.amazonaws.com:3306/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIESZCNJ3OEXAMPLE%2F20180731%2Fus-east-1%2Frds-db%2Faws4_request&X-Amz-Date=20180731T235209Z&X-Amz-Expires=900&X-Amz-SignedHeaders=host&X-Amz-Signature=5a8753ebEXAMPLEa2c724e5667797EXAMPLE9d6ec6e3f427191fa41aeEXAMPLE
```
+ Per i dettagli sull'API, consulta [GenerateAuthToken AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/generate-auth-token.html)*Command Reference*.
### `generate-db-auth-token`
Il seguente esempio di codice mostra come utilizzare`generate-db-auth-token`.
**AWS CLI**
**Come generare un token di autenticazione IAM**
L’esempio `generate-db-auth-token` seguente genera un token di autenticazione IAM per connettersi a un database.
```
aws rds generate-db-auth-token \
--hostname mydb.123456789012.us-east-1.rds.amazonaws.com \
--port 3306 \
--region us-east-1 \
--username db_user
```
Output:
```
mydb.123456789012.us-east-1.rds.amazonaws.com:3306/?Action=connect&DBUser=db_user&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIEXAMPLE%2Fus-east-1%2Frds-db%2Faws4_request&X-Amz-Date=20210123T011543Z&X-Amz-Expires=900&X-Amz-SignedHeaders=host&X-Amz-Signature=88987EXAMPLE1EXAMPLE2EXAMPLE3EXAMPLE4EXAMPLE5EXAMPLE6
```
Per ulteriori informazioni, consulta [Connessione all’istanza database utilizzando l’autenticazione IAM](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.Connecting.html) nella *Guida per l’utente di Amazon RDS* e [Connessione al cluster di database utilizzando l’autenticazione IAM](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.Connecting.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [GenerateDbAuthToken AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/generate-db-auth-token.html)*Command Reference*.
### `list-tags-for-resource`
Il seguente esempio di codice mostra come utilizzare`list-tags-for-resource`.
**AWS CLI**
**Come elencare i tag su una risorsa Amazon RDS**
L’esempio `list-tags-for-resource` seguente elenca tutti i tag su un’istanza database.
```
aws rds list-tags-for-resource \
--resource-name arn:aws:rds:us-east-1:123456789012:db:orcl1
```
Output:
```
{
"TagList": [
{
"Key": "Environment",
"Value": "test"
},
{
"Key": "Name",
"Value": "MyDatabase"
}
]
}
```
Per ulteriori informazioni, consulta la pagina [Tagging delle risorse Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [ListTagsForResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/list-tags-for-resource.html)*Command Reference*.
### `modify-certificates`
Il seguente esempio di codice mostra come utilizzare`modify-certificates`.
**AWS CLI**
**Per sovrascrivere temporaneamente il SSL/TLS certificato predefinito del sistema per le nuove istanze DB**
L'`modify-certificates`esempio seguente sostituisce temporaneamente il certificato predefinito del sistema SSL/TLS per le nuove istanze DB.
```
aws rds modify-certificates \
--certificate-identifier rds-ca-2019
```
Output:
```
{
"Certificate": {
"CertificateIdentifier": "rds-ca-2019",
"CertificateType": "CA",
"Thumbprint": "EXAMPLE123456789012",
"ValidFrom": "2019-09-19T18:16:53Z",
"ValidTill": "2024-08-22T17:08:50Z",
"CertificateArn": "arn:aws:rds:us-east-1::cert:rds-ca-2019",
"CustomerOverride": true,
"CustomerOverrideValidTill": "2024-08-22T17:08:50Z"
}
}
```
Per ulteriori informazioni, consulta [Rotazione del SSL/TLS certificato](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL-certificate-rotation.html) nella *Amazon RDS User Guide* e [Rotating your SSL/TLS certificate](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.SSL-certificate-rotation.html) nella *Amazon* Aurora User Guide.
+ *Per i dettagli sull'API, consulta [ModifyCertificates](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-certificates.html)Command Reference.AWS CLI *
### `modify-current-db-cluster-capacity`
Il seguente esempio di codice mostra come utilizzare`modify-current-db-cluster-capacity`.
**AWS CLI**
**Come dimensionare la capacità di un cluster di database Aurora serverless**
L’esempio `modify-current-db-cluster-capacity` seguente scala la capacità di un cluster database Aurora serverless a 8.
```
aws rds modify-current-db-cluster-capacity \
--db-cluster-identifier mydbcluster \
--capacity 8
```
Output:
```
{
"DBClusterIdentifier": "mydbcluster",
"PendingCapacity": 8,
"CurrentCapacity": 1,
"SecondsBeforeTimeout": 300,
"TimeoutAction": "ForceApplyCapacityChange"
}
```
Per ulteriori informazioni, consulta [Dimensionamento manuale della capacità del cluster di database di Aurora Serverless v1](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless.setting-capacity.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [ModifyCurrentDbClusterCapacity AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-current-db-cluster-capacity.html)*Command Reference*.
### `modify-db-cluster-endpoint`
Il seguente esempio di codice mostra come utilizzare`modify-db-cluster-endpoint`.
**AWS CLI**
**Come modificare un endpoint del cluster di database personalizzato**
L’esempio `modify-db-cluster-endpoint` seguente modifica l’endpoint del cluster di database personalizzato specificato.
```
aws rds modify-db-cluster-endpoint \
--db-cluster-endpoint-identifier mycustomendpoint \
--static-members dbinstance1 dbinstance2 dbinstance3
```
Output:
```
{
"DBClusterEndpointIdentifier": "mycustomendpoint",
"DBClusterIdentifier": "mydbcluster",
"DBClusterEndpointResourceIdentifier": "cluster-endpoint-ANPAJ4AE5446DAEXAMPLE",
"Endpoint": "mycustomendpoint.cluster-custom-cnpexample.us-east-1.rds.amazonaws.com",
"Status": "modifying",
"EndpointType": "CUSTOM",
"CustomEndpointType": "READER",
"StaticMembers": [
"dbinstance1",
"dbinstance2",
"dbinstance3"
],
"ExcludedMembers": [],
"DBClusterEndpointArn": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:mycustomendpoint"
}
```
Per ulteriori informazioni, consulta [Gestione delle connessioni Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Overview.Endpoints.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [ModifyDbClusterEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-cluster-endpoint.html)*Command Reference*.
### `modify-db-cluster-parameter-group`
Il seguente esempio di codice mostra come utilizzare`modify-db-cluster-parameter-group`.
**AWS CLI**
**Come modificare i parametri in un gruppo di parametri del cluster di database**
L’esempio `modify-db-cluster-parameter-group` seguente modifica i valori dei parametri in un gruppo di parametri del cluster di database.
```
aws rds modify-db-cluster-parameter-group \
--db-cluster-parameter-group-name mydbclusterpg \
--parameters "ParameterName=server_audit_logging,ParameterValue=1,ApplyMethod=immediate" \
"ParameterName=server_audit_logs_upload,ParameterValue=1,ApplyMethod=immediate"
```
Output:
```
{
"DBClusterParameterGroupName": "mydbclusterpg"
}
```
Per ulteriori informazioni, consulta [Uso di gruppi di parametri database e gruppi di parametri cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [ModifyDbClusterParameterGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-cluster-parameter-group.html)*Command Reference*.
### `modify-db-cluster-snapshot-attribute`
Il seguente esempio di codice mostra come utilizzare`modify-db-cluster-snapshot-attribute`.
**AWS CLI**
**Come modificare l’attributo dello snapshot del cluster di database**
L’esempio `modify-db-cluster-snapshot-attribute` seguente apporta modifiche all’attributo snapshot del cluster di database specificato.
```
aws rds modify-db-cluster-snapshot-attribute \
--db-cluster-snapshot-identifier myclustersnapshot \
--attribute-name restore \
--values-to-add 123456789012
```
Output:
```
{
"DBClusterSnapshotAttributesResult": {
"DBClusterSnapshotIdentifier": "myclustersnapshot",
"DBClusterSnapshotAttributes": [
{
"AttributeName": "restore",
"AttributeValues": [
"123456789012"
]
}
]
}
}
```
Per ulteriori informazioni, consulta [Ripristino da uno snapshot cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_RestoreFromSnapshot.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [ModifyDbClusterSnapshotAttribute AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-cluster-snapshot-attribute.html)*Command Reference*.
### `modify-db-cluster`
Il seguente esempio di codice mostra come utilizzare`modify-db-cluster`.
**AWS CLI**
**Esempio 1: come modificare un cluster di database**
L’esempio `modify-db-cluster` seguente modifica la password dell’utente master per il cluster di database denominato `cluster-2` e imposta il periodo di conservazione del backup su 14 giorni. Il parametro `--apply-immediately` fa in modo che le modifiche vengano apportate immediatamente, invece di attendere la successiva finestra di manutenzione.
```
aws rds modify-db-cluster \
--db-cluster-identifier cluster-2 \
--backup-retention-period 14 \
--master-user-password newpassword99 \
--apply-immediately
```
Output:
```
{
"DBCluster": {
"AllocatedStorage": 1,
"AvailabilityZones": [
"eu-central-1b",
"eu-central-1c",
"eu-central-1a"
],
"BackupRetentionPeriod": 14,
"DatabaseName": "",
"DBClusterIdentifier": "cluster-2",
"DBClusterParameterGroup": "default.aurora5.6",
"DBSubnetGroup": "default-vpc-2305ca49",
"Status": "available",
"EarliestRestorableTime": "2020-06-03T02:07:29.637Z",
"Endpoint": "cluster-2.cluster-############.eu-central-1.rds.amazonaws.com",
"ReaderEndpoint": "cluster-2.cluster-ro-############.eu-central-1.rds.amazonaws.com",
"MultiAZ": false,
"Engine": "aurora",
"EngineVersion": "5.6.10a",
"LatestRestorableTime": "2020-06-04T15:11:25.748Z",
"Port": 3306,
"MasterUsername": "admin",
"PreferredBackupWindow": "01:55-02:25",
"PreferredMaintenanceWindow": "thu:21:14-thu:21:44",
"ReadReplicaIdentifiers": [],
"DBClusterMembers": [
{
"DBInstanceIdentifier": "cluster-2-instance-1",
"IsClusterWriter": true,
"DBClusterParameterGroupStatus": "in-sync",
"PromotionTier": 1
}
],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-20a5c047",
"Status": "active"
}
],
"HostedZoneId": "Z1RLNU0EXAMPLE",
"StorageEncrypted": true,
"KmsKeyId": "arn:aws:kms:eu-central-1:123456789012:key/d1bd7c8f-5cdb-49ca-8a62-a1b2c3d4e5f6",
"DbClusterResourceId": "cluster-AGJ7XI77XVIS6FUXHU1EXAMPLE",
"DBClusterArn": "arn:aws:rds:eu-central-1:123456789012:cluster:cluster-2",
"AssociatedRoles": [],
"IAMDatabaseAuthenticationEnabled": false,
"ClusterCreateTime": "2020-04-03T14:44:02.764Z",
"EngineMode": "provisioned",
"DeletionProtection": false,
"HttpEndpointEnabled": false,
"CopyTagsToSnapshot": true,
"CrossAccountClone": false,
"DomainMemberships": []
}
}
```
Per ulteriori informazioni, consulta [Modifica di un cluster database Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Modifying.html) nella *Guida per l’utente di Amazon Aurora*.
**Esempio 2: come associare il gruppo di sicurezza VPC a un cluster di database**
L’esempio `modify-db-instance` seguente associa un gruppo di sicurezza VPC specifico e rimuove i gruppi di sicurezza database da un cluster di database.
```
aws rds modify-db-cluster \
--db-cluster-identifier dbName \
--vpc-security-group-ids sg-ID
```
Output:
```
{
"DBCluster": {
"AllocatedStorage": 1,
"AvailabilityZones": [
"us-west-2c",
"us-west-2b",
"us-west-2a"
],
"BackupRetentionPeriod": 1,
"DBClusterIdentifier": "dbName",
"DBClusterParameterGroup": "default.aurora-mysql8.0",
"DBSubnetGroup": "default",
"Status": "available",
"EarliestRestorableTime": "2024-02-15T01:12:13.966000+00:00",
"Endpoint": "dbName.cluster-abcdefghji.us-west-2.rds.amazonaws.com",
"ReaderEndpoint": "dbName.cluster-ro-abcdefghji.us-west-2.rds.amazonaws.com",
"MultiAZ": false,
"Engine": "aurora-mysql",
"EngineVersion": "8.0.mysql_aurora.3.04.1",
"LatestRestorableTime": "2024-02-15T02:25:33.696000+00:00",
"Port": 3306,
"MasterUsername": "admin",
"PreferredBackupWindow": "10:59-11:29",
"PreferredMaintenanceWindow": "thu:08:54-thu:09:24",
"ReadReplicaIdentifiers": [],
"DBClusterMembers": [
{
"DBInstanceIdentifier": "dbName-instance-1",
"IsClusterWriter": true,
"DBClusterParameterGroupStatus": "in-sync",
"PromotionTier": 1
}
],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-ID",
"Status": "active"
}
],
...output omitted...
}
}
```
Per ulteriori informazioni, consulta [Controllo dell’accesso con i gruppi di sicurezza](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Overview.RDSSecurityGroups.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [ModifyDbCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-cluster.html)*Command Reference*.
### `modify-db-instance`
Il seguente esempio di codice mostra come utilizzare`modify-db-instance`.
**AWS CLI**
**Esempio 1: come modificare un’istanza database**
L’esempio `modify-db-instance` seguente associa un gruppo di opzioni e un gruppo di parametri a un’istanza database Microsoft SQL Server compatibile. Il parametro `--apply-immediately` fa sì che l’opzione e i gruppi di parametri vengano associati immediatamente, anziché attendere la successiva finestra di manutenzione.
```
aws rds modify-db-instance \
--db-instance-identifier database-2 \
--option-group-name test-se-2017 \
--db-parameter-group-name test-sqlserver-se-2017 \
--apply-immediately
```
Output:
```
{
"DBInstance": {
"DBInstanceIdentifier": "database-2",
"DBInstanceClass": "db.r4.large",
"Engine": "sqlserver-se",
"DBInstanceStatus": "available",
...output omitted...
"DBParameterGroups": [
{
"DBParameterGroupName": "test-sqlserver-se-2017",
"ParameterApplyStatus": "applying"
}
],
"AvailabilityZone": "us-west-2d",
...output omitted...
"MultiAZ": true,
"EngineVersion": "14.00.3281.6.v1",
"AutoMinorVersionUpgrade": false,
"ReadReplicaDBInstanceIdentifiers": [],
"LicenseModel": "license-included",
"OptionGroupMemberships": [
{
"OptionGroupName": "test-se-2017",
"Status": "pending-apply"
}
],
"CharacterSetName": "SQL_Latin1_General_CP1_CI_AS",
"SecondaryAvailabilityZone": "us-west-2c",
"PubliclyAccessible": true,
"StorageType": "gp2",
...output omitted...
"DeletionProtection": false,
"AssociatedRoles": [],
"MaxAllocatedStorage": 1000
}
}
```
Per ulteriori informazioni, consulta [Modifica di un’istanza database Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.DBInstance.Modifying.html) nella *Guida per l’utente di Amazon RDS*.
**Esempio 2: come associare un gruppo di sicurezza VPC a un’istanza database**
L’esempio `modify-db-instance` seguente associa un gruppo di sicurezza VPC specifico e rimuove i gruppi di sicurezza database da un’istanza database:
```
aws rds modify-db-instance \
--db-instance-identifier dbName \
--vpc-security-group-ids sg-ID
```
Output:
```
{
"DBInstance": {
"DBInstanceIdentifier": "dbName",
"DBInstanceClass": "db.t3.micro",
"Engine": "mysql",
"DBInstanceStatus": "available",
"MasterUsername": "admin",
"Endpoint": {
"Address": "dbName.abcdefghijk.us-west-2.rds.amazonaws.com",
"Port": 3306,
"HostedZoneId": "ABCDEFGHIJK1234"
},
"AllocatedStorage": 20,
"InstanceCreateTime": "2024-02-15T00:37:58.793000+00:00",
"PreferredBackupWindow": "11:57-12:27",
"BackupRetentionPeriod": 7,
"DBSecurityGroups": [],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-ID",
"Status": "active"
}
],
... output omitted ...
"MultiAZ": false,
"EngineVersion": "8.0.35",
"AutoMinorVersionUpgrade": true,
"ReadReplicaDBInstanceIdentifiers": [],
"LicenseModel": "general-public-license",
... output omitted ...
}
}
```
Per ulteriori informazioni, consulta [Controllo dell’accesso con i gruppi di sicurezza](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.RDSSecurityGroups.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [Modify DBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-instance.html) in *AWS CLI Command Reference*.
### `modify-db-parameter-group`
Il seguente esempio di codice mostra come utilizzare`modify-db-parameter-group`.
**AWS CLI**
**Come modificare un gruppo di parametri del database**
L’esempio `modify-db-parameter-group` seguente modifica il valore del parametro `clr enabled` in un gruppo di parametri database. Il parametro `--apply-immediately` fa sì che il gruppo di parametri del database venga modificato immediatamente, anziché attendere la successiva finestra di manutenzione.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name test-sqlserver-se-2017 \
--parameters "ParameterName='clr enabled',ParameterValue=1,ApplyMethod=immediate"
```
Output:
```
{
"DBParameterGroupName": "test-sqlserver-se-2017"
}
```
Per ulteriori informazioni, consulta [Modifica di parametri in un gruppo di parametri database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html#USER_WorkingWithParamGroups.Modifying) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [Modify DBParameter Group](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-parameter-group.html) in *AWS CLI Command Reference*.
### `modify-db-proxy-endpoint`
Il seguente esempio di codice mostra come utilizzare`modify-db-proxy-endpoint`.
**AWS CLI**
**Come modificare un endpoint proxy database per un database RDS**
L’esempio `modify-db-proxy-endpoint` seguente modifica un endpoint proxy database `proxyEndpoint` per impostare il timeout di lettura su 65 secondi.
```
aws rds modify-db-proxy-endpoint \
--db-proxy-endpoint-name proxyEndpoint \
--cli-read-timeout 65
```
Output:
```
{
"DBProxyEndpoint":
{
"DBProxyEndpointName": "proxyEndpoint",
"DBProxyEndpointArn": "arn:aws:rds:us-east-1:123456789012:db-proxy-endpoint:prx-endpoint-0123a01b12345c0ab",
"DBProxyName": "proxyExample",
"Status": "available",
"VpcId": "vpc-1234567",
"VpcSecurityGroupIds": [
"sg-1234"
],
"VpcSubnetIds": [
"subnetgroup1",
"subnetgroup2"
],
"Endpoint": "proxyEndpoint.endpoint.proxyExample-ab0cd1efghij.us-east-1.rds.amazonaws.com",
"CreatedDate": "2023-04-05T16:09:33.452000+00:00",
"TargetRole": "READ_WRITE",
"IsDefault": "false"
}
}
```
Per ulteriori informazioni, consulta [Modifica di un endpoint proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-endpoints.html#rds-proxy-endpoints.ModifyingEndpoint) nella *Guida per l’utente di Amazon RDS* e [Modifica di un endpoint proxy](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-endpoints.html#rds-proxy-endpoints.ModifyingEndpoint) nella *Guida per l’utente di Amazon Aurora.*
+ Per i dettagli sull'API, consulta [ModifyDbProxyEndpoint AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-proxy-endpoint.html)*Command Reference*.
### `modify-db-proxy-target-group`
Il seguente esempio di codice mostra come utilizzare`modify-db-proxy-target-group`.
**AWS CLI**
**Come modificare gli endpoint di un proxy database**
L’esempio `modify-db-proxy-target-group` seguente modifica un gruppo di destinazione di proxy database per impostare il numero massimo di connessioni su 80% e il numero massimo di connessioni inattive su 10%.
```
aws rds modify-db-proxy-target-group \
--target-group-name default \
--db-proxy-name proxyExample \
--connection-pool-config MaxConnectionsPercent=80,MaxIdleConnectionsPercent=10
```
Output:
```
{
"DBProxyTargetGroup":
{
"DBProxyName": "proxyExample",
"TargetGroupName": "default",
"TargetGroupArn": "arn:aws:rds:us-east-1:123456789012:target-group:prx-tg-0123a01b12345c0ab",
"IsDefault": true,
"Status": "available",
"ConnectionPoolConfig": {
"MaxConnectionsPercent": 80,
"MaxIdleConnectionsPercent": 10,
"ConnectionBorrowTimeout": 120,
"SessionPinningFilters": []
},
"CreatedDate": "2023-05-02T18:41:19.495000+00:00",
"UpdatedDate": "2023-05-02T18:41:21.762000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Modifica di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-managing.html#rds-proxy-modifying-proxy) nella *Guida per l’utente di Amazon RDS* e [Modifica di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-managing.html#rds-proxy-modifying-proxy) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [ModifyDbProxyTargetGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-proxy-target-group.html)*Command Reference*.
### `modify-db-proxy`
Il seguente esempio di codice mostra come utilizzare`modify-db-proxy`.
**AWS CLI**
**Come modificare un proxy database per un database RDS**
L’esempio `modify-db-proxy` seguente modifica un proxy database denominato `proxyExample` per richiedere SSL per le sue connessioni.
```
aws rds modify-db-proxy \
--db-proxy-name proxyExample \
--require-tls
```
Output:
```
{
"DBProxy":
{
"DBProxyName": "proxyExample",
"DBProxyArn": "arn:aws:rds:us-east-1:123456789012:db-proxy:prx-0123a01b12345c0ab",
"Status": "modifying"
"EngineFamily": "PostgreSQL",
"VpcId": "sg-1234567",
"VpcSecurityGroupIds": [
"sg-1234"
],
"VpcSubnetIds": [
"subnetgroup1",
"subnetgroup2"
],
"Auth": "[
{
"Description": "proxydescription1",
"AuthScheme": "SECRETS",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789123:secret:proxysecret1-Abcd1e",
"IAMAuth": "DISABLED"
}
]",
"RoleArn": "arn:aws:iam::12345678912:role/ProxyPostgreSQLRole",
"Endpoint": "proxyExample.proxy-ab0cd1efghij.us-east-1.rds.amazonaws.com",
"RequireTLS": true,
"IdleClientTimeout": 1800,
"DebuggingLogging": false,
"CreatedDate": "2023-04-05T16:09:33.452000+00:00",
"UpdatedDate": "2023-04-13T01:49:38.568000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Modifica di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-managing.html#rds-proxy-modifying-proxy) nella *Guida per l’utente di Amazon RDS* e [Creazione di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-managing.html#rds-proxy-modifying-proxy) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [ModifyDbProxy AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-proxy.html)*Command Reference*.
### `modify-db-shard-group`
Il seguente esempio di codice mostra come utilizzare`modify-db-shard-group`.
**AWS CLI**
**Esempio 1: come modificare un gruppo di shard del database**
L’esempio `modify-db-shard-group` seguente modifica la capacità massima di un gruppo di shard del database.
```
aws rds modify-db-shard-group \
--db-shard-group-identifier my-db-shard-group \
--max-acu 1000
```
Output:
```
{
"DBShardGroups": [
{
"DBShardGroupResourceId": "shardgroup-a6e3a0226aa243e2ac6c7a1234567890",
"DBShardGroupIdentifier": "my-db-shard-group",
"DBClusterIdentifier": "my-sv2-cluster",
"MaxACU": 768.0,
"ComputeRedundancy": 0,
"Status": "available",
"PubliclyAccessible": false,
"Endpoint": "my-sv2-cluster.limitless-cekycexample.us-east-2.rds.amazonaws.com"
}
]
}
```
Per ulteriori informazioni, consulta [Cluster database Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Overview.html) nella *Guida per l’utente di Amazon Aurora*.
**Esempio 2: come descrivere i gruppi di shard del database**
L’esempio `describe-db-shard-groups` seguente recupera i dettagli dei gruppi di shard del database dopo l’esecuzione del comando `modify-db-shard-group`. La capacità massima del gruppo di shard DB `my-db-shard-group` è ora di 1000 unità ACUs di capacità Aurora ().
```
aws rds describe-db-shard-groups
```
Output:
```
{
"DBShardGroups": [
{
"DBShardGroupResourceId": "shardgroup-7bb446329da94788b3f957746example",
"DBShardGroupIdentifier": "limitless-test-shard-grp",
"DBClusterIdentifier": "limitless-test-cluster",
"MaxACU": 768.0,
"ComputeRedundancy": 0,
"Status": "available",
"PubliclyAccessible": true,
"Endpoint": "limitless-test-cluster.limitless-cekycexample.us-east-2.rds.amazonaws.com"
},
{
"DBShardGroupResourceId": "shardgroup-a6e3a0226aa243e2ac6c7a1234567890",
"DBShardGroupIdentifier": "my-db-shard-group",
"DBClusterIdentifier": "my-sv2-cluster",
"MaxACU": 1000.0,
"ComputeRedundancy": 0,
"Status": "available",
"PubliclyAccessible": false,
"Endpoint": "my-sv2-cluster.limitless-cekycexample.us-east-2.rds.amazonaws.com"
}
]
}
```
Per ulteriori informazioni, consulta [Cluster database Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.Overview.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [ModifyDbShardGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-shard-group.html)Reference*.
### `modify-db-snapshot-attribute`
Il seguente esempio di codice mostra come utilizzare`modify-db-snapshot-attribute`.
**AWS CLI**
**Esempio 1: consentire a due AWS account di ripristinare un'istantanea del DB**
L'`modify-db-snapshot-attribute`esempio seguente concede l'autorizzazione a due AWS account, con gli identificatori `111122223333` e`444455556666`, per ripristinare lo snapshot DB denominato. `mydbsnapshot`
```
aws rds modify-db-snapshot-attribute \
--db-snapshot-identifier mydbsnapshot \
--attribute-name restore \
--values-to-add {"111122223333","444455556666"}
```
Output:
```
{
"DBSnapshotAttributesResult": {
"DBSnapshotIdentifier": "mydbsnapshot",
"DBSnapshotAttributes": [
{
"AttributeName": "restore",
"AttributeValues": [
"111122223333",
"444455556666"
]
}
]
}
}
```
Per ulteriori informazioni, consulta [Condivisione di uno snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ShareSnapshot.html#USER_ShareSnapshot.Sharing) nella *Guida per l’utente di Amazon RDS*.
**Esempio 2: impedire a un AWS account di ripristinare un'istantanea del DB**
L'`modify-db-snapshot-attribute`esempio seguente rimuove l'autorizzazione da un particolare AWS account per ripristinare lo snapshot DB denominato. `mydbsnapshot` Quando si specifica un solo account, l’identificatore dell’account non può essere racchiuso tra virgolette o parentesi.
```
aws rds modify-db-snapshot-attribute \
--db-snapshot-identifier mydbsnapshot \
--attribute-name restore \
--values-to-remove 444455556666
```
Output:
```
{
"DBSnapshotAttributesResult": {
"DBSnapshotIdentifier": "mydbsnapshot",
"DBSnapshotAttributes": [
{
"AttributeName": "restore",
"AttributeValues": [
"111122223333"
]
}
]
}
}
```
Per ulteriori informazioni, consulta [Condivisione di uno snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ShareSnapshot.html#USER_ShareSnapshot.Sharing) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, vedere [ModifyDbSnapshotAttribute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-snapshot-attribute.html)in *AWS CLI Command Reference.*
### `modify-db-snapshot-attributes`
Il seguente esempio di codice mostra come utilizzare`modify-db-snapshot-attributes`.
**AWS CLI**
**Come modificare un attributo dello snapshot database**
L'`modify-db-snapshot-attribute`esempio seguente consente di ripristinare due identificatori di AWS account `111122223333` e `444455556666` lo snapshot del DB denominato. `mydbsnapshot`
```
aws rds modify-db-snapshot-attribute \
--db-snapshot-identifier mydbsnapshot \
--attribute-name restore \
--values-to-add '["111122223333","444455556666"]'
```
Output:
```
{
"DBSnapshotAttributesResult": {
"DBSnapshotIdentifier": "mydbsnapshot",
"DBSnapshotAttributes": [
{
"AttributeName": "restore",
"AttributeValues": [
"111122223333",
"444455556666"
]
}
]
}
}
```
Per ulteriori informazioni, consulta [Condivisione di uno snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ShareSnapshot.html#USER_ShareSnapshot.Sharing) nella *Guida per l’utente di Amazon RDS*.
+ *Per i dettagli sull'API, vedere [ModifyDbSnapshotAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-snapshot-attributes.html)in AWS CLI Command Reference.*
### `modify-db-snapshot`
Il seguente esempio di codice mostra come utilizzare`modify-db-snapshot`.
**AWS CLI**
**Come modificare uno snapshot database**
L’esempio `modify-db-snapshot` seguente aggiorna uno snapshot di PostgeSQL 10.6 denominato `db5-snapshot-upg-test` a PostgreSQL 11.7. La nuova versione del motore database viene mostrata dopo il completamento dell’aggiornamento dello snapshot, quando il suo stato è **disponibile**.
```
aws rds modify-db-snapshot \
--db-snapshot-identifier db5-snapshot-upg-test \
--engine-version 11.7
```
Output:
```
{
"DBSnapshot": {
"DBSnapshotIdentifier": "db5-snapshot-upg-test",
"DBInstanceIdentifier": "database-5",
"SnapshotCreateTime": "2020-03-27T20:49:17.092Z",
"Engine": "postgres",
"AllocatedStorage": 20,
"Status": "upgrading",
"Port": 5432,
"AvailabilityZone": "us-west-2a",
"VpcId": "vpc-2ff27557",
"InstanceCreateTime": "2020-03-27T19:59:04.735Z",
"MasterUsername": "postgres",
"EngineVersion": "10.6",
"LicenseModel": "postgresql-license",
"SnapshotType": "manual",
"OptionGroupName": "default:postgres-11",
"PercentProgress": 100,
"StorageType": "gp2",
"Encrypted": false,
"DBSnapshotArn": "arn:aws:rds:us-west-2:123456789012:snapshot:db5-snapshot-upg-test",
"IAMDatabaseAuthenticationEnabled": false,
"ProcessorFeatures": [],
"DbiResourceId": "db-GJMF75LM42IL6BTFRE4UZJ5YM4"
}
}
```
Per ulteriori informazioni, consulta [Aggiornamento di uno snapshot database PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_UpgradeDBSnapshot.PostgreSQL.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [ModifyDbSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-snapshot.html)*Command Reference*.
### `modify-db-subnet-group`
Il seguente esempio di codice mostra come utilizzare`modify-db-subnet-group`.
**AWS CLI**
**Come modificare un gruppo di sottoreti database**
L’esempio `modify-db-subnet-group` seguente aggiunge una sottorete con l’ID `subnet-08e41f9e230222222` al gruppo di sottoreti database denominato `mysubnetgroup`. Per mantenere le sottoreti esistenti nel gruppo di sottoreti, includete i loro valori IDs as nell'opzione. `--subnet-ids` Assicurati di disporre di un gruppo di sottoreti con almeno due zone di disponibilità diverse nel gruppo di sottoreti database.
```
aws rds modify-db-subnet-group \
--db-subnet-group-name mysubnetgroup \
--subnet-ids '["subnet-0a1dc4e1a6f123456","subnet-070dd7ecb3aaaaaaa","subnet-00f5b198bc0abcdef","subnet-08e41f9e230222222"]'
```
Output:
```
{
"DBSubnetGroup": {
"DBSubnetGroupName": "mysubnetgroup",
"DBSubnetGroupDescription": "test DB subnet group",
"VpcId": "vpc-0f08e7610a1b2c3d4",
"SubnetGroupStatus": "Complete",
"Subnets": [
{
"SubnetIdentifier": "subnet-08e41f9e230222222",
"SubnetAvailabilityZone": {
"Name": "us-west-2a"
},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-070dd7ecb3aaaaaaa",
"SubnetAvailabilityZone": {
"Name": "us-west-2b"
},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-00f5b198bc0abcdef",
"SubnetAvailabilityZone": {
"Name": "us-west-2d"
},
"SubnetStatus": "Active"
},
{
"SubnetIdentifier": "subnet-0a1dc4e1a6f123456",
"SubnetAvailabilityZone": {
"Name": "us-west-2b"
},
"SubnetStatus": "Active"
}
],
"DBSubnetGroupArn": "arn:aws:rds:us-west-2:534026745191:subgrp:mysubnetgroup"
}
}
```
Per ulteriori informazioni, consulta [Fase 3: crea un gruppo di sottoreti database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_VPC.WorkingWithRDSInstanceinaVPC.html#USER_VPC.CreateDBSubnetGroup) nella *Guida per l’utente di Amazon RDS*.
+ *Per i dettagli sull'API, consulta Command [ModifyDbSubnetGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-subnet-group.html)Reference AWS CLI .*
### `modify-event-subscription`
Il seguente esempio di codice mostra come utilizzare`modify-event-subscription`.
**AWS CLI**
**Come modificare un abbonamento all’evento**
L’esempio `modify-event-subscription` seguente disabilita l’abbonamento all’evento specificato, in modo che non pubblichi più notifiche sull’argomento Amazon Simple Notification Service specificato.
```
aws rds modify-event-subscription \
--subscription-name my-instance-events \
--no-enabled
```
Output:
```
{
"EventSubscription": {
"EventCategoriesList": [
"backup",
"recovery"
],
"CustomerAwsId": "123456789012",
"SourceType": "db-instance",
"SubscriptionCreationTime": "Tue Jul 31 23:22:01 UTC 2018",
"EventSubscriptionArn": "arn:aws:rds:us-east-1:123456789012:es:my-instance-events",
"SnsTopicArn": "arn:aws:sns:us-east-1:123456789012:interesting-events",
"CustSubscriptionId": "my-instance-events",
"Status": "modifying",
"Enabled": false
}
}
```
+ Per i dettagli sull'API, consulta [ModifyEventSubscription AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-event-subscription.html)*Command Reference*.
### `modify-global-cluster`
Il seguente esempio di codice mostra come utilizzare`modify-global-cluster`.
**AWS CLI**
**Come modificare un cluster di database globale**
L’esempio `modify-global-cluster` seguente abilita la protezione da eliminazione per un cluster di database globale compatibile con Aurora MySQL.
```
aws rds modify-global-cluster \
--global-cluster-identifier myglobalcluster \
--deletion-protection
```
Output:
```
{
"GlobalCluster": {
"GlobalClusterIdentifier": "myglobalcluster",
"GlobalClusterResourceId": "cluster-f0e523bfe07aabb",
"GlobalClusterArn": "arn:aws:rds::123456789012:global-cluster:myglobalcluster",
"Status": "available",
"Engine": "aurora-mysql",
"EngineVersion": "5.7.mysql_aurora.2.07.2",
"StorageEncrypted": false,
"DeletionProtection": true,
"GlobalClusterMembers": []
}
}
```
Per ulteriori informazioni, consulta [Utilizzo dei database globali Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-managing.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [ModifyGlobalCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-global-cluster.html)*Command Reference*.
### `promote-read-replica-db-cluster`
Il seguente esempio di codice mostra come utilizzare`promote-read-replica-db-cluster`.
**AWS CLI**
**Come promuovere una replica di lettura al cluster di database**
L’esempio `promote-read-replica-db-cluster` seguente promuove la replica di lettura specificata a un cluster di database autonomo.
```
aws rds promote-read-replica-db-cluster \
--db-cluster-identifier mydbcluster-1
```
Output:
```
{
"DBCluster": {
"AllocatedStorage": 1,
"AvailabilityZones": [
"us-east-1a",
"us-east-1b",
"us-east-1c"
],
"BackupRetentionPeriod": 1,
"DatabaseName": "",
"DBClusterIdentifier": "mydbcluster-1",
...some output truncated...
}
}
```
Per ulteriori informazioni, consulta [Promozione di una replica di lettura a cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Replication.CrossRegion.html#AuroraMySQL.Replication.CrossRegion.Promote) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [PromoteReadReplicaDbCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/promote-read-replica-db-cluster.html)*Command Reference*.
### `promote-read-replica`
Il seguente esempio di codice mostra come utilizzare`promote-read-replica`.
**AWS CLI**
**Come promuovere una replica di lettura**
L’esempio `promote-read-replica` seguente promuove la replica di lettura specificata a diventare un’istanza database autonoma.
```
aws rds promote-read-replica \
--db-instance-identifier test-instance-repl
```
Output:
```
{
"DBInstance": {
"DBInstanceArn": "arn:aws:rds:us-east-1:123456789012:db:test-instance-repl",
"StorageType": "standard",
"ReadReplicaSourceDBInstanceIdentifier": "test-instance",
"DBInstanceStatus": "modifying",
...some output truncated...
}
}
```
+ Per i dettagli sull'API, consulta [PromoteReadReplica AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/promote-read-replica.html)*Command Reference*.
### `purchase-reserved-db-instance`
Il seguente esempio di codice mostra come utilizzare`purchase-reserved-db-instance`.
**AWS CLI**
**Come acquistare un’offerta di istanza database riservata**
L’esempio `purchase-reserved-db-instances-offering` seguente acquista un’offerta di istanza database riservata. `reserved-db-instances-offering-id` deve essere un ID di offerta valido, come restituito dal comando `describe-reserved-db-instances-offering`.
aws rds purchase-reserved-db-instances -offering -- reserved-db-instances-offering -id 438012d3-4a52-4cc7-b2e3-8dff72e0e706
+ Per i dettagli sull'API, [PurchaseReservedDbInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/purchase-reserved-db-instance.html)consulta *AWS CLI Command Reference.*
### `purchase-reserved-db-instances-offerings`
Il seguente esempio di codice mostra come utilizzare`purchase-reserved-db-instances-offerings`.
**AWS CLI**
**Esempio 1: come trovare un’istanza database riservata da acquistare**
L’esempio `describe-reserved-db-instances-offerings` seguente elenca le istanze database MySQL riservate disponibili con la classe di istanze db.t2.micro e una durata di un anno. L’ID dell’offerta è necessario per acquistare un’istanza database riservata.
```
aws rds describe-reserved-db-instances-offerings \
--product-description mysql \
--db-instance-class db.t2.micro \
--duration 1
```
Output:
```
{
"ReservedDBInstancesOfferings": [
{
"ReservedDBInstancesOfferingId": "8ba30be1-b9ec-447f-8f23-6114e3f4c7b4",
"DBInstanceClass": "db.t2.micro",
"Duration": 31536000,
"FixedPrice": 51.0,
"UsagePrice": 0.0,
"CurrencyCode": "USD",
"ProductDescription": "mysql",
"OfferingType": "Partial Upfront",
"MultiAZ": false,
"RecurringCharges": [
{
"RecurringChargeAmount": 0.006,
"RecurringChargeFrequency": "Hourly"
}
]
},
... some output truncated ...
]
}
```
Per ulteriori informazioni, consulta [Istanze database riservate per Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithReservedDBInstances.html) nella *Guida per l’utente di Amazon RDS*.
**Esempio 2: come acquistare un’istanza database riservata**
L’esempio `purchase-reserved-db-instances-offering` seguente mostra come acquistare l’offerta di istanza database riservata dell’esempio precedente.
aws rds purchase-reserved-db-instances -offering -- reserved-db-instances-offering -id 8ba30be1-b9ec-447f-8f23-6114e3f4c7b4
Output:
```
{
"ReservedDBInstance": {
"ReservedDBInstanceId": "ri-2020-06-29-16-54-57-670",
"ReservedDBInstancesOfferingId": "8ba30be1-b9ec-447f-8f23-6114e3f4c7b4",
"DBInstanceClass": "db.t2.micro",
"StartTime": "2020-06-29T16:54:57.670Z",
"Duration": 31536000,
"FixedPrice": 51.0,
"UsagePrice": 0.0,
"CurrencyCode": "USD",
"DBInstanceCount": 1,
"ProductDescription": "mysql",
"OfferingType": "Partial Upfront",
"MultiAZ": false,
"State": "payment-pending",
"RecurringCharges": [
{
"RecurringChargeAmount": 0.006,
"RecurringChargeFrequency": "Hourly"
}
],
"ReservedDBInstanceArn": "arn:aws:rds:us-west-2:123456789012:ri:ri-2020-06-29-16-54-57-670"
}
}
```
Per ulteriori informazioni, consulta [Istanze database riservate per Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithReservedDBInstances.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'*AWS CLI API, [PurchaseReservedDbInstancesOfferings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/purchase-reserved-db-instances-offerings.html)consulta Command Reference*.
### `reboot-db-instance`
Il seguente esempio di codice mostra come utilizzare`reboot-db-instance`.
**AWS CLI**
**Come riavviare un’istanza database**
L’esempio `reboot-db-instance` seguente avvia il riavvio dell’istanza database specificata.
```
aws rds reboot-db-instance \
--db-instance-identifier test-mysql-instance
```
Output:
```
{
"DBInstance": {
"DBInstanceIdentifier": "test-mysql-instance",
"DBInstanceClass": "db.t3.micro",
"Engine": "mysql",
"DBInstanceStatus": "rebooting",
"MasterUsername": "admin",
"Endpoint": {
"Address": "test-mysql-instance.############.us-west-2.rds.amazonaws.com",
"Port": 3306,
"HostedZoneId": "Z1PVIF0EXAMPLE"
},
... output omitted...
}
}
```
Per ulteriori informazioni, consulta [Riavvio di un’istanza database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RebootInstance.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [Reboot DBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/reboot-db-instance.html) in *AWS CLI Command Reference.*
### `reboot-db-shard-group`
Il seguente esempio di codice mostra come utilizzare`reboot-db-shard-group`.
**AWS CLI**
**Esempio 1: come riavviare un gruppo di shard del database**
L’esempio `reboot-db-shard-group` seguente riavvia un gruppo di shard del database.
```
aws rds reboot-db-shard-group \
--db-shard-group-identifier my-db-shard-group
```
Output:
```
{
"DBShardGroups": [
{
"DBShardGroupResourceId": "shardgroup-a6e3a0226aa243e2ac6c7a1234567890",
"DBShardGroupIdentifier": "my-db-shard-group",
"DBClusterIdentifier": "my-sv2-cluster",
"MaxACU": 1000.0,
"ComputeRedundancy": 0,
"Status": "available",
"PubliclyAccessible": false,
"Endpoint": "my-sv2-cluster.limitless-cekycexample.us-east-2.rds.amazonaws.com"
}
]
}
```
Per ulteriori informazioni, consulta [Riavvio di un cluster Amazon Aurora DB o di un’istanza Amazon Aurora DB](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_RebootCluster.html) nella *Guida per l’utente di Amazon Aurora*.
**Esempio 2: come descrivere i gruppi di shard del database**
L’esempio `describe-db-shard-groups` seguente recupera i dettagli dei gruppi di shard del database dopo l’esecuzione del comando `reboot-db-shard-group`. Il gruppo di shard del database `my-db-shard-group` ora è in fase di riavvio.
```
aws rds describe-db-shard-groups
```
Output:
```
{
"DBShardGroups": [
{
"DBShardGroupResourceId": "shardgroup-7bb446329da94788b3f957746example",
"DBShardGroupIdentifier": "limitless-test-shard-grp",
"DBClusterIdentifier": "limitless-test-cluster",
"MaxACU": 768.0,
"ComputeRedundancy": 0,
"Status": "available",
"PubliclyAccessible": true,
"Endpoint": "limitless-test-cluster.limitless-cekycexample.us-east-2.rds.amazonaws.com"
},
{
"DBShardGroupResourceId": "shardgroup-a6e3a0226aa243e2ac6c7a1234567890",
"DBShardGroupIdentifier": "my-db-shard-group",
"DBClusterIdentifier": "my-sv2-cluster",
"MaxACU": 1000.0,
"ComputeRedundancy": 0,
"Status": "rebooting",
"PubliclyAccessible": false,
"Endpoint": "my-sv2-cluster.limitless-cekycexample.us-east-2.rds.amazonaws.com"
}
]
}
```
Per ulteriori informazioni, consulta [Riavvio di un cluster Amazon Aurora DB o di un’istanza Amazon Aurora DB](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_RebootCluster.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [RebootDbShardGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/reboot-db-shard-group.html)*Command Reference*.
### `register-db-proxy-targets`
Il seguente esempio di codice mostra come utilizzare`register-db-proxy-targets`.
**AWS CLI**
**Come registrare un proxy database con un database**
L’esempio `register-db-proxy-targets` seguente crea l’associazione tra un database e un proxy.
```
aws rds register-db-proxy-targets \
--db-proxy-name proxyExample \
--db-cluster-identifiers database-5
```
Output:
```
{
"DBProxyTargets": [
{
"RdsResourceId": "database-5",
"Port": 3306,
"Type": "TRACKED_CLUSTER",
"TargetHealth": {
"State": "REGISTERING"
}
},
{
"Endpoint": "database-5instance-1.ab0cd1efghij.us-east-1.rds.amazonaws.com",
"RdsResourceId": "database-5",
"Port": 3306,
"Type": "RDS_INSTANCE",
"TargetHealth": {
"State": "REGISTERING"
}
}
]
}
```
Per ulteriori informazioni, consulta [Creazione di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-proxy-setup.html#rds-proxy-creating) nella *Guida per l’utente di Amazon RDS* e [Creazione di un RDS Proxy](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-proxy-setup.html#rds-proxy-creating) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [RegisterDbProxyTargets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/register-db-proxy-targets.html)*Command Reference*.
### `remove-from-global-cluster`
Il seguente esempio di codice mostra come utilizzare`remove-from-global-cluster`.
**AWS CLI**
**Come scollegare un cluster secondario di Aurora da un cluster di database globale di Aurora**
L’esempio `remove-from-global-cluster` seguente distacca un cluster secondario di Aurora da un cluster di database globale di Aurora. Il cluster passa da cluster di sola lettura a cluster autonomo con funzionalità di lettura-scrittura.
```
aws rds remove-from-global-cluster \
--region us-west-2 \
--global-cluster-identifier myglobalcluster \
--db-cluster-identifier arn:aws:rds:us-west-2:123456789012:cluster:DB-1
```
Output:
```
{
"GlobalCluster": {
"GlobalClusterIdentifier": "myglobalcluster",
"GlobalClusterResourceId": "cluster-abc123def456gh",
"GlobalClusterArn": "arn:aws:rds::123456789012:global-cluster:myglobalcluster",
"Status": "available",
"Engine": "aurora-postgresql",
"EngineVersion": "10.11",
"StorageEncrypted": true,
"DeletionProtection": false,
"GlobalClusterMembers": [
{
"DBClusterArn": "arn:aws:rds:us-east-1:123456789012:cluster:js-global-cluster",
"Readers": [
"arn:aws:rds:us-west-2:123456789012:cluster:DB-1"
],
"IsWriter": true
},
{
"DBClusterArn": "arn:aws:rds:us-west-2:123456789012:cluster:DB-1",
"Readers": [],
"IsWriter": false,
"GlobalWriteForwardingStatus": "disabled"
}
]
}
}
```
Per ulteriori informazioni, consulta [Rimozione di un cluster da un database globale Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-managing.html#aurora-global-database-detaching) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [RemoveFromGlobalCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/remove-from-global-cluster.html)*Command Reference*.
### `remove-option-from-option-group`
Il seguente esempio di codice mostra come utilizzare`remove-option-from-option-group`.
**AWS CLI**
**Come eliminare un’opzione da un gruppo di opzioni**
L’esempio `remove-option-from-option-group` seguente rimuove l’opzione `OEM` da `myoptiongroup`.
```
aws rds remove-option-from-option-group \
--option-group-name myoptiongroup \
--options OEM \
--apply-immediately
```
Output:
```
{
"OptionGroup": {
"OptionGroupName": "myoptiongroup",
"OptionGroupDescription": "Test",
"EngineName": "oracle-ee",
"MajorEngineVersion": "19",
"Options": [],
"AllowsVpcAndNonVpcInstanceMemberships": true,
"OptionGroupArn": "arn:aws:rds:us-east-1:123456789012:og:myoptiongroup"
}
}
```
Per ulteriori informazioni, consulta [Rimozione di un’opzione da un gruppo di opzioni](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithOptionGroups.html#USER_WorkingWithOptionGroups.RemoveOption) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [RemoveOptionFromOptionGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/remove-option-from-option-group.html)*Command Reference*.
### `remove-role-from-db-cluster`
Il seguente esempio di codice mostra come utilizzare`remove-role-from-db-cluster`.
**AWS CLI**
**Per dissociare un ruolo AWS Identity and Access Management (IAM) da un cluster DB**
L’esempio `remove-role-from-db-cluster` seguente rimuove un ruolo da un cluster di database.
```
aws rds remove-role-from-db-cluster \
--db-cluster-identifier mydbcluster \
--role-arn arn:aws:iam::123456789012:role/RDSLoadFromS3
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Associazione di un ruolo IAM a un cluster DB Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Integrating.Authorizing.IAM.AddRoleToDBCluster.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [RemoveRoleFromDbCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/remove-role-from-db-cluster.html)*Command Reference.*
### `remove-role-from-db-instance`
Il seguente esempio di codice mostra come utilizzare`remove-role-from-db-instance`.
**AWS CLI**
**Per dissociare un ruolo AWS Identity and Access Management (IAM) da un'istanza DB**
L’esempio `remove-role-from-db-instance` seguente rimuove il ruolo denominato `rds-s3-integration-role` da un’istanza Oracle DB denominata `test-instance`.
```
aws rds remove-role-from-db-instance \
--db-instance-identifier test-instance \
--feature-name S3_INTEGRATION \
--role-arn arn:aws:iam::111122223333:role/rds-s3-integration-role
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Disabilitazione dell’integrazione di RDS SQL Server con S3](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/User.SQLServer.Options.S3-integration.html#Appendix.SQLServer.Options.S3-integration.disabling) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [RemoveRoleFromDbInstance AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/remove-role-from-db-instance.html)*Command Reference.*
### `remove-source-identifier-from-subscription`
Il seguente esempio di codice mostra come utilizzare`remove-source-identifier-from-subscription`.
**AWS CLI**
**Come rimuovere un identificatore di origine da un abbonamento**
L’esempio `remove-source-identifier` seguente rimuove l’identificatore di origine specificato da un abbonamento esistente.
```
aws rds remove-source-identifier-from-subscription \
--subscription-name my-instance-events \
--source-identifier test-instance-repl
```
Output:
```
{
"EventSubscription": {
"EventSubscriptionArn": "arn:aws:rds:us-east-1:123456789012:es:my-instance-events",
"SubscriptionCreationTime": "Tue Jul 31 23:22:01 UTC 2018",
"EventCategoriesList": [
"backup",
"recovery"
],
"SnsTopicArn": "arn:aws:sns:us-east-1:123456789012:interesting-events",
"Status": "modifying",
"CustSubscriptionId": "my-instance-events",
"CustomerAwsId": "123456789012",
"SourceIdsList": [
"test-instance"
],
"SourceType": "db-instance",
"Enabled": false
}
}
```
+ Per i dettagli sull'API, consulta [RemoveSourceIdentifierFromSubscription AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/remove-source-identifier-from-subscription.html)*Command Reference*.
### `remove-tags-from-resource`
Il seguente esempio di codice mostra come utilizzare`remove-tags-from-resource`.
**AWS CLI**
**Come rimuovere tag da una risorsa**
L’esempio `remove-tags-from-resource` seguente rimuove i tag da una risorsa.
```
aws rds remove-tags-from-resource \
--resource-name arn:aws:rds:us-east-1:123456789012:db:mydbinstance \
--tag-keys Name Environment
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Tagging delle risorse Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Tagging.html) nella *Guida per l’utente di Amazon RDS* e [Tagging delle risorse Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [RemoveTagsFromResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/remove-tags-from-resource.html)*Command Reference*.
### `reset-db-cluster-parameter-group`
Il seguente esempio di codice mostra come utilizzare`reset-db-cluster-parameter-group`.
**AWS CLI**
**Esempio 1: come reimpostare tutti i parametri sui valori predefiniti**
L’esempio `reset-db-cluster-parameter-group` seguente reimposta i valori dei parametri in un gruppo di parametri del cluster di database creato dal cliente sui valori predefiniti.
```
aws rds reset-db-cluster-parameter-group \
--db-cluster-parameter-group-name mydbclpg \
--reset-all-parameters
```
Output:
```
{
"DBClusterParameterGroupName": "mydbclpg"
}
```
Per ulteriori informazioni, consulta [Uso di gruppi di parametri database e gruppi di parametri cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon Aurora*.
**Esempio 2: come reimpostare i parametri specifici ai valori predefiniti**
L’esempio `reset-db-cluster-parameter-group` seguente reimposta i valori dei parametri per parametri specifici sui valori predefiniti in un gruppo di parametri del cluster di database creato dal cliente.
```
aws rds reset-db-cluster-parameter-group \
--db-cluster-parameter-group-name mydbclpgy \
--parameters "ParameterName=max_connections,ApplyMethod=immediate" \
"ParameterName=max_allowed_packet,ApplyMethod=immediate"
```
Output:
```
{
"DBClusterParameterGroupName": "mydbclpg"
}
```
Per ulteriori informazioni, consulta [Uso di gruppi di parametri database e gruppi di parametri cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [ResetDbClusterParameterGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/reset-db-cluster-parameter-group.html)*Command Reference*.
### `reset-db-parameter-group`
Il seguente esempio di codice mostra come utilizzare`reset-db-parameter-group`.
**AWS CLI**
**Esempio 1: come reimpostare tutti i parametri sui valori predefiniti**
L’esempio `reset-db-parameter-group` seguente reimposta tutti i valori dei parametri in un gruppo di parametri database creato dal cliente sui valori predefiniti.
```
aws rds reset-db-parameter-group \
--db-parameter-group-name mypg \
--reset-all-parameters
```
Output:
```
{
"DBParameterGroupName": "mypg"
}
```
Per ulteriori informazioni, consulta [Utilizzo di gruppi di parametri di database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l‘utente di Amazon RDS* e [Uso di gruppi di parametri database e gruppi di parametri cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon Aurora*.
**Esempio 2: come reimpostare i parametri specifici ai valori predefiniti**
L’esempio `reset-db-parameter-group` seguente reimposta i valori dei parametri per parametri specifici sui valori predefiniti in un gruppo di parametri database creato dal cliente.
```
aws rds reset-db-parameter-group \
--db-parameter-group-name mypg \
--parameters "ParameterName=max_connections,ApplyMethod=immediate" \
"ParameterName=max_allowed_packet,ApplyMethod=immediate"
```
Output:
```
{
"DBParameterGroupName": "mypg"
}
```
Per ulteriori informazioni, consulta [Utilizzo di gruppi di parametri di database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l‘utente di Amazon RDS* e [Uso di gruppi di parametri database e gruppi di parametri cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [ResetDbParameterGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/reset-db-parameter-group.html)*Command Reference*.
### `restore-db-cluster-from-s3`
Il seguente esempio di codice mostra come utilizzare`restore-db-cluster-from-s3`.
**AWS CLI**
**Come ripristinare un cluster di database Amazon Aurora da Amazon S3**
L’esempio `restore-db-cluster-from-s3` seguente ripristina un cluster di database compatibile con Amazon Aurora MySQL versione 5.7 da un file di backup del database MySQL 5.7 in Amazon S3.
```
aws rds restore-db-cluster-from-s3 \
--db-cluster-identifier cluster-s3-restore \
--engine aurora-mysql \
--master-username admin \
--master-user-password mypassword \
--s3-bucket-name amzn-s3-demo-bucket \
--s3-prefix test-backup \
--s3-ingestion-role-arn arn:aws:iam::123456789012:role/service-role/TestBackup \
--source-engine mysql \
--source-engine-version 5.7.28
```
Output:
```
{
"DBCluster": {
"AllocatedStorage": 1,
"AvailabilityZones": [
"us-west-2c",
"us-west-2a",
"us-west-2b"
],
"BackupRetentionPeriod": 1,
"DBClusterIdentifier": "cluster-s3-restore",
"DBClusterParameterGroup": "default.aurora-mysql5.7",
"DBSubnetGroup": "default",
"Status": "creating",
"Endpoint": "cluster-s3-restore.cluster-co3xyzabc123.us-west-2.rds.amazonaws.com",
"ReaderEndpoint": "cluster-s3-restore.cluster-ro-co3xyzabc123.us-west-2.rds.amazonaws.com",
"MultiAZ": false,
"Engine": "aurora-mysql",
"EngineVersion": "5.7.12",
"Port": 3306,
"MasterUsername": "admin",
"PreferredBackupWindow": "11:15-11:45",
"PreferredMaintenanceWindow": "thu:12:19-thu:12:49",
"ReadReplicaIdentifiers": [],
"DBClusterMembers": [],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-########",
"Status": "active"
}
],
"HostedZoneId": "Z1PVIF0EXAMPLE",
"StorageEncrypted": false,
"DbClusterResourceId": "cluster-SU5THYQQHOWCXZZDGXREXAMPLE",
"DBClusterArn": "arn:aws:rds:us-west-2:123456789012:cluster:cluster-s3-restore",
"AssociatedRoles": [],
"IAMDatabaseAuthenticationEnabled": false,
"ClusterCreateTime": "2020-07-27T14:22:08.095Z",
"EngineMode": "provisioned",
"DeletionProtection": false,
"HttpEndpointEnabled": false,
"CopyTagsToSnapshot": false,
"CrossAccountClone": false,
"DomainMemberships": []
}
}
```
Per ulteriori informazioni, consulta [Migrazione dei dati da MySQL utilizzando un bucket Amazon S3](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Migrating.ExtMySQL.html#AuroraMySQL.Migrating.ExtMySQL.S3) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [RestoreDbClusterFromS3](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/restore-db-cluster-from-s3.html) in *AWS CLI Command Reference.*
### `restore-db-cluster-from-snapshot`
Il seguente esempio di codice mostra come usare`restore-db-cluster-from-snapshot`.
**AWS CLI**
**Come ripristinare un cluster di database da uno snapshot**
L’esempio `restore-db-cluster-from-snapshot` seguente ripristina un cluster di database Aurora PostgreSQL compatibile con PostgreSQL versione 10.7 da uno snapshot del cluster di database denominato `test-instance-snapshot`.
```
aws rds restore-db-cluster-from-snapshot \
--db-cluster-identifier newdbcluster \
--snapshot-identifier test-instance-snapshot \
--engine aurora-postgresql \
--engine-version 10.7
```
Output:
```
{
"DBCluster": {
"AllocatedStorage": 1,
"AvailabilityZones": [
"us-west-2c",
"us-west-2a",
"us-west-2b"
],
"BackupRetentionPeriod": 7,
"DatabaseName": "",
"DBClusterIdentifier": "newdbcluster",
"DBClusterParameterGroup": "default.aurora-postgresql10",
"DBSubnetGroup": "default",
"Status": "creating",
"Endpoint": "newdbcluster.cluster-############.us-west-2.rds.amazonaws.com",
"ReaderEndpoint": "newdbcluster.cluster-ro-############.us-west-2.rds.amazonaws.com",
"MultiAZ": false,
"Engine": "aurora-postgresql",
"EngineVersion": "10.7",
"Port": 5432,
"MasterUsername": "postgres",
"PreferredBackupWindow": "09:33-10:03",
"PreferredMaintenanceWindow": "sun:12:22-sun:12:52",
"ReadReplicaIdentifiers": [],
"DBClusterMembers": [],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-########",
"Status": "active"
}
],
"HostedZoneId": "Z1PVIF0EXAMPLE",
"StorageEncrypted": true,
"KmsKeyId": "arn:aws:kms:us-west-2:123456789012:key/287364e4-33e3-4755-a3b0-a1b2c3d4e5f6",
"DbClusterResourceId": "cluster-5DSB5IFQDDUVAWOUWM1EXAMPLE",
"DBClusterArn": "arn:aws:rds:us-west-2:123456789012:cluster:newdbcluster",
"AssociatedRoles": [],
"IAMDatabaseAuthenticationEnabled": false,
"ClusterCreateTime": "2020-06-05T15:06:58.634Z",
"EngineMode": "provisioned",
"DeletionProtection": false,
"HttpEndpointEnabled": false,
"CopyTagsToSnapshot": false,
"CrossAccountClone": false,
"DomainMemberships": []
}
}
```
Per ulteriori informazioni, consulta [Ripristino da uno snapshot cluster database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_RestoreFromSnapshot.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [RestoreDbClusterFromSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/restore-db-cluster-from-snapshot.html)*Command Reference*.
### `restore-db-cluster-to-point-in-time`
Il seguente esempio di codice mostra come utilizzare`restore-db-cluster-to-point-in-time`.
**AWS CLI**
**Come ripristinare un cluster di database a un determinato momento**
L’esempio `restore-db-cluster-to-point-in-time` seguente ripristina il cluster di database denominato `database-4` all’ora più recente possibile. L’utilizzo di `copy-on-write` come tipo di ripristino consente di ripristinare il nuovo cluster di database come clone del cluster di database di origine.
```
aws rds restore-db-cluster-to-point-in-time \
--source-db-cluster-identifier database-4 \
--db-cluster-identifier sample-cluster-clone \
--restore-type copy-on-write \
--use-latest-restorable-time
```
Output:
```
{
"DBCluster": {
"AllocatedStorage": 1,
"AvailabilityZones": [
"us-west-2c",
"us-west-2a",
"us-west-2b"
],
"BackupRetentionPeriod": 7,
"DatabaseName": "",
"DBClusterIdentifier": "sample-cluster-clone",
"DBClusterParameterGroup": "default.aurora-postgresql10",
"DBSubnetGroup": "default",
"Status": "creating",
"Endpoint": "sample-cluster-clone.cluster-############.us-west-2.rds.amazonaws.com",
"ReaderEndpoint": "sample-cluster-clone.cluster-ro-############.us-west-2.rds.amazonaws.com",
"MultiAZ": false,
"Engine": "aurora-postgresql",
"EngineVersion": "10.7",
"Port": 5432,
"MasterUsername": "postgres",
"PreferredBackupWindow": "09:33-10:03",
"PreferredMaintenanceWindow": "sun:12:22-sun:12:52",
"ReadReplicaIdentifiers": [],
"DBClusterMembers": [],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-########",
"Status": "active"
}
],
"HostedZoneId": "Z1PVIF0EXAMPLE",
"StorageEncrypted": true,
"KmsKeyId": "arn:aws:kms:us-west-2:123456789012:key/287364e4-33e3-4755-a3b0-a1b2c3d4e5f6",
"DbClusterResourceId": "cluster-BIZ77GDSA2XBSTNPFW1EXAMPLE",
"DBClusterArn": "arn:aws:rds:us-west-2:123456789012:cluster:sample-cluster-clone",
"AssociatedRoles": [],
"IAMDatabaseAuthenticationEnabled": false,
"CloneGroupId": "8d19331a-099a-45a4-b4aa-11aa22bb33cc44dd",
"ClusterCreateTime": "2020-03-10T19:57:38.967Z",
"EngineMode": "provisioned",
"DeletionProtection": false,
"HttpEndpointEnabled": false,
"CopyTagsToSnapshot": false,
"CrossAccountClone": false
}
}
```
Per ulteriori informazioni, consulta [Ripristino di un cluster DB a un’ora specificata](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_PIT.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [RestoreDbClusterToPointInTime AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/restore-db-cluster-to-point-in-time.html)*Command Reference*.
### `restore-db-instance-from-db-snapshot`
Il seguente esempio di codice mostra come utilizzare`restore-db-instance-from-db-snapshot`.
**AWS CLI**
**Come ripristinare un’istanza database da uno snapshot di database**
L’esempio `restore-db-instance-from-db-snapshot` seguente crea una nuova istanza database denominata `db7-new-instance` con la classe di istanza database `db.t3.small` dallo snapshot database specificato. L’istanza database di origine da cui è stata acquisita lo snapshot utilizza una classe di istanza database obsoleta, quindi non è possibile aggiornarla.
```
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier db7-new-instance \
--db-snapshot-identifier db7-test-snapshot \
--db-instance-class db.t3.small
```
Output:
```
{
"DBInstance": {
"DBInstanceIdentifier": "db7-new-instance",
"DBInstanceClass": "db.t3.small",
"Engine": "mysql",
"DBInstanceStatus": "creating",
...output omitted...
"PreferredMaintenanceWindow": "mon:07:37-mon:08:07",
"PendingModifiedValues": {},
"MultiAZ": false,
"EngineVersion": "5.7.22",
"AutoMinorVersionUpgrade": true,
"ReadReplicaDBInstanceIdentifiers": [],
"LicenseModel": "general-public-license",
...output omitted...
"DBInstanceArn": "arn:aws:rds:us-west-2:123456789012:db:db7-new-instance",
"IAMDatabaseAuthenticationEnabled": false,
"PerformanceInsightsEnabled": false,
"DeletionProtection": false,
"AssociatedRoles": []
}
}
```
Per ulteriori informazioni, consulta [Ripristino da uno snapshot di database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RestoreFromSnapshot.html) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [RestoreDbInstanceFromDbSnapshot AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/restore-db-instance-from-db-snapshot.html)*Command Reference*.
### `restore-db-instance-from-s3`
Il seguente esempio di codice mostra come utilizzare`restore-db-instance-from-s3`.
**AWS CLI**
**Come ripristinare un’istanza database da un backup in Amazon S3**
L’esempio `restore-db-instance-from-s3` seguente crea una nuova istanza database denominata `restored-test-instance` da un backup esistente nel bucket S3 `my-backups`.
```
aws rds restore-db-instance-from-s3 \
--db-instance-identifier restored-test-instance \
--allocated-storage 250 --db-instance-class db.m4.large --engine mysql \
--master-username master --master-user-password secret99 \
--s3-bucket-name my-backups --s3-ingestion-role-arn arn:aws:iam::123456789012:role/my-role \
--source-engine mysql --source-engine-version 5.6.27
```
+ Per i dettagli sull'API, consulta [RestoreDbInstanceFromS3](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/restore-db-instance-from-s3.html) in *AWS CLI Command Reference.*
### `restore-db-instance-to-point-in-time`
Il seguente esempio di codice mostra come usare`restore-db-instance-to-point-in-time`.
**AWS CLI**
**Esempio 1: come ripristinare un’istanza database a un punto temporale**
L’esempio `restore-db-instance-to-point-in-time` seguente reimposta `test-instance` su una nuova istanza database denominata `restored-test-instance`, a partire dal tempo specificato.
```
aws rds restore-db-instance-to-point-in-time \
--source-db-instance-identifier test-instance \
--target-db-instance restored-test-instance \
--restore-time 2018-07-30T23:45:00.000Z
```
Output:
```
{
"DBInstance": {
"AllocatedStorage": 20,
"DBInstanceArn": "arn:aws:rds:us-east-1:123456789012:db:restored-test-instance",
"DBInstanceStatus": "creating",
"DBInstanceIdentifier": "restored-test-instance",
...some output omitted...
}
}
```
Per ulteriori informazioni, consulta [Ripristino a un’ora specifica per un’istanza database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_PIT.html) nella *Guida per l’utente di Amazon RDS*.
**Esempio 2: come ripristinare un’istanza database a un’ora specificata da un backup replicato**
L’esempio `restore-db-instance-to-point-in-time` seguente ripristina un’istanza database Oracle all’ora specificata da un backup automatico replicato.
```
aws rds restore-db-instance-to-point-in-time \
--source-db-instance-automated-backups-arn "arn:aws:rds:us-west-2:123456789012:auto-backup:ab-jkib2gfq5rv7replzadausbrktni2bn4example" \
--target-db-instance-identifier myorclinstance-from-replicated-backup \
--restore-time 2020-12-08T18:45:00.000Z
```
Output:
```
{
"DBInstance": {
"DBInstanceIdentifier": "myorclinstance-from-replicated-backup",
"DBInstanceClass": "db.t3.micro",
"Engine": "oracle-se2",
"DBInstanceStatus": "creating",
"MasterUsername": "admin",
"DBName": "ORCL",
"AllocatedStorage": 20,
"PreferredBackupWindow": "07:45-08:15",
"BackupRetentionPeriod": 14,
... some output omitted ...
"DbiResourceId": "db-KGLXG75BGVIWKQT7NQ4EXAMPLE",
"CACertificateIdentifier": "rds-ca-2019",
"DomainMemberships": [],
"CopyTagsToSnapshot": false,
"MonitoringInterval": 0,
"DBInstanceArn": "arn:aws:rds:us-west-2:123456789012:db:myorclinstance-from-replicated-backup",
"IAMDatabaseAuthenticationEnabled": false,
"PerformanceInsightsEnabled": false,
"DeletionProtection": false,
"AssociatedRoles": [],
"TagList": []
}
}
```
Per ulteriori informazioni, consulta [Ripristino a un’ora specificata da un backup replicato](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReplicateBackups.html#AutomatedBackups.PiTR) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [RestoreDbInstanceToPointInTime AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/restore-db-instance-to-point-in-time.html)*Command Reference*.
### `start-activity-stream`
Il seguente esempio di codice mostra come utilizzare`start-activity-stream`.
**AWS CLI**
**Come avviare un flusso di attività del database**
L'`start-activity-stream`esempio seguente avvia un flusso di attività asincrono per monitorare un cluster Aurora denominato. my-pg-cluster
```
aws rds start-activity-stream \
--region us-east-1 \
--mode async \
--kms-key-id arn:aws:kms:us-east-1:1234567890123:key/a12c345d-6ef7-890g-h123-456i789jk0l1 \
--resource-arn arn:aws:rds:us-east-1:1234567890123:cluster:my-pg-cluster \
--apply-immediately
```
Output:
```
{
"KmsKeyId": "arn:aws:kms:us-east-1:1234567890123:key/a12c345d-6ef7-890g-h123-456i789jk0l1",
"KinesisStreamName": "aws-rds-das-cluster-0ABCDEFGHI1JKLM2NOPQ3R4S",
"Status": "starting",
"Mode": "async",
"ApplyImmediately": true
}
```
Per ulteriori informazioni, consulta [Avvio di un flusso di attività di database](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.html#DBActivityStreams.Enabling) nella *Guida per l’utente di Amazon Aurora*.
+ *Per i dettagli sull'API, consulta [StartActivityStream](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/start-activity-stream.html)Command Reference.AWS CLI *
### `start-db-cluster`
Il seguente esempio di codice mostra come utilizzare`start-db-cluster`.
**AWS CLI**
**Come avviare un cluster di database**
L’esempio `start-db-cluster` seguente avvia un cluster di database e le relative istanze database.
```
aws rds start-db-cluster \
--db-cluster-identifier mydbcluster
```
Output:
```
{
"DBCluster": {
"AllocatedStorage": 1,
"AvailabilityZones": [
"us-east-1a",
"us-east-1e",
"us-east-1b"
],
"BackupRetentionPeriod": 1,
"DatabaseName": "mydb",
"DBClusterIdentifier": "mydbcluster",
...some output truncated...
}
}
```
Per ulteriori informazioni, consulta [Avvio e arresto di un cluster DB Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-cluster-stop-start.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [StartDbCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/start-db-cluster.html)*Command Reference*.
### `start-db-instance-automated-backups-replication`
Il seguente esempio di codice mostra come utilizzare`start-db-instance-automated-backups-replication`.
**AWS CLI**
**Come abilitare i backup automatici tra Regioni**
L’esempio `start-db-instance-automated-backups-replication` seguente replica i backup automatici da un’istanza database nella Regione Stati Uniti orientali (Virginia settentrionale) alla Regione Stati Uniti occidentali (Oregon). Il periodo di conservazione dei backup è di 14 giorni.
```
aws rds start-db-instance-automated-backups-replication \
--region us-west-2 \
--source-db-instance-arn "arn:aws:rds:us-east-1:123456789012:db:new-orcl-db" \
--backup-retention-period 14
```
Output:
```
{
"DBInstanceAutomatedBackup": {
"DBInstanceArn": "arn:aws:rds:us-east-1:123456789012:db:new-orcl-db",
"DbiResourceId": "db-JKIB2GFQ5RV7REPLZA4EXAMPLE",
"Region": "us-east-1",
"DBInstanceIdentifier": "new-orcl-db",
"RestoreWindow": {},
"AllocatedStorage": 20,
"Status": "pending",
"Port": 1521,
"InstanceCreateTime": "2020-12-04T15:28:31Z",
"MasterUsername": "admin",
"Engine": "oracle-se2",
"EngineVersion": "12.1.0.2.v21",
"LicenseModel": "bring-your-own-license",
"OptionGroupName": "default:oracle-se2-12-1",
"Encrypted": false,
"StorageType": "gp2",
"IAMDatabaseAuthenticationEnabled": false,
"BackupRetentionPeriod": 14,
"DBInstanceAutomatedBackupsArn": "arn:aws:rds:us-west-2:123456789012:auto-backup:ab-jkib2gfq5rv7replzadausbrktni2bn4example"
}
}
```
Per ulteriori informazioni, consulta [Abilitazione dei backup automatici tra Regioni](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReplicateBackups.html#AutomatedBackups.Replicating.Enable) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [StartDbInstanceAutomatedBackupsReplication AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/start-db-instance-automated-backups-replication.html)*Command Reference*.
### `start-db-instance`
Il seguente esempio di codice mostra come utilizzare`start-db-instance`.
**AWS CLI**
**Come avviare un’istanza database**
L’esempio `start-db-instance` seguente avvia la registrazione dell’istanza database specificata.
```
aws rds start-db-instance \
--db-instance-identifier test-instance
```
Output:
```
{
"DBInstance": {
"DBInstanceStatus": "starting",
...some output truncated...
}
}
```
+ Per i dettagli sull'API, consulta [StartDbInstance AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/start-db-instance.html)*Command Reference*.
### `start-export-task`
Il seguente esempio di codice mostra come utilizzare`start-export-task`.
**AWS CLI**
**Come esportare uno snapshot in Amazon S3**
L’esempio `start-export-task` seguente esporta uno snapshot database denominato `db5-snapshot-test` nel bucket Amazon S3 denominato `amzn-s3-demo-bucket`.
```
aws rds start-export-task \
--export-task-identifier my-s3-export \
--source-arn arn:aws:rds:us-west-2:123456789012:snapshot:db5-snapshot-test \
--s3-bucket-name amzn-s3-demo-bucket \
--iam-role-arn arn:aws:iam::123456789012:role/service-role/ExportRole \
--kms-key-id arn:aws:kms:us-west-2:123456789012:key/abcd0000-7fca-4128-82f2-aabbccddeeff
```
Output:
```
{
"ExportTaskIdentifier": "my-s3-export",
"SourceArn": "arn:aws:rds:us-west-2:123456789012:snapshot:db5-snapshot-test",
"SnapshotTime": "2020-03-27T20:48:42.023Z",
"S3Bucket": "amzn-s3-demo-bucket",
"IamRoleArn": "arn:aws:iam::123456789012:role/service-role/ExportRole",
"KmsKeyId": "arn:aws:kms:us-west-2:123456789012:key/abcd0000-7fca-4128-82f2-aabbccddeeff",
"Status": "STARTING",
"PercentProgress": 0,
"TotalExtractedDataInGB": 0
}
```
Per ulteriori informazioni, consulta [Esportazione di uno snapshot in un bucket Amazon S3](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ExportSnapshot.html#USER_ExportSnapshot.Exporting) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [StartExportTask AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/start-export-task.html)*Command Reference*.
### `stop-activity-stream`
Il seguente esempio di codice mostra come utilizzare`stop-activity-stream`.
**AWS CLI**
**Come arrestare un flusso di attività del database**
L'`stop-activity-stream`esempio seguente interrompe un flusso di attività in un cluster Aurora denominato. my-pg-cluster
```
aws rds stop-activity-stream \
--region us-east-1 \
--resource-arn arn:aws:rds:us-east-1:1234567890123:cluster:my-pg-cluster \
--apply-immediately
```
Output:
```
{
"KmsKeyId": "arn:aws:kms:us-east-1:1234567890123:key/a12c345d-6ef7-890g-h123-456i789jk0l1",
"KinesisStreamName": "aws-rds-das-cluster-0ABCDEFGHI1JKLM2NOPQ3R4S",
"Status": "stopping"
}
```
Per ulteriori informazioni, consulta [Arresto di un flusso di attività](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.html#DBActivityStreams.Disabling) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [StopActivityStream AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/stop-activity-stream.html)*Command Reference.*
### `stop-db-cluster`
Il seguente esempio di codice mostra come utilizzare`stop-db-cluster`.
**AWS CLI**
**Come arrestare un cluster di database**
L’esempio `stop-db-cluster` seguente arresta un cluster di database e le relative istanze database.
```
aws rds stop-db-cluster \
--db-cluster-identifier mydbcluster
```
Output:
```
{
"DBCluster": {
"AllocatedStorage": 1,
"AvailabilityZones": [
"us-east-1a",
"us-east-1e",
"us-east-1b"
],
"BackupRetentionPeriod": 1,
"DatabaseName": "mydb",
"DBClusterIdentifier": "mydbcluster",
...some output truncated...
}
}
```
Per ulteriori informazioni, consulta [Avvio e arresto di un cluster DB Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-cluster-stop-start.html) nella *Guida per l’utente di Amazon Aurora*.
+ Per i dettagli sull'API, consulta [StopDbCluster AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/stop-db-cluster.html)*Command Reference*.
### `stop-db-instance-automated-backups-replication`
Il seguente esempio di codice mostra come utilizzare`stop-db-instance-automated-backups-replication`.
**AWS CLI**
**Come arrestare la replica dei backup automatici**
L’esempio `stop-db-instance-automated-backups-replication` seguente termina la replica dei backup automatici nella Regione Stati Uniti occidentali (Oregon). I backup replicati vengono mantenuti in base al periodo di conservazione dei backup impostato.
```
aws rds stop-db-instance-automated-backups-replication \
--region us-west-2 \
--source-db-instance-arn "arn:aws:rds:us-east-1:123456789012:db:new-orcl-db"
```
Output:
```
{
"DBInstanceAutomatedBackup": {
"DBInstanceArn": "arn:aws:rds:us-east-1:123456789012:db:new-orcl-db",
"DbiResourceId": "db-JKIB2GFQ5RV7REPLZA4EXAMPLE",
"Region": "us-east-1",
"DBInstanceIdentifier": "new-orcl-db",
"RestoreWindow": {
"EarliestTime": "2020-12-04T23:13:21.030Z",
"LatestTime": "2020-12-07T19:59:57Z"
},
"AllocatedStorage": 20,
"Status": "replicating",
"Port": 1521,
"InstanceCreateTime": "2020-12-04T15:28:31Z",
"MasterUsername": "admin",
"Engine": "oracle-se2",
"EngineVersion": "12.1.0.2.v21",
"LicenseModel": "bring-your-own-license",
"OptionGroupName": "default:oracle-se2-12-1",
"Encrypted": false,
"StorageType": "gp2",
"IAMDatabaseAuthenticationEnabled": false,
"BackupRetentionPeriod": 7,
"DBInstanceAutomatedBackupsArn": "arn:aws:rds:us-west-2:123456789012:auto-backup:ab-jkib2gfq5rv7replzadausbrktni2bn4example"
}
}
```
Per ulteriori informazioni, consulta [Arresto della replica di backup automatici](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReplicateBackups.html#AutomatedBackups.StopReplicating) nella *Guida per l’utente di Amazon RDS*.
+ Per i dettagli sull'API, consulta [StopDbInstanceAutomatedBackupsReplication AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/stop-db-instance-automated-backups-replication.html)*Command Reference*.
### `stop-db-instance`
Il seguente esempio di codice mostra come utilizzare`stop-db-instance`.
**AWS CLI**
**Come arrestare un’istanza database**
L’esempio `stop-db-instance` seguente arresta l’istanza database specificata.
```
aws rds stop-db-instance \
--db-instance-identifier test-instance
```
Output:
```
{
"DBInstance": {
"DBInstanceStatus": "stopping",
...some output truncated...
}
}
```
+ Per i dettagli sull'API, consulta [StopDbInstance AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/stop-db-instance.html)*Command Reference*.
### `switchover-blue-green-deployment`
Il seguente esempio di codice mostra come utilizzare`switchover-blue-green-deployment`.
**AWS CLI**
**Esempio 1: cambiare una blue/green distribuzione per un'istanza DB RDS**
L’esempio `switchover-blue-green-deployment` seguente promuove l’ambiente verde specificato a nuovo ambiente di produzione.
```
aws rds switchover-blue-green-deployment \
--blue-green-deployment-identifier bgd-wi89nwzglccsfake \
--switchover-timeout 300
```
Output:
```
{
"BlueGreenDeployment": {
"BlueGreenDeploymentIdentifier": "bgd-v53303651eexfake",
"BlueGreenDeploymentName": "bgd-cli-test-instance",
"Source": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance",
"Target": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-green-blhi1e",
"SwitchoverDetails": [
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-green-blhi1e",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-1-green-k5fv7u",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-2",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-2-green-ggsh8m",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-3",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-db-instance-replica-3-green-o2vwm0",
"Status": "AVAILABLE"
}
],
"Tasks": [
{
"Name": "CREATING_READ_REPLICA_OF_SOURCE",
"Status": "COMPLETED"
},
{
"Name": "DB_ENGINE_VERSION_UPGRADE",
"Status": "COMPLETED"
},
{
"Name": "CONFIGURE_BACKUPS",
"Status": "COMPLETED"
},
{
"Name": "CREATING_TOPOLOGY_OF_SOURCE",
"Status": "COMPLETED"
}
],
"Status": "SWITCHOVER_IN_PROGRESS",
"CreateTime": "2022-02-25T22:33:22.225000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Switching a blue/green deployment](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/blue-green-deployments-switching.html) nella *Amazon RDS User Guide*.
**Esempio 2: promuovere una blue/green distribuzione per un cluster Aurora MySQL DB**
L’esempio `switchover-blue-green-deployment` seguente promuove l’ambiente verde specificato a nuovo ambiente di produzione.
```
aws rds switchover-blue-green-deployment \
--blue-green-deployment-identifier bgd-wi89nwzglccsfake \
--switchover-timeout 300
```
Output:
```
{
"BlueGreenDeployment": {
"BlueGreenDeploymentIdentifier": "bgd-wi89nwzglccsfake",
"BlueGreenDeploymentName": "my-blue-green-deployment",
"Source": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"Target": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster-green-3ud8z6",
"SwitchoverDetails": [
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster:my-aurora-mysql-cluster-green-3ud8z6",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-1",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-1-green-bvxc73",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-2",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-2-green-7wc4ie",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-3",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:db:my-aurora-mysql-cluster-3-green-p4xxkz",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-excluded-member-endpoint",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-excluded-member-endpoint-green-np1ikl",
"Status": "AVAILABLE"
},
{
"SourceMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-reader-endpoint",
"TargetMember": "arn:aws:rds:us-east-1:123456789012:cluster-endpoint:my-reader-endpoint-green-miszlf",
"Status": "AVAILABLE"
}
],
"Tasks": [
{
"Name": "CREATING_READ_REPLICA_OF_SOURCE",
"Status": "COMPLETED"
},
{
"Name": "DB_ENGINE_VERSION_UPGRADE",
"Status": "COMPLETED"
},
{
"Name": "CREATE_DB_INSTANCES_FOR_CLUSTER",
"Status": "COMPLETED"
},
{
"Name": "CREATE_CUSTOM_ENDPOINTS",
"Status": "COMPLETED"
}
],
"Status": "SWITCHOVER_IN_PROGRESS",
"CreateTime": "2022-02-25T22:38:49.522000+00:00"
}
}
```
Per ulteriori informazioni, consulta [Switching a blue/green deployment](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-switching.html) nella *Amazon Aurora User* Guide.
+ Per i dettagli sull'API, consulta [SwitchoverBlueGreenDeployment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/switchover-blue-green-deployment.html)*Command Reference.*