rds

package
v0.0.23 Latest Latest
Warning

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

 Go to latest Published: Jan 3, 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 Account 

type Account struct {
	pulumi.CustomResourceState

	// Database account name. The rules are as follows:
	// Unique name.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, or underscores (_).
	// The length is 2~32 characters.
	// The [keyword list](https://www.volcengine.com/docs/6313/66162) is disabled for database accounts, and certain reserved words, including root, admin, etc., cannot be used.
	AccountName pulumi.StringOutput `pulumi:"accountName"`
	// The password of the database account.
	// illustrate
	// Cannot start with `!` or `@`.
	// The length is 8~32 characters.
	// It consists of any three of uppercase letters, lowercase letters, numbers, and special characters.
	// The special characters are `!@#$%^*()_+-=`. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	AccountPassword pulumi.StringOutput `pulumi:"accountPassword"`
	// Database account type, value:
	// Super: A high-privilege account. Only one database account can be created for an instance.
	// Normal: An account with ordinary privileges.
	AccountType pulumi.StringOutput `pulumi:"accountType"`
	// The ID of the RDS instance.
	InstanceId pulumi.StringOutput `pulumi:"instanceId"`
}

(Deprecated! Recommend use volcengine_rds_mysql_*** replace) Provides a resource to manage rds account ## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.NewAccount(ctx, "foo", &rds.AccountArgs{
			AccountName:     pulumi.String("test"),
			AccountPassword: pulumi.String("Aatest123"),
			AccountType:     pulumi.String("Normal"),
			InstanceId:      pulumi.String("mysql-0fdd3bab2e7c"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

RDS account can be imported using the id, e.g.

```sh 

$ pulumi import volcengine:rds/account:Account default mysql-42b38c769c4b:test

```

func GetAccount 

func GetAccount(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AccountState, opts ...pulumi.ResourceOption) (*Account, error)

GetAccount gets an existing Account 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 NewAccount 

func NewAccount(ctx *pulumi.Context,
	name string, args *AccountArgs, opts ...pulumi.ResourceOption) (*Account, error)

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

func (*Account) ElementType 

func (*Account) ElementType() reflect.Type

func (*Account) ToAccountOutput 

func (i *Account) ToAccountOutput() AccountOutput

func (*Account) ToAccountOutputWithContext 

func (i *Account) ToAccountOutputWithContext(ctx context.Context) AccountOutput

type AccountArgs 

type AccountArgs struct {
	// Database account name. The rules are as follows:
	// Unique name.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, or underscores (_).
	// The length is 2~32 characters.
	// The [keyword list](https://www.volcengine.com/docs/6313/66162) is disabled for database accounts, and certain reserved words, including root, admin, etc., cannot be used.
	AccountName pulumi.StringInput
	// The password of the database account.
	// illustrate
	// Cannot start with `!` or `@`.
	// The length is 8~32 characters.
	// It consists of any three of uppercase letters, lowercase letters, numbers, and special characters.
	// The special characters are `!@#$%^*()_+-=`. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	AccountPassword pulumi.StringInput
	// Database account type, value:
	// Super: A high-privilege account. Only one database account can be created for an instance.
	// Normal: An account with ordinary privileges.
	AccountType pulumi.StringInput
	// The ID of the RDS instance.
	InstanceId pulumi.StringInput
}

The set of arguments for constructing a Account resource.

func (AccountArgs) ElementType 

func (AccountArgs) ElementType() reflect.Type

type AccountArray 

type AccountArray []AccountInput

func (AccountArray) ElementType 

func (AccountArray) ElementType() reflect.Type

func (AccountArray) ToAccountArrayOutput 

func (i AccountArray) ToAccountArrayOutput() AccountArrayOutput

func (AccountArray) ToAccountArrayOutputWithContext 

func (i AccountArray) ToAccountArrayOutputWithContext(ctx context.Context) AccountArrayOutput

type AccountArrayInput 

type AccountArrayInput interface {
	pulumi.Input

	ToAccountArrayOutput() AccountArrayOutput
	ToAccountArrayOutputWithContext(context.Context) AccountArrayOutput
}

AccountArrayInput is an input type that accepts AccountArray and AccountArrayOutput values. You can construct a concrete instance of `AccountArrayInput` via: 

AccountArray{ AccountArgs{...} }

type AccountArrayOutput 

type AccountArrayOutput struct{ *pulumi.OutputState }

func (AccountArrayOutput) ElementType 

func (AccountArrayOutput) ElementType() reflect.Type

func (AccountArrayOutput) Index 

func (o AccountArrayOutput) Index(i pulumi.IntInput) AccountOutput

func (AccountArrayOutput) ToAccountArrayOutput 

func (o AccountArrayOutput) ToAccountArrayOutput() AccountArrayOutput

func (AccountArrayOutput) ToAccountArrayOutputWithContext 

func (o AccountArrayOutput) ToAccountArrayOutputWithContext(ctx context.Context) AccountArrayOutput

type AccountInput 

type AccountInput interface {
	pulumi.Input

	ToAccountOutput() AccountOutput
	ToAccountOutputWithContext(ctx context.Context) AccountOutput
}

type AccountMap 

type AccountMap map[string]AccountInput

func (AccountMap) ElementType 

func (AccountMap) ElementType() reflect.Type

func (AccountMap) ToAccountMapOutput 

func (i AccountMap) ToAccountMapOutput() AccountMapOutput

func (AccountMap) ToAccountMapOutputWithContext 

func (i AccountMap) ToAccountMapOutputWithContext(ctx context.Context) AccountMapOutput

type AccountMapInput 

type AccountMapInput interface {
	pulumi.Input

	ToAccountMapOutput() AccountMapOutput
	ToAccountMapOutputWithContext(context.Context) AccountMapOutput
}

AccountMapInput is an input type that accepts AccountMap and AccountMapOutput values. You can construct a concrete instance of `AccountMapInput` via: 

AccountMap{ "key": AccountArgs{...} }

type AccountMapOutput 

type AccountMapOutput struct{ *pulumi.OutputState }

func (AccountMapOutput) ElementType 

func (AccountMapOutput) ElementType() reflect.Type

func (AccountMapOutput) MapIndex 

func (o AccountMapOutput) MapIndex(k pulumi.StringInput) AccountOutput

func (AccountMapOutput) ToAccountMapOutput 

func (o AccountMapOutput) ToAccountMapOutput() AccountMapOutput

func (AccountMapOutput) ToAccountMapOutputWithContext 

func (o AccountMapOutput) ToAccountMapOutputWithContext(ctx context.Context) AccountMapOutput

type AccountOutput 

type AccountOutput struct{ *pulumi.OutputState }

func (AccountOutput) AccountName 

func (o AccountOutput) AccountName() pulumi.StringOutput

Database account name. The rules are as follows: Unique name. Start with a letter and end with a letter or number. Consists of lowercase letters, numbers, or underscores (_). The length is 2~32 characters. The [keyword list](https://www.volcengine.com/docs/6313/66162) is disabled for database accounts, and certain reserved words, including root, admin, etc., cannot be used.

func (AccountOutput) AccountPassword 

func (o AccountOutput) AccountPassword() pulumi.StringOutput

The password of the database account. illustrate Cannot start with `!` or `@`. The length is 8~32 characters. It consists of any three of uppercase letters, lowercase letters, numbers, and special characters. The special characters are `!@#$%^*()_+-=`. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.

func (AccountOutput) AccountType 

func (o AccountOutput) AccountType() pulumi.StringOutput

Database account type, value: Super: A high-privilege account. Only one database account can be created for an instance. Normal: An account with ordinary privileges.

func (AccountOutput) ElementType 

func (AccountOutput) ElementType() reflect.Type

func (AccountOutput) InstanceId 

func (o AccountOutput) InstanceId() pulumi.StringOutput

The ID of the RDS instance.

func (AccountOutput) ToAccountOutput 

func (o AccountOutput) ToAccountOutput() AccountOutput

func (AccountOutput) ToAccountOutputWithContext 

func (o AccountOutput) ToAccountOutputWithContext(ctx context.Context) AccountOutput

type AccountPrivilege 

type AccountPrivilege struct {
	pulumi.CustomResourceState

	// Database account name. The rules are as follows:
	// Unique name.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, or underscores (_).
	// The length is 2~32 characters.
	// The [keyword list](https://www.volcengine.com/docs/6313/66162) is disabled for database accounts, and certain reserved words, including root, admin, etc., cannot be used.
	AccountName pulumi.StringOutput `pulumi:"accountName"`
	// The privileges of the account.
	DbPrivileges AccountPrivilegeDbPrivilegeArrayOutput `pulumi:"dbPrivileges"`
	// The ID of the RDS instance.
	InstanceId pulumi.StringOutput `pulumi:"instanceId"`
}

(Deprecated! Recommend use volcengine_rds_mysql_*** replace) Provides a resource to manage rds account privilege ## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		appName, err := rds.NewAccount(ctx, "appName", &rds.AccountArgs{
			InstanceId:      pulumi.String("mysql-0fdd3bab2e7c"),
			AccountName:     pulumi.String("terraform-test-app"),
			AccountPassword: pulumi.String("Aatest123"),
			AccountType:     pulumi.String("Normal"),
		})
		if err != nil {
			return err
		}
		_, err = rds.NewAccountPrivilege(ctx, "foo", &rds.AccountPrivilegeArgs{
			InstanceId:  pulumi.String("mysql-0fdd3bab2e7c"),
			AccountName: appName.AccountName,
			DbPrivileges: rds.AccountPrivilegeDbPrivilegeArray{
				&rds.AccountPrivilegeDbPrivilegeArgs{
					DbName:              pulumi.String("foo"),
					AccountPrivilege:    pulumi.String("Custom"),
					AccountPrivilegeStr: pulumi.String("ALTER,ALTER ROUTINE,CREATE,CREATE ROUTINE,CREATE TEMPORARY TABLES"),
				},
				&rds.AccountPrivilegeDbPrivilegeArgs{
					DbName:           pulumi.String("bar"),
					AccountPrivilege: pulumi.String("DDLOnly"),
				},
				&rds.AccountPrivilegeDbPrivilegeArgs{
					DbName:           pulumi.String("demo"),
					AccountPrivilege: pulumi.String("ReadWrite"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

RDS account privilege can be imported using the id, e.g.

```sh 

$ pulumi import volcengine:rds/accountPrivilege:AccountPrivilege default mysql-42b38c769c4b:account_name

```

func GetAccountPrivilege 

func GetAccountPrivilege(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AccountPrivilegeState, opts ...pulumi.ResourceOption) (*AccountPrivilege, error)

GetAccountPrivilege gets an existing AccountPrivilege 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 NewAccountPrivilege 

func NewAccountPrivilege(ctx *pulumi.Context,
	name string, args *AccountPrivilegeArgs, opts ...pulumi.ResourceOption) (*AccountPrivilege, error)

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

func (*AccountPrivilege) ElementType 

func (*AccountPrivilege) ElementType() reflect.Type

func (*AccountPrivilege) ToAccountPrivilegeOutput 

func (i *AccountPrivilege) ToAccountPrivilegeOutput() AccountPrivilegeOutput

func (*AccountPrivilege) ToAccountPrivilegeOutputWithContext 

func (i *AccountPrivilege) ToAccountPrivilegeOutputWithContext(ctx context.Context) AccountPrivilegeOutput

type AccountPrivilegeArgs 

type AccountPrivilegeArgs struct {
	// Database account name. The rules are as follows:
	// Unique name.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, or underscores (_).
	// The length is 2~32 characters.
	// The [keyword list](https://www.volcengine.com/docs/6313/66162) is disabled for database accounts, and certain reserved words, including root, admin, etc., cannot be used.
	AccountName pulumi.StringInput
	// The privileges of the account.
	DbPrivileges AccountPrivilegeDbPrivilegeArrayInput
	// The ID of the RDS instance.
	InstanceId pulumi.StringInput
}

The set of arguments for constructing a AccountPrivilege resource.

func (AccountPrivilegeArgs) ElementType 

func (AccountPrivilegeArgs) ElementType() reflect.Type

type AccountPrivilegeArray 

type AccountPrivilegeArray []AccountPrivilegeInput

func (AccountPrivilegeArray) ElementType 

func (AccountPrivilegeArray) ElementType() reflect.Type

func (AccountPrivilegeArray) ToAccountPrivilegeArrayOutput 

func (i AccountPrivilegeArray) ToAccountPrivilegeArrayOutput() AccountPrivilegeArrayOutput

func (AccountPrivilegeArray) ToAccountPrivilegeArrayOutputWithContext 

func (i AccountPrivilegeArray) ToAccountPrivilegeArrayOutputWithContext(ctx context.Context) AccountPrivilegeArrayOutput

type AccountPrivilegeArrayInput 

type AccountPrivilegeArrayInput interface {
	pulumi.Input

	ToAccountPrivilegeArrayOutput() AccountPrivilegeArrayOutput
	ToAccountPrivilegeArrayOutputWithContext(context.Context) AccountPrivilegeArrayOutput
}

AccountPrivilegeArrayInput is an input type that accepts AccountPrivilegeArray and AccountPrivilegeArrayOutput values. You can construct a concrete instance of `AccountPrivilegeArrayInput` via: 

AccountPrivilegeArray{ AccountPrivilegeArgs{...} }

type AccountPrivilegeArrayOutput 

type AccountPrivilegeArrayOutput struct{ *pulumi.OutputState }

func (AccountPrivilegeArrayOutput) ElementType 

func (AccountPrivilegeArrayOutput) ElementType() reflect.Type

func (AccountPrivilegeArrayOutput) Index 

func (o AccountPrivilegeArrayOutput) Index(i pulumi.IntInput) AccountPrivilegeOutput

func (AccountPrivilegeArrayOutput) ToAccountPrivilegeArrayOutput 

func (o AccountPrivilegeArrayOutput) ToAccountPrivilegeArrayOutput() AccountPrivilegeArrayOutput

func (AccountPrivilegeArrayOutput) ToAccountPrivilegeArrayOutputWithContext 

func (o AccountPrivilegeArrayOutput) ToAccountPrivilegeArrayOutputWithContext(ctx context.Context) AccountPrivilegeArrayOutput

type AccountPrivilegeDbPrivilege 

type AccountPrivilegeDbPrivilege struct {
	// The privilege type of the account.
	AccountPrivilege string `pulumi:"accountPrivilege"`
	// The privilege string of the account.
	AccountPrivilegeStr *string `pulumi:"accountPrivilegeStr"`
	// The name of database.
	DbName string `pulumi:"dbName"`
}

type AccountPrivilegeDbPrivilegeArgs 

type AccountPrivilegeDbPrivilegeArgs struct {
	// The privilege type of the account.
	AccountPrivilege pulumi.StringInput `pulumi:"accountPrivilege"`
	// The privilege string of the account.
	AccountPrivilegeStr pulumi.StringPtrInput `pulumi:"accountPrivilegeStr"`
	// The name of database.
	DbName pulumi.StringInput `pulumi:"dbName"`
}

func (AccountPrivilegeDbPrivilegeArgs) ElementType 

func (AccountPrivilegeDbPrivilegeArgs) ElementType() reflect.Type

func (AccountPrivilegeDbPrivilegeArgs) ToAccountPrivilegeDbPrivilegeOutput 

func (i AccountPrivilegeDbPrivilegeArgs) ToAccountPrivilegeDbPrivilegeOutput() AccountPrivilegeDbPrivilegeOutput

func (AccountPrivilegeDbPrivilegeArgs) ToAccountPrivilegeDbPrivilegeOutputWithContext 

func (i AccountPrivilegeDbPrivilegeArgs) ToAccountPrivilegeDbPrivilegeOutputWithContext(ctx context.Context) AccountPrivilegeDbPrivilegeOutput

type AccountPrivilegeDbPrivilegeArray 

type AccountPrivilegeDbPrivilegeArray []AccountPrivilegeDbPrivilegeInput

func (AccountPrivilegeDbPrivilegeArray) ElementType 

func (AccountPrivilegeDbPrivilegeArray) ElementType() reflect.Type

func (AccountPrivilegeDbPrivilegeArray) ToAccountPrivilegeDbPrivilegeArrayOutput 

func (i AccountPrivilegeDbPrivilegeArray) ToAccountPrivilegeDbPrivilegeArrayOutput() AccountPrivilegeDbPrivilegeArrayOutput

func (AccountPrivilegeDbPrivilegeArray) ToAccountPrivilegeDbPrivilegeArrayOutputWithContext 

func (i AccountPrivilegeDbPrivilegeArray) ToAccountPrivilegeDbPrivilegeArrayOutputWithContext(ctx context.Context) AccountPrivilegeDbPrivilegeArrayOutput

type AccountPrivilegeDbPrivilegeArrayInput 

type AccountPrivilegeDbPrivilegeArrayInput interface {
	pulumi.Input

	ToAccountPrivilegeDbPrivilegeArrayOutput() AccountPrivilegeDbPrivilegeArrayOutput
	ToAccountPrivilegeDbPrivilegeArrayOutputWithContext(context.Context) AccountPrivilegeDbPrivilegeArrayOutput
}

AccountPrivilegeDbPrivilegeArrayInput is an input type that accepts AccountPrivilegeDbPrivilegeArray and AccountPrivilegeDbPrivilegeArrayOutput values. You can construct a concrete instance of `AccountPrivilegeDbPrivilegeArrayInput` via: 

AccountPrivilegeDbPrivilegeArray{ AccountPrivilegeDbPrivilegeArgs{...} }

type AccountPrivilegeDbPrivilegeArrayOutput 

type AccountPrivilegeDbPrivilegeArrayOutput struct{ *pulumi.OutputState }

func (AccountPrivilegeDbPrivilegeArrayOutput) ElementType 

func (AccountPrivilegeDbPrivilegeArrayOutput) ElementType() reflect.Type

func (AccountPrivilegeDbPrivilegeArrayOutput) Index 

func (o AccountPrivilegeDbPrivilegeArrayOutput) Index(i pulumi.IntInput) AccountPrivilegeDbPrivilegeOutput

func (AccountPrivilegeDbPrivilegeArrayOutput) ToAccountPrivilegeDbPrivilegeArrayOutput 

func (o AccountPrivilegeDbPrivilegeArrayOutput) ToAccountPrivilegeDbPrivilegeArrayOutput() AccountPrivilegeDbPrivilegeArrayOutput

func (AccountPrivilegeDbPrivilegeArrayOutput) ToAccountPrivilegeDbPrivilegeArrayOutputWithContext 

func (o AccountPrivilegeDbPrivilegeArrayOutput) ToAccountPrivilegeDbPrivilegeArrayOutputWithContext(ctx context.Context) AccountPrivilegeDbPrivilegeArrayOutput

type AccountPrivilegeDbPrivilegeInput 

type AccountPrivilegeDbPrivilegeInput interface {
	pulumi.Input

	ToAccountPrivilegeDbPrivilegeOutput() AccountPrivilegeDbPrivilegeOutput
	ToAccountPrivilegeDbPrivilegeOutputWithContext(context.Context) AccountPrivilegeDbPrivilegeOutput
}

AccountPrivilegeDbPrivilegeInput is an input type that accepts AccountPrivilegeDbPrivilegeArgs and AccountPrivilegeDbPrivilegeOutput values. You can construct a concrete instance of `AccountPrivilegeDbPrivilegeInput` via: 

AccountPrivilegeDbPrivilegeArgs{...}

type AccountPrivilegeDbPrivilegeOutput 

type AccountPrivilegeDbPrivilegeOutput struct{ *pulumi.OutputState }

func (AccountPrivilegeDbPrivilegeOutput) AccountPrivilege 

func (o AccountPrivilegeDbPrivilegeOutput) AccountPrivilege() pulumi.StringOutput

The privilege type of the account.

func (AccountPrivilegeDbPrivilegeOutput) AccountPrivilegeStr 

func (o AccountPrivilegeDbPrivilegeOutput) AccountPrivilegeStr() pulumi.StringPtrOutput

The privilege string of the account.

func (AccountPrivilegeDbPrivilegeOutput) DbName 

func (o AccountPrivilegeDbPrivilegeOutput) DbName() pulumi.StringOutput

The name of database.

func (AccountPrivilegeDbPrivilegeOutput) ElementType 

func (AccountPrivilegeDbPrivilegeOutput) ElementType() reflect.Type

func (AccountPrivilegeDbPrivilegeOutput) ToAccountPrivilegeDbPrivilegeOutput 

func (o AccountPrivilegeDbPrivilegeOutput) ToAccountPrivilegeDbPrivilegeOutput() AccountPrivilegeDbPrivilegeOutput

func (AccountPrivilegeDbPrivilegeOutput) ToAccountPrivilegeDbPrivilegeOutputWithContext 

func (o AccountPrivilegeDbPrivilegeOutput) ToAccountPrivilegeDbPrivilegeOutputWithContext(ctx context.Context) AccountPrivilegeDbPrivilegeOutput

type AccountPrivilegeInput 

type AccountPrivilegeInput interface {
	pulumi.Input

	ToAccountPrivilegeOutput() AccountPrivilegeOutput
	ToAccountPrivilegeOutputWithContext(ctx context.Context) AccountPrivilegeOutput
}

type AccountPrivilegeMap 

type AccountPrivilegeMap map[string]AccountPrivilegeInput

func (AccountPrivilegeMap) ElementType 

func (AccountPrivilegeMap) ElementType() reflect.Type

func (AccountPrivilegeMap) ToAccountPrivilegeMapOutput 

func (i AccountPrivilegeMap) ToAccountPrivilegeMapOutput() AccountPrivilegeMapOutput

func (AccountPrivilegeMap) ToAccountPrivilegeMapOutputWithContext 

func (i AccountPrivilegeMap) ToAccountPrivilegeMapOutputWithContext(ctx context.Context) AccountPrivilegeMapOutput

type AccountPrivilegeMapInput 

type AccountPrivilegeMapInput interface {
	pulumi.Input

	ToAccountPrivilegeMapOutput() AccountPrivilegeMapOutput
	ToAccountPrivilegeMapOutputWithContext(context.Context) AccountPrivilegeMapOutput
}

AccountPrivilegeMapInput is an input type that accepts AccountPrivilegeMap and AccountPrivilegeMapOutput values. You can construct a concrete instance of `AccountPrivilegeMapInput` via: 

AccountPrivilegeMap{ "key": AccountPrivilegeArgs{...} }

type AccountPrivilegeMapOutput 

type AccountPrivilegeMapOutput struct{ *pulumi.OutputState }

func (AccountPrivilegeMapOutput) ElementType 

func (AccountPrivilegeMapOutput) ElementType() reflect.Type

func (AccountPrivilegeMapOutput) MapIndex 

func (o AccountPrivilegeMapOutput) MapIndex(k pulumi.StringInput) AccountPrivilegeOutput

func (AccountPrivilegeMapOutput) ToAccountPrivilegeMapOutput 

func (o AccountPrivilegeMapOutput) ToAccountPrivilegeMapOutput() AccountPrivilegeMapOutput

func (AccountPrivilegeMapOutput) ToAccountPrivilegeMapOutputWithContext 

func (o AccountPrivilegeMapOutput) ToAccountPrivilegeMapOutputWithContext(ctx context.Context) AccountPrivilegeMapOutput

type AccountPrivilegeOutput 

type AccountPrivilegeOutput struct{ *pulumi.OutputState }

func (AccountPrivilegeOutput) AccountName 

func (o AccountPrivilegeOutput) AccountName() pulumi.StringOutput

Database account name. The rules are as follows: Unique name. Start with a letter and end with a letter or number. Consists of lowercase letters, numbers, or underscores (_). The length is 2~32 characters. The [keyword list](https://www.volcengine.com/docs/6313/66162) is disabled for database accounts, and certain reserved words, including root, admin, etc., cannot be used.

func (AccountPrivilegeOutput) DbPrivileges 

func (o AccountPrivilegeOutput) DbPrivileges() AccountPrivilegeDbPrivilegeArrayOutput

The privileges of the account.

func (AccountPrivilegeOutput) ElementType 

func (AccountPrivilegeOutput) ElementType() reflect.Type

func (AccountPrivilegeOutput) InstanceId 

func (o AccountPrivilegeOutput) InstanceId() pulumi.StringOutput

The ID of the RDS instance.

func (AccountPrivilegeOutput) ToAccountPrivilegeOutput 

func (o AccountPrivilegeOutput) ToAccountPrivilegeOutput() AccountPrivilegeOutput

func (AccountPrivilegeOutput) ToAccountPrivilegeOutputWithContext 

func (o AccountPrivilegeOutput) ToAccountPrivilegeOutputWithContext(ctx context.Context) AccountPrivilegeOutput

type AccountPrivilegeState 

type AccountPrivilegeState struct {
	// Database account name. The rules are as follows:
	// Unique name.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, or underscores (_).
	// The length is 2~32 characters.
	// The [keyword list](https://www.volcengine.com/docs/6313/66162) is disabled for database accounts, and certain reserved words, including root, admin, etc., cannot be used.
	AccountName pulumi.StringPtrInput
	// The privileges of the account.
	DbPrivileges AccountPrivilegeDbPrivilegeArrayInput
	// The ID of the RDS instance.
	InstanceId pulumi.StringPtrInput
}

func (AccountPrivilegeState) ElementType 

func (AccountPrivilegeState) ElementType() reflect.Type

type AccountState 

type AccountState struct {
	// Database account name. The rules are as follows:
	// Unique name.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, or underscores (_).
	// The length is 2~32 characters.
	// The [keyword list](https://www.volcengine.com/docs/6313/66162) is disabled for database accounts, and certain reserved words, including root, admin, etc., cannot be used.
	AccountName pulumi.StringPtrInput
	// The password of the database account.
	// illustrate
	// Cannot start with `!` or `@`.
	// The length is 8~32 characters.
	// It consists of any three of uppercase letters, lowercase letters, numbers, and special characters.
	// The special characters are `!@#$%^*()_+-=`. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	AccountPassword pulumi.StringPtrInput
	// Database account type, value:
	// Super: A high-privilege account. Only one database account can be created for an instance.
	// Normal: An account with ordinary privileges.
	AccountType pulumi.StringPtrInput
	// The ID of the RDS instance.
	InstanceId pulumi.StringPtrInput
}

func (AccountState) ElementType 

func (AccountState) ElementType() reflect.Type

type AccountsArgs 

type AccountsArgs struct {
	// The name of the database account.
	AccountName *string `pulumi:"accountName"`
	// The id of the RDS instance.
	InstanceId string `pulumi:"instanceId"`
	// A Name Regex of database account.
	NameRegex *string `pulumi:"nameRegex"`
	// File name where to save data source results.
	OutputFile *string `pulumi:"outputFile"`
}

A collection of arguments for invoking Accounts.

type AccountsOutputArgs 

type AccountsOutputArgs struct {
	// The name of the database account.
	AccountName pulumi.StringPtrInput `pulumi:"accountName"`
	// The id of the RDS instance.
	InstanceId pulumi.StringInput `pulumi:"instanceId"`
	// A Name Regex of database account.
	NameRegex pulumi.StringPtrInput `pulumi:"nameRegex"`
	// File name where to save data source results.
	OutputFile pulumi.StringPtrInput `pulumi:"outputFile"`
}

A collection of arguments for invoking Accounts.

func (AccountsOutputArgs) ElementType 

func (AccountsOutputArgs) ElementType() reflect.Type

type AccountsRdsAccount 

type AccountsRdsAccount struct {
	// The name of the database account.
	AccountName string `pulumi:"accountName"`
	// The status of the database account.
	AccountStatus string `pulumi:"accountStatus"`
	// The type of the database account.
	AccountType string `pulumi:"accountType"`
	// The privilege detail list of RDS instance account.
	DbPrivileges []AccountsRdsAccountDbPrivilege `pulumi:"dbPrivileges"`
	// The ID of the RDS instance account.
	Id string `pulumi:"id"`
}

type AccountsRdsAccountArgs 

type AccountsRdsAccountArgs struct {
	// The name of the database account.
	AccountName pulumi.StringInput `pulumi:"accountName"`
	// The status of the database account.
	AccountStatus pulumi.StringInput `pulumi:"accountStatus"`
	// The type of the database account.
	AccountType pulumi.StringInput `pulumi:"accountType"`
	// The privilege detail list of RDS instance account.
	DbPrivileges AccountsRdsAccountDbPrivilegeArrayInput `pulumi:"dbPrivileges"`
	// The ID of the RDS instance account.
	Id pulumi.StringInput `pulumi:"id"`
}

func (AccountsRdsAccountArgs) ElementType 

func (AccountsRdsAccountArgs) ElementType() reflect.Type

func (AccountsRdsAccountArgs) ToAccountsRdsAccountOutput 

func (i AccountsRdsAccountArgs) ToAccountsRdsAccountOutput() AccountsRdsAccountOutput

func (AccountsRdsAccountArgs) ToAccountsRdsAccountOutputWithContext 

func (i AccountsRdsAccountArgs) ToAccountsRdsAccountOutputWithContext(ctx context.Context) AccountsRdsAccountOutput

type AccountsRdsAccountArray 

type AccountsRdsAccountArray []AccountsRdsAccountInput

func (AccountsRdsAccountArray) ElementType 

func (AccountsRdsAccountArray) ElementType() reflect.Type

func (AccountsRdsAccountArray) ToAccountsRdsAccountArrayOutput 

func (i AccountsRdsAccountArray) ToAccountsRdsAccountArrayOutput() AccountsRdsAccountArrayOutput

func (AccountsRdsAccountArray) ToAccountsRdsAccountArrayOutputWithContext 

func (i AccountsRdsAccountArray) ToAccountsRdsAccountArrayOutputWithContext(ctx context.Context) AccountsRdsAccountArrayOutput

type AccountsRdsAccountArrayInput 

type AccountsRdsAccountArrayInput interface {
	pulumi.Input

	ToAccountsRdsAccountArrayOutput() AccountsRdsAccountArrayOutput
	ToAccountsRdsAccountArrayOutputWithContext(context.Context) AccountsRdsAccountArrayOutput
}

AccountsRdsAccountArrayInput is an input type that accepts AccountsRdsAccountArray and AccountsRdsAccountArrayOutput values. You can construct a concrete instance of `AccountsRdsAccountArrayInput` via: 

AccountsRdsAccountArray{ AccountsRdsAccountArgs{...} }

type AccountsRdsAccountArrayOutput 

type AccountsRdsAccountArrayOutput struct{ *pulumi.OutputState }

func (AccountsRdsAccountArrayOutput) ElementType 

func (AccountsRdsAccountArrayOutput) ElementType() reflect.Type

func (AccountsRdsAccountArrayOutput) Index 

func (o AccountsRdsAccountArrayOutput) Index(i pulumi.IntInput) AccountsRdsAccountOutput

func (AccountsRdsAccountArrayOutput) ToAccountsRdsAccountArrayOutput 

func (o AccountsRdsAccountArrayOutput) ToAccountsRdsAccountArrayOutput() AccountsRdsAccountArrayOutput

func (AccountsRdsAccountArrayOutput) ToAccountsRdsAccountArrayOutputWithContext 

func (o AccountsRdsAccountArrayOutput) ToAccountsRdsAccountArrayOutputWithContext(ctx context.Context) AccountsRdsAccountArrayOutput

type AccountsRdsAccountDbPrivilege 

type AccountsRdsAccountDbPrivilege struct {
	// The privilege type of the account.
	AccountPrivilege string `pulumi:"accountPrivilege"`
	// The privilege string of the account.
	AccountPrivilegeStr string `pulumi:"accountPrivilegeStr"`
	// The name of database.
	DbName string `pulumi:"dbName"`
}

type AccountsRdsAccountDbPrivilegeArgs 

type AccountsRdsAccountDbPrivilegeArgs struct {
	// The privilege type of the account.
	AccountPrivilege pulumi.StringInput `pulumi:"accountPrivilege"`
	// The privilege string of the account.
	AccountPrivilegeStr pulumi.StringInput `pulumi:"accountPrivilegeStr"`
	// The name of database.
	DbName pulumi.StringInput `pulumi:"dbName"`
}

func (AccountsRdsAccountDbPrivilegeArgs) ElementType 

func (AccountsRdsAccountDbPrivilegeArgs) ElementType() reflect.Type

func (AccountsRdsAccountDbPrivilegeArgs) ToAccountsRdsAccountDbPrivilegeOutput 

func (i AccountsRdsAccountDbPrivilegeArgs) ToAccountsRdsAccountDbPrivilegeOutput() AccountsRdsAccountDbPrivilegeOutput

func (AccountsRdsAccountDbPrivilegeArgs) ToAccountsRdsAccountDbPrivilegeOutputWithContext 

func (i AccountsRdsAccountDbPrivilegeArgs) ToAccountsRdsAccountDbPrivilegeOutputWithContext(ctx context.Context) AccountsRdsAccountDbPrivilegeOutput

type AccountsRdsAccountDbPrivilegeArray 

type AccountsRdsAccountDbPrivilegeArray []AccountsRdsAccountDbPrivilegeInput

func (AccountsRdsAccountDbPrivilegeArray) ElementType 

func (AccountsRdsAccountDbPrivilegeArray) ElementType() reflect.Type

func (AccountsRdsAccountDbPrivilegeArray) ToAccountsRdsAccountDbPrivilegeArrayOutput 

func (i AccountsRdsAccountDbPrivilegeArray) ToAccountsRdsAccountDbPrivilegeArrayOutput() AccountsRdsAccountDbPrivilegeArrayOutput

func (AccountsRdsAccountDbPrivilegeArray) ToAccountsRdsAccountDbPrivilegeArrayOutputWithContext 

func (i AccountsRdsAccountDbPrivilegeArray) ToAccountsRdsAccountDbPrivilegeArrayOutputWithContext(ctx context.Context) AccountsRdsAccountDbPrivilegeArrayOutput

type AccountsRdsAccountDbPrivilegeArrayInput 

type AccountsRdsAccountDbPrivilegeArrayInput interface {
	pulumi.Input

	ToAccountsRdsAccountDbPrivilegeArrayOutput() AccountsRdsAccountDbPrivilegeArrayOutput
	ToAccountsRdsAccountDbPrivilegeArrayOutputWithContext(context.Context) AccountsRdsAccountDbPrivilegeArrayOutput
}

AccountsRdsAccountDbPrivilegeArrayInput is an input type that accepts AccountsRdsAccountDbPrivilegeArray and AccountsRdsAccountDbPrivilegeArrayOutput values. You can construct a concrete instance of `AccountsRdsAccountDbPrivilegeArrayInput` via: 

AccountsRdsAccountDbPrivilegeArray{ AccountsRdsAccountDbPrivilegeArgs{...} }

type AccountsRdsAccountDbPrivilegeArrayOutput 

type AccountsRdsAccountDbPrivilegeArrayOutput struct{ *pulumi.OutputState }

func (AccountsRdsAccountDbPrivilegeArrayOutput) ElementType 

func (AccountsRdsAccountDbPrivilegeArrayOutput) ElementType() reflect.Type

func (AccountsRdsAccountDbPrivilegeArrayOutput) Index 

func (o AccountsRdsAccountDbPrivilegeArrayOutput) Index(i pulumi.IntInput) AccountsRdsAccountDbPrivilegeOutput

func (AccountsRdsAccountDbPrivilegeArrayOutput) ToAccountsRdsAccountDbPrivilegeArrayOutput 

func (o AccountsRdsAccountDbPrivilegeArrayOutput) ToAccountsRdsAccountDbPrivilegeArrayOutput() AccountsRdsAccountDbPrivilegeArrayOutput

func (AccountsRdsAccountDbPrivilegeArrayOutput) ToAccountsRdsAccountDbPrivilegeArrayOutputWithContext 

func (o AccountsRdsAccountDbPrivilegeArrayOutput) ToAccountsRdsAccountDbPrivilegeArrayOutputWithContext(ctx context.Context) AccountsRdsAccountDbPrivilegeArrayOutput

type AccountsRdsAccountDbPrivilegeInput 

type AccountsRdsAccountDbPrivilegeInput interface {
	pulumi.Input

	ToAccountsRdsAccountDbPrivilegeOutput() AccountsRdsAccountDbPrivilegeOutput
	ToAccountsRdsAccountDbPrivilegeOutputWithContext(context.Context) AccountsRdsAccountDbPrivilegeOutput
}

AccountsRdsAccountDbPrivilegeInput is an input type that accepts AccountsRdsAccountDbPrivilegeArgs and AccountsRdsAccountDbPrivilegeOutput values. You can construct a concrete instance of `AccountsRdsAccountDbPrivilegeInput` via: 

AccountsRdsAccountDbPrivilegeArgs{...}

type AccountsRdsAccountDbPrivilegeOutput 

type AccountsRdsAccountDbPrivilegeOutput struct{ *pulumi.OutputState }

func (AccountsRdsAccountDbPrivilegeOutput) AccountPrivilege 

func (o AccountsRdsAccountDbPrivilegeOutput) AccountPrivilege() pulumi.StringOutput

The privilege type of the account.

func (AccountsRdsAccountDbPrivilegeOutput) AccountPrivilegeStr 

func (o AccountsRdsAccountDbPrivilegeOutput) AccountPrivilegeStr() pulumi.StringOutput

The privilege string of the account.

func (AccountsRdsAccountDbPrivilegeOutput) DbName 

func (o AccountsRdsAccountDbPrivilegeOutput) DbName() pulumi.StringOutput

The name of database.

func (AccountsRdsAccountDbPrivilegeOutput) ElementType 

func (AccountsRdsAccountDbPrivilegeOutput) ElementType() reflect.Type

func (AccountsRdsAccountDbPrivilegeOutput) ToAccountsRdsAccountDbPrivilegeOutput 

func (o AccountsRdsAccountDbPrivilegeOutput) ToAccountsRdsAccountDbPrivilegeOutput() AccountsRdsAccountDbPrivilegeOutput

func (AccountsRdsAccountDbPrivilegeOutput) ToAccountsRdsAccountDbPrivilegeOutputWithContext 

func (o AccountsRdsAccountDbPrivilegeOutput) ToAccountsRdsAccountDbPrivilegeOutputWithContext(ctx context.Context) AccountsRdsAccountDbPrivilegeOutput

type AccountsRdsAccountInput 

type AccountsRdsAccountInput interface {
	pulumi.Input

	ToAccountsRdsAccountOutput() AccountsRdsAccountOutput
	ToAccountsRdsAccountOutputWithContext(context.Context) AccountsRdsAccountOutput
}

AccountsRdsAccountInput is an input type that accepts AccountsRdsAccountArgs and AccountsRdsAccountOutput values. You can construct a concrete instance of `AccountsRdsAccountInput` via: 

AccountsRdsAccountArgs{...}

type AccountsRdsAccountOutput 

type AccountsRdsAccountOutput struct{ *pulumi.OutputState }

func (AccountsRdsAccountOutput) AccountName 

func (o AccountsRdsAccountOutput) AccountName() pulumi.StringOutput

The name of the database account.

func (AccountsRdsAccountOutput) AccountStatus 

func (o AccountsRdsAccountOutput) AccountStatus() pulumi.StringOutput

The status of the database account.

func (AccountsRdsAccountOutput) AccountType 

func (o AccountsRdsAccountOutput) AccountType() pulumi.StringOutput

The type of the database account.

func (AccountsRdsAccountOutput) DbPrivileges 

func (o AccountsRdsAccountOutput) DbPrivileges() AccountsRdsAccountDbPrivilegeArrayOutput

The privilege detail list of RDS instance account.

func (AccountsRdsAccountOutput) ElementType 

func (AccountsRdsAccountOutput) ElementType() reflect.Type

func (AccountsRdsAccountOutput) Id 

func (o AccountsRdsAccountOutput) Id() pulumi.StringOutput

The ID of the RDS instance account.

func (AccountsRdsAccountOutput) ToAccountsRdsAccountOutput 

func (o AccountsRdsAccountOutput) ToAccountsRdsAccountOutput() AccountsRdsAccountOutput

func (AccountsRdsAccountOutput) ToAccountsRdsAccountOutputWithContext 

func (o AccountsRdsAccountOutput) ToAccountsRdsAccountOutputWithContext(ctx context.Context) AccountsRdsAccountOutput

type AccountsResult 

type AccountsResult struct {
	// The name of the database account.
	AccountName *string `pulumi:"accountName"`
	// The provider-assigned unique ID for this managed resource.
	Id         string  `pulumi:"id"`
	InstanceId string  `pulumi:"instanceId"`
	NameRegex  *string `pulumi:"nameRegex"`
	OutputFile *string `pulumi:"outputFile"`
	// The collection of RDS instance account query.
	RdsAccounts []AccountsRdsAccount `pulumi:"rdsAccounts"`
	// The total count of database account query.
	TotalCount int `pulumi:"totalCount"`
}

A collection of values returned by Accounts.

func Accounts 

func Accounts(ctx *pulumi.Context, args *AccountsArgs, opts ...pulumi.InvokeOption) (*AccountsResult, error)

(Deprecated! Recommend use volcengine_rds_mysql_*** replace) Use this data source to query detailed information of rds accounts ## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.Accounts(ctx, &rds.AccountsArgs{
			InstanceId: "mysql-0fdd3bab2e7c",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type AccountsResultOutput 

type AccountsResultOutput struct{ *pulumi.OutputState }

A collection of values returned by Accounts.

func AccountsOutput 

func AccountsOutput(ctx *pulumi.Context, args AccountsOutputArgs, opts ...pulumi.InvokeOption) AccountsResultOutput

func (AccountsResultOutput) AccountName 

func (o AccountsResultOutput) AccountName() pulumi.StringPtrOutput

The name of the database account.

func (AccountsResultOutput) ElementType 

func (AccountsResultOutput) ElementType() reflect.Type

func (AccountsResultOutput) Id 

func (o AccountsResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (AccountsResultOutput) InstanceId 

func (o AccountsResultOutput) InstanceId() pulumi.StringOutput

func (AccountsResultOutput) NameRegex 

func (o AccountsResultOutput) NameRegex() pulumi.StringPtrOutput

func (AccountsResultOutput) OutputFile 

func (o AccountsResultOutput) OutputFile() pulumi.StringPtrOutput

func (AccountsResultOutput) RdsAccounts 

func (o AccountsResultOutput) RdsAccounts() AccountsRdsAccountArrayOutput

The collection of RDS instance account query.

func (AccountsResultOutput) ToAccountsResultOutput 

func (o AccountsResultOutput) ToAccountsResultOutput() AccountsResultOutput

func (AccountsResultOutput) ToAccountsResultOutputWithContext 

func (o AccountsResultOutput) ToAccountsResultOutputWithContext(ctx context.Context) AccountsResultOutput

func (AccountsResultOutput) TotalCount 

func (o AccountsResultOutput) TotalCount() pulumi.IntOutput

The total count of database account query.

type Database 

type Database struct {
	pulumi.CustomResourceState

	// Database character set. Currently supported character sets include: utf8, utf8mb4, latin1, ascii.
	CharacterSetName pulumi.StringOutput `pulumi:"characterSetName"`
	// Name database.
	// illustrate:
	// Unique name.
	// The length is 2~64 characters.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, and underscores (_) or dashes (-).
	// Database names are disabled [keywords](https://www.volcengine.com/docs/6313/66162).
	DbName pulumi.StringOutput `pulumi:"dbName"`
	// The ID of the RDS instance.
	InstanceId pulumi.StringOutput `pulumi:"instanceId"`
}

(Deprecated! Recommend use volcengine_rds_mysql_*** replace) Provides a resource to manage rds database ## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.NewDatabase(ctx, "foo", &rds.DatabaseArgs{
			CharacterSetName: pulumi.String("utf8mb4"),
			DbName:           pulumi.String("foo"),
			InstanceId:       pulumi.String("mysql-0fdd3bab2e7c"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Database can be imported using the id, e.g.

```sh 

$ pulumi import volcengine:rds/database:Database default mysql-42b38c769c4b:dbname

```

func GetDatabase 

func GetDatabase(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DatabaseState, opts ...pulumi.ResourceOption) (*Database, error)

GetDatabase gets an existing Database 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 NewDatabase 

func NewDatabase(ctx *pulumi.Context,
	name string, args *DatabaseArgs, opts ...pulumi.ResourceOption) (*Database, error)

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

func (*Database) ElementType 

func (*Database) ElementType() reflect.Type

func (*Database) ToDatabaseOutput 

func (i *Database) ToDatabaseOutput() DatabaseOutput

func (*Database) ToDatabaseOutputWithContext 

func (i *Database) ToDatabaseOutputWithContext(ctx context.Context) DatabaseOutput

type DatabaseArgs 

type DatabaseArgs struct {
	// Database character set. Currently supported character sets include: utf8, utf8mb4, latin1, ascii.
	CharacterSetName pulumi.StringInput
	// Name database.
	// illustrate:
	// Unique name.
	// The length is 2~64 characters.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, and underscores (_) or dashes (-).
	// Database names are disabled [keywords](https://www.volcengine.com/docs/6313/66162).
	DbName pulumi.StringInput
	// The ID of the RDS instance.
	InstanceId pulumi.StringInput
}

The set of arguments for constructing a Database resource.

func (DatabaseArgs) ElementType 

func (DatabaseArgs) ElementType() reflect.Type

type DatabaseArray 

type DatabaseArray []DatabaseInput

func (DatabaseArray) ElementType 

func (DatabaseArray) ElementType() reflect.Type

func (DatabaseArray) ToDatabaseArrayOutput 

func (i DatabaseArray) ToDatabaseArrayOutput() DatabaseArrayOutput

func (DatabaseArray) ToDatabaseArrayOutputWithContext 

func (i DatabaseArray) ToDatabaseArrayOutputWithContext(ctx context.Context) DatabaseArrayOutput

type DatabaseArrayInput 

type DatabaseArrayInput interface {
	pulumi.Input

	ToDatabaseArrayOutput() DatabaseArrayOutput
	ToDatabaseArrayOutputWithContext(context.Context) DatabaseArrayOutput
}

DatabaseArrayInput is an input type that accepts DatabaseArray and DatabaseArrayOutput values. You can construct a concrete instance of `DatabaseArrayInput` via: 

DatabaseArray{ DatabaseArgs{...} }

type DatabaseArrayOutput 

type DatabaseArrayOutput struct{ *pulumi.OutputState }

func (DatabaseArrayOutput) ElementType 

func (DatabaseArrayOutput) ElementType() reflect.Type

func (DatabaseArrayOutput) Index 

func (o DatabaseArrayOutput) Index(i pulumi.IntInput) DatabaseOutput

func (DatabaseArrayOutput) ToDatabaseArrayOutput 

func (o DatabaseArrayOutput) ToDatabaseArrayOutput() DatabaseArrayOutput

func (DatabaseArrayOutput) ToDatabaseArrayOutputWithContext 

func (o DatabaseArrayOutput) ToDatabaseArrayOutputWithContext(ctx context.Context) DatabaseArrayOutput

type DatabaseInput 

type DatabaseInput interface {
	pulumi.Input

	ToDatabaseOutput() DatabaseOutput
	ToDatabaseOutputWithContext(ctx context.Context) DatabaseOutput
}

type DatabaseMap 

type DatabaseMap map[string]DatabaseInput

func (DatabaseMap) ElementType 

func (DatabaseMap) ElementType() reflect.Type

func (DatabaseMap) ToDatabaseMapOutput 

func (i DatabaseMap) ToDatabaseMapOutput() DatabaseMapOutput

func (DatabaseMap) ToDatabaseMapOutputWithContext 

func (i DatabaseMap) ToDatabaseMapOutputWithContext(ctx context.Context) DatabaseMapOutput

type DatabaseMapInput 

type DatabaseMapInput interface {
	pulumi.Input

	ToDatabaseMapOutput() DatabaseMapOutput
	ToDatabaseMapOutputWithContext(context.Context) DatabaseMapOutput
}

DatabaseMapInput is an input type that accepts DatabaseMap and DatabaseMapOutput values. You can construct a concrete instance of `DatabaseMapInput` via: 

DatabaseMap{ "key": DatabaseArgs{...} }

type DatabaseMapOutput 

type DatabaseMapOutput struct{ *pulumi.OutputState }

func (DatabaseMapOutput) ElementType 

func (DatabaseMapOutput) ElementType() reflect.Type

func (DatabaseMapOutput) MapIndex 

func (o DatabaseMapOutput) MapIndex(k pulumi.StringInput) DatabaseOutput

func (DatabaseMapOutput) ToDatabaseMapOutput 

func (o DatabaseMapOutput) ToDatabaseMapOutput() DatabaseMapOutput

func (DatabaseMapOutput) ToDatabaseMapOutputWithContext 

func (o DatabaseMapOutput) ToDatabaseMapOutputWithContext(ctx context.Context) DatabaseMapOutput

type DatabaseOutput 

type DatabaseOutput struct{ *pulumi.OutputState }

func (DatabaseOutput) CharacterSetName 

func (o DatabaseOutput) CharacterSetName() pulumi.StringOutput

Database character set. Currently supported character sets include: utf8, utf8mb4, latin1, ascii.

func (DatabaseOutput) DbName 

func (o DatabaseOutput) DbName() pulumi.StringOutput

Name database. illustrate: Unique name. The length is 2~64 characters. Start with a letter and end with a letter or number. Consists of lowercase letters, numbers, and underscores (_) or dashes (-). Database names are disabled [keywords](https://www.volcengine.com/docs/6313/66162).

func (DatabaseOutput) ElementType 

func (DatabaseOutput) ElementType() reflect.Type

func (DatabaseOutput) InstanceId 

func (o DatabaseOutput) InstanceId() pulumi.StringOutput

The ID of the RDS instance.

func (DatabaseOutput) ToDatabaseOutput 

func (o DatabaseOutput) ToDatabaseOutput() DatabaseOutput

func (DatabaseOutput) ToDatabaseOutputWithContext 

func (o DatabaseOutput) ToDatabaseOutputWithContext(ctx context.Context) DatabaseOutput

type DatabaseState 

type DatabaseState struct {
	// Database character set. Currently supported character sets include: utf8, utf8mb4, latin1, ascii.
	CharacterSetName pulumi.StringPtrInput
	// Name database.
	// illustrate:
	// Unique name.
	// The length is 2~64 characters.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, and underscores (_) or dashes (-).
	// Database names are disabled [keywords](https://www.volcengine.com/docs/6313/66162).
	DbName pulumi.StringPtrInput
	// The ID of the RDS instance.
	InstanceId pulumi.StringPtrInput
}

func (DatabaseState) ElementType 

func (DatabaseState) ElementType() reflect.Type

type DatabasesArgs 

type DatabasesArgs struct {
	// The status of the RDS database.
	DbStatus *string `pulumi:"dbStatus"`
	// The id of the RDS instance.
	InstanceId string `pulumi:"instanceId"`
	// A Name Regex of RDS database.
	NameRegex *string `pulumi:"nameRegex"`
	// File name where to save data source results.
	OutputFile *string `pulumi:"outputFile"`
}

A collection of arguments for invoking Databases.

type DatabasesOutputArgs 

type DatabasesOutputArgs struct {
	// The status of the RDS database.
	DbStatus pulumi.StringPtrInput `pulumi:"dbStatus"`
	// The id of the RDS instance.
	InstanceId pulumi.StringInput `pulumi:"instanceId"`
	// A Name Regex of RDS database.
	NameRegex pulumi.StringPtrInput `pulumi:"nameRegex"`
	// File name where to save data source results.
	OutputFile pulumi.StringPtrInput `pulumi:"outputFile"`
}

A collection of arguments for invoking Databases.

func (DatabasesOutputArgs) ElementType 

func (DatabasesOutputArgs) ElementType() reflect.Type

type DatabasesRdsDatabase 

type DatabasesRdsDatabase struct {
	// The account names of the RDS database.
	AccountNames string `pulumi:"accountNames"`
	// The character set of the RDS database.
	CharacterSetName string `pulumi:"characterSetName"`
	// The name of the RDS database.
	DbName string `pulumi:"dbName"`
	// The status of the RDS database.
	DbStatus string `pulumi:"dbStatus"`
	// The ID of the RDS database.
	Id string `pulumi:"id"`
}

type DatabasesRdsDatabaseArgs 

type DatabasesRdsDatabaseArgs struct {
	// The account names of the RDS database.
	AccountNames pulumi.StringInput `pulumi:"accountNames"`
	// The character set of the RDS database.
	CharacterSetName pulumi.StringInput `pulumi:"characterSetName"`
	// The name of the RDS database.
	DbName pulumi.StringInput `pulumi:"dbName"`
	// The status of the RDS database.
	DbStatus pulumi.StringInput `pulumi:"dbStatus"`
	// The ID of the RDS database.
	Id pulumi.StringInput `pulumi:"id"`
}

func (DatabasesRdsDatabaseArgs) ElementType 

func (DatabasesRdsDatabaseArgs) ElementType() reflect.Type

func (DatabasesRdsDatabaseArgs) ToDatabasesRdsDatabaseOutput 

func (i DatabasesRdsDatabaseArgs) ToDatabasesRdsDatabaseOutput() DatabasesRdsDatabaseOutput

func (DatabasesRdsDatabaseArgs) ToDatabasesRdsDatabaseOutputWithContext 

func (i DatabasesRdsDatabaseArgs) ToDatabasesRdsDatabaseOutputWithContext(ctx context.Context) DatabasesRdsDatabaseOutput

type DatabasesRdsDatabaseArray 

type DatabasesRdsDatabaseArray []DatabasesRdsDatabaseInput

func (DatabasesRdsDatabaseArray) ElementType 

func (DatabasesRdsDatabaseArray) ElementType() reflect.Type

func (DatabasesRdsDatabaseArray) ToDatabasesRdsDatabaseArrayOutput 

func (i DatabasesRdsDatabaseArray) ToDatabasesRdsDatabaseArrayOutput() DatabasesRdsDatabaseArrayOutput

func (DatabasesRdsDatabaseArray) ToDatabasesRdsDatabaseArrayOutputWithContext 

func (i DatabasesRdsDatabaseArray) ToDatabasesRdsDatabaseArrayOutputWithContext(ctx context.Context) DatabasesRdsDatabaseArrayOutput

type DatabasesRdsDatabaseArrayInput 

type DatabasesRdsDatabaseArrayInput interface {
	pulumi.Input

	ToDatabasesRdsDatabaseArrayOutput() DatabasesRdsDatabaseArrayOutput
	ToDatabasesRdsDatabaseArrayOutputWithContext(context.Context) DatabasesRdsDatabaseArrayOutput
}

DatabasesRdsDatabaseArrayInput is an input type that accepts DatabasesRdsDatabaseArray and DatabasesRdsDatabaseArrayOutput values. You can construct a concrete instance of `DatabasesRdsDatabaseArrayInput` via: 

DatabasesRdsDatabaseArray{ DatabasesRdsDatabaseArgs{...} }

type DatabasesRdsDatabaseArrayOutput 

type DatabasesRdsDatabaseArrayOutput struct{ *pulumi.OutputState }

func (DatabasesRdsDatabaseArrayOutput) ElementType 

func (DatabasesRdsDatabaseArrayOutput) ElementType() reflect.Type

func (DatabasesRdsDatabaseArrayOutput) Index 

func (o DatabasesRdsDatabaseArrayOutput) Index(i pulumi.IntInput) DatabasesRdsDatabaseOutput

func (DatabasesRdsDatabaseArrayOutput) ToDatabasesRdsDatabaseArrayOutput 

func (o DatabasesRdsDatabaseArrayOutput) ToDatabasesRdsDatabaseArrayOutput() DatabasesRdsDatabaseArrayOutput

func (DatabasesRdsDatabaseArrayOutput) ToDatabasesRdsDatabaseArrayOutputWithContext 

func (o DatabasesRdsDatabaseArrayOutput) ToDatabasesRdsDatabaseArrayOutputWithContext(ctx context.Context) DatabasesRdsDatabaseArrayOutput

type DatabasesRdsDatabaseInput 

type DatabasesRdsDatabaseInput interface {
	pulumi.Input

	ToDatabasesRdsDatabaseOutput() DatabasesRdsDatabaseOutput
	ToDatabasesRdsDatabaseOutputWithContext(context.Context) DatabasesRdsDatabaseOutput
}

DatabasesRdsDatabaseInput is an input type that accepts DatabasesRdsDatabaseArgs and DatabasesRdsDatabaseOutput values. You can construct a concrete instance of `DatabasesRdsDatabaseInput` via: 

DatabasesRdsDatabaseArgs{...}

type DatabasesRdsDatabaseOutput 

type DatabasesRdsDatabaseOutput struct{ *pulumi.OutputState }

func (DatabasesRdsDatabaseOutput) AccountNames 

func (o DatabasesRdsDatabaseOutput) AccountNames() pulumi.StringOutput

The account names of the RDS database.

func (DatabasesRdsDatabaseOutput) CharacterSetName 

func (o DatabasesRdsDatabaseOutput) CharacterSetName() pulumi.StringOutput

The character set of the RDS database.

func (DatabasesRdsDatabaseOutput) DbName 

func (o DatabasesRdsDatabaseOutput) DbName() pulumi.StringOutput

The name of the RDS database.

func (DatabasesRdsDatabaseOutput) DbStatus 

func (o DatabasesRdsDatabaseOutput) DbStatus() pulumi.StringOutput

The status of the RDS database.

func (DatabasesRdsDatabaseOutput) ElementType 

func (DatabasesRdsDatabaseOutput) ElementType() reflect.Type

func (DatabasesRdsDatabaseOutput) Id 

func (o DatabasesRdsDatabaseOutput) Id() pulumi.StringOutput

The ID of the RDS database.

func (DatabasesRdsDatabaseOutput) ToDatabasesRdsDatabaseOutput 

func (o DatabasesRdsDatabaseOutput) ToDatabasesRdsDatabaseOutput() DatabasesRdsDatabaseOutput

func (DatabasesRdsDatabaseOutput) ToDatabasesRdsDatabaseOutputWithContext 

func (o DatabasesRdsDatabaseOutput) ToDatabasesRdsDatabaseOutputWithContext(ctx context.Context) DatabasesRdsDatabaseOutput

type DatabasesResult 

type DatabasesResult struct {
	// The status of the RDS database.
	DbStatus *string `pulumi:"dbStatus"`
	// The provider-assigned unique ID for this managed resource.
	Id         string  `pulumi:"id"`
	InstanceId string  `pulumi:"instanceId"`
	NameRegex  *string `pulumi:"nameRegex"`
	OutputFile *string `pulumi:"outputFile"`
	// The collection of RDS instance account query.
	RdsDatabases []DatabasesRdsDatabase `pulumi:"rdsDatabases"`
	// The total count of RDS database query.
	TotalCount int `pulumi:"totalCount"`
}

A collection of values returned by Databases.

func Databases 

func Databases(ctx *pulumi.Context, args *DatabasesArgs, opts ...pulumi.InvokeOption) (*DatabasesResult, error)

(Deprecated! Recommend use volcengine_rds_mysql_*** replace) Use this data source to query detailed information of rds databases ## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.Databases(ctx, &rds.DatabasesArgs{
			InstanceId: "mysql-0fdd3bab2e7c",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type DatabasesResultOutput 

type DatabasesResultOutput struct{ *pulumi.OutputState }

A collection of values returned by Databases.

func DatabasesOutput 

func DatabasesOutput(ctx *pulumi.Context, args DatabasesOutputArgs, opts ...pulumi.InvokeOption) DatabasesResultOutput

func (DatabasesResultOutput) DbStatus 

func (o DatabasesResultOutput) DbStatus() pulumi.StringPtrOutput

The status of the RDS database.

func (DatabasesResultOutput) ElementType 

func (DatabasesResultOutput) ElementType() reflect.Type

func (DatabasesResultOutput) Id 

func (o DatabasesResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (DatabasesResultOutput) InstanceId 

func (o DatabasesResultOutput) InstanceId() pulumi.StringOutput

func (DatabasesResultOutput) NameRegex 

func (o DatabasesResultOutput) NameRegex() pulumi.StringPtrOutput

func (DatabasesResultOutput) OutputFile 

func (o DatabasesResultOutput) OutputFile() pulumi.StringPtrOutput

func (DatabasesResultOutput) RdsDatabases 

func (o DatabasesResultOutput) RdsDatabases() DatabasesRdsDatabaseArrayOutput

The collection of RDS instance account query.

func (DatabasesResultOutput) ToDatabasesResultOutput 

func (o DatabasesResultOutput) ToDatabasesResultOutput() DatabasesResultOutput

func (DatabasesResultOutput) ToDatabasesResultOutputWithContext 

func (o DatabasesResultOutput) ToDatabasesResultOutputWithContext(ctx context.Context) DatabasesResultOutput

func (DatabasesResultOutput) TotalCount 

func (o DatabasesResultOutput) TotalCount() pulumi.IntOutput

The total count of RDS database query.

type Instance 

type Instance struct {
	pulumi.CustomResourceState

	// Whether to automatically renew. Default: false. Value:
	// true: yes.
	// false: no. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	AutoRenew pulumi.BoolPtrOutput `pulumi:"autoRenew"`
	// Billing type. Value:
	// PostPaid: Postpaid (pay-as-you-go).
	// Prepaid: Prepaid (yearly and monthly).
	ChargeType pulumi.StringOutput `pulumi:"chargeType"`
	// The connection info ot the RDS instance.
	ConnectionInfo InstanceConnectionInfoOutput `pulumi:"connectionInfo"`
	// Database type. Value:
	// MySQL (default).
	DbEngine pulumi.StringPtrOutput `pulumi:"dbEngine"`
	// Instance type. Value:
	// MySQL_Community_5_7
	// MySQL_8_0.
	DbEngineVersion pulumi.StringOutput `pulumi:"dbEngineVersion"`
	// Set the name of the instance. The naming rules are as follows:
	//
	// Cannot start with a number, a dash (-).
	// It can only contain Chinese characters, letters, numbers, underscores (_) and underscores (-).
	// The length needs to be within 1~128 characters.
	InstanceName pulumi.StringPtrOutput `pulumi:"instanceName"`
	// Instance specification name, you can specify the specification name of the instance to be created. Value:
	// rds.mysql.1c2g
	// rds.mysql.2c4g
	// rds.mysql.4c8g
	// rds.mysql.4c16g
	// rds.mysql.8c32g
	// rds.mysql.16c64g
	// rds.mysql.16c128g
	// rds.mysql.32c128g
	// rds.mysql.32c256g.
	InstanceSpecName pulumi.StringOutput `pulumi:"instanceSpecName"`
	// Instance type. Value:
	// HA: High availability version.
	InstanceType pulumi.StringOutput `pulumi:"instanceType"`
	// The purchase cycle in the prepaid scenario. Value:
	// Month: monthly subscription.
	// Year: yearly subscription. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	PrepaidPeriod pulumi.StringPtrOutput `pulumi:"prepaidPeriod"`
	// Select the project to which the instance belongs. If this parameter is left blank, the new instance will not be added to any project. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	ProjectName pulumi.StringPtrOutput `pulumi:"projectName"`
	// The region of the RDS instance.
	Region pulumi.StringPtrOutput `pulumi:"region"`
	// The storage space(GB) of the RDS instance.
	StorageSpaceGb pulumi.IntOutput `pulumi:"storageSpaceGb"`
	// Instance storage type. Value:
	// LocalSSD: Local SSD disk.
	StorageType pulumi.StringOutput `pulumi:"storageType"`
	// Subnet ID. The subnet must belong to the selected Availability Zone.
	SubnetId pulumi.StringOutput `pulumi:"subnetId"`
	// Fill in the high-privileged user account name. The naming rules are as follows:
	// Unique name.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, or underscores (_).
	// The length is 2~32 characters.
	// [Keywords](https://www.volcengine.com/docs/6313/66162) are not allowed for account names.
	SuperAccountName pulumi.StringPtrOutput `pulumi:"superAccountName"`
	// Set a high-privilege account password. The rules are as follows:
	// Only uppercase and lowercase letters, numbers and the following special characters _#!@$%^*()+=-.
	// The length needs to be within 8~32 characters.
	// Contains at least 3 of uppercase letters, lowercase letters, numbers or special characters.
	SuperAccountPassword pulumi.StringPtrOutput `pulumi:"superAccountPassword"`
	// supper_account_password is deprecated, use superAccountPassword instead Set a high-privilege account password. The rules are as follows:
	// Only uppercase and lowercase letters, numbers and the following special characters _#!@$%^*()+=-.
	// The length needs to be within 8~32 characters.
	// Contains at least 3 of uppercase letters, lowercase letters, numbers or special characters.
	//
	// Deprecated: supper_account_password is deprecated, use super_account_password instead
	SupperAccountPassword pulumi.StringPtrOutput `pulumi:"supperAccountPassword"`
	// The purchase time of RDS instance. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	UsedTime pulumi.IntPtrOutput `pulumi:"usedTime"`
	// The vpc ID of the RDS instance.
	VpcId pulumi.StringOutput `pulumi:"vpcId"`
	// The available zone of the RDS instance.
	Zone pulumi.StringOutput `pulumi:"zone"`
}

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.NewInstance(ctx, "foo", &rds.InstanceArgs{
			ChargeType:       pulumi.String("PostPaid"),
			DbEngine:         pulumi.String("MySQL"),
			DbEngineVersion:  pulumi.String("MySQL_Community_5_7"),
			InstanceName:     pulumi.String("tf-test"),
			InstanceSpecName: pulumi.String("rds.mysql.1c2g"),
			InstanceType:     pulumi.String("HA"),
			Region:           pulumi.String("cn-north-4"),
			StorageSpaceGb:   pulumi.Int(100),
			StorageType:      pulumi.String("LocalSSD"),
			SubnetId:         pulumi.String("subnet-1g0d4fkh1nabk8ibuxx1jtvss"),
			VpcId:            pulumi.String("vpc-3cj17x7u9bzeo6c6rrtzfpaeb"),
			Zone:             pulumi.String("cn-langfang-b"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

RDS Instance can be imported using the id, e.g.

```sh 

$ pulumi import volcengine:rds/instance:Instance default mysql-42b38c769c4b

```

func GetInstance 

func GetInstance(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *InstanceState, opts ...pulumi.ResourceOption) (*Instance, error)

GetInstance gets an existing Instance 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 NewInstance 

func NewInstance(ctx *pulumi.Context,
	name string, args *InstanceArgs, opts ...pulumi.ResourceOption) (*Instance, error)

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

func (*Instance) ElementType 

func (*Instance) ElementType() reflect.Type

func (*Instance) ToInstanceOutput 

func (i *Instance) ToInstanceOutput() InstanceOutput

func (*Instance) ToInstanceOutputWithContext 

func (i *Instance) ToInstanceOutputWithContext(ctx context.Context) InstanceOutput

type InstanceArgs 

type InstanceArgs struct {
	// Whether to automatically renew. Default: false. Value:
	// true: yes.
	// false: no. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	AutoRenew pulumi.BoolPtrInput
	// Billing type. Value:
	// PostPaid: Postpaid (pay-as-you-go).
	// Prepaid: Prepaid (yearly and monthly).
	ChargeType pulumi.StringInput
	// Database type. Value:
	// MySQL (default).
	DbEngine pulumi.StringPtrInput
	// Instance type. Value:
	// MySQL_Community_5_7
	// MySQL_8_0.
	DbEngineVersion pulumi.StringInput
	// Set the name of the instance. The naming rules are as follows:
	//
	// Cannot start with a number, a dash (-).
	// It can only contain Chinese characters, letters, numbers, underscores (_) and underscores (-).
	// The length needs to be within 1~128 characters.
	InstanceName pulumi.StringPtrInput
	// Instance specification name, you can specify the specification name of the instance to be created. Value:
	// rds.mysql.1c2g
	// rds.mysql.2c4g
	// rds.mysql.4c8g
	// rds.mysql.4c16g
	// rds.mysql.8c32g
	// rds.mysql.16c64g
	// rds.mysql.16c128g
	// rds.mysql.32c128g
	// rds.mysql.32c256g.
	InstanceSpecName pulumi.StringInput
	// Instance type. Value:
	// HA: High availability version.
	InstanceType pulumi.StringInput
	// The purchase cycle in the prepaid scenario. Value:
	// Month: monthly subscription.
	// Year: yearly subscription. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	PrepaidPeriod pulumi.StringPtrInput
	// Select the project to which the instance belongs. If this parameter is left blank, the new instance will not be added to any project. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	ProjectName pulumi.StringPtrInput
	// The region of the RDS instance.
	Region pulumi.StringPtrInput
	// The storage space(GB) of the RDS instance.
	StorageSpaceGb pulumi.IntInput
	// Instance storage type. Value:
	// LocalSSD: Local SSD disk.
	StorageType pulumi.StringInput
	// Subnet ID. The subnet must belong to the selected Availability Zone.
	SubnetId pulumi.StringInput
	// Fill in the high-privileged user account name. The naming rules are as follows:
	// Unique name.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, or underscores (_).
	// The length is 2~32 characters.
	// [Keywords](https://www.volcengine.com/docs/6313/66162) are not allowed for account names.
	SuperAccountName pulumi.StringPtrInput
	// Set a high-privilege account password. The rules are as follows:
	// Only uppercase and lowercase letters, numbers and the following special characters _#!@$%^*()+=-.
	// The length needs to be within 8~32 characters.
	// Contains at least 3 of uppercase letters, lowercase letters, numbers or special characters.
	SuperAccountPassword pulumi.StringPtrInput
	// supper_account_password is deprecated, use superAccountPassword instead Set a high-privilege account password. The rules are as follows:
	// Only uppercase and lowercase letters, numbers and the following special characters _#!@$%^*()+=-.
	// The length needs to be within 8~32 characters.
	// Contains at least 3 of uppercase letters, lowercase letters, numbers or special characters.
	//
	// Deprecated: supper_account_password is deprecated, use super_account_password instead
	SupperAccountPassword pulumi.StringPtrInput
	// The purchase time of RDS instance. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	UsedTime pulumi.IntPtrInput
	// The vpc ID of the RDS instance.
	VpcId pulumi.StringInput
	// The available zone of the RDS instance.
	Zone pulumi.StringInput
}

The set of arguments for constructing a Instance resource.

func (InstanceArgs) ElementType 

func (InstanceArgs) ElementType() reflect.Type

type InstanceArray 

type InstanceArray []InstanceInput

func (InstanceArray) ElementType 

func (InstanceArray) ElementType() reflect.Type

func (InstanceArray) ToInstanceArrayOutput 

func (i InstanceArray) ToInstanceArrayOutput() InstanceArrayOutput

func (InstanceArray) ToInstanceArrayOutputWithContext 

func (i InstanceArray) ToInstanceArrayOutputWithContext(ctx context.Context) InstanceArrayOutput

type InstanceArrayInput 

type InstanceArrayInput interface {
	pulumi.Input

	ToInstanceArrayOutput() InstanceArrayOutput
	ToInstanceArrayOutputWithContext(context.Context) InstanceArrayOutput
}

InstanceArrayInput is an input type that accepts InstanceArray and InstanceArrayOutput values. You can construct a concrete instance of `InstanceArrayInput` via: 

InstanceArray{ InstanceArgs{...} }

type InstanceArrayOutput 

type InstanceArrayOutput struct{ *pulumi.OutputState }

func (InstanceArrayOutput) ElementType 

func (InstanceArrayOutput) ElementType() reflect.Type

func (InstanceArrayOutput) Index 

func (o InstanceArrayOutput) Index(i pulumi.IntInput) InstanceOutput

func (InstanceArrayOutput) ToInstanceArrayOutput 

func (o InstanceArrayOutput) ToInstanceArrayOutput() InstanceArrayOutput

func (InstanceArrayOutput) ToInstanceArrayOutputWithContext 

func (o InstanceArrayOutput) ToInstanceArrayOutputWithContext(ctx context.Context) InstanceArrayOutput

type InstanceConnectionInfo 

type InstanceConnectionInfo struct {
	// Whether global read-only is enabled.
	EnableReadOnly *string `pulumi:"enableReadOnly"`
	// Whether read-write separation is enabled.
	EnableReadWriteSplitting *string `pulumi:"enableReadWriteSplitting"`
	// The internal domain of the RDS instance.
	InternalDomain *string `pulumi:"internalDomain"`
	// The interval port of the RDS instance.
	InternalPort *string `pulumi:"internalPort"`
	// The public domain of the RDS instance.
	PublicDomain *string `pulumi:"publicDomain"`
	// The public port of the RDS instance.
	PublicPort *string `pulumi:"publicPort"`
}

type InstanceConnectionInfoArgs 

type InstanceConnectionInfoArgs struct {
	// Whether global read-only is enabled.
	EnableReadOnly pulumi.StringPtrInput `pulumi:"enableReadOnly"`
	// Whether read-write separation is enabled.
	EnableReadWriteSplitting pulumi.StringPtrInput `pulumi:"enableReadWriteSplitting"`
	// The internal domain of the RDS instance.
	InternalDomain pulumi.StringPtrInput `pulumi:"internalDomain"`
	// The interval port of the RDS instance.
	InternalPort pulumi.StringPtrInput `pulumi:"internalPort"`
	// The public domain of the RDS instance.
	PublicDomain pulumi.StringPtrInput `pulumi:"publicDomain"`
	// The public port of the RDS instance.
	PublicPort pulumi.StringPtrInput `pulumi:"publicPort"`
}

func (InstanceConnectionInfoArgs) ElementType 

func (InstanceConnectionInfoArgs) ElementType() reflect.Type

func (InstanceConnectionInfoArgs) ToInstanceConnectionInfoOutput 

func (i InstanceConnectionInfoArgs) ToInstanceConnectionInfoOutput() InstanceConnectionInfoOutput

func (InstanceConnectionInfoArgs) ToInstanceConnectionInfoOutputWithContext 

func (i InstanceConnectionInfoArgs) ToInstanceConnectionInfoOutputWithContext(ctx context.Context) InstanceConnectionInfoOutput

func (InstanceConnectionInfoArgs) ToInstanceConnectionInfoPtrOutput 

func (i InstanceConnectionInfoArgs) ToInstanceConnectionInfoPtrOutput() InstanceConnectionInfoPtrOutput

func (InstanceConnectionInfoArgs) ToInstanceConnectionInfoPtrOutputWithContext 

func (i InstanceConnectionInfoArgs) ToInstanceConnectionInfoPtrOutputWithContext(ctx context.Context) InstanceConnectionInfoPtrOutput

type InstanceConnectionInfoInput 

type InstanceConnectionInfoInput interface {
	pulumi.Input

	ToInstanceConnectionInfoOutput() InstanceConnectionInfoOutput
	ToInstanceConnectionInfoOutputWithContext(context.Context) InstanceConnectionInfoOutput
}

InstanceConnectionInfoInput is an input type that accepts InstanceConnectionInfoArgs and InstanceConnectionInfoOutput values. You can construct a concrete instance of `InstanceConnectionInfoInput` via: 

InstanceConnectionInfoArgs{...}

type InstanceConnectionInfoOutput 

type InstanceConnectionInfoOutput struct{ *pulumi.OutputState }

func (InstanceConnectionInfoOutput) ElementType 

func (InstanceConnectionInfoOutput) ElementType() reflect.Type

func (InstanceConnectionInfoOutput) EnableReadOnly 

func (o InstanceConnectionInfoOutput) EnableReadOnly() pulumi.StringPtrOutput

Whether global read-only is enabled.

func (InstanceConnectionInfoOutput) EnableReadWriteSplitting 

func (o InstanceConnectionInfoOutput) EnableReadWriteSplitting() pulumi.StringPtrOutput

Whether read-write separation is enabled.

func (InstanceConnectionInfoOutput) InternalDomain 

func (o InstanceConnectionInfoOutput) InternalDomain() pulumi.StringPtrOutput

The internal domain of the RDS instance.

func (InstanceConnectionInfoOutput) InternalPort 

func (o InstanceConnectionInfoOutput) InternalPort() pulumi.StringPtrOutput

The interval port of the RDS instance.

func (InstanceConnectionInfoOutput) PublicDomain 

func (o InstanceConnectionInfoOutput) PublicDomain() pulumi.StringPtrOutput

The public domain of the RDS instance.

func (InstanceConnectionInfoOutput) PublicPort 

func (o InstanceConnectionInfoOutput) PublicPort() pulumi.StringPtrOutput

The public port of the RDS instance.

func (InstanceConnectionInfoOutput) ToInstanceConnectionInfoOutput 

func (o InstanceConnectionInfoOutput) ToInstanceConnectionInfoOutput() InstanceConnectionInfoOutput

func (InstanceConnectionInfoOutput) ToInstanceConnectionInfoOutputWithContext 

func (o InstanceConnectionInfoOutput) ToInstanceConnectionInfoOutputWithContext(ctx context.Context) InstanceConnectionInfoOutput

func (InstanceConnectionInfoOutput) ToInstanceConnectionInfoPtrOutput 

func (o InstanceConnectionInfoOutput) ToInstanceConnectionInfoPtrOutput() InstanceConnectionInfoPtrOutput

func (InstanceConnectionInfoOutput) ToInstanceConnectionInfoPtrOutputWithContext 

func (o InstanceConnectionInfoOutput) ToInstanceConnectionInfoPtrOutputWithContext(ctx context.Context) InstanceConnectionInfoPtrOutput

type InstanceConnectionInfoPtrInput 

type InstanceConnectionInfoPtrInput interface {
	pulumi.Input

	ToInstanceConnectionInfoPtrOutput() InstanceConnectionInfoPtrOutput
	ToInstanceConnectionInfoPtrOutputWithContext(context.Context) InstanceConnectionInfoPtrOutput
}

InstanceConnectionInfoPtrInput is an input type that accepts InstanceConnectionInfoArgs, InstanceConnectionInfoPtr and InstanceConnectionInfoPtrOutput values. You can construct a concrete instance of `InstanceConnectionInfoPtrInput` via: 

        InstanceConnectionInfoArgs{...}

or:

        nil

func InstanceConnectionInfoPtr 

func InstanceConnectionInfoPtr(v *InstanceConnectionInfoArgs) InstanceConnectionInfoPtrInput

type InstanceConnectionInfoPtrOutput 

type InstanceConnectionInfoPtrOutput struct{ *pulumi.OutputState }

func (InstanceConnectionInfoPtrOutput) Elem 

func (o InstanceConnectionInfoPtrOutput) Elem() InstanceConnectionInfoOutput

func (InstanceConnectionInfoPtrOutput) ElementType 

func (InstanceConnectionInfoPtrOutput) ElementType() reflect.Type

func (InstanceConnectionInfoPtrOutput) EnableReadOnly 

func (o InstanceConnectionInfoPtrOutput) EnableReadOnly() pulumi.StringPtrOutput

Whether global read-only is enabled.

func (InstanceConnectionInfoPtrOutput) EnableReadWriteSplitting 

func (o InstanceConnectionInfoPtrOutput) EnableReadWriteSplitting() pulumi.StringPtrOutput

Whether read-write separation is enabled.

func (InstanceConnectionInfoPtrOutput) InternalDomain 

func (o InstanceConnectionInfoPtrOutput) InternalDomain() pulumi.StringPtrOutput

The internal domain of the RDS instance.

func (InstanceConnectionInfoPtrOutput) InternalPort 

func (o InstanceConnectionInfoPtrOutput) InternalPort() pulumi.StringPtrOutput

The interval port of the RDS instance.

func (InstanceConnectionInfoPtrOutput) PublicDomain 

func (o InstanceConnectionInfoPtrOutput) PublicDomain() pulumi.StringPtrOutput

The public domain of the RDS instance.

func (InstanceConnectionInfoPtrOutput) PublicPort 

func (o InstanceConnectionInfoPtrOutput) PublicPort() pulumi.StringPtrOutput

The public port of the RDS instance.

func (InstanceConnectionInfoPtrOutput) ToInstanceConnectionInfoPtrOutput 

func (o InstanceConnectionInfoPtrOutput) ToInstanceConnectionInfoPtrOutput() InstanceConnectionInfoPtrOutput

func (InstanceConnectionInfoPtrOutput) ToInstanceConnectionInfoPtrOutputWithContext 

func (o InstanceConnectionInfoPtrOutput) ToInstanceConnectionInfoPtrOutputWithContext(ctx context.Context) InstanceConnectionInfoPtrOutput

type InstanceInput 

type InstanceInput interface {
	pulumi.Input

	ToInstanceOutput() InstanceOutput
	ToInstanceOutputWithContext(ctx context.Context) InstanceOutput
}

type InstanceMap 

type InstanceMap map[string]InstanceInput

func (InstanceMap) ElementType 

func (InstanceMap) ElementType() reflect.Type

func (InstanceMap) ToInstanceMapOutput 

func (i InstanceMap) ToInstanceMapOutput() InstanceMapOutput

func (InstanceMap) ToInstanceMapOutputWithContext 

func (i InstanceMap) ToInstanceMapOutputWithContext(ctx context.Context) InstanceMapOutput

type InstanceMapInput 

type InstanceMapInput interface {
	pulumi.Input

	ToInstanceMapOutput() InstanceMapOutput
	ToInstanceMapOutputWithContext(context.Context) InstanceMapOutput
}

InstanceMapInput is an input type that accepts InstanceMap and InstanceMapOutput values. You can construct a concrete instance of `InstanceMapInput` via: 

InstanceMap{ "key": InstanceArgs{...} }

type InstanceMapOutput 

type InstanceMapOutput struct{ *pulumi.OutputState }

func (InstanceMapOutput) ElementType 

func (InstanceMapOutput) ElementType() reflect.Type

func (InstanceMapOutput) MapIndex 

func (o InstanceMapOutput) MapIndex(k pulumi.StringInput) InstanceOutput

func (InstanceMapOutput) ToInstanceMapOutput 

func (o InstanceMapOutput) ToInstanceMapOutput() InstanceMapOutput

func (InstanceMapOutput) ToInstanceMapOutputWithContext 

func (o InstanceMapOutput) ToInstanceMapOutputWithContext(ctx context.Context) InstanceMapOutput

type InstanceOutput 

type InstanceOutput struct{ *pulumi.OutputState }

func (InstanceOutput) AutoRenew 

func (o InstanceOutput) AutoRenew() pulumi.BoolPtrOutput

Whether to automatically renew. Default: false. Value: true: yes. false: no. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.

func (InstanceOutput) ChargeType 

func (o InstanceOutput) ChargeType() pulumi.StringOutput

Billing type. Value: PostPaid: Postpaid (pay-as-you-go). Prepaid: Prepaid (yearly and monthly).

func (InstanceOutput) ConnectionInfo 

func (o InstanceOutput) ConnectionInfo() InstanceConnectionInfoOutput

The connection info ot the RDS instance.

func (InstanceOutput) DbEngine 

func (o InstanceOutput) DbEngine() pulumi.StringPtrOutput

Database type. Value: MySQL (default).

func (InstanceOutput) DbEngineVersion 

func (o InstanceOutput) DbEngineVersion() pulumi.StringOutput

Instance type. Value: MySQL_Community_5_7 MySQL_8_0.

func (InstanceOutput) ElementType 

func (InstanceOutput) ElementType() reflect.Type

func (InstanceOutput) InstanceName 

func (o InstanceOutput) InstanceName() pulumi.StringPtrOutput

Set the name of the instance. The naming rules are as follows:

Cannot start with a number, a dash (-). It can only contain Chinese characters, letters, numbers, underscores (_) and underscores (-). The length needs to be within 1~128 characters.

func (InstanceOutput) InstanceSpecName 

func (o InstanceOutput) InstanceSpecName() pulumi.StringOutput

Instance specification name, you can specify the specification name of the instance to be created. Value: rds.mysql.1c2g rds.mysql.2c4g rds.mysql.4c8g rds.mysql.4c16g rds.mysql.8c32g rds.mysql.16c64g rds.mysql.16c128g rds.mysql.32c128g rds.mysql.32c256g.

func (InstanceOutput) InstanceType 

func (o InstanceOutput) InstanceType() pulumi.StringOutput

Instance type. Value: HA: High availability version.

func (InstanceOutput) PrepaidPeriod 

func (o InstanceOutput) PrepaidPeriod() pulumi.StringPtrOutput

The purchase cycle in the prepaid scenario. Value: Month: monthly subscription. Year: yearly subscription. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.

func (InstanceOutput) ProjectName 

func (o InstanceOutput) ProjectName() pulumi.StringPtrOutput

Select the project to which the instance belongs. If this parameter is left blank, the new instance will not be added to any project. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.

func (InstanceOutput) Region 

func (o InstanceOutput) Region() pulumi.StringPtrOutput

The region of the RDS instance.

func (InstanceOutput) StorageSpaceGb 

func (o InstanceOutput) StorageSpaceGb() pulumi.IntOutput

The storage space(GB) of the RDS instance.

func (InstanceOutput) StorageType 

func (o InstanceOutput) StorageType() pulumi.StringOutput

Instance storage type. Value: LocalSSD: Local SSD disk.

func (InstanceOutput) SubnetId 

func (o InstanceOutput) SubnetId() pulumi.StringOutput

Subnet ID. The subnet must belong to the selected Availability Zone.

func (InstanceOutput) SuperAccountName 

func (o InstanceOutput) SuperAccountName() pulumi.StringPtrOutput

Fill in the high-privileged user account name. The naming rules are as follows: Unique name. Start with a letter and end with a letter or number. Consists of lowercase letters, numbers, or underscores (_). The length is 2~32 characters. [Keywords](https://www.volcengine.com/docs/6313/66162) are not allowed for account names.

func (InstanceOutput) SuperAccountPassword 

func (o InstanceOutput) SuperAccountPassword() pulumi.StringPtrOutput

Set a high-privilege account password. The rules are as follows: Only uppercase and lowercase letters, numbers and the following special characters _#!@$%^*()+=-. The length needs to be within 8~32 characters. Contains at least 3 of uppercase letters, lowercase letters, numbers or special characters.

func (InstanceOutput) SupperAccountPassword deprecated 

func (o InstanceOutput) SupperAccountPassword() pulumi.StringPtrOutput

supper_account_password is deprecated, use superAccountPassword instead Set a high-privilege account password. The rules are as follows: Only uppercase and lowercase letters, numbers and the following special characters _#!@$%^*()+=-. The length needs to be within 8~32 characters. Contains at least 3 of uppercase letters, lowercase letters, numbers or special characters.

Deprecated: supper_account_password is deprecated, use super_account_password instead

func (InstanceOutput) ToInstanceOutput 

func (o InstanceOutput) ToInstanceOutput() InstanceOutput

func (InstanceOutput) ToInstanceOutputWithContext 

func (o InstanceOutput) ToInstanceOutputWithContext(ctx context.Context) InstanceOutput

func (InstanceOutput) UsedTime 

func (o InstanceOutput) UsedTime() pulumi.IntPtrOutput

The purchase time of RDS instance. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.

func (InstanceOutput) VpcId 

func (o InstanceOutput) VpcId() pulumi.StringOutput

The vpc ID of the RDS instance.

func (InstanceOutput) Zone 

func (o InstanceOutput) Zone() pulumi.StringOutput

The available zone of the RDS instance.

type InstanceState 

type InstanceState struct {
	// Whether to automatically renew. Default: false. Value:
	// true: yes.
	// false: no. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	AutoRenew pulumi.BoolPtrInput
	// Billing type. Value:
	// PostPaid: Postpaid (pay-as-you-go).
	// Prepaid: Prepaid (yearly and monthly).
	ChargeType pulumi.StringPtrInput
	// The connection info ot the RDS instance.
	ConnectionInfo InstanceConnectionInfoPtrInput
	// Database type. Value:
	// MySQL (default).
	DbEngine pulumi.StringPtrInput
	// Instance type. Value:
	// MySQL_Community_5_7
	// MySQL_8_0.
	DbEngineVersion pulumi.StringPtrInput
	// Set the name of the instance. The naming rules are as follows:
	//
	// Cannot start with a number, a dash (-).
	// It can only contain Chinese characters, letters, numbers, underscores (_) and underscores (-).
	// The length needs to be within 1~128 characters.
	InstanceName pulumi.StringPtrInput
	// Instance specification name, you can specify the specification name of the instance to be created. Value:
	// rds.mysql.1c2g
	// rds.mysql.2c4g
	// rds.mysql.4c8g
	// rds.mysql.4c16g
	// rds.mysql.8c32g
	// rds.mysql.16c64g
	// rds.mysql.16c128g
	// rds.mysql.32c128g
	// rds.mysql.32c256g.
	InstanceSpecName pulumi.StringPtrInput
	// Instance type. Value:
	// HA: High availability version.
	InstanceType pulumi.StringPtrInput
	// The purchase cycle in the prepaid scenario. Value:
	// Month: monthly subscription.
	// Year: yearly subscription. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	PrepaidPeriod pulumi.StringPtrInput
	// Select the project to which the instance belongs. If this parameter is left blank, the new instance will not be added to any project. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	ProjectName pulumi.StringPtrInput
	// The region of the RDS instance.
	Region pulumi.StringPtrInput
	// The storage space(GB) of the RDS instance.
	StorageSpaceGb pulumi.IntPtrInput
	// Instance storage type. Value:
	// LocalSSD: Local SSD disk.
	StorageType pulumi.StringPtrInput
	// Subnet ID. The subnet must belong to the selected Availability Zone.
	SubnetId pulumi.StringPtrInput
	// Fill in the high-privileged user account name. The naming rules are as follows:
	// Unique name.
	// Start with a letter and end with a letter or number.
	// Consists of lowercase letters, numbers, or underscores (_).
	// The length is 2~32 characters.
	// [Keywords](https://www.volcengine.com/docs/6313/66162) are not allowed for account names.
	SuperAccountName pulumi.StringPtrInput
	// Set a high-privilege account password. The rules are as follows:
	// Only uppercase and lowercase letters, numbers and the following special characters _#!@$%^*()+=-.
	// The length needs to be within 8~32 characters.
	// Contains at least 3 of uppercase letters, lowercase letters, numbers or special characters.
	SuperAccountPassword pulumi.StringPtrInput
	// supper_account_password is deprecated, use superAccountPassword instead Set a high-privilege account password. The rules are as follows:
	// Only uppercase and lowercase letters, numbers and the following special characters _#!@$%^*()+=-.
	// The length needs to be within 8~32 characters.
	// Contains at least 3 of uppercase letters, lowercase letters, numbers or special characters.
	//
	// Deprecated: supper_account_password is deprecated, use super_account_password instead
	SupperAccountPassword pulumi.StringPtrInput
	// The purchase time of RDS instance. When importing resources, this attribute will not be imported. If this attribute is set, please use lifecycle and ignoreChanges ignore changes in fields.
	UsedTime pulumi.IntPtrInput
	// The vpc ID of the RDS instance.
	VpcId pulumi.StringPtrInput
	// The available zone of the RDS instance.
	Zone pulumi.StringPtrInput
}

func (InstanceState) ElementType 

func (InstanceState) ElementType() reflect.Type

type InstancesArgs 

type InstancesArgs struct {
	// The end time of creating RDS instance.
	CreateEndTime *string `pulumi:"createEndTime"`
	// The start time of creating RDS instance.
	CreateStartTime *string `pulumi:"createStartTime"`
	// The id of the RDS instance.
	InstanceId *string `pulumi:"instanceId"`
	// The status of the RDS instance.
	InstanceStatus *string `pulumi:"instanceStatus"`
	// The type of the RDS instance.
	InstanceType *string `pulumi:"instanceType"`
	// A Name Regex of RDS instance.
	NameRegex *string `pulumi:"nameRegex"`
	// File name where to save data source results.
	OutputFile *string `pulumi:"outputFile"`
	// The region of the RDS instance.
	Region *string `pulumi:"region"`
	// The available zone of the RDS instance.
	Zone *string `pulumi:"zone"`
}

A collection of arguments for invoking Instances.

type InstancesOutputArgs 

type InstancesOutputArgs struct {
	// The end time of creating RDS instance.
	CreateEndTime pulumi.StringPtrInput `pulumi:"createEndTime"`
	// The start time of creating RDS instance.
	CreateStartTime pulumi.StringPtrInput `pulumi:"createStartTime"`
	// The id of the RDS instance.
	InstanceId pulumi.StringPtrInput `pulumi:"instanceId"`
	// The status of the RDS instance.
	InstanceStatus pulumi.StringPtrInput `pulumi:"instanceStatus"`
	// The type of the RDS instance.
	InstanceType pulumi.StringPtrInput `pulumi:"instanceType"`
	// A Name Regex of RDS instance.
	NameRegex pulumi.StringPtrInput `pulumi:"nameRegex"`
	// File name where to save data source results.
	OutputFile pulumi.StringPtrInput `pulumi:"outputFile"`
	// The region of the RDS instance.
	Region pulumi.StringPtrInput `pulumi:"region"`
	// The available zone of the RDS instance.
	Zone pulumi.StringPtrInput `pulumi:"zone"`
}

A collection of arguments for invoking Instances.

func (InstancesOutputArgs) ElementType 

func (InstancesOutputArgs) ElementType() reflect.Type

type InstancesRdsInstance 

type InstancesRdsInstance struct {
	// The charge status of the RDS instance.
	ChargeStatus string `pulumi:"chargeStatus"`
	// The charge type of the RDS instance.
	ChargeType string `pulumi:"chargeType"`
	// The connection info ot the RDS instance.
	ConnectionInfo InstancesRdsInstanceConnectionInfo `pulumi:"connectionInfo"`
	// The create time of the RDS instance.
	CreateTime string `pulumi:"createTime"`
	// The engine of the RDS instance.
	DbEngine string `pulumi:"dbEngine"`
	// The engine version of the RDS instance.
	DbEngineVersion string `pulumi:"dbEngineVersion"`
	// The ID of the RDS instance.
	Id string `pulumi:"id"`
	// The id of the RDS instance.
	InstanceId string `pulumi:"instanceId"`
	// The name of the RDS instance.
	InstanceName string `pulumi:"instanceName"`
	// The spec type detail of RDS instance.
	InstanceSpec InstancesRdsInstanceInstanceSpec `pulumi:"instanceSpec"`
	// The status of the RDS instance.
	InstanceStatus string `pulumi:"instanceStatus"`
	// The type of the RDS instance.
	InstanceType        string   `pulumi:"instanceType"`
	ReadOnlyInstanceIds []string `pulumi:"readOnlyInstanceIds"`
	// The region of the RDS instance.
	Region string `pulumi:"region"`
	// The total storage GB of the RDS instance.
	StorageSpaceGb int `pulumi:"storageSpaceGb"`
	// The update time of the RDS instance.
	UpdateTime string `pulumi:"updateTime"`
	// The vpc ID of the RDS instance.
	VpcId string `pulumi:"vpcId"`
	// The available zone of the RDS instance.
	Zone string `pulumi:"zone"`
}

type InstancesRdsInstanceArgs 

type InstancesRdsInstanceArgs struct {
	// The charge status of the RDS instance.
	ChargeStatus pulumi.StringInput `pulumi:"chargeStatus"`
	// The charge type of the RDS instance.
	ChargeType pulumi.StringInput `pulumi:"chargeType"`
	// The connection info ot the RDS instance.
	ConnectionInfo InstancesRdsInstanceConnectionInfoInput `pulumi:"connectionInfo"`
	// The create time of the RDS instance.
	CreateTime pulumi.StringInput `pulumi:"createTime"`
	// The engine of the RDS instance.
	DbEngine pulumi.StringInput `pulumi:"dbEngine"`
	// The engine version of the RDS instance.
	DbEngineVersion pulumi.StringInput `pulumi:"dbEngineVersion"`
	// The ID of the RDS instance.
	Id pulumi.StringInput `pulumi:"id"`
	// The id of the RDS instance.
	InstanceId pulumi.StringInput `pulumi:"instanceId"`
	// The name of the RDS instance.
	InstanceName pulumi.StringInput `pulumi:"instanceName"`
	// The spec type detail of RDS instance.
	InstanceSpec InstancesRdsInstanceInstanceSpecInput `pulumi:"instanceSpec"`
	// The status of the RDS instance.
	InstanceStatus pulumi.StringInput `pulumi:"instanceStatus"`
	// The type of the RDS instance.
	InstanceType        pulumi.StringInput      `pulumi:"instanceType"`
	ReadOnlyInstanceIds pulumi.StringArrayInput `pulumi:"readOnlyInstanceIds"`
	// The region of the RDS instance.
	Region pulumi.StringInput `pulumi:"region"`
	// The total storage GB of the RDS instance.
	StorageSpaceGb pulumi.IntInput `pulumi:"storageSpaceGb"`
	// The update time of the RDS instance.
	UpdateTime pulumi.StringInput `pulumi:"updateTime"`
	// The vpc ID of the RDS instance.
	VpcId pulumi.StringInput `pulumi:"vpcId"`
	// The available zone of the RDS instance.
	Zone pulumi.StringInput `pulumi:"zone"`
}

func (InstancesRdsInstanceArgs) ElementType 

func (InstancesRdsInstanceArgs) ElementType() reflect.Type

func (InstancesRdsInstanceArgs) ToInstancesRdsInstanceOutput 

func (i InstancesRdsInstanceArgs) ToInstancesRdsInstanceOutput() InstancesRdsInstanceOutput

func (InstancesRdsInstanceArgs) ToInstancesRdsInstanceOutputWithContext 

func (i InstancesRdsInstanceArgs) ToInstancesRdsInstanceOutputWithContext(ctx context.Context) InstancesRdsInstanceOutput

type InstancesRdsInstanceArray 

type InstancesRdsInstanceArray []InstancesRdsInstanceInput

func (InstancesRdsInstanceArray) ElementType 

func (InstancesRdsInstanceArray) ElementType() reflect.Type

func (InstancesRdsInstanceArray) ToInstancesRdsInstanceArrayOutput 

func (i InstancesRdsInstanceArray) ToInstancesRdsInstanceArrayOutput() InstancesRdsInstanceArrayOutput

func (InstancesRdsInstanceArray) ToInstancesRdsInstanceArrayOutputWithContext 

func (i InstancesRdsInstanceArray) ToInstancesRdsInstanceArrayOutputWithContext(ctx context.Context) InstancesRdsInstanceArrayOutput

type InstancesRdsInstanceArrayInput 

type InstancesRdsInstanceArrayInput interface {
	pulumi.Input

	ToInstancesRdsInstanceArrayOutput() InstancesRdsInstanceArrayOutput
	ToInstancesRdsInstanceArrayOutputWithContext(context.Context) InstancesRdsInstanceArrayOutput
}

InstancesRdsInstanceArrayInput is an input type that accepts InstancesRdsInstanceArray and InstancesRdsInstanceArrayOutput values. You can construct a concrete instance of `InstancesRdsInstanceArrayInput` via: 

InstancesRdsInstanceArray{ InstancesRdsInstanceArgs{...} }

type InstancesRdsInstanceArrayOutput 

type InstancesRdsInstanceArrayOutput struct{ *pulumi.OutputState }

func (InstancesRdsInstanceArrayOutput) ElementType 

func (InstancesRdsInstanceArrayOutput) ElementType() reflect.Type

func (InstancesRdsInstanceArrayOutput) Index 

func (o InstancesRdsInstanceArrayOutput) Index(i pulumi.IntInput) InstancesRdsInstanceOutput

func (InstancesRdsInstanceArrayOutput) ToInstancesRdsInstanceArrayOutput 

func (o InstancesRdsInstanceArrayOutput) ToInstancesRdsInstanceArrayOutput() InstancesRdsInstanceArrayOutput

func (InstancesRdsInstanceArrayOutput) ToInstancesRdsInstanceArrayOutputWithContext 

func (o InstancesRdsInstanceArrayOutput) ToInstancesRdsInstanceArrayOutputWithContext(ctx context.Context) InstancesRdsInstanceArrayOutput

type InstancesRdsInstanceConnectionInfo 

type InstancesRdsInstanceConnectionInfo struct {
	// Whether global read-only is enabled.
	EnableReadOnly string `pulumi:"enableReadOnly"`
	// Whether read-write separation is enabled.
	EnableReadWriteSplitting string `pulumi:"enableReadWriteSplitting"`
	// The internal domain of the RDS instance.
	InternalDomain string `pulumi:"internalDomain"`
	// The interval port of the RDS instance.
	InternalPort string `pulumi:"internalPort"`
	// The public domain of the RDS instance.
	PublicDomain string `pulumi:"publicDomain"`
	// The public port of the RDS instance.
	PublicPort string `pulumi:"publicPort"`
}

type InstancesRdsInstanceConnectionInfoArgs 

type InstancesRdsInstanceConnectionInfoArgs struct {
	// Whether global read-only is enabled.
	EnableReadOnly pulumi.StringInput `pulumi:"enableReadOnly"`
	// Whether read-write separation is enabled.
	EnableReadWriteSplitting pulumi.StringInput `pulumi:"enableReadWriteSplitting"`
	// The internal domain of the RDS instance.
	InternalDomain pulumi.StringInput `pulumi:"internalDomain"`
	// The interval port of the RDS instance.
	InternalPort pulumi.StringInput `pulumi:"internalPort"`
	// The public domain of the RDS instance.
	PublicDomain pulumi.StringInput `pulumi:"publicDomain"`
	// The public port of the RDS instance.
	PublicPort pulumi.StringInput `pulumi:"publicPort"`
}

func (InstancesRdsInstanceConnectionInfoArgs) ElementType 

func (InstancesRdsInstanceConnectionInfoArgs) ElementType() reflect.Type

func (InstancesRdsInstanceConnectionInfoArgs) ToInstancesRdsInstanceConnectionInfoOutput 

func (i InstancesRdsInstanceConnectionInfoArgs) ToInstancesRdsInstanceConnectionInfoOutput() InstancesRdsInstanceConnectionInfoOutput

func (InstancesRdsInstanceConnectionInfoArgs) ToInstancesRdsInstanceConnectionInfoOutputWithContext 

func (i InstancesRdsInstanceConnectionInfoArgs) ToInstancesRdsInstanceConnectionInfoOutputWithContext(ctx context.Context) InstancesRdsInstanceConnectionInfoOutput

type InstancesRdsInstanceConnectionInfoInput 

type InstancesRdsInstanceConnectionInfoInput interface {
	pulumi.Input

	ToInstancesRdsInstanceConnectionInfoOutput() InstancesRdsInstanceConnectionInfoOutput
	ToInstancesRdsInstanceConnectionInfoOutputWithContext(context.Context) InstancesRdsInstanceConnectionInfoOutput
}

InstancesRdsInstanceConnectionInfoInput is an input type that accepts InstancesRdsInstanceConnectionInfoArgs and InstancesRdsInstanceConnectionInfoOutput values. You can construct a concrete instance of `InstancesRdsInstanceConnectionInfoInput` via: 

InstancesRdsInstanceConnectionInfoArgs{...}

type InstancesRdsInstanceConnectionInfoOutput 

type InstancesRdsInstanceConnectionInfoOutput struct{ *pulumi.OutputState }

func (InstancesRdsInstanceConnectionInfoOutput) ElementType 

func (InstancesRdsInstanceConnectionInfoOutput) ElementType() reflect.Type

func (InstancesRdsInstanceConnectionInfoOutput) EnableReadOnly 

func (o InstancesRdsInstanceConnectionInfoOutput) EnableReadOnly() pulumi.StringOutput

Whether global read-only is enabled.

func (InstancesRdsInstanceConnectionInfoOutput) EnableReadWriteSplitting 

func (o InstancesRdsInstanceConnectionInfoOutput) EnableReadWriteSplitting() pulumi.StringOutput

Whether read-write separation is enabled.

func (InstancesRdsInstanceConnectionInfoOutput) InternalDomain 

func (o InstancesRdsInstanceConnectionInfoOutput) InternalDomain() pulumi.StringOutput

The internal domain of the RDS instance.

func (InstancesRdsInstanceConnectionInfoOutput) InternalPort 

func (o InstancesRdsInstanceConnectionInfoOutput) InternalPort() pulumi.StringOutput

The interval port of the RDS instance.

func (InstancesRdsInstanceConnectionInfoOutput) PublicDomain 

func (o InstancesRdsInstanceConnectionInfoOutput) PublicDomain() pulumi.StringOutput

The public domain of the RDS instance.

func (InstancesRdsInstanceConnectionInfoOutput) PublicPort 

func (o InstancesRdsInstanceConnectionInfoOutput) PublicPort() pulumi.StringOutput

The public port of the RDS instance.

func (InstancesRdsInstanceConnectionInfoOutput) ToInstancesRdsInstanceConnectionInfoOutput 

func (o InstancesRdsInstanceConnectionInfoOutput) ToInstancesRdsInstanceConnectionInfoOutput() InstancesRdsInstanceConnectionInfoOutput

func (InstancesRdsInstanceConnectionInfoOutput) ToInstancesRdsInstanceConnectionInfoOutputWithContext 

func (o InstancesRdsInstanceConnectionInfoOutput) ToInstancesRdsInstanceConnectionInfoOutputWithContext(ctx context.Context) InstancesRdsInstanceConnectionInfoOutput

type InstancesRdsInstanceInput 

type InstancesRdsInstanceInput interface {
	pulumi.Input

	ToInstancesRdsInstanceOutput() InstancesRdsInstanceOutput
	ToInstancesRdsInstanceOutputWithContext(context.Context) InstancesRdsInstanceOutput
}

InstancesRdsInstanceInput is an input type that accepts InstancesRdsInstanceArgs and InstancesRdsInstanceOutput values. You can construct a concrete instance of `InstancesRdsInstanceInput` via: 

InstancesRdsInstanceArgs{...}

type InstancesRdsInstanceInstanceSpec 

type InstancesRdsInstanceInstanceSpec struct {
	// The cpu core count of spec type.
	CpuNum int `pulumi:"cpuNum"`
	// The memory size(GB) of spec type.
	MemInGb int `pulumi:"memInGb"`
	// The name of spec type.
	SpecName string `pulumi:"specName"`
}

type InstancesRdsInstanceInstanceSpecArgs 

type InstancesRdsInstanceInstanceSpecArgs struct {
	// The cpu core count of spec type.
	CpuNum pulumi.IntInput `pulumi:"cpuNum"`
	// The memory size(GB) of spec type.
	MemInGb pulumi.IntInput `pulumi:"memInGb"`
	// The name of spec type.
	SpecName pulumi.StringInput `pulumi:"specName"`
}

func (InstancesRdsInstanceInstanceSpecArgs) ElementType 

func (InstancesRdsInstanceInstanceSpecArgs) ElementType() reflect.Type

func (InstancesRdsInstanceInstanceSpecArgs) ToInstancesRdsInstanceInstanceSpecOutput 

func (i InstancesRdsInstanceInstanceSpecArgs) ToInstancesRdsInstanceInstanceSpecOutput() InstancesRdsInstanceInstanceSpecOutput

func (InstancesRdsInstanceInstanceSpecArgs) ToInstancesRdsInstanceInstanceSpecOutputWithContext 

func (i InstancesRdsInstanceInstanceSpecArgs) ToInstancesRdsInstanceInstanceSpecOutputWithContext(ctx context.Context) InstancesRdsInstanceInstanceSpecOutput

type InstancesRdsInstanceInstanceSpecInput 

type InstancesRdsInstanceInstanceSpecInput interface {
	pulumi.Input

	ToInstancesRdsInstanceInstanceSpecOutput() InstancesRdsInstanceInstanceSpecOutput
	ToInstancesRdsInstanceInstanceSpecOutputWithContext(context.Context) InstancesRdsInstanceInstanceSpecOutput
}

InstancesRdsInstanceInstanceSpecInput is an input type that accepts InstancesRdsInstanceInstanceSpecArgs and InstancesRdsInstanceInstanceSpecOutput values. You can construct a concrete instance of `InstancesRdsInstanceInstanceSpecInput` via: 

InstancesRdsInstanceInstanceSpecArgs{...}

type InstancesRdsInstanceInstanceSpecOutput 

type InstancesRdsInstanceInstanceSpecOutput struct{ *pulumi.OutputState }

func (InstancesRdsInstanceInstanceSpecOutput) CpuNum 

func (o InstancesRdsInstanceInstanceSpecOutput) CpuNum() pulumi.IntOutput

The cpu core count of spec type.

func (InstancesRdsInstanceInstanceSpecOutput) ElementType 

func (InstancesRdsInstanceInstanceSpecOutput) ElementType() reflect.Type

func (InstancesRdsInstanceInstanceSpecOutput) MemInGb 

func (o InstancesRdsInstanceInstanceSpecOutput) MemInGb() pulumi.IntOutput

The memory size(GB) of spec type.

func (InstancesRdsInstanceInstanceSpecOutput) SpecName 

func (o InstancesRdsInstanceInstanceSpecOutput) SpecName() pulumi.StringOutput

The name of spec type.

func (InstancesRdsInstanceInstanceSpecOutput) ToInstancesRdsInstanceInstanceSpecOutput 

func (o InstancesRdsInstanceInstanceSpecOutput) ToInstancesRdsInstanceInstanceSpecOutput() InstancesRdsInstanceInstanceSpecOutput

func (InstancesRdsInstanceInstanceSpecOutput) ToInstancesRdsInstanceInstanceSpecOutputWithContext 

func (o InstancesRdsInstanceInstanceSpecOutput) ToInstancesRdsInstanceInstanceSpecOutputWithContext(ctx context.Context) InstancesRdsInstanceInstanceSpecOutput

type InstancesRdsInstanceOutput 

type InstancesRdsInstanceOutput struct{ *pulumi.OutputState }

func (InstancesRdsInstanceOutput) ChargeStatus 

func (o InstancesRdsInstanceOutput) ChargeStatus() pulumi.StringOutput

The charge status of the RDS instance.

func (InstancesRdsInstanceOutput) ChargeType 

func (o InstancesRdsInstanceOutput) ChargeType() pulumi.StringOutput

The charge type of the RDS instance.

func (InstancesRdsInstanceOutput) ConnectionInfo 

func (o InstancesRdsInstanceOutput) ConnectionInfo() InstancesRdsInstanceConnectionInfoOutput

The connection info ot the RDS instance.

func (InstancesRdsInstanceOutput) CreateTime 

func (o InstancesRdsInstanceOutput) CreateTime() pulumi.StringOutput

The create time of the RDS instance.

func (InstancesRdsInstanceOutput) DbEngine 

func (o InstancesRdsInstanceOutput) DbEngine() pulumi.StringOutput

The engine of the RDS instance.

func (InstancesRdsInstanceOutput) DbEngineVersion 

func (o InstancesRdsInstanceOutput) DbEngineVersion() pulumi.StringOutput

The engine version of the RDS instance.

func (InstancesRdsInstanceOutput) ElementType 

func (InstancesRdsInstanceOutput) ElementType() reflect.Type

func (InstancesRdsInstanceOutput) Id 

func (o InstancesRdsInstanceOutput) Id() pulumi.StringOutput

The ID of the RDS instance.

func (InstancesRdsInstanceOutput) InstanceId 

func (o InstancesRdsInstanceOutput) InstanceId() pulumi.StringOutput

The id of the RDS instance.

func (InstancesRdsInstanceOutput) InstanceName 

func (o InstancesRdsInstanceOutput) InstanceName() pulumi.StringOutput

The name of the RDS instance.

func (InstancesRdsInstanceOutput) InstanceSpec 

func (o InstancesRdsInstanceOutput) InstanceSpec() InstancesRdsInstanceInstanceSpecOutput

The spec type detail of RDS instance.

func (InstancesRdsInstanceOutput) InstanceStatus 

func (o InstancesRdsInstanceOutput) InstanceStatus() pulumi.StringOutput

The status of the RDS instance.

func (InstancesRdsInstanceOutput) InstanceType 

func (o InstancesRdsInstanceOutput) InstanceType() pulumi.StringOutput

The type of the RDS instance.

func (InstancesRdsInstanceOutput) ReadOnlyInstanceIds 

func (o InstancesRdsInstanceOutput) ReadOnlyInstanceIds() pulumi.StringArrayOutput

func (InstancesRdsInstanceOutput) Region 

func (o InstancesRdsInstanceOutput) Region() pulumi.StringOutput

The region of the RDS instance.

func (InstancesRdsInstanceOutput) StorageSpaceGb 

func (o InstancesRdsInstanceOutput) StorageSpaceGb() pulumi.IntOutput

The total storage GB of the RDS instance.

func (InstancesRdsInstanceOutput) ToInstancesRdsInstanceOutput 

func (o InstancesRdsInstanceOutput) ToInstancesRdsInstanceOutput() InstancesRdsInstanceOutput

func (InstancesRdsInstanceOutput) ToInstancesRdsInstanceOutputWithContext 

func (o InstancesRdsInstanceOutput) ToInstancesRdsInstanceOutputWithContext(ctx context.Context) InstancesRdsInstanceOutput

func (InstancesRdsInstanceOutput) UpdateTime 

func (o InstancesRdsInstanceOutput) UpdateTime() pulumi.StringOutput

The update time of the RDS instance.

func (InstancesRdsInstanceOutput) VpcId 

func (o InstancesRdsInstanceOutput) VpcId() pulumi.StringOutput

The vpc ID of the RDS instance.

func (InstancesRdsInstanceOutput) Zone 

func (o InstancesRdsInstanceOutput) Zone() pulumi.StringOutput

The available zone of the RDS instance.

type InstancesResult 

type InstancesResult struct {
	CreateEndTime   *string `pulumi:"createEndTime"`
	CreateStartTime *string `pulumi:"createStartTime"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// The ID of the RDS instance.
	InstanceId *string `pulumi:"instanceId"`
	// The status of the RDS instance.
	InstanceStatus *string `pulumi:"instanceStatus"`
	// The type of the RDS instance.
	InstanceType *string `pulumi:"instanceType"`
	NameRegex    *string `pulumi:"nameRegex"`
	OutputFile   *string `pulumi:"outputFile"`
	// The collection of RDS instance query.
	RdsInstances []InstancesRdsInstance `pulumi:"rdsInstances"`
	// The region of the RDS instance.
	Region *string `pulumi:"region"`
	// The total count of RDS instance query.
	TotalCount int `pulumi:"totalCount"`
	// The available zone of the RDS instance.
	Zone *string `pulumi:"zone"`
}

A collection of values returned by Instances.

func Instances 

func Instances(ctx *pulumi.Context, args *InstancesArgs, opts ...pulumi.InvokeOption) (*InstancesResult, error)

(Deprecated! Recommend use volcengine_rds_mysql_*** replace) Use this data source to query detailed information of rds instances ## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.Instances(ctx, &rds.InstancesArgs{
			InstanceId: pulumi.StringRef("mysql-0fdd3bab2e7c"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type InstancesResultOutput 

type InstancesResultOutput struct{ *pulumi.OutputState }

A collection of values returned by Instances.

func InstancesOutput 

func InstancesOutput(ctx *pulumi.Context, args InstancesOutputArgs, opts ...pulumi.InvokeOption) InstancesResultOutput

func (InstancesResultOutput) CreateEndTime 

func (o InstancesResultOutput) CreateEndTime() pulumi.StringPtrOutput

func (InstancesResultOutput) CreateStartTime 

func (o InstancesResultOutput) CreateStartTime() pulumi.StringPtrOutput

func (InstancesResultOutput) ElementType 

func (InstancesResultOutput) ElementType() reflect.Type

func (InstancesResultOutput) Id 

func (o InstancesResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (InstancesResultOutput) InstanceId 

func (o InstancesResultOutput) InstanceId() pulumi.StringPtrOutput

The ID of the RDS instance.

func (InstancesResultOutput) InstanceStatus 

func (o InstancesResultOutput) InstanceStatus() pulumi.StringPtrOutput

The status of the RDS instance.

func (InstancesResultOutput) InstanceType 

func (o InstancesResultOutput) InstanceType() pulumi.StringPtrOutput

The type of the RDS instance.

func (InstancesResultOutput) NameRegex 

func (o InstancesResultOutput) NameRegex() pulumi.StringPtrOutput

func (InstancesResultOutput) OutputFile 

func (o InstancesResultOutput) OutputFile() pulumi.StringPtrOutput

func (InstancesResultOutput) RdsInstances 

func (o InstancesResultOutput) RdsInstances() InstancesRdsInstanceArrayOutput

The collection of RDS instance query.

func (InstancesResultOutput) Region 

func (o InstancesResultOutput) Region() pulumi.StringPtrOutput

The region of the RDS instance.

func (InstancesResultOutput) ToInstancesResultOutput 

func (o InstancesResultOutput) ToInstancesResultOutput() InstancesResultOutput

func (InstancesResultOutput) ToInstancesResultOutputWithContext 

func (o InstancesResultOutput) ToInstancesResultOutputWithContext(ctx context.Context) InstancesResultOutput

func (InstancesResultOutput) TotalCount 

func (o InstancesResultOutput) TotalCount() pulumi.IntOutput

The total count of RDS instance query.

func (InstancesResultOutput) Zone 

func (o InstancesResultOutput) Zone() pulumi.StringPtrOutput

The available zone of the RDS instance.

type IpList 

type IpList struct {
	pulumi.CustomResourceState

	// The name of the RDS ip list.
	GroupName pulumi.StringOutput `pulumi:"groupName"`
	// The ID of the RDS instance.
	InstanceId pulumi.StringOutput `pulumi:"instanceId"`
	// The list of IP address.
	IpLists pulumi.StringArrayOutput `pulumi:"ipLists"`
}

(Deprecated! Recommend use volcengine_rds_mysql_*** replace) Provides a resource to manage rds ip list ## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.NewIpList(ctx, "foo", &rds.IpListArgs{
			GroupName:  pulumi.String("foo"),
			InstanceId: pulumi.String("mysql-0fdd3bab2e7c"),
			IpLists: pulumi.StringArray{
				pulumi.String("1.1.1.1"),
				pulumi.String("2.2.2.2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

RDSIPList can be imported using the id, e.g.

```sh 

$ pulumi import volcengine:rds/ipList:IpList default mysql-42b38c769c4b:group_name

```

func GetIpList 

func GetIpList(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IpListState, opts ...pulumi.ResourceOption) (*IpList, error)

GetIpList gets an existing IpList 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 NewIpList 

func NewIpList(ctx *pulumi.Context,
	name string, args *IpListArgs, opts ...pulumi.ResourceOption) (*IpList, error)

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

func (*IpList) ElementType 

func (*IpList) ElementType() reflect.Type

func (*IpList) ToIpListOutput 

func (i *IpList) ToIpListOutput() IpListOutput

func (*IpList) ToIpListOutputWithContext 

func (i *IpList) ToIpListOutputWithContext(ctx context.Context) IpListOutput

type IpListArgs 

type IpListArgs struct {
	// The name of the RDS ip list.
	GroupName pulumi.StringInput
	// The ID of the RDS instance.
	InstanceId pulumi.StringInput
	// The list of IP address.
	IpLists pulumi.StringArrayInput
}

The set of arguments for constructing a IpList resource.

func (IpListArgs) ElementType 

func (IpListArgs) ElementType() reflect.Type

type IpListArray 

type IpListArray []IpListInput

func (IpListArray) ElementType 

func (IpListArray) ElementType() reflect.Type

func (IpListArray) ToIpListArrayOutput 

func (i IpListArray) ToIpListArrayOutput() IpListArrayOutput

func (IpListArray) ToIpListArrayOutputWithContext 

func (i IpListArray) ToIpListArrayOutputWithContext(ctx context.Context) IpListArrayOutput

type IpListArrayInput 

type IpListArrayInput interface {
	pulumi.Input

	ToIpListArrayOutput() IpListArrayOutput
	ToIpListArrayOutputWithContext(context.Context) IpListArrayOutput
}

IpListArrayInput is an input type that accepts IpListArray and IpListArrayOutput values. You can construct a concrete instance of `IpListArrayInput` via: 

IpListArray{ IpListArgs{...} }

type IpListArrayOutput 

type IpListArrayOutput struct{ *pulumi.OutputState }

func (IpListArrayOutput) ElementType 

func (IpListArrayOutput) ElementType() reflect.Type

func (IpListArrayOutput) Index 

func (o IpListArrayOutput) Index(i pulumi.IntInput) IpListOutput

func (IpListArrayOutput) ToIpListArrayOutput 

func (o IpListArrayOutput) ToIpListArrayOutput() IpListArrayOutput

func (IpListArrayOutput) ToIpListArrayOutputWithContext 

func (o IpListArrayOutput) ToIpListArrayOutputWithContext(ctx context.Context) IpListArrayOutput

type IpListInput 

type IpListInput interface {
	pulumi.Input

	ToIpListOutput() IpListOutput
	ToIpListOutputWithContext(ctx context.Context) IpListOutput
}

type IpListMap 

type IpListMap map[string]IpListInput

func (IpListMap) ElementType 

func (IpListMap) ElementType() reflect.Type

func (IpListMap) ToIpListMapOutput 

func (i IpListMap) ToIpListMapOutput() IpListMapOutput

func (IpListMap) ToIpListMapOutputWithContext 

func (i IpListMap) ToIpListMapOutputWithContext(ctx context.Context) IpListMapOutput

type IpListMapInput 

type IpListMapInput interface {
	pulumi.Input

	ToIpListMapOutput() IpListMapOutput
	ToIpListMapOutputWithContext(context.Context) IpListMapOutput
}

IpListMapInput is an input type that accepts IpListMap and IpListMapOutput values. You can construct a concrete instance of `IpListMapInput` via: 

IpListMap{ "key": IpListArgs{...} }

type IpListMapOutput 

type IpListMapOutput struct{ *pulumi.OutputState }

func (IpListMapOutput) ElementType 

func (IpListMapOutput) ElementType() reflect.Type

func (IpListMapOutput) MapIndex 

func (o IpListMapOutput) MapIndex(k pulumi.StringInput) IpListOutput

func (IpListMapOutput) ToIpListMapOutput 

func (o IpListMapOutput) ToIpListMapOutput() IpListMapOutput

func (IpListMapOutput) ToIpListMapOutputWithContext 

func (o IpListMapOutput) ToIpListMapOutputWithContext(ctx context.Context) IpListMapOutput

type IpListOutput 

type IpListOutput struct{ *pulumi.OutputState }

func (IpListOutput) ElementType 

func (IpListOutput) ElementType() reflect.Type

func (IpListOutput) GroupName 

func (o IpListOutput) GroupName() pulumi.StringOutput

The name of the RDS ip list.

func (IpListOutput) InstanceId 

func (o IpListOutput) InstanceId() pulumi.StringOutput

The ID of the RDS instance.

func (IpListOutput) IpLists 

func (o IpListOutput) IpLists() pulumi.StringArrayOutput

The list of IP address.

func (IpListOutput) ToIpListOutput 

func (o IpListOutput) ToIpListOutput() IpListOutput

func (IpListOutput) ToIpListOutputWithContext 

func (o IpListOutput) ToIpListOutputWithContext(ctx context.Context) IpListOutput

type IpListState 

type IpListState struct {
	// The name of the RDS ip list.
	GroupName pulumi.StringPtrInput
	// The ID of the RDS instance.
	InstanceId pulumi.StringPtrInput
	// The list of IP address.
	IpLists pulumi.StringArrayInput
}

func (IpListState) ElementType 

func (IpListState) ElementType() reflect.Type

type IpListsArgs 

type IpListsArgs struct {
	// The id of the RDS instance.
	InstanceId string `pulumi:"instanceId"`
	// A Name Regex of RDS ip list.
	NameRegex *string `pulumi:"nameRegex"`
	// File name where to save data source results.
	OutputFile *string `pulumi:"outputFile"`
}

A collection of arguments for invoking IpLists.

type IpListsOutputArgs 

type IpListsOutputArgs struct {
	// The id of the RDS instance.
	InstanceId pulumi.StringInput `pulumi:"instanceId"`
	// A Name Regex of RDS ip list.
	NameRegex pulumi.StringPtrInput `pulumi:"nameRegex"`
	// File name where to save data source results.
	OutputFile pulumi.StringPtrInput `pulumi:"outputFile"`
}

A collection of arguments for invoking IpLists.

func (IpListsOutputArgs) ElementType 

func (IpListsOutputArgs) ElementType() reflect.Type

type IpListsRdsIpList 

type IpListsRdsIpList struct {
	// The name of the RDS ip list.
	GroupName string `pulumi:"groupName"`
	// The ID of the RDS ip list.
	Id string `pulumi:"id"`
	// The list of IP address.
	IpLists []string `pulumi:"ipLists"`
}

type IpListsRdsIpListArgs 

type IpListsRdsIpListArgs struct {
	// The name of the RDS ip list.
	GroupName pulumi.StringInput `pulumi:"groupName"`
	// The ID of the RDS ip list.
	Id pulumi.StringInput `pulumi:"id"`
	// The list of IP address.
	IpLists pulumi.StringArrayInput `pulumi:"ipLists"`
}

func (IpListsRdsIpListArgs) ElementType 

func (IpListsRdsIpListArgs) ElementType() reflect.Type

func (IpListsRdsIpListArgs) ToIpListsRdsIpListOutput 

func (i IpListsRdsIpListArgs) ToIpListsRdsIpListOutput() IpListsRdsIpListOutput

func (IpListsRdsIpListArgs) ToIpListsRdsIpListOutputWithContext 

func (i IpListsRdsIpListArgs) ToIpListsRdsIpListOutputWithContext(ctx context.Context) IpListsRdsIpListOutput

type IpListsRdsIpListArray 

type IpListsRdsIpListArray []IpListsRdsIpListInput

func (IpListsRdsIpListArray) ElementType 

func (IpListsRdsIpListArray) ElementType() reflect.Type

func (IpListsRdsIpListArray) ToIpListsRdsIpListArrayOutput 

func (i IpListsRdsIpListArray) ToIpListsRdsIpListArrayOutput() IpListsRdsIpListArrayOutput

func (IpListsRdsIpListArray) ToIpListsRdsIpListArrayOutputWithContext 

func (i IpListsRdsIpListArray) ToIpListsRdsIpListArrayOutputWithContext(ctx context.Context) IpListsRdsIpListArrayOutput

type IpListsRdsIpListArrayInput 

type IpListsRdsIpListArrayInput interface {
	pulumi.Input

	ToIpListsRdsIpListArrayOutput() IpListsRdsIpListArrayOutput
	ToIpListsRdsIpListArrayOutputWithContext(context.Context) IpListsRdsIpListArrayOutput
}

IpListsRdsIpListArrayInput is an input type that accepts IpListsRdsIpListArray and IpListsRdsIpListArrayOutput values. You can construct a concrete instance of `IpListsRdsIpListArrayInput` via: 

IpListsRdsIpListArray{ IpListsRdsIpListArgs{...} }

type IpListsRdsIpListArrayOutput 

type IpListsRdsIpListArrayOutput struct{ *pulumi.OutputState }

func (IpListsRdsIpListArrayOutput) ElementType 

func (IpListsRdsIpListArrayOutput) ElementType() reflect.Type

func (IpListsRdsIpListArrayOutput) Index 

func (o IpListsRdsIpListArrayOutput) Index(i pulumi.IntInput) IpListsRdsIpListOutput

func (IpListsRdsIpListArrayOutput) ToIpListsRdsIpListArrayOutput 

func (o IpListsRdsIpListArrayOutput) ToIpListsRdsIpListArrayOutput() IpListsRdsIpListArrayOutput

func (IpListsRdsIpListArrayOutput) ToIpListsRdsIpListArrayOutputWithContext 

func (o IpListsRdsIpListArrayOutput) ToIpListsRdsIpListArrayOutputWithContext(ctx context.Context) IpListsRdsIpListArrayOutput

type IpListsRdsIpListInput 

type IpListsRdsIpListInput interface {
	pulumi.Input

	ToIpListsRdsIpListOutput() IpListsRdsIpListOutput
	ToIpListsRdsIpListOutputWithContext(context.Context) IpListsRdsIpListOutput
}

IpListsRdsIpListInput is an input type that accepts IpListsRdsIpListArgs and IpListsRdsIpListOutput values. You can construct a concrete instance of `IpListsRdsIpListInput` via: 

IpListsRdsIpListArgs{...}

type IpListsRdsIpListOutput 

type IpListsRdsIpListOutput struct{ *pulumi.OutputState }

func (IpListsRdsIpListOutput) ElementType 

func (IpListsRdsIpListOutput) ElementType() reflect.Type

func (IpListsRdsIpListOutput) GroupName 

func (o IpListsRdsIpListOutput) GroupName() pulumi.StringOutput

The name of the RDS ip list.

func (IpListsRdsIpListOutput) Id 

func (o IpListsRdsIpListOutput) Id() pulumi.StringOutput

The ID of the RDS ip list.

func (IpListsRdsIpListOutput) IpLists 

func (o IpListsRdsIpListOutput) IpLists() pulumi.StringArrayOutput

The list of IP address.

func (IpListsRdsIpListOutput) ToIpListsRdsIpListOutput 

func (o IpListsRdsIpListOutput) ToIpListsRdsIpListOutput() IpListsRdsIpListOutput

func (IpListsRdsIpListOutput) ToIpListsRdsIpListOutputWithContext 

func (o IpListsRdsIpListOutput) ToIpListsRdsIpListOutputWithContext(ctx context.Context) IpListsRdsIpListOutput

type IpListsResult 

type IpListsResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id         string  `pulumi:"id"`
	InstanceId string  `pulumi:"instanceId"`
	NameRegex  *string `pulumi:"nameRegex"`
	OutputFile *string `pulumi:"outputFile"`
	// The collection of RDS ip list account query.
	RdsIpLists []IpListsRdsIpList `pulumi:"rdsIpLists"`
	// The total count of RDS ip list query.
	TotalCount int `pulumi:"totalCount"`
}

A collection of values returned by IpLists.

func IpLists 

func IpLists(ctx *pulumi.Context, args *IpListsArgs, opts ...pulumi.InvokeOption) (*IpListsResult, error)

(Deprecated! Recommend use volcengine_rds_mysql_*** replace) Use this data source to query detailed information of rds ip lists ## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.IpLists(ctx, &rds.IpListsArgs{
			InstanceId: "mysql-0fdd3bab2e7c",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type IpListsResultOutput 

type IpListsResultOutput struct{ *pulumi.OutputState }

A collection of values returned by IpLists.

func IpListsOutput 

func IpListsOutput(ctx *pulumi.Context, args IpListsOutputArgs, opts ...pulumi.InvokeOption) IpListsResultOutput

func (IpListsResultOutput) ElementType 

func (IpListsResultOutput) ElementType() reflect.Type

func (IpListsResultOutput) Id 

func (o IpListsResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (IpListsResultOutput) InstanceId 

func (o IpListsResultOutput) InstanceId() pulumi.StringOutput

func (IpListsResultOutput) NameRegex 

func (o IpListsResultOutput) NameRegex() pulumi.StringPtrOutput

func (IpListsResultOutput) OutputFile 

func (o IpListsResultOutput) OutputFile() pulumi.StringPtrOutput

func (IpListsResultOutput) RdsIpLists 

func (o IpListsResultOutput) RdsIpLists() IpListsRdsIpListArrayOutput

The collection of RDS ip list account query.

func (IpListsResultOutput) ToIpListsResultOutput 

func (o IpListsResultOutput) ToIpListsResultOutput() IpListsResultOutput

func (IpListsResultOutput) ToIpListsResultOutputWithContext 

func (o IpListsResultOutput) ToIpListsResultOutputWithContext(ctx context.Context) IpListsResultOutput

func (IpListsResultOutput) TotalCount 

func (o IpListsResultOutput) TotalCount() pulumi.IntOutput

The total count of RDS ip list query.

type ParameterTemplate 

type ParameterTemplate struct {
	pulumi.CustomResourceState

	// Parameter template description.
	TemplateDesc pulumi.StringPtrOutput `pulumi:"templateDesc"`
	// Parameter template name.
	TemplateName pulumi.StringOutput `pulumi:"templateName"`
	// Template parameters. InstanceParam only needs to pass Name and RunningValue.
	TemplateParams ParameterTemplateTemplateParamArrayOutput `pulumi:"templateParams"`
	// Parameter template database type, range of values:
	// MySQL - MySQL database. (Defaults).
	TemplateType pulumi.StringPtrOutput `pulumi:"templateType"`
	// Parameter template database version, value range:
	// MySQL_Community_5_7 - MySQL 5.7 (default)
	// MySQL_8_0 - MySQL 8.0.
	TemplateTypeVersion pulumi.StringPtrOutput `pulumi:"templateTypeVersion"`
}

(Deprecated! Recommend use volcengine_rds_mysql_*** replace) Provides a resource to manage rds parameter template ## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.NewParameterTemplate(ctx, "foo", &rds.ParameterTemplateArgs{
			TemplateDesc: pulumi.String("created by terraform"),
			TemplateName: pulumi.String("tf-template"),
			TemplateParams: rds.ParameterTemplateTemplateParamArray{
				&rds.ParameterTemplateTemplateParamArgs{
					Name:         pulumi.String("auto_increment_increment"),
					RunningValue: pulumi.String("2"),
				},
				&rds.ParameterTemplateTemplateParamArgs{
					Name:         pulumi.String("slow_query_log"),
					RunningValue: pulumi.String("ON"),
				},
				&rds.ParameterTemplateTemplateParamArgs{
					Name:         pulumi.String("net_retry_count"),
					RunningValue: pulumi.String("33"),
				},
			},
			TemplateType:        pulumi.String("MySQL"),
			TemplateTypeVersion: pulumi.String("MySQL_Community_5_7"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

RDS Instance can be imported using the id, e.g.

```sh 

$ pulumi import volcengine:rds/parameterTemplate:ParameterTemplate default mysql-sys-80bb93aa14be22d0

```

func GetParameterTemplate 

func GetParameterTemplate(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ParameterTemplateState, opts ...pulumi.ResourceOption) (*ParameterTemplate, error)

GetParameterTemplate gets an existing ParameterTemplate 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 NewParameterTemplate 

func NewParameterTemplate(ctx *pulumi.Context,
	name string, args *ParameterTemplateArgs, opts ...pulumi.ResourceOption) (*ParameterTemplate, error)

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

func (*ParameterTemplate) ElementType 

func (*ParameterTemplate) ElementType() reflect.Type

func (*ParameterTemplate) ToParameterTemplateOutput 

func (i *ParameterTemplate) ToParameterTemplateOutput() ParameterTemplateOutput

func (*ParameterTemplate) ToParameterTemplateOutputWithContext 

func (i *ParameterTemplate) ToParameterTemplateOutputWithContext(ctx context.Context) ParameterTemplateOutput

type ParameterTemplateArgs 

type ParameterTemplateArgs struct {
	// Parameter template description.
	TemplateDesc pulumi.StringPtrInput
	// Parameter template name.
	TemplateName pulumi.StringInput
	// Template parameters. InstanceParam only needs to pass Name and RunningValue.
	TemplateParams ParameterTemplateTemplateParamArrayInput
	// Parameter template database type, range of values:
	// MySQL - MySQL database. (Defaults).
	TemplateType pulumi.StringPtrInput
	// Parameter template database version, value range:
	// MySQL_Community_5_7 - MySQL 5.7 (default)
	// MySQL_8_0 - MySQL 8.0.
	TemplateTypeVersion pulumi.StringPtrInput
}

The set of arguments for constructing a ParameterTemplate resource.

func (ParameterTemplateArgs) ElementType 

func (ParameterTemplateArgs) ElementType() reflect.Type

type ParameterTemplateArray 

type ParameterTemplateArray []ParameterTemplateInput

func (ParameterTemplateArray) ElementType 

func (ParameterTemplateArray) ElementType() reflect.Type

func (ParameterTemplateArray) ToParameterTemplateArrayOutput 

func (i ParameterTemplateArray) ToParameterTemplateArrayOutput() ParameterTemplateArrayOutput

func (ParameterTemplateArray) ToParameterTemplateArrayOutputWithContext 

func (i ParameterTemplateArray) ToParameterTemplateArrayOutputWithContext(ctx context.Context) ParameterTemplateArrayOutput

type ParameterTemplateArrayInput 

type ParameterTemplateArrayInput interface {
	pulumi.Input

	ToParameterTemplateArrayOutput() ParameterTemplateArrayOutput
	ToParameterTemplateArrayOutputWithContext(context.Context) ParameterTemplateArrayOutput
}

ParameterTemplateArrayInput is an input type that accepts ParameterTemplateArray and ParameterTemplateArrayOutput values. You can construct a concrete instance of `ParameterTemplateArrayInput` via: 

ParameterTemplateArray{ ParameterTemplateArgs{...} }

type ParameterTemplateArrayOutput 

type ParameterTemplateArrayOutput struct{ *pulumi.OutputState }

func (ParameterTemplateArrayOutput) ElementType 

func (ParameterTemplateArrayOutput) ElementType() reflect.Type

func (ParameterTemplateArrayOutput) Index 

func (o ParameterTemplateArrayOutput) Index(i pulumi.IntInput) ParameterTemplateOutput

func (ParameterTemplateArrayOutput) ToParameterTemplateArrayOutput 

func (o ParameterTemplateArrayOutput) ToParameterTemplateArrayOutput() ParameterTemplateArrayOutput

func (ParameterTemplateArrayOutput) ToParameterTemplateArrayOutputWithContext 

func (o ParameterTemplateArrayOutput) ToParameterTemplateArrayOutputWithContext(ctx context.Context) ParameterTemplateArrayOutput

type ParameterTemplateInput 

type ParameterTemplateInput interface {
	pulumi.Input

	ToParameterTemplateOutput() ParameterTemplateOutput
	ToParameterTemplateOutputWithContext(ctx context.Context) ParameterTemplateOutput
}

type ParameterTemplateMap 

type ParameterTemplateMap map[string]ParameterTemplateInput

func (ParameterTemplateMap) ElementType 

func (ParameterTemplateMap) ElementType() reflect.Type

func (ParameterTemplateMap) ToParameterTemplateMapOutput 

func (i ParameterTemplateMap) ToParameterTemplateMapOutput() ParameterTemplateMapOutput

func (ParameterTemplateMap) ToParameterTemplateMapOutputWithContext 

func (i ParameterTemplateMap) ToParameterTemplateMapOutputWithContext(ctx context.Context) ParameterTemplateMapOutput

type ParameterTemplateMapInput 

type ParameterTemplateMapInput interface {
	pulumi.Input

	ToParameterTemplateMapOutput() ParameterTemplateMapOutput
	ToParameterTemplateMapOutputWithContext(context.Context) ParameterTemplateMapOutput
}

ParameterTemplateMapInput is an input type that accepts ParameterTemplateMap and ParameterTemplateMapOutput values. You can construct a concrete instance of `ParameterTemplateMapInput` via: 

ParameterTemplateMap{ "key": ParameterTemplateArgs{...} }

type ParameterTemplateMapOutput 

type ParameterTemplateMapOutput struct{ *pulumi.OutputState }

func (ParameterTemplateMapOutput) ElementType 

func (ParameterTemplateMapOutput) ElementType() reflect.Type

func (ParameterTemplateMapOutput) MapIndex 

func (o ParameterTemplateMapOutput) MapIndex(k pulumi.StringInput) ParameterTemplateOutput

func (ParameterTemplateMapOutput) ToParameterTemplateMapOutput 

func (o ParameterTemplateMapOutput) ToParameterTemplateMapOutput() ParameterTemplateMapOutput

func (ParameterTemplateMapOutput) ToParameterTemplateMapOutputWithContext 

func (o ParameterTemplateMapOutput) ToParameterTemplateMapOutputWithContext(ctx context.Context) ParameterTemplateMapOutput

type ParameterTemplateOutput 

type ParameterTemplateOutput struct{ *pulumi.OutputState }

func (ParameterTemplateOutput) ElementType 

func (ParameterTemplateOutput) ElementType() reflect.Type

func (ParameterTemplateOutput) TemplateDesc 

func (o ParameterTemplateOutput) TemplateDesc() pulumi.StringPtrOutput

Parameter template description.

func (ParameterTemplateOutput) TemplateName 

func (o ParameterTemplateOutput) TemplateName() pulumi.StringOutput

Parameter template name.

func (ParameterTemplateOutput) TemplateParams 

func (o ParameterTemplateOutput) TemplateParams() ParameterTemplateTemplateParamArrayOutput

Template parameters. InstanceParam only needs to pass Name and RunningValue.

func (ParameterTemplateOutput) TemplateType 

func (o ParameterTemplateOutput) TemplateType() pulumi.StringPtrOutput

Parameter template database type, range of values: MySQL - MySQL database. (Defaults).

func (ParameterTemplateOutput) TemplateTypeVersion 

func (o ParameterTemplateOutput) TemplateTypeVersion() pulumi.StringPtrOutput

Parameter template database version, value range: MySQL_Community_5_7 - MySQL 5.7 (default) MySQL_8_0 - MySQL 8.0.

func (ParameterTemplateOutput) ToParameterTemplateOutput 

func (o ParameterTemplateOutput) ToParameterTemplateOutput() ParameterTemplateOutput

func (ParameterTemplateOutput) ToParameterTemplateOutputWithContext 

func (o ParameterTemplateOutput) ToParameterTemplateOutputWithContext(ctx context.Context) ParameterTemplateOutput

type ParameterTemplateState 

type ParameterTemplateState struct {
	// Parameter template description.
	TemplateDesc pulumi.StringPtrInput
	// Parameter template name.
	TemplateName pulumi.StringPtrInput
	// Template parameters. InstanceParam only needs to pass Name and RunningValue.
	TemplateParams ParameterTemplateTemplateParamArrayInput
	// Parameter template database type, range of values:
	// MySQL - MySQL database. (Defaults).
	TemplateType pulumi.StringPtrInput
	// Parameter template database version, value range:
	// MySQL_Community_5_7 - MySQL 5.7 (default)
	// MySQL_8_0 - MySQL 8.0.
	TemplateTypeVersion pulumi.StringPtrInput
}

func (ParameterTemplateState) ElementType 

func (ParameterTemplateState) ElementType() reflect.Type

type ParameterTemplateTemplateParam 

type ParameterTemplateTemplateParam struct {
	// Parameter name.
	Name *string `pulumi:"name"`
	// Parameter running value.
	RunningValue *string `pulumi:"runningValue"`
}

type ParameterTemplateTemplateParamArgs 

type ParameterTemplateTemplateParamArgs struct {
	// Parameter name.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// Parameter running value.
	RunningValue pulumi.StringPtrInput `pulumi:"runningValue"`
}

func (ParameterTemplateTemplateParamArgs) ElementType 

func (ParameterTemplateTemplateParamArgs) ElementType() reflect.Type

func (ParameterTemplateTemplateParamArgs) ToParameterTemplateTemplateParamOutput 

func (i ParameterTemplateTemplateParamArgs) ToParameterTemplateTemplateParamOutput() ParameterTemplateTemplateParamOutput

func (ParameterTemplateTemplateParamArgs) ToParameterTemplateTemplateParamOutputWithContext 

func (i ParameterTemplateTemplateParamArgs) ToParameterTemplateTemplateParamOutputWithContext(ctx context.Context) ParameterTemplateTemplateParamOutput

type ParameterTemplateTemplateParamArray 

type ParameterTemplateTemplateParamArray []ParameterTemplateTemplateParamInput

func (ParameterTemplateTemplateParamArray) ElementType 

func (ParameterTemplateTemplateParamArray) ElementType() reflect.Type

func (ParameterTemplateTemplateParamArray) ToParameterTemplateTemplateParamArrayOutput 

func (i ParameterTemplateTemplateParamArray) ToParameterTemplateTemplateParamArrayOutput() ParameterTemplateTemplateParamArrayOutput

func (ParameterTemplateTemplateParamArray) ToParameterTemplateTemplateParamArrayOutputWithContext 

func (i ParameterTemplateTemplateParamArray) ToParameterTemplateTemplateParamArrayOutputWithContext(ctx context.Context) ParameterTemplateTemplateParamArrayOutput

type ParameterTemplateTemplateParamArrayInput 

type ParameterTemplateTemplateParamArrayInput interface {
	pulumi.Input

	ToParameterTemplateTemplateParamArrayOutput() ParameterTemplateTemplateParamArrayOutput
	ToParameterTemplateTemplateParamArrayOutputWithContext(context.Context) ParameterTemplateTemplateParamArrayOutput
}

ParameterTemplateTemplateParamArrayInput is an input type that accepts ParameterTemplateTemplateParamArray and ParameterTemplateTemplateParamArrayOutput values. You can construct a concrete instance of `ParameterTemplateTemplateParamArrayInput` via: 

ParameterTemplateTemplateParamArray{ ParameterTemplateTemplateParamArgs{...} }

type ParameterTemplateTemplateParamArrayOutput 

type ParameterTemplateTemplateParamArrayOutput struct{ *pulumi.OutputState }

func (ParameterTemplateTemplateParamArrayOutput) ElementType 

func (ParameterTemplateTemplateParamArrayOutput) ElementType() reflect.Type

func (ParameterTemplateTemplateParamArrayOutput) Index 

func (o ParameterTemplateTemplateParamArrayOutput) Index(i pulumi.IntInput) ParameterTemplateTemplateParamOutput

func (ParameterTemplateTemplateParamArrayOutput) ToParameterTemplateTemplateParamArrayOutput 

func (o ParameterTemplateTemplateParamArrayOutput) ToParameterTemplateTemplateParamArrayOutput() ParameterTemplateTemplateParamArrayOutput

func (ParameterTemplateTemplateParamArrayOutput) ToParameterTemplateTemplateParamArrayOutputWithContext 

func (o ParameterTemplateTemplateParamArrayOutput) ToParameterTemplateTemplateParamArrayOutputWithContext(ctx context.Context) ParameterTemplateTemplateParamArrayOutput

type ParameterTemplateTemplateParamInput 

type ParameterTemplateTemplateParamInput interface {
	pulumi.Input

	ToParameterTemplateTemplateParamOutput() ParameterTemplateTemplateParamOutput
	ToParameterTemplateTemplateParamOutputWithContext(context.Context) ParameterTemplateTemplateParamOutput
}

ParameterTemplateTemplateParamInput is an input type that accepts ParameterTemplateTemplateParamArgs and ParameterTemplateTemplateParamOutput values. You can construct a concrete instance of `ParameterTemplateTemplateParamInput` via: 

ParameterTemplateTemplateParamArgs{...}

type ParameterTemplateTemplateParamOutput 

type ParameterTemplateTemplateParamOutput struct{ *pulumi.OutputState }

func (ParameterTemplateTemplateParamOutput) ElementType 

func (ParameterTemplateTemplateParamOutput) ElementType() reflect.Type

func (ParameterTemplateTemplateParamOutput) Name 

func (o ParameterTemplateTemplateParamOutput) Name() pulumi.StringPtrOutput

Parameter name.

func (ParameterTemplateTemplateParamOutput) RunningValue 

func (o ParameterTemplateTemplateParamOutput) RunningValue() pulumi.StringPtrOutput

Parameter running value.

func (ParameterTemplateTemplateParamOutput) ToParameterTemplateTemplateParamOutput 

func (o ParameterTemplateTemplateParamOutput) ToParameterTemplateTemplateParamOutput() ParameterTemplateTemplateParamOutput

func (ParameterTemplateTemplateParamOutput) ToParameterTemplateTemplateParamOutputWithContext 

func (o ParameterTemplateTemplateParamOutput) ToParameterTemplateTemplateParamOutputWithContext(ctx context.Context) ParameterTemplateTemplateParamOutput

type ParameterTemplatesArgs 

type ParameterTemplatesArgs struct {
	// A Name Regex of RDS parameter template.
	NameRegex *string `pulumi:"nameRegex"`
	// File name where to save data source results.
	OutputFile *string `pulumi:"outputFile"`
	// Parameter template type, range of values:
	// DBEngine - Engine parameters.
	TemplateCategory *string `pulumi:"templateCategory"`
	// Template source, value range:
	// System - System
	// User - the user.
	TemplateSource *string `pulumi:"templateSource"`
	// Parameter template database type, range of values:
	// MySQL - MySQL database.
	TemplateType *string `pulumi:"templateType"`
	// Parameter template database version, value range:
	// MySQL_Community_5_7 - MySQL 5.7
	// MySQL_8_0 - MySQL 8.0.
	TemplateTypeVersion *string `pulumi:"templateTypeVersion"`
}

A collection of arguments for invoking ParameterTemplates.

type ParameterTemplatesOutputArgs 

type ParameterTemplatesOutputArgs struct {
	// A Name Regex of RDS parameter template.
	NameRegex pulumi.StringPtrInput `pulumi:"nameRegex"`
	// File name where to save data source results.
	OutputFile pulumi.StringPtrInput `pulumi:"outputFile"`
	// Parameter template type, range of values:
	// DBEngine - Engine parameters.
	TemplateCategory pulumi.StringPtrInput `pulumi:"templateCategory"`
	// Template source, value range:
	// System - System
	// User - the user.
	TemplateSource pulumi.StringPtrInput `pulumi:"templateSource"`
	// Parameter template database type, range of values:
	// MySQL - MySQL database.
	TemplateType pulumi.StringPtrInput `pulumi:"templateType"`
	// Parameter template database version, value range:
	// MySQL_Community_5_7 - MySQL 5.7
	// MySQL_8_0 - MySQL 8.0.
	TemplateTypeVersion pulumi.StringPtrInput `pulumi:"templateTypeVersion"`
}

A collection of arguments for invoking ParameterTemplates.

func (ParameterTemplatesOutputArgs) ElementType 

func (ParameterTemplatesOutputArgs) ElementType() reflect.Type

type ParameterTemplatesRdsParameterTemplate 

type ParameterTemplatesRdsParameterTemplate struct {
	// Creation time.
	CreateTime string `pulumi:"createTime"`
	// The ID of the RDS parameter template.
	Id string `pulumi:"id"`
	// Whether the template contains parameters that need to be restarted.
	NeedRestart bool `pulumi:"needRestart"`
	// The number of parameters the template contains.
	ParameterNum int `pulumi:"parameterNum"`
	// The description of the RDS parameter template.
	TemplateDesc string `pulumi:"templateDesc"`
	// The ID of the RDS parameter template.
	TemplateId string `pulumi:"templateId"`
	// The name of the RDS parameter template.
	TemplateName string `pulumi:"templateName"`
	// Parameters contained in the template.
	TemplateParams []ParameterTemplatesRdsParameterTemplateTemplateParam `pulumi:"templateParams"`
	// Parameter template database type, range of values:
	// MySQL - MySQL database.
	TemplateType string `pulumi:"templateType"`
	// Parameter template database version, value range:
	// MySQL_Community_5_7 - MySQL 5.7
	// MySQL_8_0 - MySQL 8.0.
	TemplateTypeVersion string `pulumi:"templateTypeVersion"`
	// Update time.
	UpdateTime string `pulumi:"updateTime"`
}

type ParameterTemplatesRdsParameterTemplateArgs 

type ParameterTemplatesRdsParameterTemplateArgs struct {
	// Creation time.
	CreateTime pulumi.StringInput `pulumi:"createTime"`
	// The ID of the RDS parameter template.
	Id pulumi.StringInput `pulumi:"id"`
	// Whether the template contains parameters that need to be restarted.
	NeedRestart pulumi.BoolInput `pulumi:"needRestart"`
	// The number of parameters the template contains.
	ParameterNum pulumi.IntInput `pulumi:"parameterNum"`
	// The description of the RDS parameter template.
	TemplateDesc pulumi.StringInput `pulumi:"templateDesc"`
	// The ID of the RDS parameter template.
	TemplateId pulumi.StringInput `pulumi:"templateId"`
	// The name of the RDS parameter template.
	TemplateName pulumi.StringInput `pulumi:"templateName"`
	// Parameters contained in the template.
	TemplateParams ParameterTemplatesRdsParameterTemplateTemplateParamArrayInput `pulumi:"templateParams"`
	// Parameter template database type, range of values:
	// MySQL - MySQL database.
	TemplateType pulumi.StringInput `pulumi:"templateType"`
	// Parameter template database version, value range:
	// MySQL_Community_5_7 - MySQL 5.7
	// MySQL_8_0 - MySQL 8.0.
	TemplateTypeVersion pulumi.StringInput `pulumi:"templateTypeVersion"`
	// Update time.
	UpdateTime pulumi.StringInput `pulumi:"updateTime"`
}

func (ParameterTemplatesRdsParameterTemplateArgs) ElementType 

func (ParameterTemplatesRdsParameterTemplateArgs) ElementType() reflect.Type

func (ParameterTemplatesRdsParameterTemplateArgs) ToParameterTemplatesRdsParameterTemplateOutput 

func (i ParameterTemplatesRdsParameterTemplateArgs) ToParameterTemplatesRdsParameterTemplateOutput() ParameterTemplatesRdsParameterTemplateOutput

func (ParameterTemplatesRdsParameterTemplateArgs) ToParameterTemplatesRdsParameterTemplateOutputWithContext 

func (i ParameterTemplatesRdsParameterTemplateArgs) ToParameterTemplatesRdsParameterTemplateOutputWithContext(ctx context.Context) ParameterTemplatesRdsParameterTemplateOutput

type ParameterTemplatesRdsParameterTemplateArray 

type ParameterTemplatesRdsParameterTemplateArray []ParameterTemplatesRdsParameterTemplateInput

func (ParameterTemplatesRdsParameterTemplateArray) ElementType 

func (ParameterTemplatesRdsParameterTemplateArray) ElementType() reflect.Type

func (ParameterTemplatesRdsParameterTemplateArray) ToParameterTemplatesRdsParameterTemplateArrayOutput 

func (i ParameterTemplatesRdsParameterTemplateArray) ToParameterTemplatesRdsParameterTemplateArrayOutput() ParameterTemplatesRdsParameterTemplateArrayOutput

func (ParameterTemplatesRdsParameterTemplateArray) ToParameterTemplatesRdsParameterTemplateArrayOutputWithContext 

func (i ParameterTemplatesRdsParameterTemplateArray) ToParameterTemplatesRdsParameterTemplateArrayOutputWithContext(ctx context.Context) ParameterTemplatesRdsParameterTemplateArrayOutput

type ParameterTemplatesRdsParameterTemplateArrayInput 

type ParameterTemplatesRdsParameterTemplateArrayInput interface {
	pulumi.Input

	ToParameterTemplatesRdsParameterTemplateArrayOutput() ParameterTemplatesRdsParameterTemplateArrayOutput
	ToParameterTemplatesRdsParameterTemplateArrayOutputWithContext(context.Context) ParameterTemplatesRdsParameterTemplateArrayOutput
}

ParameterTemplatesRdsParameterTemplateArrayInput is an input type that accepts ParameterTemplatesRdsParameterTemplateArray and ParameterTemplatesRdsParameterTemplateArrayOutput values. You can construct a concrete instance of `ParameterTemplatesRdsParameterTemplateArrayInput` via: 

ParameterTemplatesRdsParameterTemplateArray{ ParameterTemplatesRdsParameterTemplateArgs{...} }

type ParameterTemplatesRdsParameterTemplateArrayOutput 

type ParameterTemplatesRdsParameterTemplateArrayOutput struct{ *pulumi.OutputState }

func (ParameterTemplatesRdsParameterTemplateArrayOutput) ElementType 

func (ParameterTemplatesRdsParameterTemplateArrayOutput) ElementType() reflect.Type

func (ParameterTemplatesRdsParameterTemplateArrayOutput) Index 

func (o ParameterTemplatesRdsParameterTemplateArrayOutput) Index(i pulumi.IntInput) ParameterTemplatesRdsParameterTemplateOutput

func (ParameterTemplatesRdsParameterTemplateArrayOutput) ToParameterTemplatesRdsParameterTemplateArrayOutput 

func (o ParameterTemplatesRdsParameterTemplateArrayOutput) ToParameterTemplatesRdsParameterTemplateArrayOutput() ParameterTemplatesRdsParameterTemplateArrayOutput

func (ParameterTemplatesRdsParameterTemplateArrayOutput) ToParameterTemplatesRdsParameterTemplateArrayOutputWithContext 

func (o ParameterTemplatesRdsParameterTemplateArrayOutput) ToParameterTemplatesRdsParameterTemplateArrayOutputWithContext(ctx context.Context) ParameterTemplatesRdsParameterTemplateArrayOutput

type ParameterTemplatesRdsParameterTemplateInput 

type ParameterTemplatesRdsParameterTemplateInput interface {
	pulumi.Input

	ToParameterTemplatesRdsParameterTemplateOutput() ParameterTemplatesRdsParameterTemplateOutput
	ToParameterTemplatesRdsParameterTemplateOutputWithContext(context.Context) ParameterTemplatesRdsParameterTemplateOutput
}

ParameterTemplatesRdsParameterTemplateInput is an input type that accepts ParameterTemplatesRdsParameterTemplateArgs and ParameterTemplatesRdsParameterTemplateOutput values. You can construct a concrete instance of `ParameterTemplatesRdsParameterTemplateInput` via: 

ParameterTemplatesRdsParameterTemplateArgs{...}

type ParameterTemplatesRdsParameterTemplateOutput 

type ParameterTemplatesRdsParameterTemplateOutput struct{ *pulumi.OutputState }

func (ParameterTemplatesRdsParameterTemplateOutput) CreateTime 

func (o ParameterTemplatesRdsParameterTemplateOutput) CreateTime() pulumi.StringOutput

Creation time.

func (ParameterTemplatesRdsParameterTemplateOutput) ElementType 

func (ParameterTemplatesRdsParameterTemplateOutput) ElementType() reflect.Type

func (ParameterTemplatesRdsParameterTemplateOutput) Id 

func (o ParameterTemplatesRdsParameterTemplateOutput) Id() pulumi.StringOutput

The ID of the RDS parameter template.

func (ParameterTemplatesRdsParameterTemplateOutput) NeedRestart 

func (o ParameterTemplatesRdsParameterTemplateOutput) NeedRestart() pulumi.BoolOutput

Whether the template contains parameters that need to be restarted.

func (ParameterTemplatesRdsParameterTemplateOutput) ParameterNum 

func (o ParameterTemplatesRdsParameterTemplateOutput) ParameterNum() pulumi.IntOutput

The number of parameters the template contains.

func (ParameterTemplatesRdsParameterTemplateOutput) TemplateDesc 

func (o ParameterTemplatesRdsParameterTemplateOutput) TemplateDesc() pulumi.StringOutput

The description of the RDS parameter template.

func (ParameterTemplatesRdsParameterTemplateOutput) TemplateId 

func (o ParameterTemplatesRdsParameterTemplateOutput) TemplateId() pulumi.StringOutput

The ID of the RDS parameter template.

func (ParameterTemplatesRdsParameterTemplateOutput) TemplateName 

func (o ParameterTemplatesRdsParameterTemplateOutput) TemplateName() pulumi.StringOutput

The name of the RDS parameter template.

func (ParameterTemplatesRdsParameterTemplateOutput) TemplateParams 

func (o ParameterTemplatesRdsParameterTemplateOutput) TemplateParams() ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput

Parameters contained in the template.

func (ParameterTemplatesRdsParameterTemplateOutput) TemplateType 

func (o ParameterTemplatesRdsParameterTemplateOutput) TemplateType() pulumi.StringOutput

Parameter template database type, range of values: MySQL - MySQL database.

func (ParameterTemplatesRdsParameterTemplateOutput) TemplateTypeVersion 

func (o ParameterTemplatesRdsParameterTemplateOutput) TemplateTypeVersion() pulumi.StringOutput

Parameter template database version, value range: MySQL_Community_5_7 - MySQL 5.7 MySQL_8_0 - MySQL 8.0.

func (ParameterTemplatesRdsParameterTemplateOutput) ToParameterTemplatesRdsParameterTemplateOutput 

func (o ParameterTemplatesRdsParameterTemplateOutput) ToParameterTemplatesRdsParameterTemplateOutput() ParameterTemplatesRdsParameterTemplateOutput

func (ParameterTemplatesRdsParameterTemplateOutput) ToParameterTemplatesRdsParameterTemplateOutputWithContext 

func (o ParameterTemplatesRdsParameterTemplateOutput) ToParameterTemplatesRdsParameterTemplateOutputWithContext(ctx context.Context) ParameterTemplatesRdsParameterTemplateOutput

func (ParameterTemplatesRdsParameterTemplateOutput) UpdateTime 

func (o ParameterTemplatesRdsParameterTemplateOutput) UpdateTime() pulumi.StringOutput

Update time.

type ParameterTemplatesRdsParameterTemplateTemplateParam 

type ParameterTemplatesRdsParameterTemplateTemplateParam struct {
	// Parameter default value.
	DefaultValue string `pulumi:"defaultValue"`
	// Parameter description.
	Description string `pulumi:"description"`
	// Parameter name.
	Name string `pulumi:"name"`
	// Whether the modified parameters need to be restarted to take effect.
	Restart bool `pulumi:"restart"`
	// Parameter running value.
	RunningValue string `pulumi:"runningValue"`
	// Parameter value range.
	ValueRange string `pulumi:"valueRange"`
}

type ParameterTemplatesRdsParameterTemplateTemplateParamArgs 

type ParameterTemplatesRdsParameterTemplateTemplateParamArgs struct {
	// Parameter default value.
	DefaultValue pulumi.StringInput `pulumi:"defaultValue"`
	// Parameter description.
	Description pulumi.StringInput `pulumi:"description"`
	// Parameter name.
	Name pulumi.StringInput `pulumi:"name"`
	// Whether the modified parameters need to be restarted to take effect.
	Restart pulumi.BoolInput `pulumi:"restart"`
	// Parameter running value.
	RunningValue pulumi.StringInput `pulumi:"runningValue"`
	// Parameter value range.
	ValueRange pulumi.StringInput `pulumi:"valueRange"`
}

func (ParameterTemplatesRdsParameterTemplateTemplateParamArgs) ElementType 

func (ParameterTemplatesRdsParameterTemplateTemplateParamArgs) ElementType() reflect.Type

func (ParameterTemplatesRdsParameterTemplateTemplateParamArgs) ToParameterTemplatesRdsParameterTemplateTemplateParamOutput 

func (i ParameterTemplatesRdsParameterTemplateTemplateParamArgs) ToParameterTemplatesRdsParameterTemplateTemplateParamOutput() ParameterTemplatesRdsParameterTemplateTemplateParamOutput

func (ParameterTemplatesRdsParameterTemplateTemplateParamArgs) ToParameterTemplatesRdsParameterTemplateTemplateParamOutputWithContext 

func (i ParameterTemplatesRdsParameterTemplateTemplateParamArgs) ToParameterTemplatesRdsParameterTemplateTemplateParamOutputWithContext(ctx context.Context) ParameterTemplatesRdsParameterTemplateTemplateParamOutput

type ParameterTemplatesRdsParameterTemplateTemplateParamArray 

type ParameterTemplatesRdsParameterTemplateTemplateParamArray []ParameterTemplatesRdsParameterTemplateTemplateParamInput

func (ParameterTemplatesRdsParameterTemplateTemplateParamArray) ElementType 

func (ParameterTemplatesRdsParameterTemplateTemplateParamArray) ElementType() reflect.Type

func (ParameterTemplatesRdsParameterTemplateTemplateParamArray) ToParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput 

func (i ParameterTemplatesRdsParameterTemplateTemplateParamArray) ToParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput() ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput

func (ParameterTemplatesRdsParameterTemplateTemplateParamArray) ToParameterTemplatesRdsParameterTemplateTemplateParamArrayOutputWithContext 

func (i ParameterTemplatesRdsParameterTemplateTemplateParamArray) ToParameterTemplatesRdsParameterTemplateTemplateParamArrayOutputWithContext(ctx context.Context) ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput

type ParameterTemplatesRdsParameterTemplateTemplateParamArrayInput 

type ParameterTemplatesRdsParameterTemplateTemplateParamArrayInput interface {
	pulumi.Input

	ToParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput() ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput
	ToParameterTemplatesRdsParameterTemplateTemplateParamArrayOutputWithContext(context.Context) ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput
}

ParameterTemplatesRdsParameterTemplateTemplateParamArrayInput is an input type that accepts ParameterTemplatesRdsParameterTemplateTemplateParamArray and ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput values. You can construct a concrete instance of `ParameterTemplatesRdsParameterTemplateTemplateParamArrayInput` via: 

ParameterTemplatesRdsParameterTemplateTemplateParamArray{ ParameterTemplatesRdsParameterTemplateTemplateParamArgs{...} }

type ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput 

type ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput struct{ *pulumi.OutputState }

func (ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput) ElementType 

func (ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput) ElementType() reflect.Type

func (ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput) Index 

func (o ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput) Index(i pulumi.IntInput) ParameterTemplatesRdsParameterTemplateTemplateParamOutput

func (ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput) ToParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput 

func (o ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput) ToParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput() ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput

func (ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput) ToParameterTemplatesRdsParameterTemplateTemplateParamArrayOutputWithContext 

func (o ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput) ToParameterTemplatesRdsParameterTemplateTemplateParamArrayOutputWithContext(ctx context.Context) ParameterTemplatesRdsParameterTemplateTemplateParamArrayOutput

type ParameterTemplatesRdsParameterTemplateTemplateParamInput 

type ParameterTemplatesRdsParameterTemplateTemplateParamInput interface {
	pulumi.Input

	ToParameterTemplatesRdsParameterTemplateTemplateParamOutput() ParameterTemplatesRdsParameterTemplateTemplateParamOutput
	ToParameterTemplatesRdsParameterTemplateTemplateParamOutputWithContext(context.Context) ParameterTemplatesRdsParameterTemplateTemplateParamOutput
}

ParameterTemplatesRdsParameterTemplateTemplateParamInput is an input type that accepts ParameterTemplatesRdsParameterTemplateTemplateParamArgs and ParameterTemplatesRdsParameterTemplateTemplateParamOutput values. You can construct a concrete instance of `ParameterTemplatesRdsParameterTemplateTemplateParamInput` via: 

ParameterTemplatesRdsParameterTemplateTemplateParamArgs{...}

type ParameterTemplatesRdsParameterTemplateTemplateParamOutput 

type ParameterTemplatesRdsParameterTemplateTemplateParamOutput struct{ *pulumi.OutputState }

func (ParameterTemplatesRdsParameterTemplateTemplateParamOutput) DefaultValue 

func (o ParameterTemplatesRdsParameterTemplateTemplateParamOutput) DefaultValue() pulumi.StringOutput

Parameter default value.

func (ParameterTemplatesRdsParameterTemplateTemplateParamOutput) Description 

func (o ParameterTemplatesRdsParameterTemplateTemplateParamOutput) Description() pulumi.StringOutput

Parameter description.

func (ParameterTemplatesRdsParameterTemplateTemplateParamOutput) ElementType 

func (ParameterTemplatesRdsParameterTemplateTemplateParamOutput) ElementType() reflect.Type

func (ParameterTemplatesRdsParameterTemplateTemplateParamOutput) Name 

func (o ParameterTemplatesRdsParameterTemplateTemplateParamOutput) Name() pulumi.StringOutput

Parameter name.

func (ParameterTemplatesRdsParameterTemplateTemplateParamOutput) Restart 

func (o ParameterTemplatesRdsParameterTemplateTemplateParamOutput) Restart() pulumi.BoolOutput

Whether the modified parameters need to be restarted to take effect.

func (ParameterTemplatesRdsParameterTemplateTemplateParamOutput) RunningValue 

func (o ParameterTemplatesRdsParameterTemplateTemplateParamOutput) RunningValue() pulumi.StringOutput

Parameter running value.

func (ParameterTemplatesRdsParameterTemplateTemplateParamOutput) ToParameterTemplatesRdsParameterTemplateTemplateParamOutput 

func (o ParameterTemplatesRdsParameterTemplateTemplateParamOutput) ToParameterTemplatesRdsParameterTemplateTemplateParamOutput() ParameterTemplatesRdsParameterTemplateTemplateParamOutput

func (ParameterTemplatesRdsParameterTemplateTemplateParamOutput) ToParameterTemplatesRdsParameterTemplateTemplateParamOutputWithContext 

func (o ParameterTemplatesRdsParameterTemplateTemplateParamOutput) ToParameterTemplatesRdsParameterTemplateTemplateParamOutputWithContext(ctx context.Context) ParameterTemplatesRdsParameterTemplateTemplateParamOutput

func (ParameterTemplatesRdsParameterTemplateTemplateParamOutput) ValueRange 

func (o ParameterTemplatesRdsParameterTemplateTemplateParamOutput) ValueRange() pulumi.StringOutput

Parameter value range.

type ParameterTemplatesResult 

type ParameterTemplatesResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id         string  `pulumi:"id"`
	NameRegex  *string `pulumi:"nameRegex"`
	OutputFile *string `pulumi:"outputFile"`
	// The collection of RDS parameter templates query.
	RdsParameterTemplates []ParameterTemplatesRdsParameterTemplate `pulumi:"rdsParameterTemplates"`
	TemplateCategory      *string                                  `pulumi:"templateCategory"`
	TemplateSource        *string                                  `pulumi:"templateSource"`
	// Parameter template database type, range of values:
	// MySQL - MySQL database.
	TemplateType *string `pulumi:"templateType"`
	// Parameter template database version, value range:
	// MySQL_Community_5_7 - MySQL 5.7
	// MySQL_8_0 - MySQL 8.0.
	TemplateTypeVersion *string `pulumi:"templateTypeVersion"`
	// The total count of RDS parameter templates query.
	TotalCount int `pulumi:"totalCount"`
}

A collection of values returned by ParameterTemplates.

func ParameterTemplates 

func ParameterTemplates(ctx *pulumi.Context, args *ParameterTemplatesArgs, opts ...pulumi.InvokeOption) (*ParameterTemplatesResult, error)

(Deprecated! Recommend use volcengine_rds_mysql_*** replace) Use this data source to query detailed information of rds parameter templates ## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rds.ParameterTemplates(ctx, nil, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type ParameterTemplatesResultOutput 

type ParameterTemplatesResultOutput struct{ *pulumi.OutputState }

A collection of values returned by ParameterTemplates.

func ParameterTemplatesOutput 

func ParameterTemplatesOutput(ctx *pulumi.Context, args ParameterTemplatesOutputArgs, opts ...pulumi.InvokeOption) ParameterTemplatesResultOutput

func (ParameterTemplatesResultOutput) ElementType 

func (ParameterTemplatesResultOutput) ElementType() reflect.Type

func (ParameterTemplatesResultOutput) Id 

func (o ParameterTemplatesResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (ParameterTemplatesResultOutput) NameRegex 

func (o ParameterTemplatesResultOutput) NameRegex() pulumi.StringPtrOutput

func (ParameterTemplatesResultOutput) OutputFile 

func (o ParameterTemplatesResultOutput) OutputFile() pulumi.StringPtrOutput

func (ParameterTemplatesResultOutput) RdsParameterTemplates 

func (o ParameterTemplatesResultOutput) RdsParameterTemplates() ParameterTemplatesRdsParameterTemplateArrayOutput

The collection of RDS parameter templates query.

func (ParameterTemplatesResultOutput) TemplateCategory 

func (o ParameterTemplatesResultOutput) TemplateCategory() pulumi.StringPtrOutput

func (ParameterTemplatesResultOutput) TemplateSource 

func (o ParameterTemplatesResultOutput) TemplateSource() pulumi.StringPtrOutput

func (ParameterTemplatesResultOutput) TemplateType 

func (o ParameterTemplatesResultOutput) TemplateType() pulumi.StringPtrOutput

Parameter template database type, range of values: MySQL - MySQL database.

func (ParameterTemplatesResultOutput) TemplateTypeVersion 

func (o ParameterTemplatesResultOutput) TemplateTypeVersion() pulumi.StringPtrOutput

Parameter template database version, value range: MySQL_Community_5_7 - MySQL 5.7 MySQL_8_0 - MySQL 8.0.

func (ParameterTemplatesResultOutput) ToParameterTemplatesResultOutput 

func (o ParameterTemplatesResultOutput) ToParameterTemplatesResultOutput() ParameterTemplatesResultOutput

func (ParameterTemplatesResultOutput) ToParameterTemplatesResultOutputWithContext 

func (o ParameterTemplatesResultOutput) ToParameterTemplatesResultOutputWithContext(ctx context.Context) ParameterTemplatesResultOutput

func (ParameterTemplatesResultOutput) TotalCount 

func (o ParameterTemplatesResultOutput) TotalCount() pulumi.IntOutput

The total count of RDS parameter templates query.

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.