There are more AWS SDK examples available in the [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub repo.
# Use `CreateCluster` with an AWS SDK or CLI
The following code examples show how to use `CreateCluster`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code examples:
+ [Learn the basics](redshift_example_redshift_Scenario_section.md)
+ [Getting started with Amazon Redshift provisioned clusters](redshift_example_redshift_GettingStarted_039_section.md)
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Redshift#code-examples).
```
///
/// Create a new Amazon Redshift cluster.
///
/// The identifier for the cluster.
/// The name of the database.
/// The master username.
/// The master user password.
/// The node type for the cluster.
/// The cluster that was created.
public async Task CreateClusterAsync(string clusterIdentifier, string databaseName,
string masterUsername, string masterUserPassword, string nodeType = "ra3.large")
{
try
{
var request = new CreateClusterRequest
{
ClusterIdentifier = clusterIdentifier,
DBName = databaseName,
MasterUsername = masterUsername,
MasterUserPassword = masterUserPassword,
NodeType = nodeType,
NumberOfNodes = 1,
ClusterType = "single-node"
};
var response = await _redshiftClient.CreateClusterAsync(request);
Console.WriteLine($"Created cluster {clusterIdentifier}");
return response.Cluster;
}
catch (ClusterAlreadyExistsException ex)
{
Console.WriteLine($"Cluster already exists: {ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"Couldn't create cluster. Here's why: {ex.Message}");
throw;
}
}
```
+ For API details, see [CreateCluster](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/CreateCluster) in *AWS SDK for .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Create a Cluster with Minimal ParametersThis example creates a cluster with the minimal set of parameters. By default, the output is in JSON format.Command:
```
aws redshift create-cluster --node-type dw.hs1.xlarge --number-of-nodes 2 --master-username adminuser --master-user-password TopSecret1 --cluster-identifier mycluster
```
Result:
```
{
"Cluster": {
"NodeType": "dw.hs1.xlarge",
"ClusterVersion": "1.0",
"PubliclyAccessible": "true",
"MasterUsername": "adminuser",
"ClusterParameterGroups": [
{
"ParameterApplyStatus": "in-sync",
"ParameterGroupName": "default.redshift-1.0"
} ],
"ClusterSecurityGroups": [
{
"Status": "active",
"ClusterSecurityGroupName": "default"
} ],
"AllowVersionUpgrade": true,
"VpcSecurityGroups": \[],
"PreferredMaintenanceWindow": "sat:03:30-sat:04:00",
"AutomatedSnapshotRetentionPeriod": 1,
"ClusterStatus": "creating",
"ClusterIdentifier": "mycluster",
"DBName": "dev",
"NumberOfNodes": 2,
"PendingModifiedValues": {
"MasterUserPassword": "\****"
}
},
"ResponseMetadata": {
"RequestId": "7cf4bcfc-64dd-11e2-bea9-49e0ce183f07"
}
}
```
+ For API details, see [CreateCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/redshift/create-cluster.html) in *AWS CLI Command Reference*.
------
#### [ Go ]
**SDK for Go V2**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/redshift#code-examples).
```
import (
"context"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/redshift"
"github.com/aws/aws-sdk-go-v2/service/redshift/types"
)
// RedshiftActions wraps Redshift service actions.
type RedshiftActions struct {
RedshiftClient *redshift.Client
}
// CreateCluster sends a request to create a cluster with the given clusterId using the provided credentials.
func (actor RedshiftActions) CreateCluster(ctx context.Context, clusterId string, userName string, userPassword string, nodeType string, clusterType string, publiclyAccessible bool) (*redshift.CreateClusterOutput, error) {
// Create a new Redshift cluster
input := &redshift.CreateClusterInput{
ClusterIdentifier: aws.String(clusterId),
MasterUserPassword: aws.String(userPassword),
MasterUsername: aws.String(userName),
NodeType: aws.String(nodeType),
ClusterType: aws.String(clusterType),
PubliclyAccessible: aws.Bool(publiclyAccessible),
}
var opErr *types.ClusterAlreadyExistsFault
output, err := actor.RedshiftClient.CreateCluster(ctx, input)
if err != nil && errors.As(err, &opErr) {
log.Println("Cluster already exists")
return nil, nil
} else if err != nil {
log.Printf("Failed to create Redshift cluster: %v\n", err)
return nil, err
}
log.Printf("Created cluster %s\n", *output.Cluster.ClusterIdentifier)
return output, nil
}
```
+ For API details, see [CreateCluster](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/redshift#Client.CreateCluster) in *AWS SDK for Go API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Create the cluster.
```
/**
* Creates a new Amazon Redshift cluster asynchronously.
* @param clusterId the unique identifier for the cluster
* @param username the username for the administrative user
* @param userPassword the password for the administrative user
* @return a CompletableFuture that represents the asynchronous operation of creating the cluster
* @throws RuntimeException if the cluster creation fails
*/
public CompletableFuture createClusterAsync(String clusterId, String username, String userPassword) {
CreateClusterRequest clusterRequest = CreateClusterRequest.builder()
.clusterIdentifier(clusterId)
.masterUsername(username)
.masterUserPassword(userPassword)
.nodeType("ra3.4xlarge")
.publiclyAccessible(true)
.numberOfNodes(2)
.build();
return getAsyncClient().createCluster(clusterRequest)
.whenComplete((response, exception) -> {
if (response != null) {
logger.info("Created cluster ");
} else {
throw new RuntimeException("Failed to create cluster: " + exception.getMessage(), exception);
}
});
}
```
+ For API details, see [CreateCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/CreateCluster) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift#code-examples).
Create the client.
```
import { RedshiftClient } from "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION";
//Set the Redshift Service Object
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```
Create the cluster.
```
// Import required AWS SDK clients and commands for Node.js
import { CreateClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";
const params = {
ClusterIdentifier: "CLUSTER_NAME", // Required
NodeType: "NODE_TYPE", //Required
MasterUsername: "MASTER_USER_NAME", // Required - must be lowercase
MasterUserPassword: "MASTER_USER_PASSWORD", // Required - must contain at least one uppercase letter, and one number
ClusterType: "CLUSTER_TYPE", // Required
IAMRoleARN: "IAM_ROLE_ARN", // Optional - the ARN of an IAM role with permissions your cluster needs to access other AWS services on your behalf, such as Amazon S3.
ClusterSubnetGroupName: "CLUSTER_SUBNET_GROUPNAME", //Optional - the name of a cluster subnet group to be associated with this cluster. Defaults to 'default' if not specified.
DBName: "DATABASE_NAME", // Optional - defaults to 'dev' if not specified
Port: "PORT_NUMBER", // Optional - defaults to '5439' if not specified
};
const run = async () => {
try {
const data = await redshiftClient.send(new CreateClusterCommand(params));
console.log(
`Cluster ${data.Cluster.ClusterIdentifier} successfully created`,
);
return data; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
+ For API details, see [CreateCluster](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/redshift/command/CreateClusterCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Kotlin ]
**SDK for Kotlin**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/redshift#code-examples).
Create the cluster.
```
suspend fun createCluster(
clusterId: String?,
masterUsernameVal: String?,
masterUserPasswordVal: String?,
) {
val clusterRequest =
CreateClusterRequest {
clusterIdentifier = clusterId
availabilityZone = "us-east-1a"
masterUsername = masterUsernameVal
masterUserPassword = masterUserPasswordVal
nodeType = "ra3.4xlarge"
publiclyAccessible = true
numberOfNodes = 2
}
RedshiftClient.fromEnvironment { region = "us-east-1" }.use { redshiftClient ->
val clusterResponse = redshiftClient.createCluster(clusterRequest)
println("Created cluster ${clusterResponse.cluster?.clusterIdentifier}")
}
}
```
+ For API details, see [CreateCluster](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK for Kotlin API reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/redshift#code-examples).
```
class RedshiftWrapper:
"""
Encapsulates Amazon Redshift cluster operations.
"""
def __init__(self, redshift_client):
"""
:param redshift_client: A Boto3 Redshift client.
"""
self.client = redshift_client
def create_cluster(
self,
cluster_identifier,
node_type,
master_username,
master_user_password,
publicly_accessible,
number_of_nodes,
):
"""
Creates a cluster.
:param cluster_identifier: The name of the cluster.
:param node_type: The type of node in the cluster.
:param master_username: The master username.
:param master_user_password: The master user password.
:param publicly_accessible: Whether the cluster is publicly accessible.
:param number_of_nodes: The number of nodes in the cluster.
:return: The cluster.
"""
try:
cluster = self.client.create_cluster(
ClusterIdentifier=cluster_identifier,
NodeType=node_type,
MasterUsername=master_username,
MasterUserPassword=master_user_password,
PubliclyAccessible=publicly_accessible,
NumberOfNodes=number_of_nodes,
)
return cluster
except ClientError as err:
logging.error(
"Couldn't create a cluster. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
The following code instantiates the RedshiftWrapper object.
```
client = boto3.client("redshift")
redhift_wrapper = RedshiftWrapper(client)
```
+ For API details, see [CreateCluster](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/CreateCluster) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsh#code-examples).
Create the cluster.
```
TRY.
" Example values: iv_cluster_identifier = 'my-redshift-cluster'
" Example values: iv_node_type = 'ra3.4xlarge'
" Example values: iv_master_username = 'awsuser'
" Example values: iv_master_password = 'AwsUser1000'
" Example values: iv_publicly_accessible = abap_true
" Example values: iv_number_of_nodes = 2
oo_result = lo_rsh->createcluster(
iv_clusteridentifier = iv_cluster_identifier
iv_nodetype = iv_node_type
iv_masterusername = iv_master_username
iv_masteruserpassword = iv_master_password
iv_publiclyaccessible = iv_publicly_accessible
iv_numberofnodes = iv_number_of_nodes
).
MESSAGE 'Redshift cluster created successfully.' TYPE 'I'.
CATCH /aws1/cx_rshclustalrdyexfault.
MESSAGE 'Cluster already exists.' TYPE 'I'.
CATCH /aws1/cx_rshclstquotaexcdfault.
MESSAGE 'Cluster quota exceeded.' TYPE 'I'.
ENDTRY.
```
+ For API details, see [CreateCluster](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP API reference*.
------