1. Packages
  2. Packages
  3. Volcenginecc Provider
  4. API Docs
  5. rdspostgresql
  6. DbAccount
Viewing docs for volcenginecc v0.0.32
published on Thursday, Apr 23, 2026 by Volcengine
Schema (JSON)
volcengine/pulumi-volcenginecc

volcenginecc.rdspostgresql.DbAccount

volcenginecc logo
Viewing docs for volcenginecc v0.0.32
published on Thursday, Apr 23, 2026 by Volcengine
Schema (JSON)
volcengine/pulumi-volcenginecc

    RDS PostgreSQL Database Account

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as volcenginecc from "@volcengine/pulumi-volcenginecc";

const rDSPostgreSQLDBAccountNormalDemo = new volcenginecc.rdspostgresql.DbAccount("RDSPostgreSQLDBAccountNormalDemo", {
    instanceId: "postgres-xxxxxxx",
    accountName: "ccapi-test-Normal",
    accountPassword: "**********",
    accountType: "Normal",
    accountPrivileges: "Inherit,Login,CreateRole,CreateDB",
    notAllowPrivileges: ["DDL"],
});

    import pulumi
import pulumi_volcenginecc as volcenginecc

r_ds_postgre_sqldb_account_normal_demo = volcenginecc.rdspostgresql.DbAccount("RDSPostgreSQLDBAccountNormalDemo",
    instance_id="postgres-xxxxxxx",
    account_name="ccapi-test-Normal",
    account_password="**********",
    account_type="Normal",
    account_privileges="Inherit,Login,CreateRole,CreateDB",
    not_allow_privileges=["DDL"])

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcenginecc/sdk/go/volcenginecc/rdspostgresql"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rdspostgresql.NewDbAccount(ctx, "RDSPostgreSQLDBAccountNormalDemo", &rdspostgresql.DbAccountArgs{
			InstanceId:        pulumi.String("postgres-xxxxxxx"),
			AccountName:       pulumi.String("ccapi-test-Normal"),
			AccountPassword:   pulumi.String("**********"),
			AccountType:       pulumi.String("Normal"),
			AccountPrivileges: pulumi.String("Inherit,Login,CreateRole,CreateDB"),
			NotAllowPrivileges: pulumi.StringArray{
				pulumi.String("DDL"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Volcenginecc = Volcengine.Pulumi.Volcenginecc;

return await Deployment.RunAsync(() => 
{
    var rDSPostgreSQLDBAccountNormalDemo = new Volcenginecc.Rdspostgresql.DbAccount("RDSPostgreSQLDBAccountNormalDemo", new()
    {
        InstanceId = "postgres-xxxxxxx",
        AccountName = "ccapi-test-Normal",
        AccountPassword = "**********",
        AccountType = "Normal",
        AccountPrivileges = "Inherit,Login,CreateRole,CreateDB",
        NotAllowPrivileges = new[]
        {
            "DDL",
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.volcengine.volcenginecc.rdspostgresql.DbAccount;
import com.volcengine.volcenginecc.rdspostgresql.DbAccountArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var rDSPostgreSQLDBAccountNormalDemo = new DbAccount("rDSPostgreSQLDBAccountNormalDemo", DbAccountArgs.builder()
            .instanceId("postgres-xxxxxxx")
            .accountName("ccapi-test-Normal")
            .accountPassword("**********")
            .accountType("Normal")
            .accountPrivileges("Inherit,Login,CreateRole,CreateDB")
            .notAllowPrivileges("DDL")
            .build());

    }
}

    resources:
  rDSPostgreSQLDBAccountNormalDemo:
    type: volcenginecc:rdspostgresql:DbAccount
    name: RDSPostgreSQLDBAccountNormalDemo
    properties:
      instanceId: postgres-xxxxxxx
      accountName: ccapi-test-Normal
      accountPassword: '**********'
      accountType: Normal
      accountPrivileges: Inherit,Login,CreateRole,CreateDB
      notAllowPrivileges:
        - DDL

    Create DbAccount Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new DbAccount(name: string, args: DbAccountArgs, opts?: CustomResourceOptions);
    @overload
def DbAccount(resource_name: str,
              args: DbAccountArgs,
              opts: Optional[ResourceOptions] = None)

@overload
def DbAccount(resource_name: str,
              opts: Optional[ResourceOptions] = None,
              account_name: Optional[str] = None,
              account_password: Optional[str] = None,
              account_type: Optional[str] = None,
              account_privileges: Optional[str] = None,
              instance_id: Optional[str] = None,
              not_allow_privileges: Optional[Sequence[str]] = None)
    func NewDbAccount(ctx *Context, name string, args DbAccountArgs, opts ...ResourceOption) (*DbAccount, error)
    public DbAccount(string name, DbAccountArgs args, CustomResourceOptions? opts = null)
    public DbAccount(String name, DbAccountArgs args)
public DbAccount(String name, DbAccountArgs args, CustomResourceOptions options)

    type: volcenginecc:rdspostgresql:DbAccount
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args DbAccountArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args DbAccountArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args DbAccountArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args DbAccountArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args DbAccountArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var volcengineccDbAccountResource = new Volcenginecc.Rdspostgresql.DbAccount("volcengineccDbAccountResource", new()
{
    AccountName = "string",
    AccountPassword = "string",
    AccountType = "string",
    AccountPrivileges = "string",
    InstanceId = "string",
    NotAllowPrivileges = new[]
    {
        "string",
    },
});

    example, err := rdspostgresql.NewDbAccount(ctx, "volcengineccDbAccountResource", &rdspostgresql.DbAccountArgs{
	AccountName:       pulumi.String("string"),
	AccountPassword:   pulumi.String("string"),
	AccountType:       pulumi.String("string"),
	AccountPrivileges: pulumi.String("string"),
	InstanceId:        pulumi.String("string"),
	NotAllowPrivileges: pulumi.StringArray{
		pulumi.String("string"),
	},
})

    var volcengineccDbAccountResource = new com.volcengine.volcenginecc.rdspostgresql.DbAccount("volcengineccDbAccountResource", com.volcengine.volcenginecc.rdspostgresql.DbAccountArgs.builder()
    .accountName("string")
    .accountPassword("string")
    .accountType("string")
    .accountPrivileges("string")
    .instanceId("string")
    .notAllowPrivileges("string")
    .build());

    volcenginecc_db_account_resource = volcenginecc.rdspostgresql.DbAccount("volcengineccDbAccountResource",
    account_name="string",
    account_password="string",
    account_type="string",
    account_privileges="string",
    instance_id="string",
    not_allow_privileges=["string"])

    const volcengineccDbAccountResource = new volcenginecc.rdspostgresql.DbAccount("volcengineccDbAccountResource", {
    accountName: "string",
    accountPassword: "string",
    accountType: "string",
    accountPrivileges: "string",
    instanceId: "string",
    notAllowPrivileges: ["string"],
});

    type: volcenginecc:rdspostgresql:DbAccount
properties:
    accountName: string
    accountPassword: string
    accountPrivileges: string
    accountType: string
    instanceId: string
    notAllowPrivileges:
        - string

    DbAccount Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The DbAccount resource accepts the following input properties:

    AccountName string
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    AccountPassword string
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    AccountType string
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    AccountPrivileges string
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    InstanceId string
    Instance ID
    NotAllowPrivileges List<string>
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.
    AccountName string
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    AccountPassword string
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    AccountType string
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    AccountPrivileges string
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    InstanceId string
    Instance ID
    NotAllowPrivileges []string
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.
    accountName String
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    accountPassword String
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    accountType String
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    accountPrivileges String
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    instanceId String
    Instance ID
    notAllowPrivileges List<String>
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.
    accountName string
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    accountPassword string
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    accountType string
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    accountPrivileges string
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    instanceId string
    Instance ID
    notAllowPrivileges string[]
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.
    account_name str
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    account_password str
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    account_type str
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    account_privileges str
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    instance_id str
    Instance ID
    not_allow_privileges Sequence[str]
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.
    accountName String
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    accountPassword String
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    accountType String
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    accountPrivileges String
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    instanceId String
    Instance ID
    notAllowPrivileges List<String>
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the DbAccount resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing DbAccount Resource

    Get an existing DbAccount resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: DbAccountState, opts?: CustomResourceOptions): DbAccount
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        account_name: Optional[str] = None,
        account_password: Optional[str] = None,
        account_privileges: Optional[str] = None,
        account_type: Optional[str] = None,
        instance_id: Optional[str] = None,
        not_allow_privileges: Optional[Sequence[str]] = None) -> DbAccount
    func GetDbAccount(ctx *Context, name string, id IDInput, state *DbAccountState, opts ...ResourceOption) (*DbAccount, error)
    public static DbAccount Get(string name, Input<string> id, DbAccountState? state, CustomResourceOptions? opts = null)
    public static DbAccount get(String name, Output<String> id, DbAccountState state, CustomResourceOptions options)
    resources:  _:    type: volcenginecc:rdspostgresql:DbAccount    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    AccountName string
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    AccountPassword string
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    AccountPrivileges string
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    AccountType string
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    InstanceId string
    Instance ID
    NotAllowPrivileges List<string>
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.
    AccountName string
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    AccountPassword string
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    AccountPrivileges string
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    AccountType string
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    InstanceId string
    Instance ID
    NotAllowPrivileges []string
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.
    accountName String
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    accountPassword String
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    accountPrivileges String
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    accountType String
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    instanceId String
    Instance ID
    notAllowPrivileges List<String>
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.
    accountName string
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    accountPassword string
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    accountPrivileges string
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    accountType string
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    instanceId string
    Instance ID
    notAllowPrivileges string[]
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.
    account_name str
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    account_password str
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    account_privileges str
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    account_type str
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    instance_id str
    Instance ID
    not_allow_privileges Sequence[str]
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.
    accountName String
    Database account name. The account name rules are as follows: Length must be 2–63 characters. Can contain letters, numbers, underscores (), or hyphens (-). Must start with a letter and end with a letter or number. Cannot start with pg. Reserved keywords cannot be used. For all disabled keywords, see Disabled Keywords.
    accountPassword String
    Database account password. The password rules are as follows: Length must be 8–32 characters. Must contain any three of the following: uppercase letters, lowercase letters, numbers, special characters. Supported special characters: !@#$%^*()&_+-=.
    accountPrivileges String
    Account permission information. Separate multiple permissions with commas (,). Valid values: Login: Login permission. Inherit: Inherit permission. CreateRole: Create role permission. CreateDB: Create database permission. Note: If the account type is high privilege, you do not need to provide this parameter; all permissions are supported by default. If the account type is normal, you can provide this parameter; the default values are Login and Inherit. If the account type is instance read-only, that is, AccountType is set to InstanceReadOnly, this parameter is not supported.
    accountType String
    Database account type. Valid values: Super: High privilege account. Normal: Normal account. InstanceReadOnly: Instance read-only account.
    instanceId String
    Instance ID
    notAllowPrivileges List<String>
    Permissions disabled for the account. Currently, only DDL is supported. Note: This field can only be provided for high privilege or normal accounts, that is, when AccountType is set to Super or Normal.

    Import

    $ pulumi import volcenginecc:rdspostgresql/dbAccount:DbAccount example "instance_id|account_name"

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    volcenginecc volcengine/pulumi-volcenginecc
    License
    MPL-2.0
    Notes
    This Pulumi package is based on the volcenginecc Terraform Provider.
    volcenginecc logo
    Viewing docs for volcenginecc v0.0.32
    published on Thursday, Apr 23, 2026 by Volcengine
    Schema (JSON)
    volcengine/pulumi-volcenginecc
      Try Pulumi Cloud free. Your team will thank you.