@volcengine/pulumi

import * as pulumi from "@pulumi/pulumi"; import * as inputs from "../types/input"; import * as outputs from "../types/output"; /** * Provides a resource to manage vedb mysql account * ## Example Usage * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as volcengine from "@pulumi/volcengine"; * import * as volcengine from "@volcengine/pulumi"; * * const fooZones = volcengine.ecs.getZones({}); * const fooVpc = new volcengine.vpc.Vpc("fooVpc", { * vpcName: "acc-test-vpc", * cidrBlock: "172.16.0.0/16", * }); * const fooSubnet = new volcengine.vpc.Subnet("fooSubnet", { * subnetName: "acc-test-subnet", * cidrBlock: "172.16.0.0/24", * zoneId: fooZones.then(fooZones => fooZones.zones?.[2]?.id), * vpcId: fooVpc.id, * }); * const fooInstance = new volcengine.vedb_mysql.Instance("fooInstance", { * chargeType: "PostPaid", * storageChargeType: "PostPaid", * dbEngineVersion: "MySQL_8_0", * dbMinorVersion: "3.0", * nodeNumber: 2, * nodeSpec: "vedb.mysql.x4.large", * subnetId: fooSubnet.id, * instanceName: "tf-test", * projectName: "testA", * tags: [ * { * key: "tftest", * value: "tftest", * }, * { * key: "tftest2", * value: "tftest2", * }, * ], * }); * const fooDatabase = new volcengine.vedb_mysql.Database("fooDatabase", { * dbName: "tf-table", * instanceId: fooInstance.id, * }); * const fooAccount = new volcengine.vedb_mysql.Account("fooAccount", { * accountName: "tftest", * accountPassword: "93f0cb0614Aab12", * accountType: "Normal", * instanceId: fooInstance.id, * accountPrivileges: [{ * dbName: fooDatabase.dbName, * accountPrivilege: "Custom", * accountPrivilegeDetail: "SELECT,INSERT,DELETE", * }], * }); * ``` * * ## Import * * VedbMysqlAccount can be imported using the instance id and account name, e.g. * * ```sh * $ pulumi import volcengine:vedb_mysql/account:Account default vedbm-r3xq0zdl****:testuser * ``` */ export declare class Account extends pulumi.CustomResource { /** * Get an existing Account resource's state with the given name, ID, and optional extra * properties used to qualify the lookup. * * @param name The _unique_ name of the resulting resource. * @param id The _unique_ provider ID of the resource to lookup. * @param state Any extra arguments used during the lookup. * @param opts Optional settings to control the behavior of the CustomResource. */ static get(name: string, id: pulumi.Input<pulumi.ID>, state?: AccountState, opts?: pulumi.CustomResourceOptions): Account; /** * Returns true if the given object is an instance of Account. This is designed to work even * when multiple copies of the Pulumi SDK have been loaded into the same process. */ static isInstance(obj: any): obj is Account; /** * Database account name. The account name must meet the following requirements: * The name is unique and within 2 to 32 characters in length. * Consists of lowercase letters, numbers, or underscores (_). * Starts with a lowercase letter and ends with a letter or number. * The name cannot contain certain prohibited words. For detailed information, please refer to prohibited keywords. And certain reserved words such as root, admin, etc. cannot be used. */ readonly accountName: pulumi.Output<string>; /** * Password of database account. The account password must meet the following requirements: * It can only contain upper and lower case letters, numbers and the following special characters _#!@$%^&*()+=-. * It must be within 8 to 32 characters in length. * It must contain at least three of upper case letters, lower case letters, numbers or special characters. */ readonly accountPassword: pulumi.Output<string>; /** * Database permission information. When the value of AccountType is Super, this parameter does not need to be passed. High-privilege accounts by default have all permissions for all databases under this instance. When the value of AccountType is Normal, it is recommended to pass this parameter to grant specified permissions for specified databases to ordinary accounts. If not set, this account does not have any permissions for any database. */ readonly accountPrivileges: pulumi.Output<outputs.vedb_mysql.AccountAccountPrivilege[] | undefined>; /** * Database account type. Values: * Super: High-privilege account. Only one high-privilege account can be created for an instance. It has all permissions for all databases under this instance and can manage all ordinary accounts and databases. * Normal: Multiple ordinary accounts can be created for an instance. Specific database permissions need to be manually granted to ordinary accounts. */ readonly accountType: pulumi.Output<string>; /** * The id of the instance. */ readonly instanceId: pulumi.Output<string>; /** * Create a Account resource with the given unique name, arguments, and options. * * @param name The _unique_ name of the resource. * @param args The arguments to use to populate this resource's properties. * @param opts A bag of options that control this resource's behavior. */ constructor(name: string, args: AccountArgs, opts?: pulumi.CustomResourceOptions); } /** * Input properties used for looking up and filtering Account resources. */ export interface AccountState { /** * Database account name. The account name must meet the following requirements: * The name is unique and within 2 to 32 characters in length. * Consists of lowercase letters, numbers, or underscores (_). * Starts with a lowercase letter and ends with a letter or number. * The name cannot contain certain prohibited words. For detailed information, please refer to prohibited keywords. And certain reserved words such as root, admin, etc. cannot be used. */ accountName?: pulumi.Input<string>; /** * Password of database account. The account password must meet the following requirements: * It can only contain upper and lower case letters, numbers and the following special characters _#!@$%^&*()+=-. * It must be within 8 to 32 characters in length. * It must contain at least three of upper case letters, lower case letters, numbers or special characters. */ accountPassword?: pulumi.Input<string>; /** * Database permission information. When the value of AccountType is Super, this parameter does not need to be passed. High-privilege accounts by default have all permissions for all databases under this instance. When the value of AccountType is Normal, it is recommended to pass this parameter to grant specified permissions for specified databases to ordinary accounts. If not set, this account does not have any permissions for any database. */ accountPrivileges?: pulumi.Input<pulumi.Input<inputs.vedb_mysql.AccountAccountPrivilege>[]>; /** * Database account type. Values: * Super: High-privilege account. Only one high-privilege account can be created for an instance. It has all permissions for all databases under this instance and can manage all ordinary accounts and databases. * Normal: Multiple ordinary accounts can be created for an instance. Specific database permissions need to be manually granted to ordinary accounts. */ accountType?: pulumi.Input<string>; /** * The id of the instance. */ instanceId?: pulumi.Input<string>; } /** * The set of arguments for constructing a Account resource. */ export interface AccountArgs { /** * Database account name. The account name must meet the following requirements: * The name is unique and within 2 to 32 characters in length. * Consists of lowercase letters, numbers, or underscores (_). * Starts with a lowercase letter and ends with a letter or number. * The name cannot contain certain prohibited words. For detailed information, please refer to prohibited keywords. And certain reserved words such as root, admin, etc. cannot be used. */ accountName: pulumi.Input<string>; /** * Password of database account. The account password must meet the following requirements: * It can only contain upper and lower case letters, numbers and the following special characters _#!@$%^&*()+=-. * It must be within 8 to 32 characters in length. * It must contain at least three of upper case letters, lower case letters, numbers or special characters. */ accountPassword: pulumi.Input<string>; /** * Database permission information. When the value of AccountType is Super, this parameter does not need to be passed. High-privilege accounts by default have all permissions for all databases under this instance. When the value of AccountType is Normal, it is recommended to pass this parameter to grant specified permissions for specified databases to ordinary accounts. If not set, this account does not have any permissions for any database. */ accountPrivileges?: pulumi.Input<pulumi.Input<inputs.vedb_mysql.AccountAccountPrivilege>[]>; /** * Database account type. Values: * Super: High-privilege account. Only one high-privilege account can be created for an instance. It has all permissions for all databases under this instance and can manage all ordinary accounts and databases. * Normal: Multiple ordinary accounts can be created for an instance. Specific database permissions need to be manually granted to ordinary accounts. */ accountType: pulumi.Input<string>; /** * The id of the instance. */ instanceId: pulumi.Input<string>; }