@aws-sdk/client-rds
Advanced tools
AWS SDK for JavaScript Rds Client for Node.js, Browser and React Native
The @aws-sdk/client-rds package is part of the AWS SDK for JavaScript. It allows developers to interact with Amazon Relational Database Service (RDS) programmatically. This includes creating, managing, and deleting RDS instances, managing databases, and handling backups and snapshots.
CreateDBInstance
This feature allows you to create a new RDS instance. The code sample demonstrates how to create a MySQL database instance with specific parameters such as instance identifier, storage, instance class, engine type, and master username and password.
const { RDSClient, CreateDBInstanceCommand } = require('@aws-sdk/client-rds');
const client = new RDSClient({ region: 'us-west-2' });
const params = {
DBInstanceIdentifier: 'mydbinstance',
AllocatedStorage: 20,
DBInstanceClass: 'db.t2.micro',
Engine: 'mysql',
MasterUsername: 'admin',
MasterUserPassword: 'password123'
};
const run = async () => {
try {
const data = await client.send(new CreateDBInstanceCommand(params));
console.log('DB Instance Created', data);
} catch (err) {
console.error(err);
}
};
run();DescribeDBInstances
This feature allows you to retrieve information about your RDS instances. The code sample demonstrates how to describe all RDS instances in a specific region.
const { RDSClient, DescribeDBInstancesCommand } = require('@aws-sdk/client-rds');
const client = new RDSClient({ region: 'us-west-2' });
const run = async () => {
try {
const data = await client.send(new DescribeDBInstancesCommand({}));
console.log('DB Instances', data);
} catch (err) {
console.error(err);
}
};
run();DeleteDBInstance
This feature allows you to delete an existing RDS instance. The code sample demonstrates how to delete a database instance by specifying the instance identifier and skipping the final snapshot.
const { RDSClient, DeleteDBInstanceCommand } = require('@aws-sdk/client-rds');
const client = new RDSClient({ region: 'us-west-2' });
const params = {
DBInstanceIdentifier: 'mydbinstance',
SkipFinalSnapshot: true
};
const run = async () => {
try {
const data = await client.send(new DeleteDBInstanceCommand(params));
console.log('DB Instance Deleted', data);
} catch (err) {
console.error(err);
}
};
run();The 'pg' package is a PostgreSQL client for Node.js. It allows you to interact with PostgreSQL databases, including executing SQL queries and managing database connections. Unlike @aws-sdk/client-rds, which is specific to AWS RDS, 'pg' is specific to PostgreSQL and does not provide management features for other types of databases or cloud services.
The 'mysql' package is a MySQL client for Node.js. It allows you to interact with MySQL databases, including executing SQL queries and managing database connections. Similar to 'pg', it is specific to MySQL and does not provide the broader management capabilities for RDS instances that @aws-sdk/client-rds offers.
Sequelize is a promise-based Node.js ORM for various SQL databases, including MySQL, PostgreSQL, SQLite, and MSSQL. It provides a higher-level abstraction for database operations, including model definitions and associations. While it can be used with RDS databases, it does not provide the direct management capabilities for RDS instances that @aws-sdk/client-rds does.
AWS SDK for JavaScript RDS Client for Node.js, Browser and React Native.
Amazon Relational Database Service
Amazon Relational Database Service (Amazon RDS) is a web service that makes it easier to set up, operate, and scale a relational database in the cloud. It provides cost-efficient, resizeable capacity for an industry-standard relational database and manages common database administration tasks, freeing up developers to focus on what makes their applications and businesses unique.
Amazon RDS gives you access to the capabilities of a MySQL, MariaDB, PostgreSQL, Microsoft SQL Server, Oracle, Db2, or Amazon Aurora database server. These capabilities mean that the code, applications, and tools you already use today with your existing databases work with Amazon RDS without modification. Amazon RDS automatically backs up your database and maintains the database software that powers your DB instance. Amazon RDS is flexible: you can scale your DB instance's compute resources and storage capacity to meet your application's demand. As with all Amazon Web Services, there are no up-front investments, and you pay only for the resources you use.
This interface reference for Amazon RDS contains documentation for a programming or command line interface you can use to manage Amazon RDS. Amazon RDS is asynchronous, which means that some interfaces might require techniques such as polling or callback functions to determine when a command has been applied. In this reference, the parameter descriptions indicate whether a command is applied immediately, on the next instance reboot, or during the maintenance window. The reference structure is as follows, and we list following some related topics from the user guide.
Amazon RDS API Reference
For the alphabetical list of API actions, see API Actions.
For the alphabetical list of data types, see Data Types.
For a list of common query parameters, see Common Parameters.
For descriptions of the error codes, see Common Errors.
Amazon RDS User Guide
For a summary of the Amazon RDS interfaces, see Available RDS Interfaces.
For more information about how to use the Query API, see Using the Query API.
To install the this package, simply type add or install @aws-sdk/client-rds using your favorite package manager:
npm install @aws-sdk/client-rdsyarn add @aws-sdk/client-rdspnpm add @aws-sdk/client-rdsThe AWS SDK is modulized by clients and commands.
To send a request, you only need to import the RDSClient and
the commands you need, for example ListTagsForResourceCommand:
// ES5 example
const { RDSClient, ListTagsForResourceCommand } = require("@aws-sdk/client-rds");
// ES6+ example
import { RDSClient, ListTagsForResourceCommand } from "@aws-sdk/client-rds";
To send a request, you:
send operation on client with command object as input.destroy() to close open connections.// a client can be shared by different commands.
const client = new RDSClient({ region: "REGION" });
const params = {
/** input parameters */
};
const command = new ListTagsForResourceCommand(params);
We recommend using await operator to wait for the promise returned by send operation as follows:
// async/await.
try {
const data = await client.send(command);
// process data.
} catch (error) {
// error handling.
} finally {
// finally.
}
Async-await is clean, concise, intuitive, easy to debug and has better error handling as compared to using Promise chains or callbacks.
You can also use Promise chaining to execute send operation.
client.send(command).then(
(data) => {
// process data.
},
(error) => {
// error handling.
}
);
Promises can also be called using .catch() and .finally() as follows:
client
.send(command)
.then((data) => {
// process data.
})
.catch((error) => {
// error handling.
})
.finally(() => {
// finally.
});
We do not recommend using callbacks because of callback hell, but they are supported by the send operation.
// callbacks.
client.send(command, (err, data) => {
// process err and data.
});
The client can also send requests using v2 compatible style. However, it results in a bigger bundle size and may be dropped in next major version. More details in the blog post on modular packages in AWS SDK for JavaScript
import * as AWS from "@aws-sdk/client-rds";
const client = new AWS.RDS({ region: "REGION" });
// async/await.
try {
const data = await client.listTagsForResource(params);
// process data.
} catch (error) {
// error handling.
}
// Promises.
client
.listTagsForResource(params)
.then((data) => {
// process data.
})
.catch((error) => {
// error handling.
});
// callbacks.
client.listTagsForResource(params, (err, data) => {
// process err and data.
});
When the service returns an exception, the error will include the exception information, as well as response metadata (e.g. request id).
try {
const data = await client.send(command);
// process data.
} catch (error) {
const { requestId, cfId, extendedRequestId } = error.$metadata;
console.log({ requestId, cfId, extendedRequestId });
/**
* The keys within exceptions are also parsed.
* You can access them by specifying exception names:
* if (error.name === 'SomeServiceException') {
* const value = error.specialKeyInException;
* }
*/
}
Please use these community resources for getting help. We use the GitHub issues for tracking bugs and feature requests, but have limited bandwidth to address them.
aws-sdk-js
on AWS Developer Blog.aws-sdk-js.To test your universal JavaScript code in Node.js, browser and react-native environments, visit our code samples repo.
This client code is generated automatically. Any modifications will be overwritten the next time the @aws-sdk/client-rds package is updated.
To contribute to client you can check our generate clients scripts.
This SDK is distributed under the Apache License, Version 2.0, see LICENSE for more information.
3.650.0 (2024-09-11)
FAQs
AWS SDK for JavaScript Rds Client for Node.js, Browser and React Native
The npm package @aws-sdk/client-rds receives a total of 310,460 weekly downloads. As such, @aws-sdk/client-rds popularity was classified as popular.
We found that @aws-sdk/client-rds demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 5 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.