# Working with SQL Server Developer Edition on RDS for SQL Server
RDS for SQL Server supports SQL Server Developer Edition. Developer Edition includes all SQL Server Enterprise Edition features but is licensed only for non-production use. You can create RDS for SQL Server Developer Edition instances using your own installation media through the custom engine version (CEV) feature.
## Benefits
You can use RDS for SQL Server Developer Edition to:
+ Lower costs in development and test environments while maintaining feature parity with production databases.
+ Access Enterprise Edition capabilities in non-production environments without Enterprise licensing fees.
+ Use Amazon RDS-automated management features, including backups, patching, and monitoring.
**Note**
SQL Server Developer Edition is licensed for development and testing purposes only and cannot be used in production environments.
## Region availability
RDS for SQL Server Developer Edition is available in the following AWS Regions:
+ US East (N. Virginia)
+ US East (Ohio)
+ US West (Oregon)
+ US West (N. California)
+ Asia Pacific (Mumbai)
+ Asia Pacific (Seoul)
+ Asia Pacific (Singapore)
+ Asia Pacific (Osaka)
+ Asia Pacific (Sydney)
+ Asia Pacific (Tokyo)
+ Europe (Ireland)
+ Europe (Frankfurt)
+ Europe (London)
+ Europe (Stockholm)
+ Europe (Paris)
+ Canada (Central)
+ South America (São Paulo)
+ Africa (Cape Town)
+ AWS GovCloud (US-East)
+ AWS GovCloud (US-West)
## Licensing and usage
SQL Server Developer Edition is licensed by Microsoft for development and test environments only. You cannot use Developer Edition as a production server. When you use SQL Server Developer Edition on Amazon RDS, you are responsible for complying with Microsoft's SQL Server Developer Edition licensing terms. You pay only for the AWS infrastructure costs - there is no additional SQL Server licensing fee. For pricing details, see [RDS for SQL Server pricing](https://aws.amazon.com/rds/sqlserver/pricing/).
## Prerequisites
Before using SQL Server Developer Edition on RDS for SQL Server, ensure you have the following requirements:
+ You must obtain the installation binaries directly from Microsoft and ensure compliance with Microsoft's licensing terms.
+ You must have access to use the following resources to create a Developer Edition DB instance:
+ AWS account with `AmazonRDSFullAccess` and `s3:GetObject` permissions.
+ An Amazon S3 bucket is required for storing installation media. You will need an ISO and cumulative update file to upload to the Amazon S3 bucket as part of CEV creation. For more information, see [Uploading installation media to an Amazon S3 bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html).
+ All installation media files must reside within the same Amazon S3 bucket and the same folder path within that Amazon S3 bucket in the same Region where the custom engine version is created.
### Supported versions
Developer Edition on RDS for SQL Server supports the following versions:
+ SQL Server 2022 CU 21 (16.00.4215.2)
+ SQL Server 2019 CU 32 GDR (15.00.4455.2)
To list all supported engine versions for Developer Edition CEV creation, use the following AWS CLI command:
```
aws rds describe-db-engine-versions --engine sqlserver-dev-ee --output json --query "{DBEngineVersions: DBEngineVersions[?Status=='requires-custom-engine-version'].{Engine: Engine, EngineVersion: EngineVersion, Status: Status, DBEngineVersionDescription: DBEngineVersionDescription}}"
```
The command returns output similar to the following example:
```
{
"DBEngineVersions": [
{
"Engine": "sqlserver-dev-ee",
"EngineVersion": "16.00.4215.2.v1",
"Status": "requires-custom-engine-version",
"DBEngineDescription": "Microsoft SQL Server Enterprise Developer Edition",
"DBEngineVersionDescription": "SQL Server 2022 16.00.4215.2.v1"
}
]
}
```
The engine version status as `requires_custom_engine_version` identifies template engine versions that are supported. These templates show which SQL Server versions you can import.
## Limitations
The following limitations apply to SQL Server Developer Edition on Amazon RDS:
+ Currently only supported on M6i and R6i instance classes.
+ Multi-AZ deployments and read replicas are not supported.
+ You must provide and manage your own SQL Server installation media.
+ Custom engine versions for SQL Server Developer Edition (sqlserver-dev-ee) cannot be shared cross-Region or cross-account.
# Preparing a CEV for RDS for SQL Server
## Prerequisites
Before creating a custom engine version, make sure you have completed the following prerequisites:
### Prepare SQL Server Developer Edition installation media
You must obtain the SQL Server Developer Edition installation media from Microsoft and prepare it for upload to S3.
**To download installation media from Microsoft**
1. **Option A:** Use your [Visual Studio subscription](https://visualstudio.microsoft.com/subscriptions/) to download the Developer Edition ISO. Only the English version is supported.
1. **Option B: Using SQL Server Installer**
1. Download the [SQL Server Developer Edition installer](https://download.microsoft.com/download/c/c/9/cc9c6797-383c-4b24-8920-dc057c1de9d3/SQL2022-SSEI-Dev.exe).
1. Run the installer and choose **Download Media** to download the full ISO.
1. Choose **English** as the preferred language.
1. Choose **ISO** as the media type.
1. Choose **Download**.
**To download cumulative updates**
1. Visit the [Microsoft Catalog Update](https://www.catalog.update.microsoft.com/Home.aspx) page.
1. Find a SQL Server Developer Edition supported by RDS for SQL Server, for example "SQL Server 2022 Cumulative Update".
1. Download the latest supported CU executable file and save it to your machine.
1. Example files: `SQLServer2022-KB5065865-x64.exe` (CU21 for SQL Server 2022)
**Important**
RDS for SQL Server only supports specific Cumulative Update (CU) versions. You must use the exact version listed in the table below. Do not use newer CU versions even if available from Microsoft, as they may not be compatible with RDS.
Alternatively, you can also download the required Cumulative Update (CU) file directly from the following:
The following table lists the supported SQL Server Developer Edition version and its corresponding Cumulative Update for use with RDS:
| SQL Server Version | Supported CU | KB Article | Download File Name |
| --- | --- | --- | --- |
| SQL Server 2022 | `CU21` | [KB5065865](https://learn.microsoft.com/en-us/troubleshoot/sql/releases/sqlserver-2022/cumulativeupdate21) | `SQLServer2022-KB5065865-x64.exe` |
| SQL Server 2019 | `CU32 GDR` | [KB5068404](https://support.microsoft.com/en-us/topic/kb5068404-description-of-the-security-update-for-sql-server-2019-cu32-november-11-2025-c203bfbf-036e-46d2-bc10-6c01200dc48a) | `SQLServer2019-KB5068404-x64.exe` |
# Creating a custom engine version for RDS for SQL Server
A custom engine version (CEV) for RDS for SQL Server consists of your SQL Server Developer Edition installation media imported into Amazon RDS. It is necessary to upload the base ISO installer and cumulative update files (.exe) to your Amazon S3 bucket. Once uploaded, you should provide the Amazon S3 location to RDS for it to download, validate, and subsequently create your CEV.
## Naming limitations
When creating a CEV, you must follow specific naming conventions:
+ CEV name must follow the pattern `major-version.minor-version.customized-string`.
+ `customized-string` can contain 1-50 alphanumeric characters, underscores, dashes, and periods. For example: `16.00.4215.2.my-dev-cev` for SQL Server 2022.
To list all supported engine versions, use the following AWS CLI command:
```
aws rds describe-db-engine-versions --engine sqlserver-dev-ee --output json --query "{DBEngineVersions: DBEngineVersions[?Status=='requires-custom-engine-version'].{Engine: Engine, EngineVersion: EngineVersion, Status: Status, DBEngineVersionDescription: DBEngineVersionDescription}}"
{
"DBEngineVersions": [
{
"Engine": "sqlserver-dev-ee",
"EngineVersion": "16.00.4215.2.v1",
"Status": "requires-custom-engine-version",
"DBEngineDescription": "Microsoft SQL Server Enterprise Developer Edition",
"DBEngineVersionDescription": "SQL Server 2022 16.00.4215.2.v1"
}
]
}
```
## AWS CLI
**To create the custom engine version**
+ Use the [create-custom-db-engine-version](https://docs.aws.amazon.com/cli/latest/reference/rds/create-custom-db-engine-version.html) command.
The following options are required:
+ `--engine`
+ `--engine-version`
+ `--database-installation-files-s3-bucket-name`
+ `--database-installation-files`
+ `--region`
You can also specify the following options:
+ `--database-installation-files-s3-prefix`
+ `--description`
+ `--tags`
```
aws rds create-custom-db-engine-version \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.cev-dev-ss2022-cu21 \
--region us-west-2 \
--database-installation-files-s3-bucket-name my-s3-installation-media-bucket \
--database-installation-files-s3-prefix sqlserver-dev-media \
--database-installation-files "SQLServer2022-x64-ENU-Dev.iso" "SQLServer2022-KB5065865-x64.exe"
```
CEV creation typically takes 15-30 minutes. To monitor the CEV creation progress, use the following command:
```
# Check CEV status
aws rds describe-db-engine-versions \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.my-dev-cev \
--region us-west-2
```
## Lifecycle of an RDS for SQL Server CEV
When working with SQL Server Developer Edition on RDS for SQL Server, your custom engine versions transition through various lifecycle states.
| Lifecycle State | Description | When It Occurs | Available Actions |
| --- | --- | --- | --- |
| pending-validation | Initial state when CEV is created | This is the initial state after creation with the `create-custom-db-engine-version` command. | Monitor status via `describe-db-engine-version`. |
| validating | CEV Validation state | Amazon RDS is validating your custom engine version (CEV). This asynchronous process may take some time to complete. | Monitor the status until validation is complete. |
| available | The custom engine version (CEV) validation completed successfully. | Custom Engine Version (CEV) is now available. Amazon RDS successfully validated your SQL Server ISO and cumulative update files. You can now create DB instances using this CEV. | Create DB instances using this CEV |
| failed | RDS for SQL Server can't create the custom engine version (CEV) because the validation check failed. | ISO and cumulative media validation failed. | ISO validation failed. Check the failure reason in `describe-db-engine-version`, fix any file issues such as hash mismatches or corrupted content, and then recreate your custom engine version (CEV). |
| deleting | The custom engine version (CEV) is deleting | After customer calls `delete-custom-db-engine-version` until deletion workflow completes. | Monitor status via `describe-db-engine-version`. |
| incompatible-installation-media | Amazon RDS was unable to validate the installation media provided for the custom engine version (CEV) | The custom engine version (CEV) validation has failed. This is a terminal state. | See failureReason via `describe-db-engine-versions` for info on why validation failed; delete CEV. |
### Describe CEV Status
You can see the state of your CEVs using the AWS CLI:
```
1. aws rds describe-db-engine-versions \
2. --engine sqlserver-dev-ee \
3. --engine-version 16.00.4215.2.my-dev-cev \
4. --region us-west-2 \
5. --query 'DBEngineVersions[0].{Version:EngineVersion,Status:Status}'
```
Sample output
```
| DescribeDBEngineVersions |
+------------+---------------------------------+
| Status | Version |
+------------+---------------------------------+
| available | 16.00.4215.2.cev-dev-ss2022-cu21 |
+------------+---------------------------------+
```
When a CEV shows `failed` status, you can determine the reason using the following command:
```
1. aws rds describe-db-engine-versions \
2. --engine sqlserver-dev-ee \
3. --engine-version 16.00.4215.2.my-dev-cev \
4. --region us-west-2 \
5. --query 'DBEngineVersions[0].{Version:EngineVersion,Status:Status,FailureReason:FailureReason}'
```
# Creating an RDS for SQL Server Developer Edition DB instance
Launching Developer Edition instance on RDS for SQL Server follows a two-step process: first create a CEV with `create-custom-db-engine-version`, Once your custom engine version is in the available state, you can create Amazon RDS database instances using the CEV.
**Key differences for Developer Edition instance creation**
| Parameter | Developer Edition |
| --- | --- |
| `--engine` | sqlserver-dev-ee |
| `--engine-version` | Custom engine version (e.g., 16.00.4215.2.cev-dev-ss2022-cu21) |
| `--license-model` | bring-your-own-license |
## AWS CLI
To create a SQL Server Developer Edition DB instance, use the [create-db-instance](https://docs.aws.amazon.com//cli/latest/reference/rds/create-db-instance.html) command with the following parameters:
The following options are required:
+ `--db-instance-identifier`
+ `--db-instance-class`
+ `--engine` – `sqlserver-dev-ee`
+ `--region`
**Examples:**
For Linux, macOS, or Unix:
```
aws rds create-db-instance \
--db-instance-identifier my-dev-sqlserver \
--db-instance-class db.m6i.xlarge \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.my-dev-cev \
--allocated-storage 200 \
--master-username admin \
--master-user-password changeThisPassword \
--license-model bring-your-own-license \
--no-multi-az \
--vpc-security-group-ids sg-xxxxxxxxx \
--db-subnet-group-name my-db-subnet-group \
--backup-retention-period 7 \
--region us-west-2
```
For Windows:
```
aws rds create-db-instance ^
--db-instance-identifier my-dev-sqlserver ^
--db-instance-class db.m6i.xlarge ^
--engine sqlserver-dev-ee ^
--engine-version 16.00.4215.2.cev-dev-ss2022-cu21 ^
--allocated-storage 200 ^
--master-username admin ^
--master-user-password master_user_password ^
--license-model bring-your-own-license ^
--no-multi-az ^
--vpc-security-group-ids sg-xxxxxxxxx ^
--db-subnet-group-name my-db-subnet-group ^
--backup-retention-period 7 ^
--region us-west-2
```
Refer to [Creating a DB instance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.html#USER_CreateDBInstance.Creating) to create using the AWS console.
# Applying database minor version upgrades
RDS for SQL Server Developer Edition requires creating a new custom engine version (CEV) with latest cumulative update to apply database minor version upgrade. Database minor version upgrades for SQL Server Developer Edition involve the following steps:
1. Before upgrading, verify current engine version on the instance, identify the target database engine version from Amazon RDS supported versions. For information about what SQL Server versions are available on Amazon RDS, see [Working with SQL Server Developer Edition on RDS for SQL Server](sqlserver-dev-edition.md).
1. Obtain and upload installation media (ISO and CU), then [create a new custom engine version](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/sqlserver-dev-edition.creating-cev.html).
1. Apply database minor version upgrade by using Amazon RDS [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) with the new CEV.
```
aws rds modify-db-instance \
--db-instance-identifier \
--engine-version \
--no-apply-immediately ## use --apply-immediately for immediate update
```
**Note**
`--no-apply-immediately` (the default) to apply the changes during the next maintenance window.
# Viewing and managing custom engine versions
To view all your RDS for SQL Server Developer Edition CEVs, use the `describe-db-engine-versions` command with the `--engine` input as `sqlserver-dev-ee`.
```
aws rds describe-db-engine-versions \
--engine sqlserver-dev-ee \
--include-all \
--region us-west-2
```
To view the details of a specific CEV, use the following command:
```
aws rds describe-db-engine-versions \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.cev-dev-ss2022-cu21 \
--region us-west-2
```
**Note**
This command only returns CEVs with an `available` status. To view CEVs in validating or other states, include the `--include-all` flag.
## Deleting custom engine versions
Before deleting a CEV, make sure it isn't being used by any of the following:
+ An Amazon RDS DB instance
+ A snapshot of an Amazon RDS DB instance
+ An automated backup of an Amazon RDS DB instance
**Note**
You can't delete a CEV if there are any resources associated with it.
To delete a custom engine version, use the [ delete-custom-db-engine-version](https://docs.aws.amazon.com//cli/latest/reference/rds/delete-custom-db-engine-version.html) command.
+ `--engine`: Specify `sqlserver-dev-ee` for Developer Edition
+ `--engine-version`: The exact CEV version identifier to delete
+ `--region`: AWS Region where the CEV exists
```
aws rds delete-custom-db-engine-version \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.my-dev-cev \
--region us-west-2
```
To monitor the CEV deletion process, use the `describe-db-engine-versions` command and specify your RDS for SQL Server CEV engine version
```
aws rds describe-db-engine-versions \
--engine sqlserver-dev-ee \
--engine-version 16.00.4215.2.my-dev-cev \
--region us-west-2
```
Status Values:
+ `deleting`: CEV deletion in progress
+ No results returned: CEV successfully deleted
# Troubleshooting SQL Server Developer Edition for RDS for SQL Server
The following table lists some common errors and corresponding solutions when working with SQL Server Developer Edition for RDS for SQL Server
**Common Errors and Solutions**
| Error Code | Description | Solution |
| --- | --- | --- |
| InvalidParameterValue | Invalid CEV parameters or file references | Verify file names, paths, and parameter syntax |
| DBSubnetGroupNotFound | Subnet group doesn't exist | Create subnet group or verify name |
| InvalidVPCNetworkState | VPC configuration issue | Check VPC, subnets, and routing tables |
| InvalidEngineVersion | CEV not available or invalid | Verify CEV status and name |
| InvalidDBInstanceClass | Instance class not supported | Choose supported instance class |
| CustomDBEngineVersionQuotaExceededFault | You have reached the maximum number of custom engine versions | If required increase service quota, alternatively Delete unused CEVs if required |
| CreateCustomDBEngineVersionFault | Amazon RDS was unable to access the specified installer file in the Amazon S3 bucket. | Amazon RDS cannot access the SQL Server installation files in the specified Amazon S3 location. Grant the Amazon RDS service principal (rds.amazonaws.com) s3:GetObject permission in your Amazon S3 bucket policy. Validate that the Amazon S3 bucket Region is the same as the Region where you are creating the CEV. |