@upcloud/pulumi-upcloud/managedDatabaseRedis.d.ts

A Pulumi package for creating and managing UpCloud resources.

import * as pulumi from "@pulumi/pulumi";
import * as inputs from "./types/input";
import * as outputs from "./types/output";
/**
 * > Redis is deprecated in favor of Valkey. Please use Valkey for new key value store instances.
 *
 * This resource represents Redis managed database. See UpCloud [Managed Databases](https://upcloud.com/products/managed-databases) product page for more details about the service.
 *
 * ## Example Usage
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as upcloud from "@upcloud/pulumi-upcloud";
 *
 * // Minimal config
 * const example1 = new upcloud.ManagedDatabaseRedis("example_1", {
 *     name: "redis-1",
 *     title: "redis-1-example-2",
 *     plan: "1x1xCPU-2GB",
 *     zone: "fi-hel2",
 * });
 * // Service with custom properties
 * const example2 = new upcloud.ManagedDatabaseRedis("example_2", {
 *     name: "redis-2",
 *     title: "redis-2-example-2",
 *     plan: "1x1xCPU-2GB",
 *     zone: "fi-hel1",
 *     properties: {
 *         publicAccess: false,
 *     },
 * });
 * ```
 */
export declare class ManagedDatabaseRedis extends pulumi.CustomResource {
    /**
     * Get an existing ManagedDatabaseRedis 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?: ManagedDatabaseRedisState, opts?: pulumi.CustomResourceOptions): ManagedDatabaseRedis;
    /**
     * Returns true if the given object is an instance of ManagedDatabaseRedis.  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 ManagedDatabaseRedis;
    /**
     * Service component information
     */
    readonly components: pulumi.Output<outputs.ManagedDatabaseRedisComponent[]>;
    /**
     * User defined key-value pairs to classify the managed database.
     */
    readonly labels: pulumi.Output<{
        [key: string]: string;
    } | undefined>;
    /**
     * Maintenance window day of week. Lower case weekday name (monday, tuesday, ...)
     */
    readonly maintenanceWindowDow: pulumi.Output<string>;
    /**
     * Maintenance window UTC time in hh:mm:ss format
     */
    readonly maintenanceWindowTime: pulumi.Output<string>;
    /**
     * Name of the service. The name is used as a prefix for the logical hostname. Must be unique within an account
     */
    readonly name: pulumi.Output<string>;
    /**
     * Private networks attached to the managed database
     */
    readonly networks: pulumi.Output<outputs.ManagedDatabaseRedisNetwork[] | undefined>;
    /**
     * Information about nodes providing the managed service
     */
    readonly nodeStates: pulumi.Output<outputs.ManagedDatabaseRedisNodeState[]>;
    /**
     * Service plan to use. This determines how much resources the instance will have. You can list available plans with `upctl
     * database plans <type>`.
     */
    readonly plan: pulumi.Output<string>;
    /**
     * The administrative power state of the service
     */
    readonly powered: pulumi.Output<boolean | undefined>;
    /**
     * Primary database name
     */
    readonly primaryDatabase: pulumi.Output<string>;
    /**
     * Database Engine properties for Redis
     */
    readonly properties: pulumi.Output<outputs.ManagedDatabaseRedisProperties>;
    /**
     * Hostname to the service instance
     */
    readonly serviceHost: pulumi.Output<string>;
    /**
     * Primary username's password to the service instance
     */
    readonly servicePassword: pulumi.Output<string>;
    /**
     * Port to the service instance
     */
    readonly servicePort: pulumi.Output<string>;
    /**
     * URI to the service instance
     */
    readonly serviceUri: pulumi.Output<string>;
    /**
     * Primary username to the service instance
     */
    readonly serviceUsername: pulumi.Output<string>;
    /**
     * State of the service
     */
    readonly state: pulumi.Output<string>;
    /**
     * If set to true, prevents the managed service from being powered off, or deleted.
     */
    readonly terminationProtection: pulumi.Output<boolean | undefined>;
    /**
     * Title of a managed database instance
     */
    readonly title: pulumi.Output<string>;
    /**
     * Type of the service
     */
    readonly type: pulumi.Output<string>;
    /**
     * Zone where the instance resides, e.g. `de-fra1`. You can list available zones with `upctl zone list`.
     */
    readonly zone: pulumi.Output<string>;
    /**
     * Create a ManagedDatabaseRedis 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: ManagedDatabaseRedisArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering ManagedDatabaseRedis resources.
 */
export interface ManagedDatabaseRedisState {
    /**
     * Service component information
     */
    components?: pulumi.Input<pulumi.Input<inputs.ManagedDatabaseRedisComponent>[]>;
    /**
     * User defined key-value pairs to classify the managed database.
     */
    labels?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Maintenance window day of week. Lower case weekday name (monday, tuesday, ...)
     */
    maintenanceWindowDow?: pulumi.Input<string>;
    /**
     * Maintenance window UTC time in hh:mm:ss format
     */
    maintenanceWindowTime?: pulumi.Input<string>;
    /**
     * Name of the service. The name is used as a prefix for the logical hostname. Must be unique within an account
     */
    name?: pulumi.Input<string>;
    /**
     * Private networks attached to the managed database
     */
    networks?: pulumi.Input<pulumi.Input<inputs.ManagedDatabaseRedisNetwork>[]>;
    /**
     * Information about nodes providing the managed service
     */
    nodeStates?: pulumi.Input<pulumi.Input<inputs.ManagedDatabaseRedisNodeState>[]>;
    /**
     * Service plan to use. This determines how much resources the instance will have. You can list available plans with `upctl
     * database plans <type>`.
     */
    plan?: pulumi.Input<string>;
    /**
     * The administrative power state of the service
     */
    powered?: pulumi.Input<boolean>;
    /**
     * Primary database name
     */
    primaryDatabase?: pulumi.Input<string>;
    /**
     * Database Engine properties for Redis
     */
    properties?: pulumi.Input<inputs.ManagedDatabaseRedisProperties>;
    /**
     * Hostname to the service instance
     */
    serviceHost?: pulumi.Input<string>;
    /**
     * Primary username's password to the service instance
     */
    servicePassword?: pulumi.Input<string>;
    /**
     * Port to the service instance
     */
    servicePort?: pulumi.Input<string>;
    /**
     * URI to the service instance
     */
    serviceUri?: pulumi.Input<string>;
    /**
     * Primary username to the service instance
     */
    serviceUsername?: pulumi.Input<string>;
    /**
     * State of the service
     */
    state?: pulumi.Input<string>;
    /**
     * If set to true, prevents the managed service from being powered off, or deleted.
     */
    terminationProtection?: pulumi.Input<boolean>;
    /**
     * Title of a managed database instance
     */
    title?: pulumi.Input<string>;
    /**
     * Type of the service
     */
    type?: pulumi.Input<string>;
    /**
     * Zone where the instance resides, e.g. `de-fra1`. You can list available zones with `upctl zone list`.
     */
    zone?: pulumi.Input<string>;
}
/**
 * The set of arguments for constructing a ManagedDatabaseRedis resource.
 */
export interface ManagedDatabaseRedisArgs {
    /**
     * User defined key-value pairs to classify the managed database.
     */
    labels?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Maintenance window day of week. Lower case weekday name (monday, tuesday, ...)
     */
    maintenanceWindowDow?: pulumi.Input<string>;
    /**
     * Maintenance window UTC time in hh:mm:ss format
     */
    maintenanceWindowTime?: pulumi.Input<string>;
    /**
     * Name of the service. The name is used as a prefix for the logical hostname. Must be unique within an account
     */
    name?: pulumi.Input<string>;
    /**
     * Private networks attached to the managed database
     */
    networks?: pulumi.Input<pulumi.Input<inputs.ManagedDatabaseRedisNetwork>[]>;
    /**
     * Service plan to use. This determines how much resources the instance will have. You can list available plans with `upctl
     * database plans <type>`.
     */
    plan: pulumi.Input<string>;
    /**
     * The administrative power state of the service
     */
    powered?: pulumi.Input<boolean>;
    /**
     * Database Engine properties for Redis
     */
    properties?: pulumi.Input<inputs.ManagedDatabaseRedisProperties>;
    /**
     * If set to true, prevents the managed service from being powered off, or deleted.
     */
    terminationProtection?: pulumi.Input<boolean>;
    /**
     * Title of a managed database instance
     */
    title: pulumi.Input<string>;
    /**
     * Zone where the instance resides, e.g. `de-fra1`. You can list available zones with `upctl zone list`.
     */
    zone: pulumi.Input<string>;
}