import * as pulumi from "@pulumi/pulumi"; import * as inputs from "../types/input"; import * as outputs from "../types/output"; /** * File storage vePFS is a newly launched high-throughput, low-latency, scalable parallel file system service designed to meet the high-throughput and low-latency data read/write requirements in high-performance computing scenarios. It can be widely used in HPC (high-performance computing), AI training or inference, energy exploration, industrial simulation, film rendering, life sciences, meteorological analysis, and other scenarios. vePFS also provides one-click deployment and integrated monitoring and alerting capabilities, eliminating deployment and maintenance costs while maximizing your business efficiency. * * ## Example Usage * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as volcenginecc from "@volcengine/pulumi-volcenginecc"; * * const vEPFSInstanceDemo = new volcenginecc.vepfs.Instance("VEPFSInstanceDemo", { * fileSystemName: "VEPFSInstanceDemo", * zoneId: "cn-beijing-a", * chargeType: "PayAsYouGo", * fileSystemType: "VePFS", * storeType: "Advance_100", * protocolType: "VePFS", * projectName: "default", * capacity: 8, * vpcId: "vpc-3nqt4kq87xn28931eclxxxxx", * subnetId: "subnet-1a0zgr5e7hslc8nvepkxxxxxx", * versionNumber: "1.4.0", * enableRestripe: true, * tags: [{ * key: "env", * value: "test", * }], * }); * ``` * * ## Import * * ```sh * $ pulumi import volcenginecc:vepfs/instance:Instance example "file_system_id" * ``` */ export declare class Instance extends pulumi.CustomResource { /** * Get an existing Instance 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, state?: InstanceState, opts?: pulumi.CustomResourceOptions): Instance; /** * Returns true if the given object is an instance of Instance. 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 Instance; /** * Account ID. */ readonly accountId: pulumi.Output; /** * VePFS file system throughput limit. */ readonly bandwidth: pulumi.Output; /** * File system capacity, unit: TiB. */ readonly capacity: pulumi.Output; /** * Capacity information. */ readonly capacityInfo: pulumi.Output; /** * Billing status. Default is Normal, indicating standard billing. */ readonly chargeStatus: pulumi.Output; /** * Billing type. Value descriptions are as follows: PayAsYouGo: Pay-as-you-go billing. */ readonly chargeType: pulumi.Output; /** * Creation time. */ readonly createdTime: pulumi.Output; /** * File system description. */ readonly description: pulumi.Output; /** * Whether to enable data balancing after expansion. Value description: true: Enable data balancing immediately after expansion. false: Do not enable data balancing after expansion. Note: Only file systems with a specification of 100MB/s/TiB support the data balancing feature. Because the data balancing process consumes the network and disk bandwidth of storage nodes and causes file system performance degradation, we recommend that you evaluate your business needs and enable with caution. The duration of data balancing mainly depends on the amount of existing data. If you have a large amount of existing data, the balancing process may take longer. Depending on the expansion size and file system status, this process may take several hours to up to 2 days. We recommend enabling it during off-peak hours and waiting patiently. */ readonly enableRestripe: pulumi.Output; /** * Expiration time. */ readonly expireTime: pulumi.Output; /** * File system ID. */ readonly fileSystemId: pulumi.Output; /** * File system name. Naming rules are as follows: Must start with a Chinese or English letter. Can only contain Chinese characters, letters, numbers, period (.), underscore (_), or hyphen (-). Length must be between 1 and 128 characters. */ readonly fileSystemName: pulumi.Output; /** * File system type. Default is VePFS. */ readonly fileSystemType: pulumi.Output; /** * File system release time. */ readonly freeTime: pulumi.Output; /** * Project to which the file system belongs. Default is default. */ readonly projectName: pulumi.Output; /** * Protocol type. Default is VePFS. */ readonly protocolType: pulumi.Output; /** * Read bandwidth value, unit: MB/s. */ readonly readBandwidth: pulumi.Output; /** * Security group ID for the generated auxiliary NIC. */ readonly securityGroupId: pulumi.Output; /** * File system status. Value descriptions are as follows: Running: Instance is running. Creating: Instance is being created. CreateError: Instance creation failed. Updating: Instance is being updated. UpdateError: Instance update failed. Expanding: Instance is being expanded. ExpandError: Instance expansion failed. Deleting: Instance is being deleted. DeleteError: Instance deletion failed. Stopped: Instance is stopped. Error: Instance is in an error state. */ readonly status: pulumi.Output; /** * File system shutdown time. */ readonly stopServiceTime: pulumi.Output; /** * File system specification. Value descriptions are as follows: Advance*100: 100MB/s/TiB. Performance: Performance. Intelligent*Computing: Intelligent Computing. */ readonly storeType: pulumi.Output; /** * File system specification name in Chinese. Supported options: 100MB/s/TiB. Performance. Intelligent Computing. */ readonly storeTypeCn: pulumi.Output; /** * Storage type English name. */ readonly storeTypeEn: pulumi.Output; /** * Subnet ID. The subnet must belong to the selected availability zone. */ readonly subnetId: pulumi.Output; readonly tags: pulumi.Output; /** * File system update time. */ readonly updatedTime: pulumi.Output; /** * File system version number. */ readonly versionNumber: pulumi.Output; /** * Private network ID. */ readonly vpcId: pulumi.Output; /** * Write bandwidth value, measured in MB/s. */ readonly writeBandwidth: pulumi.Output; /** * Availability zone ID. */ readonly zoneId: pulumi.Output; /** * Availability zone name. */ readonly zoneName: pulumi.Output; /** * Create a Instance 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: InstanceArgs, opts?: pulumi.CustomResourceOptions); } /** * Input properties used for looking up and filtering Instance resources. */ export interface InstanceState { /** * Account ID. */ accountId?: pulumi.Input; /** * VePFS file system throughput limit. */ bandwidth?: pulumi.Input; /** * File system capacity, unit: TiB. */ capacity?: pulumi.Input; /** * Capacity information. */ capacityInfo?: pulumi.Input; /** * Billing status. Default is Normal, indicating standard billing. */ chargeStatus?: pulumi.Input; /** * Billing type. Value descriptions are as follows: PayAsYouGo: Pay-as-you-go billing. */ chargeType?: pulumi.Input; /** * Creation time. */ createdTime?: pulumi.Input; /** * File system description. */ description?: pulumi.Input; /** * Whether to enable data balancing after expansion. Value description: true: Enable data balancing immediately after expansion. false: Do not enable data balancing after expansion. Note: Only file systems with a specification of 100MB/s/TiB support the data balancing feature. Because the data balancing process consumes the network and disk bandwidth of storage nodes and causes file system performance degradation, we recommend that you evaluate your business needs and enable with caution. The duration of data balancing mainly depends on the amount of existing data. If you have a large amount of existing data, the balancing process may take longer. Depending on the expansion size and file system status, this process may take several hours to up to 2 days. We recommend enabling it during off-peak hours and waiting patiently. */ enableRestripe?: pulumi.Input; /** * Expiration time. */ expireTime?: pulumi.Input; /** * File system ID. */ fileSystemId?: pulumi.Input; /** * File system name. Naming rules are as follows: Must start with a Chinese or English letter. Can only contain Chinese characters, letters, numbers, period (.), underscore (_), or hyphen (-). Length must be between 1 and 128 characters. */ fileSystemName?: pulumi.Input; /** * File system type. Default is VePFS. */ fileSystemType?: pulumi.Input; /** * File system release time. */ freeTime?: pulumi.Input; /** * Project to which the file system belongs. Default is default. */ projectName?: pulumi.Input; /** * Protocol type. Default is VePFS. */ protocolType?: pulumi.Input; /** * Read bandwidth value, unit: MB/s. */ readBandwidth?: pulumi.Input; /** * Security group ID for the generated auxiliary NIC. */ securityGroupId?: pulumi.Input; /** * File system status. Value descriptions are as follows: Running: Instance is running. Creating: Instance is being created. CreateError: Instance creation failed. Updating: Instance is being updated. UpdateError: Instance update failed. Expanding: Instance is being expanded. ExpandError: Instance expansion failed. Deleting: Instance is being deleted. DeleteError: Instance deletion failed. Stopped: Instance is stopped. Error: Instance is in an error state. */ status?: pulumi.Input; /** * File system shutdown time. */ stopServiceTime?: pulumi.Input; /** * File system specification. Value descriptions are as follows: Advance*100: 100MB/s/TiB. Performance: Performance. Intelligent*Computing: Intelligent Computing. */ storeType?: pulumi.Input; /** * File system specification name in Chinese. Supported options: 100MB/s/TiB. Performance. Intelligent Computing. */ storeTypeCn?: pulumi.Input; /** * Storage type English name. */ storeTypeEn?: pulumi.Input; /** * Subnet ID. The subnet must belong to the selected availability zone. */ subnetId?: pulumi.Input; tags?: pulumi.Input[]>; /** * File system update time. */ updatedTime?: pulumi.Input; /** * File system version number. */ versionNumber?: pulumi.Input; /** * Private network ID. */ vpcId?: pulumi.Input; /** * Write bandwidth value, measured in MB/s. */ writeBandwidth?: pulumi.Input; /** * Availability zone ID. */ zoneId?: pulumi.Input; /** * Availability zone name. */ zoneName?: pulumi.Input; } /** * The set of arguments for constructing a Instance resource. */ export interface InstanceArgs { /** * File system capacity, unit: TiB. */ capacity: pulumi.Input; /** * Billing type. Value descriptions are as follows: PayAsYouGo: Pay-as-you-go billing. */ chargeType?: pulumi.Input; /** * File system description. */ description?: pulumi.Input; /** * Whether to enable data balancing after expansion. Value description: true: Enable data balancing immediately after expansion. false: Do not enable data balancing after expansion. Note: Only file systems with a specification of 100MB/s/TiB support the data balancing feature. Because the data balancing process consumes the network and disk bandwidth of storage nodes and causes file system performance degradation, we recommend that you evaluate your business needs and enable with caution. The duration of data balancing mainly depends on the amount of existing data. If you have a large amount of existing data, the balancing process may take longer. Depending on the expansion size and file system status, this process may take several hours to up to 2 days. We recommend enabling it during off-peak hours and waiting patiently. */ enableRestripe?: pulumi.Input; /** * File system name. Naming rules are as follows: Must start with a Chinese or English letter. Can only contain Chinese characters, letters, numbers, period (.), underscore (_), or hyphen (-). Length must be between 1 and 128 characters. */ fileSystemName: pulumi.Input; /** * File system type. Default is VePFS. */ fileSystemType?: pulumi.Input; /** * Project to which the file system belongs. Default is default. */ projectName?: pulumi.Input; /** * Protocol type. Default is VePFS. */ protocolType?: pulumi.Input; /** * File system specification. Value descriptions are as follows: Advance*100: 100MB/s/TiB. Performance: Performance. Intelligent*Computing: Intelligent Computing. */ storeType: pulumi.Input; /** * Subnet ID. The subnet must belong to the selected availability zone. */ subnetId?: pulumi.Input; tags?: pulumi.Input[]>; /** * File system version number. */ versionNumber?: pulumi.Input; /** * Private network ID. */ vpcId?: pulumi.Input; /** * Availability zone ID. */ zoneId: pulumi.Input; }