pulumi-digitalocean 4.40.0a1739511652__py3-none-any.whl → 4.56.0a1766428645__py3-none-any.whl

pulumi_digitalocean/database_valkey_config.py

@@ -0,0 +1,776 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = ['DatabaseValkeyConfigArgs', 'DatabaseValkeyConfig']
+
+@pulumi.input_type
+class DatabaseValkeyConfigArgs:
+    def __init__(__self__, *,
+                 cluster_id: pulumi.Input[_builtins.str],
+                 acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
+                 frequent_snapshots: Optional[pulumi.Input[_builtins.bool]] = None,
+                 io_threads: Optional[pulumi.Input[_builtins.int]] = None,
+                 lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
+                 lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
+                 notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
+                 number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
+                 persistence: Optional[pulumi.Input[_builtins.str]] = None,
+                 pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
+                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
+                 timeout: Optional[pulumi.Input[_builtins.int]] = None,
+                 valkey_active_expire_effort: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        The set of arguments for constructing a DatabaseValkeyConfig resource.
+        :param pulumi.Input[_builtins.str] cluster_id: The ID of the target Valkey cluster.
+        :param pulumi.Input[_builtins.str] acl_channels_default: Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Valkey' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
+        :param pulumi.Input[_builtins.bool] frequent_snapshots: Frequent RDB snapshots. When enabled, Valkey will create frequent local RDB snapshots. When disabled, Valkey will only take RDB snapshots when a backup is created, based on the backup schedule. This setting is ignored when valkey_persistence is set to off.
+        :param pulumi.Input[_builtins.int] io_threads: The Valkey IO thread count.
+        :param pulumi.Input[_builtins.int] lfu_decay_time: The LFU maxmemory policy counter decay time in minutes.
+        :param pulumi.Input[_builtins.int] lfu_log_factor: The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
+        :param pulumi.Input[_builtins.str] notify_keyspace_events: The `notify-keyspace-events` option. Requires at least `K` or `E`.
+        :param pulumi.Input[_builtins.int] number_of_databases: The number of Valkey databases. Changing this will cause a restart of Valkey service.
+        :param pulumi.Input[_builtins.str] persistence: When persistence is 'rdb', Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        :param pulumi.Input[_builtins.int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
+        :param pulumi.Input[_builtins.bool] ssl: A boolean indicating whether to require SSL to access Valkey.
+        :param pulumi.Input[_builtins.int] timeout: The Valkey idle connection timeout in seconds.
+        :param pulumi.Input[_builtins.int] valkey_active_expire_effort: Active expire effort. Valkey reclaims expired keys both when accessed and in the background. The background process scans for expired keys to free memory. Increasing the active-expire-effort setting (default 1, max 10) uses more CPU to reclaim expired keys faster, reducing memory usage but potentially increasing latency.
+        """
+        pulumi.set(__self__, "cluster_id", cluster_id)
+        if acl_channels_default is not None:
+            pulumi.set(__self__, "acl_channels_default", acl_channels_default)
+        if frequent_snapshots is not None:
+            pulumi.set(__self__, "frequent_snapshots", frequent_snapshots)
+        if io_threads is not None:
+            pulumi.set(__self__, "io_threads", io_threads)
+        if lfu_decay_time is not None:
+            pulumi.set(__self__, "lfu_decay_time", lfu_decay_time)
+        if lfu_log_factor is not None:
+            pulumi.set(__self__, "lfu_log_factor", lfu_log_factor)
+        if notify_keyspace_events is not None:
+            pulumi.set(__self__, "notify_keyspace_events", notify_keyspace_events)
+        if number_of_databases is not None:
+            pulumi.set(__self__, "number_of_databases", number_of_databases)
+        if persistence is not None:
+            pulumi.set(__self__, "persistence", persistence)
+        if pubsub_client_output_buffer_limit is not None:
+            pulumi.set(__self__, "pubsub_client_output_buffer_limit", pubsub_client_output_buffer_limit)
+        if ssl is not None:
+            pulumi.set(__self__, "ssl", ssl)
+        if timeout is not None:
+            pulumi.set(__self__, "timeout", timeout)
+        if valkey_active_expire_effort is not None:
+            pulumi.set(__self__, "valkey_active_expire_effort", valkey_active_expire_effort)
+
+    @_builtins.property
+    @pulumi.getter(name="clusterId")
+    def cluster_id(self) -> pulumi.Input[_builtins.str]:
+        """
+        The ID of the target Valkey cluster.
+        """
+        return pulumi.get(self, "cluster_id")
+
+    @cluster_id.setter
+    def cluster_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "cluster_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="aclChannelsDefault")
+    def acl_channels_default(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Valkey' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
+        """
+        return pulumi.get(self, "acl_channels_default")
+
+    @acl_channels_default.setter
+    def acl_channels_default(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "acl_channels_default", value)
+
+    @_builtins.property
+    @pulumi.getter(name="frequentSnapshots")
+    def frequent_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Frequent RDB snapshots. When enabled, Valkey will create frequent local RDB snapshots. When disabled, Valkey will only take RDB snapshots when a backup is created, based on the backup schedule. This setting is ignored when valkey_persistence is set to off.
+        """
+        return pulumi.get(self, "frequent_snapshots")
+
+    @frequent_snapshots.setter
+    def frequent_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "frequent_snapshots", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ioThreads")
+    def io_threads(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The Valkey IO thread count.
+        """
+        return pulumi.get(self, "io_threads")
+
+    @io_threads.setter
+    def io_threads(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "io_threads", value)
+
+    @_builtins.property
+    @pulumi.getter(name="lfuDecayTime")
+    def lfu_decay_time(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The LFU maxmemory policy counter decay time in minutes.
+        """
+        return pulumi.get(self, "lfu_decay_time")
+
+    @lfu_decay_time.setter
+    def lfu_decay_time(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "lfu_decay_time", value)
+
+    @_builtins.property
+    @pulumi.getter(name="lfuLogFactor")
+    def lfu_log_factor(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
+        """
+        return pulumi.get(self, "lfu_log_factor")
+
+    @lfu_log_factor.setter
+    def lfu_log_factor(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "lfu_log_factor", value)
+
+    @_builtins.property
+    @pulumi.getter(name="notifyKeyspaceEvents")
+    def notify_keyspace_events(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The `notify-keyspace-events` option. Requires at least `K` or `E`.
+        """
+        return pulumi.get(self, "notify_keyspace_events")
+
+    @notify_keyspace_events.setter
+    def notify_keyspace_events(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "notify_keyspace_events", value)
+
+    @_builtins.property
+    @pulumi.getter(name="numberOfDatabases")
+    def number_of_databases(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The number of Valkey databases. Changing this will cause a restart of Valkey service.
+        """
+        return pulumi.get(self, "number_of_databases")
+
+    @number_of_databases.setter
+    def number_of_databases(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "number_of_databases", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def persistence(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        When persistence is 'rdb', Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        """
+        return pulumi.get(self, "persistence")
+
+    @persistence.setter
+    def persistence(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "persistence", value)
+
+    @_builtins.property
+    @pulumi.getter(name="pubsubClientOutputBufferLimit")
+    def pubsub_client_output_buffer_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
+        """
+        return pulumi.get(self, "pubsub_client_output_buffer_limit")
+
+    @pubsub_client_output_buffer_limit.setter
+    def pubsub_client_output_buffer_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "pubsub_client_output_buffer_limit", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        A boolean indicating whether to require SSL to access Valkey.
+        """
+        return pulumi.get(self, "ssl")
+
+    @ssl.setter
+    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "ssl", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The Valkey idle connection timeout in seconds.
+        """
+        return pulumi.get(self, "timeout")
+
+    @timeout.setter
+    def timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "timeout", value)
+
+    @_builtins.property
+    @pulumi.getter(name="valkeyActiveExpireEffort")
+    def valkey_active_expire_effort(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Active expire effort. Valkey reclaims expired keys both when accessed and in the background. The background process scans for expired keys to free memory. Increasing the active-expire-effort setting (default 1, max 10) uses more CPU to reclaim expired keys faster, reducing memory usage but potentially increasing latency.
+        """
+        return pulumi.get(self, "valkey_active_expire_effort")
+
+    @valkey_active_expire_effort.setter
+    def valkey_active_expire_effort(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "valkey_active_expire_effort", value)
+
+
+@pulumi.input_type
+class _DatabaseValkeyConfigState:
+    def __init__(__self__, *,
+                 acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
+                 cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
+                 frequent_snapshots: Optional[pulumi.Input[_builtins.bool]] = None,
+                 io_threads: Optional[pulumi.Input[_builtins.int]] = None,
+                 lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
+                 lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
+                 notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
+                 number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
+                 persistence: Optional[pulumi.Input[_builtins.str]] = None,
+                 pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
+                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
+                 timeout: Optional[pulumi.Input[_builtins.int]] = None,
+                 valkey_active_expire_effort: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        Input properties used for looking up and filtering DatabaseValkeyConfig resources.
+        :param pulumi.Input[_builtins.str] acl_channels_default: Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Valkey' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
+        :param pulumi.Input[_builtins.str] cluster_id: The ID of the target Valkey cluster.
+        :param pulumi.Input[_builtins.bool] frequent_snapshots: Frequent RDB snapshots. When enabled, Valkey will create frequent local RDB snapshots. When disabled, Valkey will only take RDB snapshots when a backup is created, based on the backup schedule. This setting is ignored when valkey_persistence is set to off.
+        :param pulumi.Input[_builtins.int] io_threads: The Valkey IO thread count.
+        :param pulumi.Input[_builtins.int] lfu_decay_time: The LFU maxmemory policy counter decay time in minutes.
+        :param pulumi.Input[_builtins.int] lfu_log_factor: The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
+        :param pulumi.Input[_builtins.str] notify_keyspace_events: The `notify-keyspace-events` option. Requires at least `K` or `E`.
+        :param pulumi.Input[_builtins.int] number_of_databases: The number of Valkey databases. Changing this will cause a restart of Valkey service.
+        :param pulumi.Input[_builtins.str] persistence: When persistence is 'rdb', Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        :param pulumi.Input[_builtins.int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
+        :param pulumi.Input[_builtins.bool] ssl: A boolean indicating whether to require SSL to access Valkey.
+        :param pulumi.Input[_builtins.int] timeout: The Valkey idle connection timeout in seconds.
+        :param pulumi.Input[_builtins.int] valkey_active_expire_effort: Active expire effort. Valkey reclaims expired keys both when accessed and in the background. The background process scans for expired keys to free memory. Increasing the active-expire-effort setting (default 1, max 10) uses more CPU to reclaim expired keys faster, reducing memory usage but potentially increasing latency.
+        """
+        if acl_channels_default is not None:
+            pulumi.set(__self__, "acl_channels_default", acl_channels_default)
+        if cluster_id is not None:
+            pulumi.set(__self__, "cluster_id", cluster_id)
+        if frequent_snapshots is not None:
+            pulumi.set(__self__, "frequent_snapshots", frequent_snapshots)
+        if io_threads is not None:
+            pulumi.set(__self__, "io_threads", io_threads)
+        if lfu_decay_time is not None:
+            pulumi.set(__self__, "lfu_decay_time", lfu_decay_time)
+        if lfu_log_factor is not None:
+            pulumi.set(__self__, "lfu_log_factor", lfu_log_factor)
+        if notify_keyspace_events is not None:
+            pulumi.set(__self__, "notify_keyspace_events", notify_keyspace_events)
+        if number_of_databases is not None:
+            pulumi.set(__self__, "number_of_databases", number_of_databases)
+        if persistence is not None:
+            pulumi.set(__self__, "persistence", persistence)
+        if pubsub_client_output_buffer_limit is not None:
+            pulumi.set(__self__, "pubsub_client_output_buffer_limit", pubsub_client_output_buffer_limit)
+        if ssl is not None:
+            pulumi.set(__self__, "ssl", ssl)
+        if timeout is not None:
+            pulumi.set(__self__, "timeout", timeout)
+        if valkey_active_expire_effort is not None:
+            pulumi.set(__self__, "valkey_active_expire_effort", valkey_active_expire_effort)
+
+    @_builtins.property
+    @pulumi.getter(name="aclChannelsDefault")
+    def acl_channels_default(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Valkey' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
+        """
+        return pulumi.get(self, "acl_channels_default")
+
+    @acl_channels_default.setter
+    def acl_channels_default(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "acl_channels_default", value)
+
+    @_builtins.property
+    @pulumi.getter(name="clusterId")
+    def cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The ID of the target Valkey cluster.
+        """
+        return pulumi.get(self, "cluster_id")
+
+    @cluster_id.setter
+    def cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "cluster_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="frequentSnapshots")
+    def frequent_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Frequent RDB snapshots. When enabled, Valkey will create frequent local RDB snapshots. When disabled, Valkey will only take RDB snapshots when a backup is created, based on the backup schedule. This setting is ignored when valkey_persistence is set to off.
+        """
+        return pulumi.get(self, "frequent_snapshots")
+
+    @frequent_snapshots.setter
+    def frequent_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "frequent_snapshots", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ioThreads")
+    def io_threads(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The Valkey IO thread count.
+        """
+        return pulumi.get(self, "io_threads")
+
+    @io_threads.setter
+    def io_threads(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "io_threads", value)
+
+    @_builtins.property
+    @pulumi.getter(name="lfuDecayTime")
+    def lfu_decay_time(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The LFU maxmemory policy counter decay time in minutes.
+        """
+        return pulumi.get(self, "lfu_decay_time")
+
+    @lfu_decay_time.setter
+    def lfu_decay_time(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "lfu_decay_time", value)
+
+    @_builtins.property
+    @pulumi.getter(name="lfuLogFactor")
+    def lfu_log_factor(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
+        """
+        return pulumi.get(self, "lfu_log_factor")
+
+    @lfu_log_factor.setter
+    def lfu_log_factor(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "lfu_log_factor", value)
+
+    @_builtins.property
+    @pulumi.getter(name="notifyKeyspaceEvents")
+    def notify_keyspace_events(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The `notify-keyspace-events` option. Requires at least `K` or `E`.
+        """
+        return pulumi.get(self, "notify_keyspace_events")
+
+    @notify_keyspace_events.setter
+    def notify_keyspace_events(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "notify_keyspace_events", value)
+
+    @_builtins.property
+    @pulumi.getter(name="numberOfDatabases")
+    def number_of_databases(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The number of Valkey databases. Changing this will cause a restart of Valkey service.
+        """
+        return pulumi.get(self, "number_of_databases")
+
+    @number_of_databases.setter
+    def number_of_databases(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "number_of_databases", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def persistence(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        When persistence is 'rdb', Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        """
+        return pulumi.get(self, "persistence")
+
+    @persistence.setter
+    def persistence(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "persistence", value)
+
+    @_builtins.property
+    @pulumi.getter(name="pubsubClientOutputBufferLimit")
+    def pubsub_client_output_buffer_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
+        """
+        return pulumi.get(self, "pubsub_client_output_buffer_limit")
+
+    @pubsub_client_output_buffer_limit.setter
+    def pubsub_client_output_buffer_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "pubsub_client_output_buffer_limit", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        A boolean indicating whether to require SSL to access Valkey.
+        """
+        return pulumi.get(self, "ssl")
+
+    @ssl.setter
+    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "ssl", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The Valkey idle connection timeout in seconds.
+        """
+        return pulumi.get(self, "timeout")
+
+    @timeout.setter
+    def timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "timeout", value)
+
+    @_builtins.property
+    @pulumi.getter(name="valkeyActiveExpireEffort")
+    def valkey_active_expire_effort(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Active expire effort. Valkey reclaims expired keys both when accessed and in the background. The background process scans for expired keys to free memory. Increasing the active-expire-effort setting (default 1, max 10) uses more CPU to reclaim expired keys faster, reducing memory usage but potentially increasing latency.
+        """
+        return pulumi.get(self, "valkey_active_expire_effort")
+
+    @valkey_active_expire_effort.setter
+    def valkey_active_expire_effort(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "valkey_active_expire_effort", value)
+
+
+@pulumi.type_token("digitalocean:index/databaseValkeyConfig:DatabaseValkeyConfig")
+class DatabaseValkeyConfig(pulumi.CustomResource):
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
+                 cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
+                 frequent_snapshots: Optional[pulumi.Input[_builtins.bool]] = None,
+                 io_threads: Optional[pulumi.Input[_builtins.int]] = None,
+                 lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
+                 lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
+                 notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
+                 number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
+                 persistence: Optional[pulumi.Input[_builtins.str]] = None,
+                 pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
+                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
+                 timeout: Optional[pulumi.Input[_builtins.int]] = None,
+                 valkey_active_expire_effort: Optional[pulumi.Input[_builtins.int]] = None,
+                 __props__=None):
+        """
+        Provides a virtual resource that can be used to change advanced configuration
+        options for a DigitalOcean managed Valkey database cluster.
+
+        > **Note** Valkey configurations are only removed from state when destroyed. The remote configuration is not unset.
+
+        ## Example Usage
+
+        ```python
+        import pulumi
+        import pulumi_digitalocean as digitalocean
+
+        example_database_cluster = digitalocean.DatabaseCluster("example",
+            name="example-valkey-cluster",
+            engine="valkey",
+            version="8",
+            size=digitalocean.DatabaseSlug.D_B_1_VPCU1_GB,
+            region=digitalocean.Region.NYC1,
+            node_count=1)
+        example = digitalocean.DatabaseValkeyConfig("example",
+            cluster_id=example_database_cluster.id,
+            notify_keyspace_events="KEA",
+            timeout=90)
+        ```
+
+        ## Import
+
+        A Valkey database cluster's configuration can be imported using the `id` the parent cluster, e.g.
+
+        ```sh
+        $ pulumi import digitalocean:index/databaseValkeyConfig:DatabaseValkeyConfig example 245bcfd0-7f31-4ce6-a2bc-475a116cca97
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[_builtins.str] acl_channels_default: Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Valkey' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
+        :param pulumi.Input[_builtins.str] cluster_id: The ID of the target Valkey cluster.
+        :param pulumi.Input[_builtins.bool] frequent_snapshots: Frequent RDB snapshots. When enabled, Valkey will create frequent local RDB snapshots. When disabled, Valkey will only take RDB snapshots when a backup is created, based on the backup schedule. This setting is ignored when valkey_persistence is set to off.
+        :param pulumi.Input[_builtins.int] io_threads: The Valkey IO thread count.
+        :param pulumi.Input[_builtins.int] lfu_decay_time: The LFU maxmemory policy counter decay time in minutes.
+        :param pulumi.Input[_builtins.int] lfu_log_factor: The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
+        :param pulumi.Input[_builtins.str] notify_keyspace_events: The `notify-keyspace-events` option. Requires at least `K` or `E`.
+        :param pulumi.Input[_builtins.int] number_of_databases: The number of Valkey databases. Changing this will cause a restart of Valkey service.
+        :param pulumi.Input[_builtins.str] persistence: When persistence is 'rdb', Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        :param pulumi.Input[_builtins.int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
+        :param pulumi.Input[_builtins.bool] ssl: A boolean indicating whether to require SSL to access Valkey.
+        :param pulumi.Input[_builtins.int] timeout: The Valkey idle connection timeout in seconds.
+        :param pulumi.Input[_builtins.int] valkey_active_expire_effort: Active expire effort. Valkey reclaims expired keys both when accessed and in the background. The background process scans for expired keys to free memory. Increasing the active-expire-effort setting (default 1, max 10) uses more CPU to reclaim expired keys faster, reducing memory usage but potentially increasing latency.
+        """
+        ...
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 args: DatabaseValkeyConfigArgs,
+                 opts: Optional[pulumi.ResourceOptions] = None):
+        """
+        Provides a virtual resource that can be used to change advanced configuration
+        options for a DigitalOcean managed Valkey database cluster.
+
+        > **Note** Valkey configurations are only removed from state when destroyed. The remote configuration is not unset.
+
+        ## Example Usage
+
+        ```python
+        import pulumi
+        import pulumi_digitalocean as digitalocean
+
+        example_database_cluster = digitalocean.DatabaseCluster("example",
+            name="example-valkey-cluster",
+            engine="valkey",
+            version="8",
+            size=digitalocean.DatabaseSlug.D_B_1_VPCU1_GB,
+            region=digitalocean.Region.NYC1,
+            node_count=1)
+        example = digitalocean.DatabaseValkeyConfig("example",
+            cluster_id=example_database_cluster.id,
+            notify_keyspace_events="KEA",
+            timeout=90)
+        ```
+
+        ## Import
+
+        A Valkey database cluster's configuration can be imported using the `id` the parent cluster, e.g.
+
+        ```sh
+        $ pulumi import digitalocean:index/databaseValkeyConfig:DatabaseValkeyConfig example 245bcfd0-7f31-4ce6-a2bc-475a116cca97
+        ```
+
+        :param str resource_name: The name of the resource.
+        :param DatabaseValkeyConfigArgs args: The arguments to use to populate this resource's properties.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        """
+        ...
+    def __init__(__self__, resource_name: str, *args, **kwargs):
+        resource_args, opts = _utilities.get_resource_args_opts(DatabaseValkeyConfigArgs, pulumi.ResourceOptions, *args, **kwargs)
+        if resource_args is not None:
+            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
+        else:
+            __self__._internal_init(resource_name, *args, **kwargs)
+
+    def _internal_init(__self__,
+                 resource_name: str,
+                 opts: Optional[pulumi.ResourceOptions] = None,
+                 acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
+                 cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
+                 frequent_snapshots: Optional[pulumi.Input[_builtins.bool]] = None,
+                 io_threads: Optional[pulumi.Input[_builtins.int]] = None,
+                 lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
+                 lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
+                 notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
+                 number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
+                 persistence: Optional[pulumi.Input[_builtins.str]] = None,
+                 pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
+                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
+                 timeout: Optional[pulumi.Input[_builtins.int]] = None,
+                 valkey_active_expire_effort: Optional[pulumi.Input[_builtins.int]] = None,
+                 __props__=None):
+        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
+        if not isinstance(opts, pulumi.ResourceOptions):
+            raise TypeError('Expected resource options to be a ResourceOptions instance')
+        if opts.id is None:
+            if __props__ is not None:
+                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
+            __props__ = DatabaseValkeyConfigArgs.__new__(DatabaseValkeyConfigArgs)
+
+            __props__.__dict__["acl_channels_default"] = acl_channels_default
+            if cluster_id is None and not opts.urn:
+                raise TypeError("Missing required property 'cluster_id'")
+            __props__.__dict__["cluster_id"] = cluster_id
+            __props__.__dict__["frequent_snapshots"] = frequent_snapshots
+            __props__.__dict__["io_threads"] = io_threads
+            __props__.__dict__["lfu_decay_time"] = lfu_decay_time
+            __props__.__dict__["lfu_log_factor"] = lfu_log_factor
+            __props__.__dict__["notify_keyspace_events"] = notify_keyspace_events
+            __props__.__dict__["number_of_databases"] = number_of_databases
+            __props__.__dict__["persistence"] = persistence
+            __props__.__dict__["pubsub_client_output_buffer_limit"] = pubsub_client_output_buffer_limit
+            __props__.__dict__["ssl"] = ssl
+            __props__.__dict__["timeout"] = timeout
+            __props__.__dict__["valkey_active_expire_effort"] = valkey_active_expire_effort
+        super(DatabaseValkeyConfig, __self__).__init__(
+            'digitalocean:index/databaseValkeyConfig:DatabaseValkeyConfig',
+            resource_name,
+            __props__,
+            opts)
+
+    @staticmethod
+    def get(resource_name: str,
+            id: pulumi.Input[str],
+            opts: Optional[pulumi.ResourceOptions] = None,
+            acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
+            cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
+            frequent_snapshots: Optional[pulumi.Input[_builtins.bool]] = None,
+            io_threads: Optional[pulumi.Input[_builtins.int]] = None,
+            lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
+            lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
+            notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
+            number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
+            persistence: Optional[pulumi.Input[_builtins.str]] = None,
+            pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
+            ssl: Optional[pulumi.Input[_builtins.bool]] = None,
+            timeout: Optional[pulumi.Input[_builtins.int]] = None,
+            valkey_active_expire_effort: Optional[pulumi.Input[_builtins.int]] = None) -> 'DatabaseValkeyConfig':
+        """
+        Get an existing DatabaseValkeyConfig resource's state with the given name, id, and optional extra
+        properties used to qualify the lookup.
+
+        :param str resource_name: The unique name of the resulting resource.
+        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
+        :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[_builtins.str] acl_channels_default: Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Valkey' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
+        :param pulumi.Input[_builtins.str] cluster_id: The ID of the target Valkey cluster.
+        :param pulumi.Input[_builtins.bool] frequent_snapshots: Frequent RDB snapshots. When enabled, Valkey will create frequent local RDB snapshots. When disabled, Valkey will only take RDB snapshots when a backup is created, based on the backup schedule. This setting is ignored when valkey_persistence is set to off.
+        :param pulumi.Input[_builtins.int] io_threads: The Valkey IO thread count.
+        :param pulumi.Input[_builtins.int] lfu_decay_time: The LFU maxmemory policy counter decay time in minutes.
+        :param pulumi.Input[_builtins.int] lfu_log_factor: The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
+        :param pulumi.Input[_builtins.str] notify_keyspace_events: The `notify-keyspace-events` option. Requires at least `K` or `E`.
+        :param pulumi.Input[_builtins.int] number_of_databases: The number of Valkey databases. Changing this will cause a restart of Valkey service.
+        :param pulumi.Input[_builtins.str] persistence: When persistence is 'rdb', Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        :param pulumi.Input[_builtins.int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
+        :param pulumi.Input[_builtins.bool] ssl: A boolean indicating whether to require SSL to access Valkey.
+        :param pulumi.Input[_builtins.int] timeout: The Valkey idle connection timeout in seconds.
+        :param pulumi.Input[_builtins.int] valkey_active_expire_effort: Active expire effort. Valkey reclaims expired keys both when accessed and in the background. The background process scans for expired keys to free memory. Increasing the active-expire-effort setting (default 1, max 10) uses more CPU to reclaim expired keys faster, reducing memory usage but potentially increasing latency.
+        """
+        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
+
+        __props__ = _DatabaseValkeyConfigState.__new__(_DatabaseValkeyConfigState)
+
+        __props__.__dict__["acl_channels_default"] = acl_channels_default
+        __props__.__dict__["cluster_id"] = cluster_id
+        __props__.__dict__["frequent_snapshots"] = frequent_snapshots
+        __props__.__dict__["io_threads"] = io_threads
+        __props__.__dict__["lfu_decay_time"] = lfu_decay_time
+        __props__.__dict__["lfu_log_factor"] = lfu_log_factor
+        __props__.__dict__["notify_keyspace_events"] = notify_keyspace_events
+        __props__.__dict__["number_of_databases"] = number_of_databases
+        __props__.__dict__["persistence"] = persistence
+        __props__.__dict__["pubsub_client_output_buffer_limit"] = pubsub_client_output_buffer_limit
+        __props__.__dict__["ssl"] = ssl
+        __props__.__dict__["timeout"] = timeout
+        __props__.__dict__["valkey_active_expire_effort"] = valkey_active_expire_effort
+        return DatabaseValkeyConfig(resource_name, opts=opts, __props__=__props__)
+
+    @_builtins.property
+    @pulumi.getter(name="aclChannelsDefault")
+    def acl_channels_default(self) -> pulumi.Output[_builtins.str]:
+        """
+        Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Valkey' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
+        """
+        return pulumi.get(self, "acl_channels_default")
+
+    @_builtins.property
+    @pulumi.getter(name="clusterId")
+    def cluster_id(self) -> pulumi.Output[_builtins.str]:
+        """
+        The ID of the target Valkey cluster.
+        """
+        return pulumi.get(self, "cluster_id")
+
+    @_builtins.property
+    @pulumi.getter(name="frequentSnapshots")
+    def frequent_snapshots(self) -> pulumi.Output[_builtins.bool]:
+        """
+        Frequent RDB snapshots. When enabled, Valkey will create frequent local RDB snapshots. When disabled, Valkey will only take RDB snapshots when a backup is created, based on the backup schedule. This setting is ignored when valkey_persistence is set to off.
+        """
+        return pulumi.get(self, "frequent_snapshots")
+
+    @_builtins.property
+    @pulumi.getter(name="ioThreads")
+    def io_threads(self) -> pulumi.Output[_builtins.int]:
+        """
+        The Valkey IO thread count.
+        """
+        return pulumi.get(self, "io_threads")
+
+    @_builtins.property
+    @pulumi.getter(name="lfuDecayTime")
+    def lfu_decay_time(self) -> pulumi.Output[_builtins.int]:
+        """
+        The LFU maxmemory policy counter decay time in minutes.
+        """
+        return pulumi.get(self, "lfu_decay_time")
+
+    @_builtins.property
+    @pulumi.getter(name="lfuLogFactor")
+    def lfu_log_factor(self) -> pulumi.Output[_builtins.int]:
+        """
+        The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
+        """
+        return pulumi.get(self, "lfu_log_factor")
+
+    @_builtins.property
+    @pulumi.getter(name="notifyKeyspaceEvents")
+    def notify_keyspace_events(self) -> pulumi.Output[_builtins.str]:
+        """
+        The `notify-keyspace-events` option. Requires at least `K` or `E`.
+        """
+        return pulumi.get(self, "notify_keyspace_events")
+
+    @_builtins.property
+    @pulumi.getter(name="numberOfDatabases")
+    def number_of_databases(self) -> pulumi.Output[_builtins.int]:
+        """
+        The number of Valkey databases. Changing this will cause a restart of Valkey service.
+        """
+        return pulumi.get(self, "number_of_databases")
+
+    @_builtins.property
+    @pulumi.getter
+    def persistence(self) -> pulumi.Output[_builtins.str]:
+        """
+        When persistence is 'rdb', Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        """
+        return pulumi.get(self, "persistence")
+
+    @_builtins.property
+    @pulumi.getter(name="pubsubClientOutputBufferLimit")
+    def pubsub_client_output_buffer_limit(self) -> pulumi.Output[_builtins.int]:
+        """
+        The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
+        """
+        return pulumi.get(self, "pubsub_client_output_buffer_limit")
+
+    @_builtins.property
+    @pulumi.getter
+    def ssl(self) -> pulumi.Output[_builtins.bool]:
+        """
+        A boolean indicating whether to require SSL to access Valkey.
+        """
+        return pulumi.get(self, "ssl")
+
+    @_builtins.property
+    @pulumi.getter
+    def timeout(self) -> pulumi.Output[_builtins.int]:
+        """
+        The Valkey idle connection timeout in seconds.
+        """
+        return pulumi.get(self, "timeout")
+
+    @_builtins.property
+    @pulumi.getter(name="valkeyActiveExpireEffort")
+    def valkey_active_expire_effort(self) -> pulumi.Output[_builtins.int]:
+        """
+        Active expire effort. Valkey reclaims expired keys both when accessed and in the background. The background process scans for expired keys to free memory. Increasing the active-expire-effort setting (default 1, max 10) uses more CPU to reclaim expired keys faster, reducing memory usage but potentially increasing latency.
+        """
+        return pulumi.get(self, "valkey_active_expire_effort")
+