redshiftserverless

package
v6.28.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 28, 2024 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type EndpointAccess 

type EndpointAccess struct {
	pulumi.CustomResourceState

	// The DNS address of the VPC endpoint.
	Address pulumi.StringOutput `pulumi:"address"`
	// Amazon Resource Name (ARN) of the Redshift Serverless Endpoint Access.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The name of the endpoint.
	EndpointName pulumi.StringOutput `pulumi:"endpointName"`
	// The owner Amazon Web Services account for the Amazon Redshift Serverless workgroup.
	OwnerAccount pulumi.StringPtrOutput `pulumi:"ownerAccount"`
	// The port that Amazon Redshift Serverless listens on.
	Port pulumi.IntOutput `pulumi:"port"`
	// An array of VPC subnet IDs to associate with the endpoint.
	SubnetIds pulumi.StringArrayOutput `pulumi:"subnetIds"`
	// The VPC endpoint or the Redshift Serverless workgroup. See `VPC Endpoint` below.
	VpcEndpoints EndpointAccessVpcEndpointArrayOutput `pulumi:"vpcEndpoints"`
	// An array of security group IDs to associate with the workgroup.
	VpcSecurityGroupIds pulumi.StringArrayOutput `pulumi:"vpcSecurityGroupIds"`
	// The name of the workgroup.
	WorkgroupName pulumi.StringOutput `pulumi:"workgroupName"`
}

Creates a new Amazon Redshift Serverless Endpoint Access.

## Example Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/redshiftserverless"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redshiftserverless.NewEndpointAccess(ctx, "example", &redshiftserverless.EndpointAccessArgs{
			EndpointName:  pulumi.String("example"),
			WorkgroupName: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

## Import

Using `pulumi import`, import Redshift Serverless Endpoint Access using the `endpoint_name`. For example:

```sh $ pulumi import aws:redshiftserverless/endpointAccess:EndpointAccess example example ```

func GetEndpointAccess 

func GetEndpointAccess(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EndpointAccessState, opts ...pulumi.ResourceOption) (*EndpointAccess, error)

GetEndpointAccess gets an existing EndpointAccess resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewEndpointAccess 

func NewEndpointAccess(ctx *pulumi.Context,
	name string, args *EndpointAccessArgs, opts ...pulumi.ResourceOption) (*EndpointAccess, error)

NewEndpointAccess registers a new resource with the given unique name, arguments, and options.

func (*EndpointAccess) ElementType 

func (*EndpointAccess) ElementType() reflect.Type

func (*EndpointAccess) ToEndpointAccessOutput 

func (i *EndpointAccess) ToEndpointAccessOutput() EndpointAccessOutput

func (*EndpointAccess) ToEndpointAccessOutputWithContext 

func (i *EndpointAccess) ToEndpointAccessOutputWithContext(ctx context.Context) EndpointAccessOutput

type EndpointAccessArgs 

type EndpointAccessArgs struct {
	// The name of the endpoint.
	EndpointName pulumi.StringInput
	// The owner Amazon Web Services account for the Amazon Redshift Serverless workgroup.
	OwnerAccount pulumi.StringPtrInput
	// An array of VPC subnet IDs to associate with the endpoint.
	SubnetIds pulumi.StringArrayInput
	// An array of security group IDs to associate with the workgroup.
	VpcSecurityGroupIds pulumi.StringArrayInput
	// The name of the workgroup.
	WorkgroupName pulumi.StringInput
}

The set of arguments for constructing a EndpointAccess resource.

func (EndpointAccessArgs) ElementType 

func (EndpointAccessArgs) ElementType() reflect.Type

type EndpointAccessArray 

type EndpointAccessArray []EndpointAccessInput

func (EndpointAccessArray) ElementType 

func (EndpointAccessArray) ElementType() reflect.Type

func (EndpointAccessArray) ToEndpointAccessArrayOutput 

func (i EndpointAccessArray) ToEndpointAccessArrayOutput() EndpointAccessArrayOutput

func (EndpointAccessArray) ToEndpointAccessArrayOutputWithContext 

func (i EndpointAccessArray) ToEndpointAccessArrayOutputWithContext(ctx context.Context) EndpointAccessArrayOutput

type EndpointAccessArrayInput 

type EndpointAccessArrayInput interface {
	pulumi.Input

	ToEndpointAccessArrayOutput() EndpointAccessArrayOutput
	ToEndpointAccessArrayOutputWithContext(context.Context) EndpointAccessArrayOutput
}

EndpointAccessArrayInput is an input type that accepts EndpointAccessArray and EndpointAccessArrayOutput values. You can construct a concrete instance of `EndpointAccessArrayInput` via: 

EndpointAccessArray{ EndpointAccessArgs{...} }

type EndpointAccessArrayOutput 

type EndpointAccessArrayOutput struct{ *pulumi.OutputState }

func (EndpointAccessArrayOutput) ElementType 

func (EndpointAccessArrayOutput) ElementType() reflect.Type

func (EndpointAccessArrayOutput) Index 

func (o EndpointAccessArrayOutput) Index(i pulumi.IntInput) EndpointAccessOutput

func (EndpointAccessArrayOutput) ToEndpointAccessArrayOutput 

func (o EndpointAccessArrayOutput) ToEndpointAccessArrayOutput() EndpointAccessArrayOutput

func (EndpointAccessArrayOutput) ToEndpointAccessArrayOutputWithContext 

func (o EndpointAccessArrayOutput) ToEndpointAccessArrayOutputWithContext(ctx context.Context) EndpointAccessArrayOutput

type EndpointAccessInput 

type EndpointAccessInput interface {
	pulumi.Input

	ToEndpointAccessOutput() EndpointAccessOutput
	ToEndpointAccessOutputWithContext(ctx context.Context) EndpointAccessOutput
}

type EndpointAccessMap 

type EndpointAccessMap map[string]EndpointAccessInput

func (EndpointAccessMap) ElementType 

func (EndpointAccessMap) ElementType() reflect.Type

func (EndpointAccessMap) ToEndpointAccessMapOutput 

func (i EndpointAccessMap) ToEndpointAccessMapOutput() EndpointAccessMapOutput

func (EndpointAccessMap) ToEndpointAccessMapOutputWithContext 

func (i EndpointAccessMap) ToEndpointAccessMapOutputWithContext(ctx context.Context) EndpointAccessMapOutput

type EndpointAccessMapInput 

type EndpointAccessMapInput interface {
	pulumi.Input

	ToEndpointAccessMapOutput() EndpointAccessMapOutput
	ToEndpointAccessMapOutputWithContext(context.Context) EndpointAccessMapOutput
}

EndpointAccessMapInput is an input type that accepts EndpointAccessMap and EndpointAccessMapOutput values. You can construct a concrete instance of `EndpointAccessMapInput` via: 

EndpointAccessMap{ "key": EndpointAccessArgs{...} }

type EndpointAccessMapOutput 

type EndpointAccessMapOutput struct{ *pulumi.OutputState }

func (EndpointAccessMapOutput) ElementType 

func (EndpointAccessMapOutput) ElementType() reflect.Type

func (EndpointAccessMapOutput) MapIndex 

func (o EndpointAccessMapOutput) MapIndex(k pulumi.StringInput) EndpointAccessOutput

func (EndpointAccessMapOutput) ToEndpointAccessMapOutput 

func (o EndpointAccessMapOutput) ToEndpointAccessMapOutput() EndpointAccessMapOutput

func (EndpointAccessMapOutput) ToEndpointAccessMapOutputWithContext 

func (o EndpointAccessMapOutput) ToEndpointAccessMapOutputWithContext(ctx context.Context) EndpointAccessMapOutput

type EndpointAccessOutput 

type EndpointAccessOutput struct{ *pulumi.OutputState }

func (EndpointAccessOutput) Address 

func (o EndpointAccessOutput) Address() pulumi.StringOutput

The DNS address of the VPC endpoint.

func (EndpointAccessOutput) Arn 

func (o EndpointAccessOutput) Arn() pulumi.StringOutput

Amazon Resource Name (ARN) of the Redshift Serverless Endpoint Access.

func (EndpointAccessOutput) ElementType 

func (EndpointAccessOutput) ElementType() reflect.Type

func (EndpointAccessOutput) EndpointName 

func (o EndpointAccessOutput) EndpointName() pulumi.StringOutput

The name of the endpoint.

func (EndpointAccessOutput) OwnerAccount added in v6.21.0 

func (o EndpointAccessOutput) OwnerAccount() pulumi.StringPtrOutput

The owner Amazon Web Services account for the Amazon Redshift Serverless workgroup.

func (EndpointAccessOutput) Port 

func (o EndpointAccessOutput) Port() pulumi.IntOutput

The port that Amazon Redshift Serverless listens on.

func (EndpointAccessOutput) SubnetIds 

func (o EndpointAccessOutput) SubnetIds() pulumi.StringArrayOutput

An array of VPC subnet IDs to associate with the endpoint.

func (EndpointAccessOutput) ToEndpointAccessOutput 

func (o EndpointAccessOutput) ToEndpointAccessOutput() EndpointAccessOutput

func (EndpointAccessOutput) ToEndpointAccessOutputWithContext 

func (o EndpointAccessOutput) ToEndpointAccessOutputWithContext(ctx context.Context) EndpointAccessOutput

func (EndpointAccessOutput) VpcEndpoints 

func (o EndpointAccessOutput) VpcEndpoints() EndpointAccessVpcEndpointArrayOutput

The VPC endpoint or the Redshift Serverless workgroup. See `VPC Endpoint` below.

func (EndpointAccessOutput) VpcSecurityGroupIds 

func (o EndpointAccessOutput) VpcSecurityGroupIds() pulumi.StringArrayOutput

An array of security group IDs to associate with the workgroup.

func (EndpointAccessOutput) WorkgroupName 

func (o EndpointAccessOutput) WorkgroupName() pulumi.StringOutput

The name of the workgroup.

type EndpointAccessState 

type EndpointAccessState struct {
	// The DNS address of the VPC endpoint.
	Address pulumi.StringPtrInput
	// Amazon Resource Name (ARN) of the Redshift Serverless Endpoint Access.
	Arn pulumi.StringPtrInput
	// The name of the endpoint.
	EndpointName pulumi.StringPtrInput
	// The owner Amazon Web Services account for the Amazon Redshift Serverless workgroup.
	OwnerAccount pulumi.StringPtrInput
	// The port that Amazon Redshift Serverless listens on.
	Port pulumi.IntPtrInput
	// An array of VPC subnet IDs to associate with the endpoint.
	SubnetIds pulumi.StringArrayInput
	// The VPC endpoint or the Redshift Serverless workgroup. See `VPC Endpoint` below.
	VpcEndpoints EndpointAccessVpcEndpointArrayInput
	// An array of security group IDs to associate with the workgroup.
	VpcSecurityGroupIds pulumi.StringArrayInput
	// The name of the workgroup.
	WorkgroupName pulumi.StringPtrInput
}

func (EndpointAccessState) ElementType 

func (EndpointAccessState) ElementType() reflect.Type

type EndpointAccessVpcEndpoint 

type EndpointAccessVpcEndpoint struct {
	// The network interfaces of the endpoint.. See `Network Interface` below.
	NetworkInterfaces []EndpointAccessVpcEndpointNetworkInterface `pulumi:"networkInterfaces"`
	// The DNS address of the VPC endpoint.
	VpcEndpointId *string `pulumi:"vpcEndpointId"`
	// The port that Amazon Redshift Serverless listens on.
	VpcId *string `pulumi:"vpcId"`
}

type EndpointAccessVpcEndpointArgs 

type EndpointAccessVpcEndpointArgs struct {
	// The network interfaces of the endpoint.. See `Network Interface` below.
	NetworkInterfaces EndpointAccessVpcEndpointNetworkInterfaceArrayInput `pulumi:"networkInterfaces"`
	// The DNS address of the VPC endpoint.
	VpcEndpointId pulumi.StringPtrInput `pulumi:"vpcEndpointId"`
	// The port that Amazon Redshift Serverless listens on.
	VpcId pulumi.StringPtrInput `pulumi:"vpcId"`
}

func (EndpointAccessVpcEndpointArgs) ElementType 

func (EndpointAccessVpcEndpointArgs) ElementType() reflect.Type

func (EndpointAccessVpcEndpointArgs) ToEndpointAccessVpcEndpointOutput 

func (i EndpointAccessVpcEndpointArgs) ToEndpointAccessVpcEndpointOutput() EndpointAccessVpcEndpointOutput

func (EndpointAccessVpcEndpointArgs) ToEndpointAccessVpcEndpointOutputWithContext 

func (i EndpointAccessVpcEndpointArgs) ToEndpointAccessVpcEndpointOutputWithContext(ctx context.Context) EndpointAccessVpcEndpointOutput

type EndpointAccessVpcEndpointArray 

type EndpointAccessVpcEndpointArray []EndpointAccessVpcEndpointInput

func (EndpointAccessVpcEndpointArray) ElementType 

func (EndpointAccessVpcEndpointArray) ElementType() reflect.Type

func (EndpointAccessVpcEndpointArray) ToEndpointAccessVpcEndpointArrayOutput 

func (i EndpointAccessVpcEndpointArray) ToEndpointAccessVpcEndpointArrayOutput() EndpointAccessVpcEndpointArrayOutput

func (EndpointAccessVpcEndpointArray) ToEndpointAccessVpcEndpointArrayOutputWithContext 

func (i EndpointAccessVpcEndpointArray) ToEndpointAccessVpcEndpointArrayOutputWithContext(ctx context.Context) EndpointAccessVpcEndpointArrayOutput

type EndpointAccessVpcEndpointArrayInput 

type EndpointAccessVpcEndpointArrayInput interface {
	pulumi.Input

	ToEndpointAccessVpcEndpointArrayOutput() EndpointAccessVpcEndpointArrayOutput
	ToEndpointAccessVpcEndpointArrayOutputWithContext(context.Context) EndpointAccessVpcEndpointArrayOutput
}

EndpointAccessVpcEndpointArrayInput is an input type that accepts EndpointAccessVpcEndpointArray and EndpointAccessVpcEndpointArrayOutput values. You can construct a concrete instance of `EndpointAccessVpcEndpointArrayInput` via: 

EndpointAccessVpcEndpointArray{ EndpointAccessVpcEndpointArgs{...} }

type EndpointAccessVpcEndpointArrayOutput 

type EndpointAccessVpcEndpointArrayOutput struct{ *pulumi.OutputState }

func (EndpointAccessVpcEndpointArrayOutput) ElementType 

func (EndpointAccessVpcEndpointArrayOutput) ElementType() reflect.Type

func (EndpointAccessVpcEndpointArrayOutput) Index 

func (o EndpointAccessVpcEndpointArrayOutput) Index(i pulumi.IntInput) EndpointAccessVpcEndpointOutput

func (EndpointAccessVpcEndpointArrayOutput) ToEndpointAccessVpcEndpointArrayOutput 

func (o EndpointAccessVpcEndpointArrayOutput) ToEndpointAccessVpcEndpointArrayOutput() EndpointAccessVpcEndpointArrayOutput

func (EndpointAccessVpcEndpointArrayOutput) ToEndpointAccessVpcEndpointArrayOutputWithContext 

func (o EndpointAccessVpcEndpointArrayOutput) ToEndpointAccessVpcEndpointArrayOutputWithContext(ctx context.Context) EndpointAccessVpcEndpointArrayOutput

type EndpointAccessVpcEndpointInput 

type EndpointAccessVpcEndpointInput interface {
	pulumi.Input

	ToEndpointAccessVpcEndpointOutput() EndpointAccessVpcEndpointOutput
	ToEndpointAccessVpcEndpointOutputWithContext(context.Context) EndpointAccessVpcEndpointOutput
}

EndpointAccessVpcEndpointInput is an input type that accepts EndpointAccessVpcEndpointArgs and EndpointAccessVpcEndpointOutput values. You can construct a concrete instance of `EndpointAccessVpcEndpointInput` via: 

EndpointAccessVpcEndpointArgs{...}

type EndpointAccessVpcEndpointNetworkInterface 

type EndpointAccessVpcEndpointNetworkInterface struct {
	// The availability Zone.
	AvailabilityZone *string `pulumi:"availabilityZone"`
	// The unique identifier of the network interface.
	NetworkInterfaceId *string `pulumi:"networkInterfaceId"`
	// The IPv4 address of the network interface within the subnet.
	PrivateIpAddress *string `pulumi:"privateIpAddress"`
	// The unique identifier of the subnet.
	SubnetId *string `pulumi:"subnetId"`
}

type EndpointAccessVpcEndpointNetworkInterfaceArgs 

type EndpointAccessVpcEndpointNetworkInterfaceArgs struct {
	// The availability Zone.
	AvailabilityZone pulumi.StringPtrInput `pulumi:"availabilityZone"`
	// The unique identifier of the network interface.
	NetworkInterfaceId pulumi.StringPtrInput `pulumi:"networkInterfaceId"`
	// The IPv4 address of the network interface within the subnet.
	PrivateIpAddress pulumi.StringPtrInput `pulumi:"privateIpAddress"`
	// The unique identifier of the subnet.
	SubnetId pulumi.StringPtrInput `pulumi:"subnetId"`
}

func (EndpointAccessVpcEndpointNetworkInterfaceArgs) ElementType 

func (EndpointAccessVpcEndpointNetworkInterfaceArgs) ElementType() reflect.Type

func (EndpointAccessVpcEndpointNetworkInterfaceArgs) ToEndpointAccessVpcEndpointNetworkInterfaceOutput 

func (i EndpointAccessVpcEndpointNetworkInterfaceArgs) ToEndpointAccessVpcEndpointNetworkInterfaceOutput() EndpointAccessVpcEndpointNetworkInterfaceOutput

func (EndpointAccessVpcEndpointNetworkInterfaceArgs) ToEndpointAccessVpcEndpointNetworkInterfaceOutputWithContext 

func (i EndpointAccessVpcEndpointNetworkInterfaceArgs) ToEndpointAccessVpcEndpointNetworkInterfaceOutputWithContext(ctx context.Context) EndpointAccessVpcEndpointNetworkInterfaceOutput

type EndpointAccessVpcEndpointNetworkInterfaceArray 

type EndpointAccessVpcEndpointNetworkInterfaceArray []EndpointAccessVpcEndpointNetworkInterfaceInput

func (EndpointAccessVpcEndpointNetworkInterfaceArray) ElementType 

func (EndpointAccessVpcEndpointNetworkInterfaceArray) ElementType() reflect.Type

func (EndpointAccessVpcEndpointNetworkInterfaceArray) ToEndpointAccessVpcEndpointNetworkInterfaceArrayOutput 

func (i EndpointAccessVpcEndpointNetworkInterfaceArray) ToEndpointAccessVpcEndpointNetworkInterfaceArrayOutput() EndpointAccessVpcEndpointNetworkInterfaceArrayOutput

func (EndpointAccessVpcEndpointNetworkInterfaceArray) ToEndpointAccessVpcEndpointNetworkInterfaceArrayOutputWithContext 

func (i EndpointAccessVpcEndpointNetworkInterfaceArray) ToEndpointAccessVpcEndpointNetworkInterfaceArrayOutputWithContext(ctx context.Context) EndpointAccessVpcEndpointNetworkInterfaceArrayOutput

type EndpointAccessVpcEndpointNetworkInterfaceArrayInput 

type EndpointAccessVpcEndpointNetworkInterfaceArrayInput interface {
	pulumi.Input

	ToEndpointAccessVpcEndpointNetworkInterfaceArrayOutput() EndpointAccessVpcEndpointNetworkInterfaceArrayOutput
	ToEndpointAccessVpcEndpointNetworkInterfaceArrayOutputWithContext(context.Context) EndpointAccessVpcEndpointNetworkInterfaceArrayOutput
}

EndpointAccessVpcEndpointNetworkInterfaceArrayInput is an input type that accepts EndpointAccessVpcEndpointNetworkInterfaceArray and EndpointAccessVpcEndpointNetworkInterfaceArrayOutput values. You can construct a concrete instance of `EndpointAccessVpcEndpointNetworkInterfaceArrayInput` via: 

EndpointAccessVpcEndpointNetworkInterfaceArray{ EndpointAccessVpcEndpointNetworkInterfaceArgs{...} }

type EndpointAccessVpcEndpointNetworkInterfaceArrayOutput 

type EndpointAccessVpcEndpointNetworkInterfaceArrayOutput struct{ *pulumi.OutputState }

func (EndpointAccessVpcEndpointNetworkInterfaceArrayOutput) ElementType 

func (EndpointAccessVpcEndpointNetworkInterfaceArrayOutput) ElementType() reflect.Type

func (EndpointAccessVpcEndpointNetworkInterfaceArrayOutput) Index 

func (o EndpointAccessVpcEndpointNetworkInterfaceArrayOutput) Index(i pulumi.IntInput) EndpointAccessVpcEndpointNetworkInterfaceOutput

func (EndpointAccessVpcEndpointNetworkInterfaceArrayOutput) ToEndpointAccessVpcEndpointNetworkInterfaceArrayOutput 

func (o EndpointAccessVpcEndpointNetworkInterfaceArrayOutput) ToEndpointAccessVpcEndpointNetworkInterfaceArrayOutput() EndpointAccessVpcEndpointNetworkInterfaceArrayOutput

func (EndpointAccessVpcEndpointNetworkInterfaceArrayOutput) ToEndpointAccessVpcEndpointNetworkInterfaceArrayOutputWithContext 

func (o EndpointAccessVpcEndpointNetworkInterfaceArrayOutput) ToEndpointAccessVpcEndpointNetworkInterfaceArrayOutputWithContext(ctx context.Context) EndpointAccessVpcEndpointNetworkInterfaceArrayOutput

type EndpointAccessVpcEndpointNetworkInterfaceInput 

type EndpointAccessVpcEndpointNetworkInterfaceInput interface {
	pulumi.Input

	ToEndpointAccessVpcEndpointNetworkInterfaceOutput() EndpointAccessVpcEndpointNetworkInterfaceOutput
	ToEndpointAccessVpcEndpointNetworkInterfaceOutputWithContext(context.Context) EndpointAccessVpcEndpointNetworkInterfaceOutput
}

EndpointAccessVpcEndpointNetworkInterfaceInput is an input type that accepts EndpointAccessVpcEndpointNetworkInterfaceArgs and EndpointAccessVpcEndpointNetworkInterfaceOutput values. You can construct a concrete instance of `EndpointAccessVpcEndpointNetworkInterfaceInput` via: 

EndpointAccessVpcEndpointNetworkInterfaceArgs{...}

type EndpointAccessVpcEndpointNetworkInterfaceOutput 

type EndpointAccessVpcEndpointNetworkInterfaceOutput struct{ *pulumi.OutputState }

func (EndpointAccessVpcEndpointNetworkInterfaceOutput) AvailabilityZone 

func (o EndpointAccessVpcEndpointNetworkInterfaceOutput) AvailabilityZone() pulumi.StringPtrOutput

The availability Zone.

func (EndpointAccessVpcEndpointNetworkInterfaceOutput) ElementType 

func (EndpointAccessVpcEndpointNetworkInterfaceOutput) ElementType() reflect.Type

func (EndpointAccessVpcEndpointNetworkInterfaceOutput) NetworkInterfaceId 

func (o EndpointAccessVpcEndpointNetworkInterfaceOutput) NetworkInterfaceId() pulumi.StringPtrOutput

The unique identifier of the network interface.

func (EndpointAccessVpcEndpointNetworkInterfaceOutput) PrivateIpAddress 

func (o EndpointAccessVpcEndpointNetworkInterfaceOutput) PrivateIpAddress() pulumi.StringPtrOutput

The IPv4 address of the network interface within the subnet.

func (EndpointAccessVpcEndpointNetworkInterfaceOutput) SubnetId 

func (o EndpointAccessVpcEndpointNetworkInterfaceOutput) SubnetId() pulumi.StringPtrOutput

The unique identifier of the subnet.

func (EndpointAccessVpcEndpointNetworkInterfaceOutput) ToEndpointAccessVpcEndpointNetworkInterfaceOutput 

func (o EndpointAccessVpcEndpointNetworkInterfaceOutput) ToEndpointAccessVpcEndpointNetworkInterfaceOutput() EndpointAccessVpcEndpointNetworkInterfaceOutput

func (EndpointAccessVpcEndpointNetworkInterfaceOutput) ToEndpointAccessVpcEndpointNetworkInterfaceOutputWithContext 

func (o EndpointAccessVpcEndpointNetworkInterfaceOutput) ToEndpointAccessVpcEndpointNetworkInterfaceOutputWithContext(ctx context.Context) EndpointAccessVpcEndpointNetworkInterfaceOutput

type EndpointAccessVpcEndpointOutput 

type EndpointAccessVpcEndpointOutput struct{ *pulumi.OutputState }

func (EndpointAccessVpcEndpointOutput) ElementType 

func (EndpointAccessVpcEndpointOutput) ElementType() reflect.Type

func (EndpointAccessVpcEndpointOutput) NetworkInterfaces 

func (o EndpointAccessVpcEndpointOutput) NetworkInterfaces() EndpointAccessVpcEndpointNetworkInterfaceArrayOutput

The network interfaces of the endpoint.. See `Network Interface` below.

func (EndpointAccessVpcEndpointOutput) ToEndpointAccessVpcEndpointOutput 

func (o EndpointAccessVpcEndpointOutput) ToEndpointAccessVpcEndpointOutput() EndpointAccessVpcEndpointOutput

func (EndpointAccessVpcEndpointOutput) ToEndpointAccessVpcEndpointOutputWithContext 

func (o EndpointAccessVpcEndpointOutput) ToEndpointAccessVpcEndpointOutputWithContext(ctx context.Context) EndpointAccessVpcEndpointOutput

func (EndpointAccessVpcEndpointOutput) VpcEndpointId 

func (o EndpointAccessVpcEndpointOutput) VpcEndpointId() pulumi.StringPtrOutput

The DNS address of the VPC endpoint.

func (EndpointAccessVpcEndpointOutput) VpcId 

func (o EndpointAccessVpcEndpointOutput) VpcId() pulumi.StringPtrOutput

The port that Amazon Redshift Serverless listens on.

type GetCredentialsArgs 

type GetCredentialsArgs struct {
	// The name of the database to get temporary authorization to log on to.
	DbName *string `pulumi:"dbName"`
	// The number of seconds until the returned temporary password expires. The minimum is 900 seconds, and the maximum is 3600 seconds.
	DurationSeconds *int `pulumi:"durationSeconds"`
	// The name of the workgroup associated with the database.
	WorkgroupName string `pulumi:"workgroupName"`
}

A collection of arguments for invoking getCredentials.

type GetCredentialsOutputArgs 

type GetCredentialsOutputArgs struct {
	// The name of the database to get temporary authorization to log on to.
	DbName pulumi.StringPtrInput `pulumi:"dbName"`
	// The number of seconds until the returned temporary password expires. The minimum is 900 seconds, and the maximum is 3600 seconds.
	DurationSeconds pulumi.IntPtrInput `pulumi:"durationSeconds"`
	// The name of the workgroup associated with the database.
	WorkgroupName pulumi.StringInput `pulumi:"workgroupName"`
}

A collection of arguments for invoking getCredentials.

func (GetCredentialsOutputArgs) ElementType 

func (GetCredentialsOutputArgs) ElementType() reflect.Type

type GetCredentialsResult 

type GetCredentialsResult struct {
	DbName *string `pulumi:"dbName"`
	// Temporary password that authorizes the user name returned by `dbUser` to log on to the database `dbName`.
	DbPassword string `pulumi:"dbPassword"`
	// A database user name that is authorized to log on to the database `dbName` using the password `dbPassword` . If the specified `dbUser` exists in the database, the new user name has the same database privileges as the user named in `dbUser` . By default, the user is added to PUBLIC. the user doesn't exist in the database.
	DbUser          string `pulumi:"dbUser"`
	DurationSeconds *int   `pulumi:"durationSeconds"`
	// Date and time the password in `dbPassword` expires.
	Expiration string `pulumi:"expiration"`
	// The provider-assigned unique ID for this managed resource.
	Id            string `pulumi:"id"`
	WorkgroupName string `pulumi:"workgroupName"`
}

A collection of values returned by getCredentials.

func GetCredentials 

func GetCredentials(ctx *pulumi.Context, args *GetCredentialsArgs, opts ...pulumi.InvokeOption) (*GetCredentialsResult, error)

Provides redshift serverless temporary credentials for a workgroup.

## Example Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/redshiftserverless"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redshiftserverless.GetCredentials(ctx, &redshiftserverless.GetCredentialsArgs{
			WorkgroupName: exampleAwsRedshiftserverlessWorkgroup.WorkgroupName,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

type GetCredentialsResultOutput 

type GetCredentialsResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getCredentials.

func GetCredentialsOutput 

func GetCredentialsOutput(ctx *pulumi.Context, args GetCredentialsOutputArgs, opts ...pulumi.InvokeOption) GetCredentialsResultOutput

func (GetCredentialsResultOutput) DbName 

func (o GetCredentialsResultOutput) DbName() pulumi.StringPtrOutput

func (GetCredentialsResultOutput) DbPassword 

func (o GetCredentialsResultOutput) DbPassword() pulumi.StringOutput

Temporary password that authorizes the user name returned by `dbUser` to log on to the database `dbName`.

func (GetCredentialsResultOutput) DbUser 

func (o GetCredentialsResultOutput) DbUser() pulumi.StringOutput

A database user name that is authorized to log on to the database `dbName` using the password `dbPassword` . If the specified `dbUser` exists in the database, the new user name has the same database privileges as the user named in `dbUser` . By default, the user is added to PUBLIC. the user doesn't exist in the database.

func (GetCredentialsResultOutput) DurationSeconds 

func (o GetCredentialsResultOutput) DurationSeconds() pulumi.IntPtrOutput

func (GetCredentialsResultOutput) ElementType 

func (GetCredentialsResultOutput) ElementType() reflect.Type

func (GetCredentialsResultOutput) Expiration 

func (o GetCredentialsResultOutput) Expiration() pulumi.StringOutput

Date and time the password in `dbPassword` expires.

func (GetCredentialsResultOutput) Id 

func (o GetCredentialsResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetCredentialsResultOutput) ToGetCredentialsResultOutput 

func (o GetCredentialsResultOutput) ToGetCredentialsResultOutput() GetCredentialsResultOutput

func (GetCredentialsResultOutput) ToGetCredentialsResultOutputWithContext 

func (o GetCredentialsResultOutput) ToGetCredentialsResultOutputWithContext(ctx context.Context) GetCredentialsResultOutput

func (GetCredentialsResultOutput) WorkgroupName 

func (o GetCredentialsResultOutput) WorkgroupName() pulumi.StringOutput

type GetWorkgroupEndpoint 

type GetWorkgroupEndpoint struct {
	// The DNS address of the VPC endpoint.
	Address string `pulumi:"address"`
	// The port that Amazon Redshift Serverless listens on.
	Port int `pulumi:"port"`
	// The VPC endpoint or the Redshift Serverless workgroup. See `VPC Endpoint` below.
	VpcEndpoints []GetWorkgroupEndpointVpcEndpoint `pulumi:"vpcEndpoints"`
}

type GetWorkgroupEndpointArgs 

type GetWorkgroupEndpointArgs struct {
	// The DNS address of the VPC endpoint.
	Address pulumi.StringInput `pulumi:"address"`
	// The port that Amazon Redshift Serverless listens on.
	Port pulumi.IntInput `pulumi:"port"`
	// The VPC endpoint or the Redshift Serverless workgroup. See `VPC Endpoint` below.
	VpcEndpoints GetWorkgroupEndpointVpcEndpointArrayInput `pulumi:"vpcEndpoints"`
}

func (GetWorkgroupEndpointArgs) ElementType 

func (GetWorkgroupEndpointArgs) ElementType() reflect.Type

func (GetWorkgroupEndpointArgs) ToGetWorkgroupEndpointOutput 

func (i GetWorkgroupEndpointArgs) ToGetWorkgroupEndpointOutput() GetWorkgroupEndpointOutput

func (GetWorkgroupEndpointArgs) ToGetWorkgroupEndpointOutputWithContext 

func (i GetWorkgroupEndpointArgs) ToGetWorkgroupEndpointOutputWithContext(ctx context.Context) GetWorkgroupEndpointOutput

type GetWorkgroupEndpointArray 

type GetWorkgroupEndpointArray []GetWorkgroupEndpointInput

func (GetWorkgroupEndpointArray) ElementType 

func (GetWorkgroupEndpointArray) ElementType() reflect.Type

func (GetWorkgroupEndpointArray) ToGetWorkgroupEndpointArrayOutput 

func (i GetWorkgroupEndpointArray) ToGetWorkgroupEndpointArrayOutput() GetWorkgroupEndpointArrayOutput

func (GetWorkgroupEndpointArray) ToGetWorkgroupEndpointArrayOutputWithContext 

func (i GetWorkgroupEndpointArray) ToGetWorkgroupEndpointArrayOutputWithContext(ctx context.Context) GetWorkgroupEndpointArrayOutput

type GetWorkgroupEndpointArrayInput 

type GetWorkgroupEndpointArrayInput interface {
	pulumi.Input

	ToGetWorkgroupEndpointArrayOutput() GetWorkgroupEndpointArrayOutput
	ToGetWorkgroupEndpointArrayOutputWithContext(context.Context) GetWorkgroupEndpointArrayOutput
}

GetWorkgroupEndpointArrayInput is an input type that accepts GetWorkgroupEndpointArray and GetWorkgroupEndpointArrayOutput values. You can construct a concrete instance of `GetWorkgroupEndpointArrayInput` via: 

GetWorkgroupEndpointArray{ GetWorkgroupEndpointArgs{...} }

type GetWorkgroupEndpointArrayOutput 

type GetWorkgroupEndpointArrayOutput struct{ *pulumi.OutputState }

func (GetWorkgroupEndpointArrayOutput) ElementType 

func (GetWorkgroupEndpointArrayOutput) ElementType() reflect.Type

func (GetWorkgroupEndpointArrayOutput) Index 

func (o GetWorkgroupEndpointArrayOutput) Index(i pulumi.IntInput) GetWorkgroupEndpointOutput

func (GetWorkgroupEndpointArrayOutput) ToGetWorkgroupEndpointArrayOutput 

func (o GetWorkgroupEndpointArrayOutput) ToGetWorkgroupEndpointArrayOutput() GetWorkgroupEndpointArrayOutput

func (GetWorkgroupEndpointArrayOutput) ToGetWorkgroupEndpointArrayOutputWithContext 

func (o GetWorkgroupEndpointArrayOutput) ToGetWorkgroupEndpointArrayOutputWithContext(ctx context.Context) GetWorkgroupEndpointArrayOutput

type GetWorkgroupEndpointInput 

type GetWorkgroupEndpointInput interface {
	pulumi.Input

	ToGetWorkgroupEndpointOutput() GetWorkgroupEndpointOutput
	ToGetWorkgroupEndpointOutputWithContext(context.Context) GetWorkgroupEndpointOutput
}

GetWorkgroupEndpointInput is an input type that accepts GetWorkgroupEndpointArgs and GetWorkgroupEndpointOutput values. You can construct a concrete instance of `GetWorkgroupEndpointInput` via: 

GetWorkgroupEndpointArgs{...}

type GetWorkgroupEndpointOutput 

type GetWorkgroupEndpointOutput struct{ *pulumi.OutputState }

func (GetWorkgroupEndpointOutput) Address 

func (o GetWorkgroupEndpointOutput) Address() pulumi.StringOutput

The DNS address of the VPC endpoint.

func (GetWorkgroupEndpointOutput) ElementType 

func (GetWorkgroupEndpointOutput) ElementType() reflect.Type

func (GetWorkgroupEndpointOutput) Port 

func (o GetWorkgroupEndpointOutput) Port() pulumi.IntOutput

The port that Amazon Redshift Serverless listens on.

func (GetWorkgroupEndpointOutput) ToGetWorkgroupEndpointOutput 

func (o GetWorkgroupEndpointOutput) ToGetWorkgroupEndpointOutput() GetWorkgroupEndpointOutput

func (GetWorkgroupEndpointOutput) ToGetWorkgroupEndpointOutputWithContext 

func (o GetWorkgroupEndpointOutput) ToGetWorkgroupEndpointOutputWithContext(ctx context.Context) GetWorkgroupEndpointOutput

func (GetWorkgroupEndpointOutput) VpcEndpoints 

func (o GetWorkgroupEndpointOutput) VpcEndpoints() GetWorkgroupEndpointVpcEndpointArrayOutput

The VPC endpoint or the Redshift Serverless workgroup. See `VPC Endpoint` below.

type GetWorkgroupEndpointVpcEndpoint 

type GetWorkgroupEndpointVpcEndpoint struct {
	// The network interfaces of the endpoint.. See `Network Interface` below.
	NetworkInterfaces []GetWorkgroupEndpointVpcEndpointNetworkInterface `pulumi:"networkInterfaces"`
	// The DNS address of the VPC endpoint.
	VpcEndpointId string `pulumi:"vpcEndpointId"`
	// The port that Amazon Redshift Serverless listens on.
	VpcId string `pulumi:"vpcId"`
}

type GetWorkgroupEndpointVpcEndpointArgs 

type GetWorkgroupEndpointVpcEndpointArgs struct {
	// The network interfaces of the endpoint.. See `Network Interface` below.
	NetworkInterfaces GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayInput `pulumi:"networkInterfaces"`
	// The DNS address of the VPC endpoint.
	VpcEndpointId pulumi.StringInput `pulumi:"vpcEndpointId"`
	// The port that Amazon Redshift Serverless listens on.
	VpcId pulumi.StringInput `pulumi:"vpcId"`
}

func (GetWorkgroupEndpointVpcEndpointArgs) ElementType 

func (GetWorkgroupEndpointVpcEndpointArgs) ElementType() reflect.Type

func (GetWorkgroupEndpointVpcEndpointArgs) ToGetWorkgroupEndpointVpcEndpointOutput 

func (i GetWorkgroupEndpointVpcEndpointArgs) ToGetWorkgroupEndpointVpcEndpointOutput() GetWorkgroupEndpointVpcEndpointOutput

func (GetWorkgroupEndpointVpcEndpointArgs) ToGetWorkgroupEndpointVpcEndpointOutputWithContext 

func (i GetWorkgroupEndpointVpcEndpointArgs) ToGetWorkgroupEndpointVpcEndpointOutputWithContext(ctx context.Context) GetWorkgroupEndpointVpcEndpointOutput

type GetWorkgroupEndpointVpcEndpointArray 

type GetWorkgroupEndpointVpcEndpointArray []GetWorkgroupEndpointVpcEndpointInput

func (GetWorkgroupEndpointVpcEndpointArray) ElementType 

func (GetWorkgroupEndpointVpcEndpointArray) ElementType() reflect.Type

func (GetWorkgroupEndpointVpcEndpointArray) ToGetWorkgroupEndpointVpcEndpointArrayOutput 

func (i GetWorkgroupEndpointVpcEndpointArray) ToGetWorkgroupEndpointVpcEndpointArrayOutput() GetWorkgroupEndpointVpcEndpointArrayOutput

func (GetWorkgroupEndpointVpcEndpointArray) ToGetWorkgroupEndpointVpcEndpointArrayOutputWithContext 

func (i GetWorkgroupEndpointVpcEndpointArray) ToGetWorkgroupEndpointVpcEndpointArrayOutputWithContext(ctx context.Context) GetWorkgroupEndpointVpcEndpointArrayOutput

type GetWorkgroupEndpointVpcEndpointArrayInput 

type GetWorkgroupEndpointVpcEndpointArrayInput interface {
	pulumi.Input

	ToGetWorkgroupEndpointVpcEndpointArrayOutput() GetWorkgroupEndpointVpcEndpointArrayOutput
	ToGetWorkgroupEndpointVpcEndpointArrayOutputWithContext(context.Context) GetWorkgroupEndpointVpcEndpointArrayOutput
}

GetWorkgroupEndpointVpcEndpointArrayInput is an input type that accepts GetWorkgroupEndpointVpcEndpointArray and GetWorkgroupEndpointVpcEndpointArrayOutput values. You can construct a concrete instance of `GetWorkgroupEndpointVpcEndpointArrayInput` via: 

GetWorkgroupEndpointVpcEndpointArray{ GetWorkgroupEndpointVpcEndpointArgs{...} }

type GetWorkgroupEndpointVpcEndpointArrayOutput 

type GetWorkgroupEndpointVpcEndpointArrayOutput struct{ *pulumi.OutputState }

func (GetWorkgroupEndpointVpcEndpointArrayOutput) ElementType 

func (GetWorkgroupEndpointVpcEndpointArrayOutput) ElementType() reflect.Type

func (GetWorkgroupEndpointVpcEndpointArrayOutput) Index 

func (o GetWorkgroupEndpointVpcEndpointArrayOutput) Index(i pulumi.IntInput) GetWorkgroupEndpointVpcEndpointOutput

func (GetWorkgroupEndpointVpcEndpointArrayOutput) ToGetWorkgroupEndpointVpcEndpointArrayOutput 

func (o GetWorkgroupEndpointVpcEndpointArrayOutput) ToGetWorkgroupEndpointVpcEndpointArrayOutput() GetWorkgroupEndpointVpcEndpointArrayOutput

func (GetWorkgroupEndpointVpcEndpointArrayOutput) ToGetWorkgroupEndpointVpcEndpointArrayOutputWithContext 

func (o GetWorkgroupEndpointVpcEndpointArrayOutput) ToGetWorkgroupEndpointVpcEndpointArrayOutputWithContext(ctx context.Context) GetWorkgroupEndpointVpcEndpointArrayOutput

type GetWorkgroupEndpointVpcEndpointInput 

type GetWorkgroupEndpointVpcEndpointInput interface {
	pulumi.Input

	ToGetWorkgroupEndpointVpcEndpointOutput() GetWorkgroupEndpointVpcEndpointOutput
	ToGetWorkgroupEndpointVpcEndpointOutputWithContext(context.Context) GetWorkgroupEndpointVpcEndpointOutput
}

GetWorkgroupEndpointVpcEndpointInput is an input type that accepts GetWorkgroupEndpointVpcEndpointArgs and GetWorkgroupEndpointVpcEndpointOutput values. You can construct a concrete instance of `GetWorkgroupEndpointVpcEndpointInput` via: 

GetWorkgroupEndpointVpcEndpointArgs{...}

type GetWorkgroupEndpointVpcEndpointNetworkInterface 

type GetWorkgroupEndpointVpcEndpointNetworkInterface struct {
	// The availability Zone.
	AvailabilityZone string `pulumi:"availabilityZone"`
	// The unique identifier of the network interface.
	NetworkInterfaceId string `pulumi:"networkInterfaceId"`
	// The IPv4 address of the network interface within the subnet.
	PrivateIpAddress string `pulumi:"privateIpAddress"`
	// The unique identifier of the subnet.
	SubnetId string `pulumi:"subnetId"`
}

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceArgs 

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceArgs struct {
	// The availability Zone.
	AvailabilityZone pulumi.StringInput `pulumi:"availabilityZone"`
	// The unique identifier of the network interface.
	NetworkInterfaceId pulumi.StringInput `pulumi:"networkInterfaceId"`
	// The IPv4 address of the network interface within the subnet.
	PrivateIpAddress pulumi.StringInput `pulumi:"privateIpAddress"`
	// The unique identifier of the subnet.
	SubnetId pulumi.StringInput `pulumi:"subnetId"`
}

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ElementType 

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ElementType() reflect.Type

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput 

func (i GetWorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput() GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceOutputWithContext 

func (i GetWorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceOutputWithContext(ctx context.Context) GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceArray 

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceArray []GetWorkgroupEndpointVpcEndpointNetworkInterfaceInput

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArray) ElementType 

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArray) ElementType() reflect.Type

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArray) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput 

func (i GetWorkgroupEndpointVpcEndpointNetworkInterfaceArray) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput() GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArray) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutputWithContext 

func (i GetWorkgroupEndpointVpcEndpointNetworkInterfaceArray) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutputWithContext(ctx context.Context) GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayInput 

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayInput interface {
	pulumi.Input

	ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput() GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput
	ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutputWithContext(context.Context) GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput
}

GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayInput is an input type that accepts GetWorkgroupEndpointVpcEndpointNetworkInterfaceArray and GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput values. You can construct a concrete instance of `GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayInput` via: 

GetWorkgroupEndpointVpcEndpointNetworkInterfaceArray{ GetWorkgroupEndpointVpcEndpointNetworkInterfaceArgs{...} }

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput 

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput struct{ *pulumi.OutputState }

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ElementType 

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ElementType() reflect.Type

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) Index 

func (o GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) Index(i pulumi.IntInput) GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput 

func (o GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput() GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutputWithContext 

func (o GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutputWithContext(ctx context.Context) GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceInput 

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceInput interface {
	pulumi.Input

	ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput() GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput
	ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceOutputWithContext(context.Context) GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput
}

GetWorkgroupEndpointVpcEndpointNetworkInterfaceInput is an input type that accepts GetWorkgroupEndpointVpcEndpointNetworkInterfaceArgs and GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput values. You can construct a concrete instance of `GetWorkgroupEndpointVpcEndpointNetworkInterfaceInput` via: 

GetWorkgroupEndpointVpcEndpointNetworkInterfaceArgs{...}

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput 

type GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput struct{ *pulumi.OutputState }

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) AvailabilityZone 

func (o GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) AvailabilityZone() pulumi.StringOutput

The availability Zone.

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ElementType 

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ElementType() reflect.Type

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) NetworkInterfaceId 

func (o GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) NetworkInterfaceId() pulumi.StringOutput

The unique identifier of the network interface.

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) PrivateIpAddress 

func (o GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) PrivateIpAddress() pulumi.StringOutput

The IPv4 address of the network interface within the subnet.

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) SubnetId 

func (o GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) SubnetId() pulumi.StringOutput

The unique identifier of the subnet.

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput 

func (o GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput() GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput

func (GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceOutputWithContext 

func (o GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ToGetWorkgroupEndpointVpcEndpointNetworkInterfaceOutputWithContext(ctx context.Context) GetWorkgroupEndpointVpcEndpointNetworkInterfaceOutput

type GetWorkgroupEndpointVpcEndpointOutput 

type GetWorkgroupEndpointVpcEndpointOutput struct{ *pulumi.OutputState }

func (GetWorkgroupEndpointVpcEndpointOutput) ElementType 

func (GetWorkgroupEndpointVpcEndpointOutput) ElementType() reflect.Type

func (GetWorkgroupEndpointVpcEndpointOutput) NetworkInterfaces 

func (o GetWorkgroupEndpointVpcEndpointOutput) NetworkInterfaces() GetWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput

The network interfaces of the endpoint.. See `Network Interface` below.

func (GetWorkgroupEndpointVpcEndpointOutput) ToGetWorkgroupEndpointVpcEndpointOutput 

func (o GetWorkgroupEndpointVpcEndpointOutput) ToGetWorkgroupEndpointVpcEndpointOutput() GetWorkgroupEndpointVpcEndpointOutput

func (GetWorkgroupEndpointVpcEndpointOutput) ToGetWorkgroupEndpointVpcEndpointOutputWithContext 

func (o GetWorkgroupEndpointVpcEndpointOutput) ToGetWorkgroupEndpointVpcEndpointOutputWithContext(ctx context.Context) GetWorkgroupEndpointVpcEndpointOutput

func (GetWorkgroupEndpointVpcEndpointOutput) VpcEndpointId 

func (o GetWorkgroupEndpointVpcEndpointOutput) VpcEndpointId() pulumi.StringOutput

The DNS address of the VPC endpoint.

func (GetWorkgroupEndpointVpcEndpointOutput) VpcId 

func (o GetWorkgroupEndpointVpcEndpointOutput) VpcId() pulumi.StringOutput

The port that Amazon Redshift Serverless listens on.

type LookupNamespaceArgs 

type LookupNamespaceArgs struct {
	// The name of the namespace.
	NamespaceName string `pulumi:"namespaceName"`
}

A collection of arguments for invoking getNamespace.

type LookupNamespaceOutputArgs 

type LookupNamespaceOutputArgs struct {
	// The name of the namespace.
	NamespaceName pulumi.StringInput `pulumi:"namespaceName"`
}

A collection of arguments for invoking getNamespace.

func (LookupNamespaceOutputArgs) ElementType 

func (LookupNamespaceOutputArgs) ElementType() reflect.Type

type LookupNamespaceResult 

type LookupNamespaceResult struct {
	// The username of the administrator for the first database created in the namespace.
	AdminUsername string `pulumi:"adminUsername"`
	// Amazon Resource Name (ARN) of the Redshift Serverless Namespace.
	Arn string `pulumi:"arn"`
	// The name of the first database created in the namespace.
	DbName string `pulumi:"dbName"`
	// The Amazon Resource Name (ARN) of the IAM role to set as a default in the namespace. When specifying `defaultIamRoleArn`, it also must be part of `iamRoles`.
	DefaultIamRoleArn string `pulumi:"defaultIamRoleArn"`
	// A list of IAM roles to associate with the namespace.
	IamRoles []string `pulumi:"iamRoles"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The ARN of the Amazon Web Services Key Management Service key used to encrypt your data.
	KmsKeyId string `pulumi:"kmsKeyId"`
	// The types of logs the namespace can export. Available export types are `userlog`, `connectionlog`, and `useractivitylog`.
	LogExports []string `pulumi:"logExports"`
	// The Redshift Namespace ID.
	NamespaceId   string `pulumi:"namespaceId"`
	NamespaceName string `pulumi:"namespaceName"`
}

A collection of values returned by getNamespace.

func LookupNamespace 

func LookupNamespace(ctx *pulumi.Context, args *LookupNamespaceArgs, opts ...pulumi.InvokeOption) (*LookupNamespaceResult, error)

Data source for managing an AWS Redshift Serverless Namespace.

## Example Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/redshiftserverless"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redshiftserverless.LookupNamespace(ctx, &redshiftserverless.LookupNamespaceArgs{
			NamespaceName: "example-namespace",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

type LookupNamespaceResultOutput 

type LookupNamespaceResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getNamespace.

func LookupNamespaceOutput 

func LookupNamespaceOutput(ctx *pulumi.Context, args LookupNamespaceOutputArgs, opts ...pulumi.InvokeOption) LookupNamespaceResultOutput

func (LookupNamespaceResultOutput) AdminUsername 

func (o LookupNamespaceResultOutput) AdminUsername() pulumi.StringOutput

The username of the administrator for the first database created in the namespace.

func (LookupNamespaceResultOutput) Arn 

func (o LookupNamespaceResultOutput) Arn() pulumi.StringOutput

Amazon Resource Name (ARN) of the Redshift Serverless Namespace.

func (LookupNamespaceResultOutput) DbName 

func (o LookupNamespaceResultOutput) DbName() pulumi.StringOutput

The name of the first database created in the namespace.

func (LookupNamespaceResultOutput) DefaultIamRoleArn 

func (o LookupNamespaceResultOutput) DefaultIamRoleArn() pulumi.StringOutput

The Amazon Resource Name (ARN) of the IAM role to set as a default in the namespace. When specifying `defaultIamRoleArn`, it also must be part of `iamRoles`.

func (LookupNamespaceResultOutput) ElementType 

func (LookupNamespaceResultOutput) ElementType() reflect.Type

func (LookupNamespaceResultOutput) IamRoles 

func (o LookupNamespaceResultOutput) IamRoles() pulumi.StringArrayOutput

A list of IAM roles to associate with the namespace.

func (LookupNamespaceResultOutput) Id 

func (o LookupNamespaceResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupNamespaceResultOutput) KmsKeyId 

func (o LookupNamespaceResultOutput) KmsKeyId() pulumi.StringOutput

The ARN of the Amazon Web Services Key Management Service key used to encrypt your data.

func (LookupNamespaceResultOutput) LogExports 

func (o LookupNamespaceResultOutput) LogExports() pulumi.StringArrayOutput

The types of logs the namespace can export. Available export types are `userlog`, `connectionlog`, and `useractivitylog`.

func (LookupNamespaceResultOutput) NamespaceId 

func (o LookupNamespaceResultOutput) NamespaceId() pulumi.StringOutput

The Redshift Namespace ID.

func (LookupNamespaceResultOutput) NamespaceName 

func (o LookupNamespaceResultOutput) NamespaceName() pulumi.StringOutput

func (LookupNamespaceResultOutput) ToLookupNamespaceResultOutput 

func (o LookupNamespaceResultOutput) ToLookupNamespaceResultOutput() LookupNamespaceResultOutput

func (LookupNamespaceResultOutput) ToLookupNamespaceResultOutputWithContext 

func (o LookupNamespaceResultOutput) ToLookupNamespaceResultOutputWithContext(ctx context.Context) LookupNamespaceResultOutput

type LookupWorkgroupArgs 

type LookupWorkgroupArgs struct {
	// The name of the workgroup associated with the database.
	WorkgroupName string `pulumi:"workgroupName"`
}

A collection of arguments for invoking getWorkgroup.

type LookupWorkgroupOutputArgs 

type LookupWorkgroupOutputArgs struct {
	// The name of the workgroup associated with the database.
	WorkgroupName pulumi.StringInput `pulumi:"workgroupName"`
}

A collection of arguments for invoking getWorkgroup.

func (LookupWorkgroupOutputArgs) ElementType 

func (LookupWorkgroupOutputArgs) ElementType() reflect.Type

type LookupWorkgroupResult 

type LookupWorkgroupResult struct {
	// Amazon Resource Name (ARN) of the Redshift Serverless Workgroup.
	Arn string `pulumi:"arn"`
	// The endpoint that is created from the workgroup. See `Endpoint` below.
	Endpoints []GetWorkgroupEndpoint `pulumi:"endpoints"`
	// The value that specifies whether to turn on enhanced virtual private cloud (VPC) routing, which forces Amazon Redshift Serverless to route traffic through your VPC instead of over the internet.
	EnhancedVpcRouting bool `pulumi:"enhancedVpcRouting"`
	// The provider-assigned unique ID for this managed resource.
	Id            string `pulumi:"id"`
	NamespaceName string `pulumi:"namespaceName"`
	// A value that specifies whether the workgroup can be accessed from a public network.
	PubliclyAccessible bool `pulumi:"publiclyAccessible"`
	// An array of security group IDs to associate with the workgroup.
	SecurityGroupIds []string `pulumi:"securityGroupIds"`
	// An array of VPC subnet IDs to associate with the workgroup. When set, must contain at least three subnets spanning three Availability Zones. A minimum number of IP addresses is required and scales with the Base Capacity. For more information, see the following [AWS document](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-known-issues.html).
	SubnetIds []string `pulumi:"subnetIds"`
	// The Redshift Workgroup ID.
	WorkgroupId   string `pulumi:"workgroupId"`
	WorkgroupName string `pulumi:"workgroupName"`
}

A collection of values returned by getWorkgroup.

func LookupWorkgroup 

func LookupWorkgroup(ctx *pulumi.Context, args *LookupWorkgroupArgs, opts ...pulumi.InvokeOption) (*LookupWorkgroupResult, error)

Data source for managing an AWS Redshift Serverless Workgroup.

## Example Usage

### Basic Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/redshiftserverless"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redshiftserverless.LookupWorkgroup(ctx, &redshiftserverless.LookupWorkgroupArgs{
			WorkgroupName: exampleAwsRedshiftserverlessWorkgroup.WorkgroupName,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

type LookupWorkgroupResultOutput 

type LookupWorkgroupResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getWorkgroup.

func LookupWorkgroupOutput 

func LookupWorkgroupOutput(ctx *pulumi.Context, args LookupWorkgroupOutputArgs, opts ...pulumi.InvokeOption) LookupWorkgroupResultOutput

func (LookupWorkgroupResultOutput) Arn 

func (o LookupWorkgroupResultOutput) Arn() pulumi.StringOutput

Amazon Resource Name (ARN) of the Redshift Serverless Workgroup.

func (LookupWorkgroupResultOutput) ElementType 

func (LookupWorkgroupResultOutput) ElementType() reflect.Type

func (LookupWorkgroupResultOutput) Endpoints 

func (o LookupWorkgroupResultOutput) Endpoints() GetWorkgroupEndpointArrayOutput

The endpoint that is created from the workgroup. See `Endpoint` below.

func (LookupWorkgroupResultOutput) EnhancedVpcRouting 

func (o LookupWorkgroupResultOutput) EnhancedVpcRouting() pulumi.BoolOutput

The value that specifies whether to turn on enhanced virtual private cloud (VPC) routing, which forces Amazon Redshift Serverless to route traffic through your VPC instead of over the internet.

func (LookupWorkgroupResultOutput) Id 

func (o LookupWorkgroupResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupWorkgroupResultOutput) NamespaceName 

func (o LookupWorkgroupResultOutput) NamespaceName() pulumi.StringOutput

func (LookupWorkgroupResultOutput) PubliclyAccessible 

func (o LookupWorkgroupResultOutput) PubliclyAccessible() pulumi.BoolOutput

A value that specifies whether the workgroup can be accessed from a public network.

func (LookupWorkgroupResultOutput) SecurityGroupIds 

func (o LookupWorkgroupResultOutput) SecurityGroupIds() pulumi.StringArrayOutput

An array of security group IDs to associate with the workgroup.

func (LookupWorkgroupResultOutput) SubnetIds 

func (o LookupWorkgroupResultOutput) SubnetIds() pulumi.StringArrayOutput

An array of VPC subnet IDs to associate with the workgroup. When set, must contain at least three subnets spanning three Availability Zones. A minimum number of IP addresses is required and scales with the Base Capacity. For more information, see the following [AWS document](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-known-issues.html).

func (LookupWorkgroupResultOutput) ToLookupWorkgroupResultOutput 

func (o LookupWorkgroupResultOutput) ToLookupWorkgroupResultOutput() LookupWorkgroupResultOutput

func (LookupWorkgroupResultOutput) ToLookupWorkgroupResultOutputWithContext 

func (o LookupWorkgroupResultOutput) ToLookupWorkgroupResultOutputWithContext(ctx context.Context) LookupWorkgroupResultOutput

func (LookupWorkgroupResultOutput) WorkgroupId 

func (o LookupWorkgroupResultOutput) WorkgroupId() pulumi.StringOutput

The Redshift Workgroup ID.

func (LookupWorkgroupResultOutput) WorkgroupName 

func (o LookupWorkgroupResultOutput) WorkgroupName() pulumi.StringOutput

type Namespace 

type Namespace struct {
	pulumi.CustomResourceState

	AdminPasswordSecretArn pulumi.StringOutput `pulumi:"adminPasswordSecretArn"`
	// ID of the KMS key used to encrypt the namespace's admin credentials secret.
	AdminPasswordSecretKmsKeyId pulumi.StringOutput `pulumi:"adminPasswordSecretKmsKeyId"`
	// The password of the administrator for the first database created in the namespace.
	// Conflicts with `manageAdminPassword`.
	AdminUserPassword pulumi.StringPtrOutput `pulumi:"adminUserPassword"`
	// The username of the administrator for the first database created in the namespace.
	AdminUsername pulumi.StringOutput `pulumi:"adminUsername"`
	// Amazon Resource Name (ARN) of the Redshift Serverless Namespace.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The name of the first database created in the namespace.
	DbName pulumi.StringOutput `pulumi:"dbName"`
	// The Amazon Resource Name (ARN) of the IAM role to set as a default in the namespace. When specifying `defaultIamRoleArn`, it also must be part of `iamRoles`.
	DefaultIamRoleArn pulumi.StringPtrOutput `pulumi:"defaultIamRoleArn"`
	// A list of IAM roles to associate with the namespace.
	IamRoles pulumi.StringArrayOutput `pulumi:"iamRoles"`
	// The ARN of the Amazon Web Services Key Management Service key used to encrypt your data.
	KmsKeyId pulumi.StringOutput `pulumi:"kmsKeyId"`
	// The types of logs the namespace can export. Available export types are `userlog`, `connectionlog`, and `useractivitylog`.
	LogExports pulumi.StringArrayOutput `pulumi:"logExports"`
	// Whether to use AWS SecretManager to manage namespace's admin credentials.
	// Conflicts with `adminUserPassword`.
	ManageAdminPassword pulumi.BoolPtrOutput `pulumi:"manageAdminPassword"`
	// The Redshift Namespace ID.
	NamespaceId pulumi.StringOutput `pulumi:"namespaceId"`
	// The name of the namespace.
	NamespaceName pulumi.StringOutput `pulumi:"namespaceName"`
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	//
	// Deprecated: Please use `tags` instead.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Creates a new Amazon Redshift Serverless Namespace.

## Example Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/redshiftserverless"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redshiftserverless.NewNamespace(ctx, "example", &redshiftserverless.NamespaceArgs{
			NamespaceName: pulumi.String("concurrency-scaling"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

## Import

Using `pulumi import`, import Redshift Serverless Namespaces using the `namespace_name`. For example:

```sh $ pulumi import aws:redshiftserverless/namespace:Namespace example example ```

func GetNamespace 

func GetNamespace(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NamespaceState, opts ...pulumi.ResourceOption) (*Namespace, error)

GetNamespace gets an existing Namespace resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewNamespace 

func NewNamespace(ctx *pulumi.Context,
	name string, args *NamespaceArgs, opts ...pulumi.ResourceOption) (*Namespace, error)

NewNamespace registers a new resource with the given unique name, arguments, and options.

func (*Namespace) ElementType 

func (*Namespace) ElementType() reflect.Type

func (*Namespace) ToNamespaceOutput 

func (i *Namespace) ToNamespaceOutput() NamespaceOutput

func (*Namespace) ToNamespaceOutputWithContext 

func (i *Namespace) ToNamespaceOutputWithContext(ctx context.Context) NamespaceOutput

type NamespaceArgs 

type NamespaceArgs struct {
	// ID of the KMS key used to encrypt the namespace's admin credentials secret.
	AdminPasswordSecretKmsKeyId pulumi.StringPtrInput
	// The password of the administrator for the first database created in the namespace.
	// Conflicts with `manageAdminPassword`.
	AdminUserPassword pulumi.StringPtrInput
	// The username of the administrator for the first database created in the namespace.
	AdminUsername pulumi.StringPtrInput
	// The name of the first database created in the namespace.
	DbName pulumi.StringPtrInput
	// The Amazon Resource Name (ARN) of the IAM role to set as a default in the namespace. When specifying `defaultIamRoleArn`, it also must be part of `iamRoles`.
	DefaultIamRoleArn pulumi.StringPtrInput
	// A list of IAM roles to associate with the namespace.
	IamRoles pulumi.StringArrayInput
	// The ARN of the Amazon Web Services Key Management Service key used to encrypt your data.
	KmsKeyId pulumi.StringPtrInput
	// The types of logs the namespace can export. Available export types are `userlog`, `connectionlog`, and `useractivitylog`.
	LogExports pulumi.StringArrayInput
	// Whether to use AWS SecretManager to manage namespace's admin credentials.
	// Conflicts with `adminUserPassword`.
	ManageAdminPassword pulumi.BoolPtrInput
	// The name of the namespace.
	NamespaceName pulumi.StringInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a Namespace resource.

func (NamespaceArgs) ElementType 

func (NamespaceArgs) ElementType() reflect.Type

type NamespaceArray 

type NamespaceArray []NamespaceInput

func (NamespaceArray) ElementType 

func (NamespaceArray) ElementType() reflect.Type

func (NamespaceArray) ToNamespaceArrayOutput 

func (i NamespaceArray) ToNamespaceArrayOutput() NamespaceArrayOutput

func (NamespaceArray) ToNamespaceArrayOutputWithContext 

func (i NamespaceArray) ToNamespaceArrayOutputWithContext(ctx context.Context) NamespaceArrayOutput

type NamespaceArrayInput 

type NamespaceArrayInput interface {
	pulumi.Input

	ToNamespaceArrayOutput() NamespaceArrayOutput
	ToNamespaceArrayOutputWithContext(context.Context) NamespaceArrayOutput
}

NamespaceArrayInput is an input type that accepts NamespaceArray and NamespaceArrayOutput values. You can construct a concrete instance of `NamespaceArrayInput` via: 

NamespaceArray{ NamespaceArgs{...} }

type NamespaceArrayOutput 

type NamespaceArrayOutput struct{ *pulumi.OutputState }

func (NamespaceArrayOutput) ElementType 

func (NamespaceArrayOutput) ElementType() reflect.Type

func (NamespaceArrayOutput) Index 

func (o NamespaceArrayOutput) Index(i pulumi.IntInput) NamespaceOutput

func (NamespaceArrayOutput) ToNamespaceArrayOutput 

func (o NamespaceArrayOutput) ToNamespaceArrayOutput() NamespaceArrayOutput

func (NamespaceArrayOutput) ToNamespaceArrayOutputWithContext 

func (o NamespaceArrayOutput) ToNamespaceArrayOutputWithContext(ctx context.Context) NamespaceArrayOutput

type NamespaceInput 

type NamespaceInput interface {
	pulumi.Input

	ToNamespaceOutput() NamespaceOutput
	ToNamespaceOutputWithContext(ctx context.Context) NamespaceOutput
}

type NamespaceMap 

type NamespaceMap map[string]NamespaceInput

func (NamespaceMap) ElementType 

func (NamespaceMap) ElementType() reflect.Type

func (NamespaceMap) ToNamespaceMapOutput 

func (i NamespaceMap) ToNamespaceMapOutput() NamespaceMapOutput

func (NamespaceMap) ToNamespaceMapOutputWithContext 

func (i NamespaceMap) ToNamespaceMapOutputWithContext(ctx context.Context) NamespaceMapOutput

type NamespaceMapInput 

type NamespaceMapInput interface {
	pulumi.Input

	ToNamespaceMapOutput() NamespaceMapOutput
	ToNamespaceMapOutputWithContext(context.Context) NamespaceMapOutput
}

NamespaceMapInput is an input type that accepts NamespaceMap and NamespaceMapOutput values. You can construct a concrete instance of `NamespaceMapInput` via: 

NamespaceMap{ "key": NamespaceArgs{...} }

type NamespaceMapOutput 

type NamespaceMapOutput struct{ *pulumi.OutputState }

func (NamespaceMapOutput) ElementType 

func (NamespaceMapOutput) ElementType() reflect.Type

func (NamespaceMapOutput) MapIndex 

func (o NamespaceMapOutput) MapIndex(k pulumi.StringInput) NamespaceOutput

func (NamespaceMapOutput) ToNamespaceMapOutput 

func (o NamespaceMapOutput) ToNamespaceMapOutput() NamespaceMapOutput

func (NamespaceMapOutput) ToNamespaceMapOutputWithContext 

func (o NamespaceMapOutput) ToNamespaceMapOutputWithContext(ctx context.Context) NamespaceMapOutput

type NamespaceOutput 

type NamespaceOutput struct{ *pulumi.OutputState }

func (NamespaceOutput) AdminPasswordSecretArn added in v6.25.0 

func (o NamespaceOutput) AdminPasswordSecretArn() pulumi.StringOutput

func (NamespaceOutput) AdminPasswordSecretKmsKeyId added in v6.25.0 

func (o NamespaceOutput) AdminPasswordSecretKmsKeyId() pulumi.StringOutput

ID of the KMS key used to encrypt the namespace's admin credentials secret.

func (NamespaceOutput) AdminUserPassword 

func (o NamespaceOutput) AdminUserPassword() pulumi.StringPtrOutput

The password of the administrator for the first database created in the namespace. Conflicts with `manageAdminPassword`.

func (NamespaceOutput) AdminUsername 

func (o NamespaceOutput) AdminUsername() pulumi.StringOutput

The username of the administrator for the first database created in the namespace.

func (NamespaceOutput) Arn 

func (o NamespaceOutput) Arn() pulumi.StringOutput

Amazon Resource Name (ARN) of the Redshift Serverless Namespace.

func (NamespaceOutput) DbName 

func (o NamespaceOutput) DbName() pulumi.StringOutput

The name of the first database created in the namespace.

func (NamespaceOutput) DefaultIamRoleArn 

func (o NamespaceOutput) DefaultIamRoleArn() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the IAM role to set as a default in the namespace. When specifying `defaultIamRoleArn`, it also must be part of `iamRoles`.

func (NamespaceOutput) ElementType 

func (NamespaceOutput) ElementType() reflect.Type

func (NamespaceOutput) IamRoles 

func (o NamespaceOutput) IamRoles() pulumi.StringArrayOutput

A list of IAM roles to associate with the namespace.

func (NamespaceOutput) KmsKeyId 

func (o NamespaceOutput) KmsKeyId() pulumi.StringOutput

The ARN of the Amazon Web Services Key Management Service key used to encrypt your data.

func (NamespaceOutput) LogExports 

func (o NamespaceOutput) LogExports() pulumi.StringArrayOutput

The types of logs the namespace can export. Available export types are `userlog`, `connectionlog`, and `useractivitylog`.

func (NamespaceOutput) ManageAdminPassword added in v6.25.0 

func (o NamespaceOutput) ManageAdminPassword() pulumi.BoolPtrOutput

Whether to use AWS SecretManager to manage namespace's admin credentials. Conflicts with `adminUserPassword`.

func (NamespaceOutput) NamespaceId 

func (o NamespaceOutput) NamespaceId() pulumi.StringOutput

The Redshift Namespace ID.

func (NamespaceOutput) NamespaceName 

func (o NamespaceOutput) NamespaceName() pulumi.StringOutput

The name of the namespace.

func (NamespaceOutput) Tags 

func (o NamespaceOutput) Tags() pulumi.StringMapOutput

A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

func (NamespaceOutput) TagsAll deprecated 

func (o NamespaceOutput) TagsAll() pulumi.StringMapOutput

A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

Deprecated: Please use `tags` instead.

func (NamespaceOutput) ToNamespaceOutput 

func (o NamespaceOutput) ToNamespaceOutput() NamespaceOutput

func (NamespaceOutput) ToNamespaceOutputWithContext 

func (o NamespaceOutput) ToNamespaceOutputWithContext(ctx context.Context) NamespaceOutput

type NamespaceState 

type NamespaceState struct {
	AdminPasswordSecretArn pulumi.StringPtrInput
	// ID of the KMS key used to encrypt the namespace's admin credentials secret.
	AdminPasswordSecretKmsKeyId pulumi.StringPtrInput
	// The password of the administrator for the first database created in the namespace.
	// Conflicts with `manageAdminPassword`.
	AdminUserPassword pulumi.StringPtrInput
	// The username of the administrator for the first database created in the namespace.
	AdminUsername pulumi.StringPtrInput
	// Amazon Resource Name (ARN) of the Redshift Serverless Namespace.
	Arn pulumi.StringPtrInput
	// The name of the first database created in the namespace.
	DbName pulumi.StringPtrInput
	// The Amazon Resource Name (ARN) of the IAM role to set as a default in the namespace. When specifying `defaultIamRoleArn`, it also must be part of `iamRoles`.
	DefaultIamRoleArn pulumi.StringPtrInput
	// A list of IAM roles to associate with the namespace.
	IamRoles pulumi.StringArrayInput
	// The ARN of the Amazon Web Services Key Management Service key used to encrypt your data.
	KmsKeyId pulumi.StringPtrInput
	// The types of logs the namespace can export. Available export types are `userlog`, `connectionlog`, and `useractivitylog`.
	LogExports pulumi.StringArrayInput
	// Whether to use AWS SecretManager to manage namespace's admin credentials.
	// Conflicts with `adminUserPassword`.
	ManageAdminPassword pulumi.BoolPtrInput
	// The Redshift Namespace ID.
	NamespaceId pulumi.StringPtrInput
	// The name of the namespace.
	NamespaceName pulumi.StringPtrInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	//
	// Deprecated: Please use `tags` instead.
	TagsAll pulumi.StringMapInput
}

func (NamespaceState) ElementType 

func (NamespaceState) ElementType() reflect.Type

type ResourcePolicy 

type ResourcePolicy struct {
	pulumi.CustomResourceState

	// The policy to create or update. For example, the following policy grants a user authorization to restore a snapshot.
	Policy pulumi.StringOutput `pulumi:"policy"`
	// The Amazon Resource Name (ARN) of the account to create or update a resource policy for.
	ResourceArn pulumi.StringOutput `pulumi:"resourceArn"`
}

Creates a new Amazon Redshift Serverless Resource Policy.

## Example Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"encoding/json"

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/redshiftserverless"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"version": "2012-10-17",
			"statement": []map[string]interface{}{
				map[string]interface{}{
					"effect": "Allow",
					"principal": map[string]interface{}{
						"AWS": []string{
							"12345678901",
						},
					},
					"action": []string{
						"redshift-serverless:RestoreFromSnapshot",
					},
					"sid": "",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = redshiftserverless.NewResourcePolicy(ctx, "example", &redshiftserverless.ResourcePolicyArgs{
			ResourceArn: pulumi.Any(exampleAwsRedshiftserverlessSnapshot.Arn),
			Policy:      pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

## Import

Using `pulumi import`, import Redshift Serverless Resource Policies using the `resource_arn`. For example:

```sh $ pulumi import aws:redshiftserverless/resourcePolicy:ResourcePolicy example example ```

func GetResourcePolicy 

func GetResourcePolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ResourcePolicyState, opts ...pulumi.ResourceOption) (*ResourcePolicy, error)

GetResourcePolicy gets an existing ResourcePolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewResourcePolicy 

func NewResourcePolicy(ctx *pulumi.Context,
	name string, args *ResourcePolicyArgs, opts ...pulumi.ResourceOption) (*ResourcePolicy, error)

NewResourcePolicy registers a new resource with the given unique name, arguments, and options.

func (*ResourcePolicy) ElementType 

func (*ResourcePolicy) ElementType() reflect.Type

func (*ResourcePolicy) ToResourcePolicyOutput 

func (i *ResourcePolicy) ToResourcePolicyOutput() ResourcePolicyOutput

func (*ResourcePolicy) ToResourcePolicyOutputWithContext 

func (i *ResourcePolicy) ToResourcePolicyOutputWithContext(ctx context.Context) ResourcePolicyOutput

type ResourcePolicyArgs 

type ResourcePolicyArgs struct {
	// The policy to create or update. For example, the following policy grants a user authorization to restore a snapshot.
	Policy pulumi.StringInput
	// The Amazon Resource Name (ARN) of the account to create or update a resource policy for.
	ResourceArn pulumi.StringInput
}

The set of arguments for constructing a ResourcePolicy resource.

func (ResourcePolicyArgs) ElementType 

func (ResourcePolicyArgs) ElementType() reflect.Type

type ResourcePolicyArray 

type ResourcePolicyArray []ResourcePolicyInput

func (ResourcePolicyArray) ElementType 

func (ResourcePolicyArray) ElementType() reflect.Type

func (ResourcePolicyArray) ToResourcePolicyArrayOutput 

func (i ResourcePolicyArray) ToResourcePolicyArrayOutput() ResourcePolicyArrayOutput

func (ResourcePolicyArray) ToResourcePolicyArrayOutputWithContext 

func (i ResourcePolicyArray) ToResourcePolicyArrayOutputWithContext(ctx context.Context) ResourcePolicyArrayOutput

type ResourcePolicyArrayInput 

type ResourcePolicyArrayInput interface {
	pulumi.Input

	ToResourcePolicyArrayOutput() ResourcePolicyArrayOutput
	ToResourcePolicyArrayOutputWithContext(context.Context) ResourcePolicyArrayOutput
}

ResourcePolicyArrayInput is an input type that accepts ResourcePolicyArray and ResourcePolicyArrayOutput values. You can construct a concrete instance of `ResourcePolicyArrayInput` via: 

ResourcePolicyArray{ ResourcePolicyArgs{...} }

type ResourcePolicyArrayOutput 

type ResourcePolicyArrayOutput struct{ *pulumi.OutputState }

func (ResourcePolicyArrayOutput) ElementType 

func (ResourcePolicyArrayOutput) ElementType() reflect.Type

func (ResourcePolicyArrayOutput) Index 

func (o ResourcePolicyArrayOutput) Index(i pulumi.IntInput) ResourcePolicyOutput

func (ResourcePolicyArrayOutput) ToResourcePolicyArrayOutput 

func (o ResourcePolicyArrayOutput) ToResourcePolicyArrayOutput() ResourcePolicyArrayOutput

func (ResourcePolicyArrayOutput) ToResourcePolicyArrayOutputWithContext 

func (o ResourcePolicyArrayOutput) ToResourcePolicyArrayOutputWithContext(ctx context.Context) ResourcePolicyArrayOutput

type ResourcePolicyInput 

type ResourcePolicyInput interface {
	pulumi.Input

	ToResourcePolicyOutput() ResourcePolicyOutput
	ToResourcePolicyOutputWithContext(ctx context.Context) ResourcePolicyOutput
}

type ResourcePolicyMap 

type ResourcePolicyMap map[string]ResourcePolicyInput

func (ResourcePolicyMap) ElementType 

func (ResourcePolicyMap) ElementType() reflect.Type

func (ResourcePolicyMap) ToResourcePolicyMapOutput 

func (i ResourcePolicyMap) ToResourcePolicyMapOutput() ResourcePolicyMapOutput

func (ResourcePolicyMap) ToResourcePolicyMapOutputWithContext 

func (i ResourcePolicyMap) ToResourcePolicyMapOutputWithContext(ctx context.Context) ResourcePolicyMapOutput

type ResourcePolicyMapInput 

type ResourcePolicyMapInput interface {
	pulumi.Input

	ToResourcePolicyMapOutput() ResourcePolicyMapOutput
	ToResourcePolicyMapOutputWithContext(context.Context) ResourcePolicyMapOutput
}

ResourcePolicyMapInput is an input type that accepts ResourcePolicyMap and ResourcePolicyMapOutput values. You can construct a concrete instance of `ResourcePolicyMapInput` via: 

ResourcePolicyMap{ "key": ResourcePolicyArgs{...} }

type ResourcePolicyMapOutput 

type ResourcePolicyMapOutput struct{ *pulumi.OutputState }

func (ResourcePolicyMapOutput) ElementType 

func (ResourcePolicyMapOutput) ElementType() reflect.Type

func (ResourcePolicyMapOutput) MapIndex 

func (o ResourcePolicyMapOutput) MapIndex(k pulumi.StringInput) ResourcePolicyOutput

func (ResourcePolicyMapOutput) ToResourcePolicyMapOutput 

func (o ResourcePolicyMapOutput) ToResourcePolicyMapOutput() ResourcePolicyMapOutput

func (ResourcePolicyMapOutput) ToResourcePolicyMapOutputWithContext 

func (o ResourcePolicyMapOutput) ToResourcePolicyMapOutputWithContext(ctx context.Context) ResourcePolicyMapOutput

type ResourcePolicyOutput 

type ResourcePolicyOutput struct{ *pulumi.OutputState }

func (ResourcePolicyOutput) ElementType 

func (ResourcePolicyOutput) ElementType() reflect.Type

func (ResourcePolicyOutput) Policy 

func (o ResourcePolicyOutput) Policy() pulumi.StringOutput

The policy to create or update. For example, the following policy grants a user authorization to restore a snapshot.

func (ResourcePolicyOutput) ResourceArn 

func (o ResourcePolicyOutput) ResourceArn() pulumi.StringOutput

The Amazon Resource Name (ARN) of the account to create or update a resource policy for.

func (ResourcePolicyOutput) ToResourcePolicyOutput 

func (o ResourcePolicyOutput) ToResourcePolicyOutput() ResourcePolicyOutput

func (ResourcePolicyOutput) ToResourcePolicyOutputWithContext 

func (o ResourcePolicyOutput) ToResourcePolicyOutputWithContext(ctx context.Context) ResourcePolicyOutput

type ResourcePolicyState 

type ResourcePolicyState struct {
	// The policy to create or update. For example, the following policy grants a user authorization to restore a snapshot.
	Policy pulumi.StringPtrInput
	// The Amazon Resource Name (ARN) of the account to create or update a resource policy for.
	ResourceArn pulumi.StringPtrInput
}

func (ResourcePolicyState) ElementType 

func (ResourcePolicyState) ElementType() reflect.Type

type Snapshot 

type Snapshot struct {
	pulumi.CustomResourceState

	// All of the Amazon Web Services accounts that have access to restore a snapshot to a provisioned cluster.
	AccountsWithProvisionedRestoreAccesses pulumi.StringArrayOutput `pulumi:"accountsWithProvisionedRestoreAccesses"`
	// All of the Amazon Web Services accounts that have access to restore a snapshot to a namespace.
	AccountsWithRestoreAccesses pulumi.StringArrayOutput `pulumi:"accountsWithRestoreAccesses"`
	// The username of the database within a snapshot.
	AdminUsername pulumi.StringOutput `pulumi:"adminUsername"`
	// The Amazon Resource Name (ARN) of the snapshot.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The unique identifier of the KMS key used to encrypt the snapshot.
	KmsKeyId pulumi.StringOutput `pulumi:"kmsKeyId"`
	// The Amazon Resource Name (ARN) of the namespace the snapshot was created from.
	NamespaceArn pulumi.StringOutput `pulumi:"namespaceArn"`
	// The namespace to create a snapshot for.
	NamespaceName pulumi.StringOutput `pulumi:"namespaceName"`
	// The owner Amazon Web Services; account of the snapshot.
	OwnerAccount pulumi.StringOutput `pulumi:"ownerAccount"`
	// How long to retain the created snapshot. Default value is `-1`.
	RetentionPeriod pulumi.IntPtrOutput `pulumi:"retentionPeriod"`
	// The name of the snapshot.
	SnapshotName pulumi.StringOutput `pulumi:"snapshotName"`
}

Creates a new Amazon Redshift Serverless Snapshot.

## Example Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/redshiftserverless"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redshiftserverless.NewSnapshot(ctx, "example", &redshiftserverless.SnapshotArgs{
			NamespaceName: pulumi.Any(exampleAwsRedshiftserverlessWorkgroup.NamespaceName),
			SnapshotName:  pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

## Import

Using `pulumi import`, import Redshift Serverless Snapshots using the `snapshot_name`. For example:

```sh $ pulumi import aws:redshiftserverless/snapshot:Snapshot example example ```

func GetSnapshot 

func GetSnapshot(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *SnapshotState, opts ...pulumi.ResourceOption) (*Snapshot, error)

GetSnapshot gets an existing Snapshot resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewSnapshot 

func NewSnapshot(ctx *pulumi.Context,
	name string, args *SnapshotArgs, opts ...pulumi.ResourceOption) (*Snapshot, error)

NewSnapshot registers a new resource with the given unique name, arguments, and options.

func (*Snapshot) ElementType 

func (*Snapshot) ElementType() reflect.Type

func (*Snapshot) ToSnapshotOutput 

func (i *Snapshot) ToSnapshotOutput() SnapshotOutput

func (*Snapshot) ToSnapshotOutputWithContext 

func (i *Snapshot) ToSnapshotOutputWithContext(ctx context.Context) SnapshotOutput

type SnapshotArgs 

type SnapshotArgs struct {
	// The namespace to create a snapshot for.
	NamespaceName pulumi.StringInput
	// How long to retain the created snapshot. Default value is `-1`.
	RetentionPeriod pulumi.IntPtrInput
	// The name of the snapshot.
	SnapshotName pulumi.StringInput
}

The set of arguments for constructing a Snapshot resource.

func (SnapshotArgs) ElementType 

func (SnapshotArgs) ElementType() reflect.Type

type SnapshotArray 

type SnapshotArray []SnapshotInput

func (SnapshotArray) ElementType 

func (SnapshotArray) ElementType() reflect.Type

func (SnapshotArray) ToSnapshotArrayOutput 

func (i SnapshotArray) ToSnapshotArrayOutput() SnapshotArrayOutput

func (SnapshotArray) ToSnapshotArrayOutputWithContext 

func (i SnapshotArray) ToSnapshotArrayOutputWithContext(ctx context.Context) SnapshotArrayOutput

type SnapshotArrayInput 

type SnapshotArrayInput interface {
	pulumi.Input

	ToSnapshotArrayOutput() SnapshotArrayOutput
	ToSnapshotArrayOutputWithContext(context.Context) SnapshotArrayOutput
}

SnapshotArrayInput is an input type that accepts SnapshotArray and SnapshotArrayOutput values. You can construct a concrete instance of `SnapshotArrayInput` via: 

SnapshotArray{ SnapshotArgs{...} }

type SnapshotArrayOutput 

type SnapshotArrayOutput struct{ *pulumi.OutputState }

func (SnapshotArrayOutput) ElementType 

func (SnapshotArrayOutput) ElementType() reflect.Type

func (SnapshotArrayOutput) Index 

func (o SnapshotArrayOutput) Index(i pulumi.IntInput) SnapshotOutput

func (SnapshotArrayOutput) ToSnapshotArrayOutput 

func (o SnapshotArrayOutput) ToSnapshotArrayOutput() SnapshotArrayOutput

func (SnapshotArrayOutput) ToSnapshotArrayOutputWithContext 

func (o SnapshotArrayOutput) ToSnapshotArrayOutputWithContext(ctx context.Context) SnapshotArrayOutput

type SnapshotInput 

type SnapshotInput interface {
	pulumi.Input

	ToSnapshotOutput() SnapshotOutput
	ToSnapshotOutputWithContext(ctx context.Context) SnapshotOutput
}

type SnapshotMap 

type SnapshotMap map[string]SnapshotInput

func (SnapshotMap) ElementType 

func (SnapshotMap) ElementType() reflect.Type

func (SnapshotMap) ToSnapshotMapOutput 

func (i SnapshotMap) ToSnapshotMapOutput() SnapshotMapOutput

func (SnapshotMap) ToSnapshotMapOutputWithContext 

func (i SnapshotMap) ToSnapshotMapOutputWithContext(ctx context.Context) SnapshotMapOutput

type SnapshotMapInput 

type SnapshotMapInput interface {
	pulumi.Input

	ToSnapshotMapOutput() SnapshotMapOutput
	ToSnapshotMapOutputWithContext(context.Context) SnapshotMapOutput
}

SnapshotMapInput is an input type that accepts SnapshotMap and SnapshotMapOutput values. You can construct a concrete instance of `SnapshotMapInput` via: 

SnapshotMap{ "key": SnapshotArgs{...} }

type SnapshotMapOutput 

type SnapshotMapOutput struct{ *pulumi.OutputState }

func (SnapshotMapOutput) ElementType 

func (SnapshotMapOutput) ElementType() reflect.Type

func (SnapshotMapOutput) MapIndex 

func (o SnapshotMapOutput) MapIndex(k pulumi.StringInput) SnapshotOutput

func (SnapshotMapOutput) ToSnapshotMapOutput 

func (o SnapshotMapOutput) ToSnapshotMapOutput() SnapshotMapOutput

func (SnapshotMapOutput) ToSnapshotMapOutputWithContext 

func (o SnapshotMapOutput) ToSnapshotMapOutputWithContext(ctx context.Context) SnapshotMapOutput

type SnapshotOutput 

type SnapshotOutput struct{ *pulumi.OutputState }

func (SnapshotOutput) AccountsWithProvisionedRestoreAccesses 

func (o SnapshotOutput) AccountsWithProvisionedRestoreAccesses() pulumi.StringArrayOutput

All of the Amazon Web Services accounts that have access to restore a snapshot to a provisioned cluster.

func (SnapshotOutput) AccountsWithRestoreAccesses 

func (o SnapshotOutput) AccountsWithRestoreAccesses() pulumi.StringArrayOutput

All of the Amazon Web Services accounts that have access to restore a snapshot to a namespace.

func (SnapshotOutput) AdminUsername 

func (o SnapshotOutput) AdminUsername() pulumi.StringOutput

The username of the database within a snapshot.

func (SnapshotOutput) Arn 

func (o SnapshotOutput) Arn() pulumi.StringOutput

The Amazon Resource Name (ARN) of the snapshot.

func (SnapshotOutput) ElementType 

func (SnapshotOutput) ElementType() reflect.Type

func (SnapshotOutput) KmsKeyId 

func (o SnapshotOutput) KmsKeyId() pulumi.StringOutput

The unique identifier of the KMS key used to encrypt the snapshot.

func (SnapshotOutput) NamespaceArn 

func (o SnapshotOutput) NamespaceArn() pulumi.StringOutput

The Amazon Resource Name (ARN) of the namespace the snapshot was created from.

func (SnapshotOutput) NamespaceName 

func (o SnapshotOutput) NamespaceName() pulumi.StringOutput

The namespace to create a snapshot for.

func (SnapshotOutput) OwnerAccount 

func (o SnapshotOutput) OwnerAccount() pulumi.StringOutput

The owner Amazon Web Services; account of the snapshot.

func (SnapshotOutput) RetentionPeriod 

func (o SnapshotOutput) RetentionPeriod() pulumi.IntPtrOutput

How long to retain the created snapshot. Default value is `-1`.

func (SnapshotOutput) SnapshotName 

func (o SnapshotOutput) SnapshotName() pulumi.StringOutput

The name of the snapshot.

func (SnapshotOutput) ToSnapshotOutput 

func (o SnapshotOutput) ToSnapshotOutput() SnapshotOutput

func (SnapshotOutput) ToSnapshotOutputWithContext 

func (o SnapshotOutput) ToSnapshotOutputWithContext(ctx context.Context) SnapshotOutput

type SnapshotState 

type SnapshotState struct {
	// All of the Amazon Web Services accounts that have access to restore a snapshot to a provisioned cluster.
	AccountsWithProvisionedRestoreAccesses pulumi.StringArrayInput
	// All of the Amazon Web Services accounts that have access to restore a snapshot to a namespace.
	AccountsWithRestoreAccesses pulumi.StringArrayInput
	// The username of the database within a snapshot.
	AdminUsername pulumi.StringPtrInput
	// The Amazon Resource Name (ARN) of the snapshot.
	Arn pulumi.StringPtrInput
	// The unique identifier of the KMS key used to encrypt the snapshot.
	KmsKeyId pulumi.StringPtrInput
	// The Amazon Resource Name (ARN) of the namespace the snapshot was created from.
	NamespaceArn pulumi.StringPtrInput
	// The namespace to create a snapshot for.
	NamespaceName pulumi.StringPtrInput
	// The owner Amazon Web Services; account of the snapshot.
	OwnerAccount pulumi.StringPtrInput
	// How long to retain the created snapshot. Default value is `-1`.
	RetentionPeriod pulumi.IntPtrInput
	// The name of the snapshot.
	SnapshotName pulumi.StringPtrInput
}

func (SnapshotState) ElementType 

func (SnapshotState) ElementType() reflect.Type

type UsageLimit 

type UsageLimit struct {
	pulumi.CustomResourceState

	// The limit amount. If time-based, this amount is in Redshift Processing Units (RPU) consumed per hour. If data-based, this amount is in terabytes (TB) of data transferred between Regions in cross-account sharing. The value must be a positive number.
	Amount pulumi.IntOutput `pulumi:"amount"`
	// Amazon Resource Name (ARN) of the Redshift Serverless Usage Limit.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The action that Amazon Redshift Serverless takes when the limit is reached. Valid values are `log`, `emit-metric`, and `deactivate`. The default is `log`.
	BreachAction pulumi.StringPtrOutput `pulumi:"breachAction"`
	// The time period that the amount applies to. A weekly period begins on Sunday. Valid values are `daily`, `weekly`, and `monthly`. The default is `monthly`.
	Period pulumi.StringPtrOutput `pulumi:"period"`
	// The Amazon Resource Name (ARN) of the Amazon Redshift Serverless resource to create the usage limit for.
	ResourceArn pulumi.StringOutput `pulumi:"resourceArn"`
	// The type of Amazon Redshift Serverless usage to create a usage limit for. Valid values are `serverless-compute` or `cross-region-datasharing`.
	UsageType pulumi.StringOutput `pulumi:"usageType"`
}

Creates a new Amazon Redshift Serverless Usage Limit.

## Example Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/redshiftserverless"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := redshiftserverless.NewWorkgroup(ctx, "example", &redshiftserverless.WorkgroupArgs{
			NamespaceName: pulumi.Any(exampleAwsRedshiftserverlessNamespace.NamespaceName),
			WorkgroupName: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		_, err = redshiftserverless.NewUsageLimit(ctx, "example", &redshiftserverless.UsageLimitArgs{
			ResourceArn: example.Arn,
			UsageType:   pulumi.String("serverless-compute"),
			Amount:      pulumi.Int(60),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

## Import

Using `pulumi import`, import Redshift Serverless Usage Limits using the `id`. For example:

```sh $ pulumi import aws:redshiftserverless/usageLimit:UsageLimit example example-id ```

func GetUsageLimit 

func GetUsageLimit(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *UsageLimitState, opts ...pulumi.ResourceOption) (*UsageLimit, error)

GetUsageLimit gets an existing UsageLimit resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewUsageLimit 

func NewUsageLimit(ctx *pulumi.Context,
	name string, args *UsageLimitArgs, opts ...pulumi.ResourceOption) (*UsageLimit, error)

NewUsageLimit registers a new resource with the given unique name, arguments, and options.

func (*UsageLimit) ElementType 

func (*UsageLimit) ElementType() reflect.Type

func (*UsageLimit) ToUsageLimitOutput 

func (i *UsageLimit) ToUsageLimitOutput() UsageLimitOutput

func (*UsageLimit) ToUsageLimitOutputWithContext 

func (i *UsageLimit) ToUsageLimitOutputWithContext(ctx context.Context) UsageLimitOutput

type UsageLimitArgs 

type UsageLimitArgs struct {
	// The limit amount. If time-based, this amount is in Redshift Processing Units (RPU) consumed per hour. If data-based, this amount is in terabytes (TB) of data transferred between Regions in cross-account sharing. The value must be a positive number.
	Amount pulumi.IntInput
	// The action that Amazon Redshift Serverless takes when the limit is reached. Valid values are `log`, `emit-metric`, and `deactivate`. The default is `log`.
	BreachAction pulumi.StringPtrInput
	// The time period that the amount applies to. A weekly period begins on Sunday. Valid values are `daily`, `weekly`, and `monthly`. The default is `monthly`.
	Period pulumi.StringPtrInput
	// The Amazon Resource Name (ARN) of the Amazon Redshift Serverless resource to create the usage limit for.
	ResourceArn pulumi.StringInput
	// The type of Amazon Redshift Serverless usage to create a usage limit for. Valid values are `serverless-compute` or `cross-region-datasharing`.
	UsageType pulumi.StringInput
}

The set of arguments for constructing a UsageLimit resource.

func (UsageLimitArgs) ElementType 

func (UsageLimitArgs) ElementType() reflect.Type

type UsageLimitArray 

type UsageLimitArray []UsageLimitInput

func (UsageLimitArray) ElementType 

func (UsageLimitArray) ElementType() reflect.Type

func (UsageLimitArray) ToUsageLimitArrayOutput 

func (i UsageLimitArray) ToUsageLimitArrayOutput() UsageLimitArrayOutput

func (UsageLimitArray) ToUsageLimitArrayOutputWithContext 

func (i UsageLimitArray) ToUsageLimitArrayOutputWithContext(ctx context.Context) UsageLimitArrayOutput

type UsageLimitArrayInput 

type UsageLimitArrayInput interface {
	pulumi.Input

	ToUsageLimitArrayOutput() UsageLimitArrayOutput
	ToUsageLimitArrayOutputWithContext(context.Context) UsageLimitArrayOutput
}

UsageLimitArrayInput is an input type that accepts UsageLimitArray and UsageLimitArrayOutput values. You can construct a concrete instance of `UsageLimitArrayInput` via: 

UsageLimitArray{ UsageLimitArgs{...} }

type UsageLimitArrayOutput 

type UsageLimitArrayOutput struct{ *pulumi.OutputState }

func (UsageLimitArrayOutput) ElementType 

func (UsageLimitArrayOutput) ElementType() reflect.Type

func (UsageLimitArrayOutput) Index 

func (o UsageLimitArrayOutput) Index(i pulumi.IntInput) UsageLimitOutput

func (UsageLimitArrayOutput) ToUsageLimitArrayOutput 

func (o UsageLimitArrayOutput) ToUsageLimitArrayOutput() UsageLimitArrayOutput

func (UsageLimitArrayOutput) ToUsageLimitArrayOutputWithContext 

func (o UsageLimitArrayOutput) ToUsageLimitArrayOutputWithContext(ctx context.Context) UsageLimitArrayOutput

type UsageLimitInput 

type UsageLimitInput interface {
	pulumi.Input

	ToUsageLimitOutput() UsageLimitOutput
	ToUsageLimitOutputWithContext(ctx context.Context) UsageLimitOutput
}

type UsageLimitMap 

type UsageLimitMap map[string]UsageLimitInput

func (UsageLimitMap) ElementType 

func (UsageLimitMap) ElementType() reflect.Type

func (UsageLimitMap) ToUsageLimitMapOutput 

func (i UsageLimitMap) ToUsageLimitMapOutput() UsageLimitMapOutput

func (UsageLimitMap) ToUsageLimitMapOutputWithContext 

func (i UsageLimitMap) ToUsageLimitMapOutputWithContext(ctx context.Context) UsageLimitMapOutput

type UsageLimitMapInput 

type UsageLimitMapInput interface {
	pulumi.Input

	ToUsageLimitMapOutput() UsageLimitMapOutput
	ToUsageLimitMapOutputWithContext(context.Context) UsageLimitMapOutput
}

UsageLimitMapInput is an input type that accepts UsageLimitMap and UsageLimitMapOutput values. You can construct a concrete instance of `UsageLimitMapInput` via: 

UsageLimitMap{ "key": UsageLimitArgs{...} }

type UsageLimitMapOutput 

type UsageLimitMapOutput struct{ *pulumi.OutputState }

func (UsageLimitMapOutput) ElementType 

func (UsageLimitMapOutput) ElementType() reflect.Type

func (UsageLimitMapOutput) MapIndex 

func (o UsageLimitMapOutput) MapIndex(k pulumi.StringInput) UsageLimitOutput

func (UsageLimitMapOutput) ToUsageLimitMapOutput 

func (o UsageLimitMapOutput) ToUsageLimitMapOutput() UsageLimitMapOutput

func (UsageLimitMapOutput) ToUsageLimitMapOutputWithContext 

func (o UsageLimitMapOutput) ToUsageLimitMapOutputWithContext(ctx context.Context) UsageLimitMapOutput

type UsageLimitOutput 

type UsageLimitOutput struct{ *pulumi.OutputState }

func (UsageLimitOutput) Amount 

func (o UsageLimitOutput) Amount() pulumi.IntOutput

The limit amount. If time-based, this amount is in Redshift Processing Units (RPU) consumed per hour. If data-based, this amount is in terabytes (TB) of data transferred between Regions in cross-account sharing. The value must be a positive number.

func (UsageLimitOutput) Arn 

func (o UsageLimitOutput) Arn() pulumi.StringOutput

Amazon Resource Name (ARN) of the Redshift Serverless Usage Limit.

func (UsageLimitOutput) BreachAction 

func (o UsageLimitOutput) BreachAction() pulumi.StringPtrOutput

The action that Amazon Redshift Serverless takes when the limit is reached. Valid values are `log`, `emit-metric`, and `deactivate`. The default is `log`.

func (UsageLimitOutput) ElementType 

func (UsageLimitOutput) ElementType() reflect.Type

func (UsageLimitOutput) Period 

func (o UsageLimitOutput) Period() pulumi.StringPtrOutput

The time period that the amount applies to. A weekly period begins on Sunday. Valid values are `daily`, `weekly`, and `monthly`. The default is `monthly`.

func (UsageLimitOutput) ResourceArn 

func (o UsageLimitOutput) ResourceArn() pulumi.StringOutput

The Amazon Resource Name (ARN) of the Amazon Redshift Serverless resource to create the usage limit for.

func (UsageLimitOutput) ToUsageLimitOutput 

func (o UsageLimitOutput) ToUsageLimitOutput() UsageLimitOutput

func (UsageLimitOutput) ToUsageLimitOutputWithContext 

func (o UsageLimitOutput) ToUsageLimitOutputWithContext(ctx context.Context) UsageLimitOutput

func (UsageLimitOutput) UsageType 

func (o UsageLimitOutput) UsageType() pulumi.StringOutput

The type of Amazon Redshift Serverless usage to create a usage limit for. Valid values are `serverless-compute` or `cross-region-datasharing`.

type UsageLimitState 

type UsageLimitState struct {
	// The limit amount. If time-based, this amount is in Redshift Processing Units (RPU) consumed per hour. If data-based, this amount is in terabytes (TB) of data transferred between Regions in cross-account sharing. The value must be a positive number.
	Amount pulumi.IntPtrInput
	// Amazon Resource Name (ARN) of the Redshift Serverless Usage Limit.
	Arn pulumi.StringPtrInput
	// The action that Amazon Redshift Serverless takes when the limit is reached. Valid values are `log`, `emit-metric`, and `deactivate`. The default is `log`.
	BreachAction pulumi.StringPtrInput
	// The time period that the amount applies to. A weekly period begins on Sunday. Valid values are `daily`, `weekly`, and `monthly`. The default is `monthly`.
	Period pulumi.StringPtrInput
	// The Amazon Resource Name (ARN) of the Amazon Redshift Serverless resource to create the usage limit for.
	ResourceArn pulumi.StringPtrInput
	// The type of Amazon Redshift Serverless usage to create a usage limit for. Valid values are `serverless-compute` or `cross-region-datasharing`.
	UsageType pulumi.StringPtrInput
}

func (UsageLimitState) ElementType 

func (UsageLimitState) ElementType() reflect.Type

type Workgroup 

type Workgroup struct {
	pulumi.CustomResourceState

	// Amazon Resource Name (ARN) of the Redshift Serverless Workgroup.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The base data warehouse capacity of the workgroup in Redshift Processing Units (RPUs).
	BaseCapacity pulumi.IntOutput `pulumi:"baseCapacity"`
	// An array of parameters to set for more control over a serverless database. See `Config Parameter` below.
	ConfigParameters WorkgroupConfigParameterArrayOutput `pulumi:"configParameters"`
	// The endpoint that is created from the workgroup. See `Endpoint` below.
	Endpoints WorkgroupEndpointArrayOutput `pulumi:"endpoints"`
	// The value that specifies whether to turn on enhanced virtual private cloud (VPC) routing, which forces Amazon Redshift Serverless to route traffic through your VPC instead of over the internet.
	EnhancedVpcRouting pulumi.BoolPtrOutput `pulumi:"enhancedVpcRouting"`
	// The maximum data-warehouse capacity Amazon Redshift Serverless uses to serve queries, specified in Redshift Processing Units (RPUs).
	MaxCapacity pulumi.IntPtrOutput `pulumi:"maxCapacity"`
	// The name of the namespace.
	NamespaceName pulumi.StringOutput `pulumi:"namespaceName"`
	// The port number on which the cluster accepts incoming connections.
	Port pulumi.IntOutput `pulumi:"port"`
	// A value that specifies whether the workgroup can be accessed from a public network.
	PubliclyAccessible pulumi.BoolPtrOutput `pulumi:"publiclyAccessible"`
	// An array of security group IDs to associate with the workgroup.
	SecurityGroupIds pulumi.StringArrayOutput `pulumi:"securityGroupIds"`
	// An array of VPC subnet IDs to associate with the workgroup. When set, must contain at least three subnets spanning three Availability Zones. A minimum number of IP addresses is required and scales with the Base Capacity. For more information, see the following [AWS document](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-known-issues.html).
	SubnetIds pulumi.StringArrayOutput `pulumi:"subnetIds"`
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	//
	// Deprecated: Please use `tags` instead.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// The Redshift Workgroup ID.
	WorkgroupId pulumi.StringOutput `pulumi:"workgroupId"`
	// The name of the workgroup.
	//
	// The following arguments are optional:
	WorkgroupName pulumi.StringOutput `pulumi:"workgroupName"`
}

Creates a new Amazon Redshift Serverless Workgroup.

## Example Usage

<!--Start PulumiCodeChooser --> ```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/redshiftserverless"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := redshiftserverless.NewWorkgroup(ctx, "example", &redshiftserverless.WorkgroupArgs{
			NamespaceName: pulumi.String("concurrency-scaling"),
			WorkgroupName: pulumi.String("concurrency-scaling"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` <!--End PulumiCodeChooser -->

## Import

Using `pulumi import`, import Redshift Serverless Workgroups using the `workgroup_name`. For example:

```sh $ pulumi import aws:redshiftserverless/workgroup:Workgroup example example ```

func GetWorkgroup 

func GetWorkgroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *WorkgroupState, opts ...pulumi.ResourceOption) (*Workgroup, error)

GetWorkgroup gets an existing Workgroup resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewWorkgroup 

func NewWorkgroup(ctx *pulumi.Context,
	name string, args *WorkgroupArgs, opts ...pulumi.ResourceOption) (*Workgroup, error)

NewWorkgroup registers a new resource with the given unique name, arguments, and options.

func (*Workgroup) ElementType 

func (*Workgroup) ElementType() reflect.Type

func (*Workgroup) ToWorkgroupOutput 

func (i *Workgroup) ToWorkgroupOutput() WorkgroupOutput

func (*Workgroup) ToWorkgroupOutputWithContext 

func (i *Workgroup) ToWorkgroupOutputWithContext(ctx context.Context) WorkgroupOutput

type WorkgroupArgs 

type WorkgroupArgs struct {
	// The base data warehouse capacity of the workgroup in Redshift Processing Units (RPUs).
	BaseCapacity pulumi.IntPtrInput
	// An array of parameters to set for more control over a serverless database. See `Config Parameter` below.
	ConfigParameters WorkgroupConfigParameterArrayInput
	// The value that specifies whether to turn on enhanced virtual private cloud (VPC) routing, which forces Amazon Redshift Serverless to route traffic through your VPC instead of over the internet.
	EnhancedVpcRouting pulumi.BoolPtrInput
	// The maximum data-warehouse capacity Amazon Redshift Serverless uses to serve queries, specified in Redshift Processing Units (RPUs).
	MaxCapacity pulumi.IntPtrInput
	// The name of the namespace.
	NamespaceName pulumi.StringInput
	// The port number on which the cluster accepts incoming connections.
	Port pulumi.IntPtrInput
	// A value that specifies whether the workgroup can be accessed from a public network.
	PubliclyAccessible pulumi.BoolPtrInput
	// An array of security group IDs to associate with the workgroup.
	SecurityGroupIds pulumi.StringArrayInput
	// An array of VPC subnet IDs to associate with the workgroup. When set, must contain at least three subnets spanning three Availability Zones. A minimum number of IP addresses is required and scales with the Base Capacity. For more information, see the following [AWS document](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-known-issues.html).
	SubnetIds pulumi.StringArrayInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// The name of the workgroup.
	//
	// The following arguments are optional:
	WorkgroupName pulumi.StringInput
}

The set of arguments for constructing a Workgroup resource.

func (WorkgroupArgs) ElementType 

func (WorkgroupArgs) ElementType() reflect.Type

type WorkgroupArray 

type WorkgroupArray []WorkgroupInput

func (WorkgroupArray) ElementType 

func (WorkgroupArray) ElementType() reflect.Type

func (WorkgroupArray) ToWorkgroupArrayOutput 

func (i WorkgroupArray) ToWorkgroupArrayOutput() WorkgroupArrayOutput

func (WorkgroupArray) ToWorkgroupArrayOutputWithContext 

func (i WorkgroupArray) ToWorkgroupArrayOutputWithContext(ctx context.Context) WorkgroupArrayOutput

type WorkgroupArrayInput 

type WorkgroupArrayInput interface {
	pulumi.Input

	ToWorkgroupArrayOutput() WorkgroupArrayOutput
	ToWorkgroupArrayOutputWithContext(context.Context) WorkgroupArrayOutput
}

WorkgroupArrayInput is an input type that accepts WorkgroupArray and WorkgroupArrayOutput values. You can construct a concrete instance of `WorkgroupArrayInput` via: 

WorkgroupArray{ WorkgroupArgs{...} }

type WorkgroupArrayOutput 

type WorkgroupArrayOutput struct{ *pulumi.OutputState }

func (WorkgroupArrayOutput) ElementType 

func (WorkgroupArrayOutput) ElementType() reflect.Type

func (WorkgroupArrayOutput) Index 

func (o WorkgroupArrayOutput) Index(i pulumi.IntInput) WorkgroupOutput

func (WorkgroupArrayOutput) ToWorkgroupArrayOutput 

func (o WorkgroupArrayOutput) ToWorkgroupArrayOutput() WorkgroupArrayOutput

func (WorkgroupArrayOutput) ToWorkgroupArrayOutputWithContext 

func (o WorkgroupArrayOutput) ToWorkgroupArrayOutputWithContext(ctx context.Context) WorkgroupArrayOutput

type WorkgroupConfigParameter 

type WorkgroupConfigParameter struct {
	// The key of the parameter. The options are `autoMv`, `datestyle`, `enableCaseSensitiveIdentifier`, `enableUserActivityLogging`, `queryGroup`, `searchPath`, `requireSsl`, `useFipsSsl`, and [query monitoring metrics](https://docs.aws.amazon.com/redshift/latest/dg/cm-c-wlm-query-monitoring-rules.html#cm-c-wlm-query-monitoring-metrics-serverless) that let you define performance boundaries: `maxQueryCpuTime`, `maxQueryBlocksRead`, `maxScanRowCount`, `maxQueryExecutionTime`, `maxQueryQueueTime`, `maxQueryCpuUsagePercent`, `maxQueryTempBlocksToDisk`, `maxJoinRowCount` and `maxNestedLoopJoinRowCount`.
	ParameterKey string `pulumi:"parameterKey"`
	// The value of the parameter to set.
	ParameterValue string `pulumi:"parameterValue"`
}

type WorkgroupConfigParameterArgs 

type WorkgroupConfigParameterArgs struct {
	// The key of the parameter. The options are `autoMv`, `datestyle`, `enableCaseSensitiveIdentifier`, `enableUserActivityLogging`, `queryGroup`, `searchPath`, `requireSsl`, `useFipsSsl`, and [query monitoring metrics](https://docs.aws.amazon.com/redshift/latest/dg/cm-c-wlm-query-monitoring-rules.html#cm-c-wlm-query-monitoring-metrics-serverless) that let you define performance boundaries: `maxQueryCpuTime`, `maxQueryBlocksRead`, `maxScanRowCount`, `maxQueryExecutionTime`, `maxQueryQueueTime`, `maxQueryCpuUsagePercent`, `maxQueryTempBlocksToDisk`, `maxJoinRowCount` and `maxNestedLoopJoinRowCount`.
	ParameterKey pulumi.StringInput `pulumi:"parameterKey"`
	// The value of the parameter to set.
	ParameterValue pulumi.StringInput `pulumi:"parameterValue"`
}

func (WorkgroupConfigParameterArgs) ElementType 

func (WorkgroupConfigParameterArgs) ElementType() reflect.Type

func (WorkgroupConfigParameterArgs) ToWorkgroupConfigParameterOutput 

func (i WorkgroupConfigParameterArgs) ToWorkgroupConfigParameterOutput() WorkgroupConfigParameterOutput

func (WorkgroupConfigParameterArgs) ToWorkgroupConfigParameterOutputWithContext 

func (i WorkgroupConfigParameterArgs) ToWorkgroupConfigParameterOutputWithContext(ctx context.Context) WorkgroupConfigParameterOutput

type WorkgroupConfigParameterArray 

type WorkgroupConfigParameterArray []WorkgroupConfigParameterInput

func (WorkgroupConfigParameterArray) ElementType 

func (WorkgroupConfigParameterArray) ElementType() reflect.Type

func (WorkgroupConfigParameterArray) ToWorkgroupConfigParameterArrayOutput 

func (i WorkgroupConfigParameterArray) ToWorkgroupConfigParameterArrayOutput() WorkgroupConfigParameterArrayOutput

func (WorkgroupConfigParameterArray) ToWorkgroupConfigParameterArrayOutputWithContext 

func (i WorkgroupConfigParameterArray) ToWorkgroupConfigParameterArrayOutputWithContext(ctx context.Context) WorkgroupConfigParameterArrayOutput

type WorkgroupConfigParameterArrayInput 

type WorkgroupConfigParameterArrayInput interface {
	pulumi.Input

	ToWorkgroupConfigParameterArrayOutput() WorkgroupConfigParameterArrayOutput
	ToWorkgroupConfigParameterArrayOutputWithContext(context.Context) WorkgroupConfigParameterArrayOutput
}

WorkgroupConfigParameterArrayInput is an input type that accepts WorkgroupConfigParameterArray and WorkgroupConfigParameterArrayOutput values. You can construct a concrete instance of `WorkgroupConfigParameterArrayInput` via: 

WorkgroupConfigParameterArray{ WorkgroupConfigParameterArgs{...} }

type WorkgroupConfigParameterArrayOutput 

type WorkgroupConfigParameterArrayOutput struct{ *pulumi.OutputState }

func (WorkgroupConfigParameterArrayOutput) ElementType 

func (WorkgroupConfigParameterArrayOutput) ElementType() reflect.Type

func (WorkgroupConfigParameterArrayOutput) Index 

func (o WorkgroupConfigParameterArrayOutput) Index(i pulumi.IntInput) WorkgroupConfigParameterOutput

func (WorkgroupConfigParameterArrayOutput) ToWorkgroupConfigParameterArrayOutput 

func (o WorkgroupConfigParameterArrayOutput) ToWorkgroupConfigParameterArrayOutput() WorkgroupConfigParameterArrayOutput

func (WorkgroupConfigParameterArrayOutput) ToWorkgroupConfigParameterArrayOutputWithContext 

func (o WorkgroupConfigParameterArrayOutput) ToWorkgroupConfigParameterArrayOutputWithContext(ctx context.Context) WorkgroupConfigParameterArrayOutput

type WorkgroupConfigParameterInput 

type WorkgroupConfigParameterInput interface {
	pulumi.Input

	ToWorkgroupConfigParameterOutput() WorkgroupConfigParameterOutput
	ToWorkgroupConfigParameterOutputWithContext(context.Context) WorkgroupConfigParameterOutput
}

WorkgroupConfigParameterInput is an input type that accepts WorkgroupConfigParameterArgs and WorkgroupConfigParameterOutput values. You can construct a concrete instance of `WorkgroupConfigParameterInput` via: 

WorkgroupConfigParameterArgs{...}

type WorkgroupConfigParameterOutput 

type WorkgroupConfigParameterOutput struct{ *pulumi.OutputState }

func (WorkgroupConfigParameterOutput) ElementType 

func (WorkgroupConfigParameterOutput) ElementType() reflect.Type

func (WorkgroupConfigParameterOutput) ParameterKey 

func (o WorkgroupConfigParameterOutput) ParameterKey() pulumi.StringOutput

The key of the parameter. The options are `autoMv`, `datestyle`, `enableCaseSensitiveIdentifier`, `enableUserActivityLogging`, `queryGroup`, `searchPath`, `requireSsl`, `useFipsSsl`, and [query monitoring metrics](https://docs.aws.amazon.com/redshift/latest/dg/cm-c-wlm-query-monitoring-rules.html#cm-c-wlm-query-monitoring-metrics-serverless) that let you define performance boundaries: `maxQueryCpuTime`, `maxQueryBlocksRead`, `maxScanRowCount`, `maxQueryExecutionTime`, `maxQueryQueueTime`, `maxQueryCpuUsagePercent`, `maxQueryTempBlocksToDisk`, `maxJoinRowCount` and `maxNestedLoopJoinRowCount`.

func (WorkgroupConfigParameterOutput) ParameterValue 

func (o WorkgroupConfigParameterOutput) ParameterValue() pulumi.StringOutput

The value of the parameter to set.

func (WorkgroupConfigParameterOutput) ToWorkgroupConfigParameterOutput 

func (o WorkgroupConfigParameterOutput) ToWorkgroupConfigParameterOutput() WorkgroupConfigParameterOutput

func (WorkgroupConfigParameterOutput) ToWorkgroupConfigParameterOutputWithContext 

func (o WorkgroupConfigParameterOutput) ToWorkgroupConfigParameterOutputWithContext(ctx context.Context) WorkgroupConfigParameterOutput

type WorkgroupEndpoint 

type WorkgroupEndpoint struct {
	// The DNS address of the VPC endpoint.
	Address *string `pulumi:"address"`
	// The port number on which the cluster accepts incoming connections.
	Port *int `pulumi:"port"`
	// The VPC endpoint or the Redshift Serverless workgroup. See `VPC Endpoint` below.
	VpcEndpoints []WorkgroupEndpointVpcEndpoint `pulumi:"vpcEndpoints"`
}

type WorkgroupEndpointArgs 

type WorkgroupEndpointArgs struct {
	// The DNS address of the VPC endpoint.
	Address pulumi.StringPtrInput `pulumi:"address"`
	// The port number on which the cluster accepts incoming connections.
	Port pulumi.IntPtrInput `pulumi:"port"`
	// The VPC endpoint or the Redshift Serverless workgroup. See `VPC Endpoint` below.
	VpcEndpoints WorkgroupEndpointVpcEndpointArrayInput `pulumi:"vpcEndpoints"`
}

func (WorkgroupEndpointArgs) ElementType 

func (WorkgroupEndpointArgs) ElementType() reflect.Type

func (WorkgroupEndpointArgs) ToWorkgroupEndpointOutput 

func (i WorkgroupEndpointArgs) ToWorkgroupEndpointOutput() WorkgroupEndpointOutput

func (WorkgroupEndpointArgs) ToWorkgroupEndpointOutputWithContext 

func (i WorkgroupEndpointArgs) ToWorkgroupEndpointOutputWithContext(ctx context.Context) WorkgroupEndpointOutput

type WorkgroupEndpointArray 

type WorkgroupEndpointArray []WorkgroupEndpointInput

func (WorkgroupEndpointArray) ElementType 

func (WorkgroupEndpointArray) ElementType() reflect.Type

func (WorkgroupEndpointArray) ToWorkgroupEndpointArrayOutput 

func (i WorkgroupEndpointArray) ToWorkgroupEndpointArrayOutput() WorkgroupEndpointArrayOutput

func (WorkgroupEndpointArray) ToWorkgroupEndpointArrayOutputWithContext 

func (i WorkgroupEndpointArray) ToWorkgroupEndpointArrayOutputWithContext(ctx context.Context) WorkgroupEndpointArrayOutput

type WorkgroupEndpointArrayInput 

type WorkgroupEndpointArrayInput interface {
	pulumi.Input

	ToWorkgroupEndpointArrayOutput() WorkgroupEndpointArrayOutput
	ToWorkgroupEndpointArrayOutputWithContext(context.Context) WorkgroupEndpointArrayOutput
}

WorkgroupEndpointArrayInput is an input type that accepts WorkgroupEndpointArray and WorkgroupEndpointArrayOutput values. You can construct a concrete instance of `WorkgroupEndpointArrayInput` via: 

WorkgroupEndpointArray{ WorkgroupEndpointArgs{...} }

type WorkgroupEndpointArrayOutput 

type WorkgroupEndpointArrayOutput struct{ *pulumi.OutputState }

func (WorkgroupEndpointArrayOutput) ElementType 

func (WorkgroupEndpointArrayOutput) ElementType() reflect.Type

func (WorkgroupEndpointArrayOutput) Index 

func (o WorkgroupEndpointArrayOutput) Index(i pulumi.IntInput) WorkgroupEndpointOutput

func (WorkgroupEndpointArrayOutput) ToWorkgroupEndpointArrayOutput 

func (o WorkgroupEndpointArrayOutput) ToWorkgroupEndpointArrayOutput() WorkgroupEndpointArrayOutput

func (WorkgroupEndpointArrayOutput) ToWorkgroupEndpointArrayOutputWithContext 

func (o WorkgroupEndpointArrayOutput) ToWorkgroupEndpointArrayOutputWithContext(ctx context.Context) WorkgroupEndpointArrayOutput

type WorkgroupEndpointInput 

type WorkgroupEndpointInput interface {
	pulumi.Input

	ToWorkgroupEndpointOutput() WorkgroupEndpointOutput
	ToWorkgroupEndpointOutputWithContext(context.Context) WorkgroupEndpointOutput
}

WorkgroupEndpointInput is an input type that accepts WorkgroupEndpointArgs and WorkgroupEndpointOutput values. You can construct a concrete instance of `WorkgroupEndpointInput` via: 

WorkgroupEndpointArgs{...}

type WorkgroupEndpointOutput 

type WorkgroupEndpointOutput struct{ *pulumi.OutputState }

func (WorkgroupEndpointOutput) Address 

func (o WorkgroupEndpointOutput) Address() pulumi.StringPtrOutput

The DNS address of the VPC endpoint.

func (WorkgroupEndpointOutput) ElementType 

func (WorkgroupEndpointOutput) ElementType() reflect.Type

func (WorkgroupEndpointOutput) Port 

func (o WorkgroupEndpointOutput) Port() pulumi.IntPtrOutput

The port number on which the cluster accepts incoming connections.

func (WorkgroupEndpointOutput) ToWorkgroupEndpointOutput 

func (o WorkgroupEndpointOutput) ToWorkgroupEndpointOutput() WorkgroupEndpointOutput

func (WorkgroupEndpointOutput) ToWorkgroupEndpointOutputWithContext 

func (o WorkgroupEndpointOutput) ToWorkgroupEndpointOutputWithContext(ctx context.Context) WorkgroupEndpointOutput

func (WorkgroupEndpointOutput) VpcEndpoints 

func (o WorkgroupEndpointOutput) VpcEndpoints() WorkgroupEndpointVpcEndpointArrayOutput

The VPC endpoint or the Redshift Serverless workgroup. See `VPC Endpoint` below.

type WorkgroupEndpointVpcEndpoint 

type WorkgroupEndpointVpcEndpoint struct {
	// The network interfaces of the endpoint.. See `Network Interface` below.
	NetworkInterfaces []WorkgroupEndpointVpcEndpointNetworkInterface `pulumi:"networkInterfaces"`
	// The DNS address of the VPC endpoint.
	VpcEndpointId *string `pulumi:"vpcEndpointId"`
	// The port that Amazon Redshift Serverless listens on.
	VpcId *string `pulumi:"vpcId"`
}

type WorkgroupEndpointVpcEndpointArgs 

type WorkgroupEndpointVpcEndpointArgs struct {
	// The network interfaces of the endpoint.. See `Network Interface` below.
	NetworkInterfaces WorkgroupEndpointVpcEndpointNetworkInterfaceArrayInput `pulumi:"networkInterfaces"`
	// The DNS address of the VPC endpoint.
	VpcEndpointId pulumi.StringPtrInput `pulumi:"vpcEndpointId"`
	// The port that Amazon Redshift Serverless listens on.
	VpcId pulumi.StringPtrInput `pulumi:"vpcId"`
}

func (WorkgroupEndpointVpcEndpointArgs) ElementType 

func (WorkgroupEndpointVpcEndpointArgs) ElementType() reflect.Type

func (WorkgroupEndpointVpcEndpointArgs) ToWorkgroupEndpointVpcEndpointOutput 

func (i WorkgroupEndpointVpcEndpointArgs) ToWorkgroupEndpointVpcEndpointOutput() WorkgroupEndpointVpcEndpointOutput

func (WorkgroupEndpointVpcEndpointArgs) ToWorkgroupEndpointVpcEndpointOutputWithContext 

func (i WorkgroupEndpointVpcEndpointArgs) ToWorkgroupEndpointVpcEndpointOutputWithContext(ctx context.Context) WorkgroupEndpointVpcEndpointOutput

type WorkgroupEndpointVpcEndpointArray 

type WorkgroupEndpointVpcEndpointArray []WorkgroupEndpointVpcEndpointInput

func (WorkgroupEndpointVpcEndpointArray) ElementType 

func (WorkgroupEndpointVpcEndpointArray) ElementType() reflect.Type

func (WorkgroupEndpointVpcEndpointArray) ToWorkgroupEndpointVpcEndpointArrayOutput 

func (i WorkgroupEndpointVpcEndpointArray) ToWorkgroupEndpointVpcEndpointArrayOutput() WorkgroupEndpointVpcEndpointArrayOutput

func (WorkgroupEndpointVpcEndpointArray) ToWorkgroupEndpointVpcEndpointArrayOutputWithContext 

func (i WorkgroupEndpointVpcEndpointArray) ToWorkgroupEndpointVpcEndpointArrayOutputWithContext(ctx context.Context) WorkgroupEndpointVpcEndpointArrayOutput

type WorkgroupEndpointVpcEndpointArrayInput 

type WorkgroupEndpointVpcEndpointArrayInput interface {
	pulumi.Input

	ToWorkgroupEndpointVpcEndpointArrayOutput() WorkgroupEndpointVpcEndpointArrayOutput
	ToWorkgroupEndpointVpcEndpointArrayOutputWithContext(context.Context) WorkgroupEndpointVpcEndpointArrayOutput
}

WorkgroupEndpointVpcEndpointArrayInput is an input type that accepts WorkgroupEndpointVpcEndpointArray and WorkgroupEndpointVpcEndpointArrayOutput values. You can construct a concrete instance of `WorkgroupEndpointVpcEndpointArrayInput` via: 

WorkgroupEndpointVpcEndpointArray{ WorkgroupEndpointVpcEndpointArgs{...} }

type WorkgroupEndpointVpcEndpointArrayOutput 

type WorkgroupEndpointVpcEndpointArrayOutput struct{ *pulumi.OutputState }

func (WorkgroupEndpointVpcEndpointArrayOutput) ElementType 

func (WorkgroupEndpointVpcEndpointArrayOutput) ElementType() reflect.Type

func (WorkgroupEndpointVpcEndpointArrayOutput) Index 

func (o WorkgroupEndpointVpcEndpointArrayOutput) Index(i pulumi.IntInput) WorkgroupEndpointVpcEndpointOutput

func (WorkgroupEndpointVpcEndpointArrayOutput) ToWorkgroupEndpointVpcEndpointArrayOutput 

func (o WorkgroupEndpointVpcEndpointArrayOutput) ToWorkgroupEndpointVpcEndpointArrayOutput() WorkgroupEndpointVpcEndpointArrayOutput

func (WorkgroupEndpointVpcEndpointArrayOutput) ToWorkgroupEndpointVpcEndpointArrayOutputWithContext 

func (o WorkgroupEndpointVpcEndpointArrayOutput) ToWorkgroupEndpointVpcEndpointArrayOutputWithContext(ctx context.Context) WorkgroupEndpointVpcEndpointArrayOutput

type WorkgroupEndpointVpcEndpointInput 

type WorkgroupEndpointVpcEndpointInput interface {
	pulumi.Input

	ToWorkgroupEndpointVpcEndpointOutput() WorkgroupEndpointVpcEndpointOutput
	ToWorkgroupEndpointVpcEndpointOutputWithContext(context.Context) WorkgroupEndpointVpcEndpointOutput
}

WorkgroupEndpointVpcEndpointInput is an input type that accepts WorkgroupEndpointVpcEndpointArgs and WorkgroupEndpointVpcEndpointOutput values. You can construct a concrete instance of `WorkgroupEndpointVpcEndpointInput` via: 

WorkgroupEndpointVpcEndpointArgs{...}

type WorkgroupEndpointVpcEndpointNetworkInterface 

type WorkgroupEndpointVpcEndpointNetworkInterface struct {
	// The availability Zone.
	AvailabilityZone *string `pulumi:"availabilityZone"`
	// The unique identifier of the network interface.
	NetworkInterfaceId *string `pulumi:"networkInterfaceId"`
	// The IPv4 address of the network interface within the subnet.
	PrivateIpAddress *string `pulumi:"privateIpAddress"`
	// The unique identifier of the subnet.
	SubnetId *string `pulumi:"subnetId"`
}

type WorkgroupEndpointVpcEndpointNetworkInterfaceArgs 

type WorkgroupEndpointVpcEndpointNetworkInterfaceArgs struct {
	// The availability Zone.
	AvailabilityZone pulumi.StringPtrInput `pulumi:"availabilityZone"`
	// The unique identifier of the network interface.
	NetworkInterfaceId pulumi.StringPtrInput `pulumi:"networkInterfaceId"`
	// The IPv4 address of the network interface within the subnet.
	PrivateIpAddress pulumi.StringPtrInput `pulumi:"privateIpAddress"`
	// The unique identifier of the subnet.
	SubnetId pulumi.StringPtrInput `pulumi:"subnetId"`
}

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ElementType 

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ElementType() reflect.Type

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ToWorkgroupEndpointVpcEndpointNetworkInterfaceOutput 

func (i WorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ToWorkgroupEndpointVpcEndpointNetworkInterfaceOutput() WorkgroupEndpointVpcEndpointNetworkInterfaceOutput

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ToWorkgroupEndpointVpcEndpointNetworkInterfaceOutputWithContext 

func (i WorkgroupEndpointVpcEndpointNetworkInterfaceArgs) ToWorkgroupEndpointVpcEndpointNetworkInterfaceOutputWithContext(ctx context.Context) WorkgroupEndpointVpcEndpointNetworkInterfaceOutput

type WorkgroupEndpointVpcEndpointNetworkInterfaceArray 

type WorkgroupEndpointVpcEndpointNetworkInterfaceArray []WorkgroupEndpointVpcEndpointNetworkInterfaceInput

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArray) ElementType 

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArray) ElementType() reflect.Type

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArray) ToWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput 

func (i WorkgroupEndpointVpcEndpointNetworkInterfaceArray) ToWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput() WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArray) ToWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutputWithContext 

func (i WorkgroupEndpointVpcEndpointNetworkInterfaceArray) ToWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutputWithContext(ctx context.Context) WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput

type WorkgroupEndpointVpcEndpointNetworkInterfaceArrayInput 

type WorkgroupEndpointVpcEndpointNetworkInterfaceArrayInput interface {
	pulumi.Input

	ToWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput() WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput
	ToWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutputWithContext(context.Context) WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput
}

WorkgroupEndpointVpcEndpointNetworkInterfaceArrayInput is an input type that accepts WorkgroupEndpointVpcEndpointNetworkInterfaceArray and WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput values. You can construct a concrete instance of `WorkgroupEndpointVpcEndpointNetworkInterfaceArrayInput` via: 

WorkgroupEndpointVpcEndpointNetworkInterfaceArray{ WorkgroupEndpointVpcEndpointNetworkInterfaceArgs{...} }

type WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput 

type WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput struct{ *pulumi.OutputState }

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ElementType 

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ElementType() reflect.Type

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) Index 

func (o WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) Index(i pulumi.IntInput) WorkgroupEndpointVpcEndpointNetworkInterfaceOutput

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ToWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput 

func (o WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ToWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput() WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput

func (WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ToWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutputWithContext 

func (o WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput) ToWorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutputWithContext(ctx context.Context) WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput

type WorkgroupEndpointVpcEndpointNetworkInterfaceInput 

type WorkgroupEndpointVpcEndpointNetworkInterfaceInput interface {
	pulumi.Input

	ToWorkgroupEndpointVpcEndpointNetworkInterfaceOutput() WorkgroupEndpointVpcEndpointNetworkInterfaceOutput
	ToWorkgroupEndpointVpcEndpointNetworkInterfaceOutputWithContext(context.Context) WorkgroupEndpointVpcEndpointNetworkInterfaceOutput
}

WorkgroupEndpointVpcEndpointNetworkInterfaceInput is an input type that accepts WorkgroupEndpointVpcEndpointNetworkInterfaceArgs and WorkgroupEndpointVpcEndpointNetworkInterfaceOutput values. You can construct a concrete instance of `WorkgroupEndpointVpcEndpointNetworkInterfaceInput` via: 

WorkgroupEndpointVpcEndpointNetworkInterfaceArgs{...}

type WorkgroupEndpointVpcEndpointNetworkInterfaceOutput 

type WorkgroupEndpointVpcEndpointNetworkInterfaceOutput struct{ *pulumi.OutputState }

func (WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) AvailabilityZone 

func (o WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) AvailabilityZone() pulumi.StringPtrOutput

The availability Zone.

func (WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ElementType 

func (WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ElementType() reflect.Type

func (WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) NetworkInterfaceId 

func (o WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) NetworkInterfaceId() pulumi.StringPtrOutput

The unique identifier of the network interface.

func (WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) PrivateIpAddress 

func (o WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) PrivateIpAddress() pulumi.StringPtrOutput

The IPv4 address of the network interface within the subnet.

func (WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) SubnetId 

func (o WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) SubnetId() pulumi.StringPtrOutput

The unique identifier of the subnet.

func (WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ToWorkgroupEndpointVpcEndpointNetworkInterfaceOutput 

func (o WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ToWorkgroupEndpointVpcEndpointNetworkInterfaceOutput() WorkgroupEndpointVpcEndpointNetworkInterfaceOutput

func (WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ToWorkgroupEndpointVpcEndpointNetworkInterfaceOutputWithContext 

func (o WorkgroupEndpointVpcEndpointNetworkInterfaceOutput) ToWorkgroupEndpointVpcEndpointNetworkInterfaceOutputWithContext(ctx context.Context) WorkgroupEndpointVpcEndpointNetworkInterfaceOutput

type WorkgroupEndpointVpcEndpointOutput 

type WorkgroupEndpointVpcEndpointOutput struct{ *pulumi.OutputState }

func (WorkgroupEndpointVpcEndpointOutput) ElementType 

func (WorkgroupEndpointVpcEndpointOutput) ElementType() reflect.Type

func (WorkgroupEndpointVpcEndpointOutput) NetworkInterfaces 

func (o WorkgroupEndpointVpcEndpointOutput) NetworkInterfaces() WorkgroupEndpointVpcEndpointNetworkInterfaceArrayOutput

The network interfaces of the endpoint.. See `Network Interface` below.

func (WorkgroupEndpointVpcEndpointOutput) ToWorkgroupEndpointVpcEndpointOutput 

func (o WorkgroupEndpointVpcEndpointOutput) ToWorkgroupEndpointVpcEndpointOutput() WorkgroupEndpointVpcEndpointOutput

func (WorkgroupEndpointVpcEndpointOutput) ToWorkgroupEndpointVpcEndpointOutputWithContext 

func (o WorkgroupEndpointVpcEndpointOutput) ToWorkgroupEndpointVpcEndpointOutputWithContext(ctx context.Context) WorkgroupEndpointVpcEndpointOutput

func (WorkgroupEndpointVpcEndpointOutput) VpcEndpointId 

func (o WorkgroupEndpointVpcEndpointOutput) VpcEndpointId() pulumi.StringPtrOutput

The DNS address of the VPC endpoint.

func (WorkgroupEndpointVpcEndpointOutput) VpcId 

func (o WorkgroupEndpointVpcEndpointOutput) VpcId() pulumi.StringPtrOutput

The port that Amazon Redshift Serverless listens on.

type WorkgroupInput 

type WorkgroupInput interface {
	pulumi.Input

	ToWorkgroupOutput() WorkgroupOutput
	ToWorkgroupOutputWithContext(ctx context.Context) WorkgroupOutput
}

type WorkgroupMap 

type WorkgroupMap map[string]WorkgroupInput

func (WorkgroupMap) ElementType 

func (WorkgroupMap) ElementType() reflect.Type

func (WorkgroupMap) ToWorkgroupMapOutput 

func (i WorkgroupMap) ToWorkgroupMapOutput() WorkgroupMapOutput

func (WorkgroupMap) ToWorkgroupMapOutputWithContext 

func (i WorkgroupMap) ToWorkgroupMapOutputWithContext(ctx context.Context) WorkgroupMapOutput

type WorkgroupMapInput 

type WorkgroupMapInput interface {
	pulumi.Input

	ToWorkgroupMapOutput() WorkgroupMapOutput
	ToWorkgroupMapOutputWithContext(context.Context) WorkgroupMapOutput
}

WorkgroupMapInput is an input type that accepts WorkgroupMap and WorkgroupMapOutput values. You can construct a concrete instance of `WorkgroupMapInput` via: 

WorkgroupMap{ "key": WorkgroupArgs{...} }

type WorkgroupMapOutput 

type WorkgroupMapOutput struct{ *pulumi.OutputState }

func (WorkgroupMapOutput) ElementType 

func (WorkgroupMapOutput) ElementType() reflect.Type

func (WorkgroupMapOutput) MapIndex 

func (o WorkgroupMapOutput) MapIndex(k pulumi.StringInput) WorkgroupOutput

func (WorkgroupMapOutput) ToWorkgroupMapOutput 

func (o WorkgroupMapOutput) ToWorkgroupMapOutput() WorkgroupMapOutput

func (WorkgroupMapOutput) ToWorkgroupMapOutputWithContext 

func (o WorkgroupMapOutput) ToWorkgroupMapOutputWithContext(ctx context.Context) WorkgroupMapOutput

type WorkgroupOutput 

type WorkgroupOutput struct{ *pulumi.OutputState }

func (WorkgroupOutput) Arn 

func (o WorkgroupOutput) Arn() pulumi.StringOutput

Amazon Resource Name (ARN) of the Redshift Serverless Workgroup.

func (WorkgroupOutput) BaseCapacity 

func (o WorkgroupOutput) BaseCapacity() pulumi.IntOutput

The base data warehouse capacity of the workgroup in Redshift Processing Units (RPUs).

func (WorkgroupOutput) ConfigParameters 

func (o WorkgroupOutput) ConfigParameters() WorkgroupConfigParameterArrayOutput

An array of parameters to set for more control over a serverless database. See `Config Parameter` below.

func (WorkgroupOutput) ElementType 

func (WorkgroupOutput) ElementType() reflect.Type

func (WorkgroupOutput) Endpoints 

func (o WorkgroupOutput) Endpoints() WorkgroupEndpointArrayOutput

The endpoint that is created from the workgroup. See `Endpoint` below.

func (WorkgroupOutput) EnhancedVpcRouting 

func (o WorkgroupOutput) EnhancedVpcRouting() pulumi.BoolPtrOutput

The value that specifies whether to turn on enhanced virtual private cloud (VPC) routing, which forces Amazon Redshift Serverless to route traffic through your VPC instead of over the internet.

func (WorkgroupOutput) MaxCapacity added in v6.24.2 

func (o WorkgroupOutput) MaxCapacity() pulumi.IntPtrOutput

The maximum data-warehouse capacity Amazon Redshift Serverless uses to serve queries, specified in Redshift Processing Units (RPUs).

func (WorkgroupOutput) NamespaceName 

func (o WorkgroupOutput) NamespaceName() pulumi.StringOutput

The name of the namespace.

func (WorkgroupOutput) Port added in v6.18.2 

func (o WorkgroupOutput) Port() pulumi.IntOutput

The port number on which the cluster accepts incoming connections.

func (WorkgroupOutput) PubliclyAccessible 

func (o WorkgroupOutput) PubliclyAccessible() pulumi.BoolPtrOutput

A value that specifies whether the workgroup can be accessed from a public network.

func (WorkgroupOutput) SecurityGroupIds 

func (o WorkgroupOutput) SecurityGroupIds() pulumi.StringArrayOutput

An array of security group IDs to associate with the workgroup.

func (WorkgroupOutput) SubnetIds 

func (o WorkgroupOutput) SubnetIds() pulumi.StringArrayOutput

An array of VPC subnet IDs to associate with the workgroup. When set, must contain at least three subnets spanning three Availability Zones. A minimum number of IP addresses is required and scales with the Base Capacity. For more information, see the following [AWS document](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-known-issues.html).

func (WorkgroupOutput) Tags 

func (o WorkgroupOutput) Tags() pulumi.StringMapOutput

A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

func (WorkgroupOutput) TagsAll deprecated 

func (o WorkgroupOutput) TagsAll() pulumi.StringMapOutput

A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

Deprecated: Please use `tags` instead.

func (WorkgroupOutput) ToWorkgroupOutput 

func (o WorkgroupOutput) ToWorkgroupOutput() WorkgroupOutput

func (WorkgroupOutput) ToWorkgroupOutputWithContext 

func (o WorkgroupOutput) ToWorkgroupOutputWithContext(ctx context.Context) WorkgroupOutput

func (WorkgroupOutput) WorkgroupId 

func (o WorkgroupOutput) WorkgroupId() pulumi.StringOutput

The Redshift Workgroup ID.

func (WorkgroupOutput) WorkgroupName 

func (o WorkgroupOutput) WorkgroupName() pulumi.StringOutput

The name of the workgroup.

The following arguments are optional:

type WorkgroupState 

type WorkgroupState struct {
	// Amazon Resource Name (ARN) of the Redshift Serverless Workgroup.
	Arn pulumi.StringPtrInput
	// The base data warehouse capacity of the workgroup in Redshift Processing Units (RPUs).
	BaseCapacity pulumi.IntPtrInput
	// An array of parameters to set for more control over a serverless database. See `Config Parameter` below.
	ConfigParameters WorkgroupConfigParameterArrayInput
	// The endpoint that is created from the workgroup. See `Endpoint` below.
	Endpoints WorkgroupEndpointArrayInput
	// The value that specifies whether to turn on enhanced virtual private cloud (VPC) routing, which forces Amazon Redshift Serverless to route traffic through your VPC instead of over the internet.
	EnhancedVpcRouting pulumi.BoolPtrInput
	// The maximum data-warehouse capacity Amazon Redshift Serverless uses to serve queries, specified in Redshift Processing Units (RPUs).
	MaxCapacity pulumi.IntPtrInput
	// The name of the namespace.
	NamespaceName pulumi.StringPtrInput
	// The port number on which the cluster accepts incoming connections.
	Port pulumi.IntPtrInput
	// A value that specifies whether the workgroup can be accessed from a public network.
	PubliclyAccessible pulumi.BoolPtrInput
	// An array of security group IDs to associate with the workgroup.
	SecurityGroupIds pulumi.StringArrayInput
	// An array of VPC subnet IDs to associate with the workgroup. When set, must contain at least three subnets spanning three Availability Zones. A minimum number of IP addresses is required and scales with the Base Capacity. For more information, see the following [AWS document](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-known-issues.html).
	SubnetIds pulumi.StringArrayInput
	// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	//
	// Deprecated: Please use `tags` instead.
	TagsAll pulumi.StringMapInput
	// The Redshift Workgroup ID.
	WorkgroupId pulumi.StringPtrInput
	// The name of the workgroup.
	//
	// The following arguments are optional:
	WorkgroupName pulumi.StringPtrInput
}

func (WorkgroupState) ElementType 

func (WorkgroupState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.