getCluster function
Provides details about a specific redshift cluster.
Example Usage
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = aws.redshift.getCluster({
clusterIdentifier: "example-cluster",
});
const exampleStream = new aws.kinesis.FirehoseDeliveryStream("example_stream", {
redshiftConfiguration: {
s3Configuration: {
roleArn: firehoseRole.arn,
bucketArn: bucket.arn,
bufferSize: 10,
bufferInterval: 400,
compressionFormat: "GZIP",
},
roleArn: firehoseRole.arn,
clusterJdbcurl: example.then(example => `jdbc:redshift://${example.endpoint}/${example.databaseName}`),
username: "exampleuser",
password: "Exampl3Pass",
dataTableName: "example-table",
copyOptions: "delimiter '|'",
dataTableColumns: "example-col",
},
name: "kinesis-firehose-example-stream",
destination: "redshift",
});
import pulumi
import pulumi_aws as aws
example = aws.redshift.get_cluster(cluster_identifier="example-cluster")
example_stream = aws.kinesis.FirehoseDeliveryStream("example_stream",
redshift_configuration={
"s3_configuration": {
"role_arn": firehose_role["arn"],
"bucket_arn": bucket["arn"],
"buffer_size": 10,
"buffer_interval": 400,
"compression_format": "GZIP",
},
"role_arn": firehose_role["arn"],
"cluster_jdbcurl": f"jdbc:redshift://{example.endpoint}/{example.database_name}",
"username": "exampleuser",
"password": "Exampl3Pass",
"data_table_name": "example-table",
"copy_options": "delimiter '|'",
"data_table_columns": "example-col",
},
name="kinesis-firehose-example-stream",
destination="redshift")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = Aws.RedShift.GetCluster.Invoke(new()
{
ClusterIdentifier = "example-cluster",
});
var exampleStream = new Aws.Kinesis.FirehoseDeliveryStream("example_stream", new()
{
RedshiftConfiguration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationArgs
{
S3Configuration = new Aws.Kinesis.Inputs.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs
{
RoleArn = firehoseRole.Arn,
BucketArn = bucket.Arn,
BufferSize = 10,
BufferInterval = 400,
CompressionFormat = "GZIP",
},
RoleArn = firehoseRole.Arn,
ClusterJdbcurl = $"jdbc:redshift://{example.Apply(getClusterResult => getClusterResult.Endpoint)}/{example.Apply(getClusterResult => getClusterResult.DatabaseName)}",
Username = "exampleuser",
Password = "Exampl3Pass",
DataTableName = "example-table",
CopyOptions = "delimiter '|'",
DataTableColumns = "example-col",
},
Name = "kinesis-firehose-example-stream",
Destination = "redshift",
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/kinesis"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/redshift"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
example, err := redshift.LookupCluster(ctx, &redshift.LookupClusterArgs{
ClusterIdentifier: "example-cluster",
}, nil)
if err != nil {
return err
}
_, err = kinesis.NewFirehoseDeliveryStream(ctx, "example_stream", &kinesis.FirehoseDeliveryStreamArgs{
RedshiftConfiguration: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationArgs{
S3Configuration: &kinesis.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs{
RoleArn: pulumi.Any(firehoseRole.Arn),
BucketArn: pulumi.Any(bucket.Arn),
BufferSize: 10,
BufferInterval: 400,
CompressionFormat: pulumi.String("GZIP"),
},
RoleArn: pulumi.Any(firehoseRole.Arn),
ClusterJdbcurl: pulumi.Sprintf("jdbc:redshift://%v/%v", example.Endpoint, example.DatabaseName),
Username: pulumi.String("exampleuser"),
Password: pulumi.String("Exampl3Pass"),
DataTableName: pulumi.String("example-table"),
CopyOptions: pulumi.String("delimiter '|'"),
DataTableColumns: pulumi.String("example-col"),
},
Name: pulumi.String("kinesis-firehose-example-stream"),
Destination: pulumi.String("redshift"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
data "aws_redshift_getcluster" "example" {
cluster_identifier = "example-cluster"
}
resource "aws_kinesis_firehosedeliverystream" "example_stream" {
redshift_configuration = {
s3_configuration = {
role_arn = firehoseRole.arn
bucket_arn = bucket.arn
buffer_size = 10
buffer_interval = 400
compression_format = "GZIP"
}
role_arn = firehoseRole.arn
cluster_jdbcurl ="jdbc:redshift://${data.aws_redshift_getcluster.example.endpoint}/${data.aws_redshift_getcluster.example.database_name}"
username = "exampleuser"
password = "Exampl3Pass"
data_table_name = "example-table"
copy_options = "delimiter '|'"
data_table_columns = "example-col"
}
# the default delimiter
name = "kinesis-firehose-example-stream"
destination = "redshift"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.redshift.RedshiftFunctions;
import com.pulumi.aws.redshift.inputs.GetClusterArgs;
import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamRedshiftConfigurationArgs;
import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
final var example = RedshiftFunctions.getCluster(GetClusterArgs.builder()
.clusterIdentifier("example-cluster")
.build());
var exampleStream = new FirehoseDeliveryStream("exampleStream", FirehoseDeliveryStreamArgs.builder()
.redshiftConfiguration(FirehoseDeliveryStreamRedshiftConfigurationArgs.builder()
.s3Configuration(FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs.builder()
.roleArn(firehoseRole.arn())
.bucketArn(bucket.arn())
.bufferSize(10)
.bufferInterval(400)
.compressionFormat("GZIP")
.build())
.roleArn(firehoseRole.arn())
.clusterJdbcurl(String.format("jdbc:redshift://%s/%s", example.endpoint(),example.databaseName()))
.username("exampleuser")
.password("Exampl3Pass")
.dataTableName("example-table")
.copyOptions("delimiter '|'")
.dataTableColumns("example-col")
.build())
.name("kinesis-firehose-example-stream")
.destination("redshift")
.build());
}
}
resources:
exampleStream:
type: aws:kinesis:FirehoseDeliveryStream
name: example_stream
properties:
redshiftConfiguration:
s3Configuration:
roleArn: ${firehoseRole.arn}
bucketArn: ${bucket.arn}
bufferSize: 10
bufferInterval: 400
compressionFormat: GZIP
roleArn: ${firehoseRole.arn}
clusterJdbcurl: jdbc:redshift://${example.endpoint}/${example.databaseName}
username: exampleuser
password: Exampl3Pass
dataTableName: example-table
copyOptions: delimiter '|'
dataTableColumns: example-col
name: kinesis-firehose-example-stream
destination: redshift
variables:
example:
fn::invoke:
function: aws:redshift:getCluster
arguments:
clusterIdentifier: example-cluster
args Arguments passed to this invoke. Arguments for getCluster.
options Invoke options controlling this call.
Implementation
Future<GetClusterResult> getCluster(
GetClusterArgs args, {
pulumi.InvokeOptions? options,
}) async {
final deployment = pulumi.Deployment.instance;
final result = await deployment.invoke<Map<String, dynamic>>(
'aws:redshift/getCluster:getCluster',
args.toMap(),
options: pulumi.toDeploymentInvokeOptions(options),
);
return GetClusterResult.fromMap(result);
}