pulumi-digitalocean 4.52.0a1755711873__py3-none-any.whl → 4.53.0__py3-none-any.whl

pulumi_digitalocean/database_valkey_config.py

@@ -36,9 +36,7 @@ class DatabaseValkeyConfigArgs:
         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.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.
@@ -48,9 +46,7 @@ class DatabaseValkeyConfigArgs:
         :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.
+        :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:
@@ -106,9 +102,7 @@ class DatabaseValkeyConfigArgs:
     @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.
+        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")
 
@@ -228,9 +222,7 @@ class DatabaseValkeyConfigArgs:
     @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.
+        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")
 
@@ -259,9 +251,7 @@ class _DatabaseValkeyConfigState:
         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.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.
@@ -271,9 +261,7 @@ class _DatabaseValkeyConfigState:
         :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.
+        :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)
@@ -330,9 +318,7 @@ class _DatabaseValkeyConfigState:
     @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.
+        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")
 
@@ -452,9 +438,7 @@ class _DatabaseValkeyConfigState:
     @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.
+        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")
 
@@ -520,9 +504,7 @@ class DatabaseValkeyConfig(pulumi.CustomResource):
         :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.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.
@@ -532,9 +514,7 @@ class DatabaseValkeyConfig(pulumi.CustomResource):
         :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.
+        :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
@@ -659,9 +639,7 @@ class DatabaseValkeyConfig(pulumi.CustomResource):
         :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.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.
@@ -671,9 +649,7 @@ class DatabaseValkeyConfig(pulumi.CustomResource):
         :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.
+        :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))
 
@@ -714,9 +690,7 @@ class DatabaseValkeyConfig(pulumi.CustomResource):
     @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.
+        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")
 
@@ -796,9 +770,7 @@ class DatabaseValkeyConfig(pulumi.CustomResource):
     @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.
+        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")
 

pulumi_digitalocean/get_kubernetes_cluster.py

@@ -28,7 +28,13 @@ class GetKubernetesClusterResult:
     """
     A collection of values returned by getKubernetesCluster.
     """
-    def __init__(__self__, auto_upgrade=None, cluster_autoscaler_configurations=None, cluster_subnet=None, control_plane_firewalls=None, created_at=None, endpoint=None, ha=None, id=None, ipv4_address=None, kube_configs=None, kubeconfig_expire_seconds=None, maintenance_policies=None, name=None, node_pools=None, region=None, routing_agent=None, service_subnet=None, status=None, surge_upgrade=None, tags=None, updated_at=None, urn=None, version=None, vpc_uuid=None):
+    def __init__(__self__, amd_gpu_device_metrics_exporter_plugin=None, amd_gpu_device_plugin=None, auto_upgrade=None, cluster_autoscaler_configurations=None, cluster_subnet=None, control_plane_firewalls=None, created_at=None, endpoint=None, ha=None, id=None, ipv4_address=None, kube_configs=None, kubeconfig_expire_seconds=None, maintenance_policies=None, name=None, node_pools=None, region=None, routing_agent=None, service_subnet=None, status=None, surge_upgrade=None, tags=None, updated_at=None, urn=None, version=None, vpc_uuid=None):
+        if amd_gpu_device_metrics_exporter_plugin and not isinstance(amd_gpu_device_metrics_exporter_plugin, dict):
+            raise TypeError("Expected argument 'amd_gpu_device_metrics_exporter_plugin' to be a dict")
+        pulumi.set(__self__, "amd_gpu_device_metrics_exporter_plugin", amd_gpu_device_metrics_exporter_plugin)
+        if amd_gpu_device_plugin and not isinstance(amd_gpu_device_plugin, dict):
+            raise TypeError("Expected argument 'amd_gpu_device_plugin' to be a dict")
+        pulumi.set(__self__, "amd_gpu_device_plugin", amd_gpu_device_plugin)
         if auto_upgrade and not isinstance(auto_upgrade, bool):
             raise TypeError("Expected argument 'auto_upgrade' to be a bool")
         pulumi.set(__self__, "auto_upgrade", auto_upgrade)
@@ -102,6 +108,16 @@ class GetKubernetesClusterResult:
             raise TypeError("Expected argument 'vpc_uuid' to be a str")
         pulumi.set(__self__, "vpc_uuid", vpc_uuid)
 
+    @_builtins.property
+    @pulumi.getter(name="amdGpuDeviceMetricsExporterPlugin")
+    def amd_gpu_device_metrics_exporter_plugin(self) -> 'outputs.GetKubernetesClusterAmdGpuDeviceMetricsExporterPluginResult':
+        return pulumi.get(self, "amd_gpu_device_metrics_exporter_plugin")
+
+    @_builtins.property
+    @pulumi.getter(name="amdGpuDevicePlugin")
+    def amd_gpu_device_plugin(self) -> 'outputs.GetKubernetesClusterAmdGpuDevicePluginResult':
+        return pulumi.get(self, "amd_gpu_device_plugin")
+
     @_builtins.property
     @pulumi.getter(name="autoUpgrade")
     def auto_upgrade(self) -> _builtins.bool:
@@ -283,6 +299,8 @@ class AwaitableGetKubernetesClusterResult(GetKubernetesClusterResult):
         if False:
             yield self
         return GetKubernetesClusterResult(
+            amd_gpu_device_metrics_exporter_plugin=self.amd_gpu_device_metrics_exporter_plugin,
+            amd_gpu_device_plugin=self.amd_gpu_device_plugin,
             auto_upgrade=self.auto_upgrade,
             cluster_autoscaler_configurations=self.cluster_autoscaler_configurations,
             cluster_subnet=self.cluster_subnet,
@@ -309,7 +327,9 @@ class AwaitableGetKubernetesClusterResult(GetKubernetesClusterResult):
             vpc_uuid=self.vpc_uuid)
 
 
-def get_kubernetes_cluster(cluster_autoscaler_configurations: Optional[Sequence[Union['GetKubernetesClusterClusterAutoscalerConfigurationArgs', 'GetKubernetesClusterClusterAutoscalerConfigurationArgsDict']]] = None,
+def get_kubernetes_cluster(amd_gpu_device_metrics_exporter_plugin: Optional[Union['GetKubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs', 'GetKubernetesClusterAmdGpuDeviceMetricsExporterPluginArgsDict']] = None,
+                           amd_gpu_device_plugin: Optional[Union['GetKubernetesClusterAmdGpuDevicePluginArgs', 'GetKubernetesClusterAmdGpuDevicePluginArgsDict']] = None,
+                           cluster_autoscaler_configurations: Optional[Sequence[Union['GetKubernetesClusterClusterAutoscalerConfigurationArgs', 'GetKubernetesClusterClusterAutoscalerConfigurationArgsDict']]] = None,
                            kubeconfig_expire_seconds: Optional[_builtins.int] = None,
                            name: Optional[_builtins.str] = None,
                            routing_agent: Optional[Union['GetKubernetesClusterRoutingAgentArgs', 'GetKubernetesClusterRoutingAgentArgsDict']] = None,
@@ -332,6 +352,8 @@ def get_kubernetes_cluster(cluster_autoscaler_configurations: Optional[Sequence[
     :param Sequence[_builtins.str] tags: A list of tag names applied to the node pool.
     """
     __args__ = dict()
+    __args__['amdGpuDeviceMetricsExporterPlugin'] = amd_gpu_device_metrics_exporter_plugin
+    __args__['amdGpuDevicePlugin'] = amd_gpu_device_plugin
     __args__['clusterAutoscalerConfigurations'] = cluster_autoscaler_configurations
     __args__['kubeconfigExpireSeconds'] = kubeconfig_expire_seconds
     __args__['name'] = name
@@ -341,6 +363,8 @@ def get_kubernetes_cluster(cluster_autoscaler_configurations: Optional[Sequence[
     __ret__ = pulumi.runtime.invoke('digitalocean:index/getKubernetesCluster:getKubernetesCluster', __args__, opts=opts, typ=GetKubernetesClusterResult).value
 
     return AwaitableGetKubernetesClusterResult(
+        amd_gpu_device_metrics_exporter_plugin=pulumi.get(__ret__, 'amd_gpu_device_metrics_exporter_plugin'),
+        amd_gpu_device_plugin=pulumi.get(__ret__, 'amd_gpu_device_plugin'),
         auto_upgrade=pulumi.get(__ret__, 'auto_upgrade'),
         cluster_autoscaler_configurations=pulumi.get(__ret__, 'cluster_autoscaler_configurations'),
         cluster_subnet=pulumi.get(__ret__, 'cluster_subnet'),
@@ -365,7 +389,9 @@ def get_kubernetes_cluster(cluster_autoscaler_configurations: Optional[Sequence[
         urn=pulumi.get(__ret__, 'urn'),
         version=pulumi.get(__ret__, 'version'),
         vpc_uuid=pulumi.get(__ret__, 'vpc_uuid'))
-def get_kubernetes_cluster_output(cluster_autoscaler_configurations: Optional[pulumi.Input[Optional[Sequence[Union['GetKubernetesClusterClusterAutoscalerConfigurationArgs', 'GetKubernetesClusterClusterAutoscalerConfigurationArgsDict']]]]] = None,
+def get_kubernetes_cluster_output(amd_gpu_device_metrics_exporter_plugin: Optional[pulumi.Input[Optional[Union['GetKubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs', 'GetKubernetesClusterAmdGpuDeviceMetricsExporterPluginArgsDict']]]] = None,
+                                  amd_gpu_device_plugin: Optional[pulumi.Input[Optional[Union['GetKubernetesClusterAmdGpuDevicePluginArgs', 'GetKubernetesClusterAmdGpuDevicePluginArgsDict']]]] = None,
+                                  cluster_autoscaler_configurations: Optional[pulumi.Input[Optional[Sequence[Union['GetKubernetesClusterClusterAutoscalerConfigurationArgs', 'GetKubernetesClusterClusterAutoscalerConfigurationArgsDict']]]]] = None,
                                   kubeconfig_expire_seconds: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
                                   name: Optional[pulumi.Input[_builtins.str]] = None,
                                   routing_agent: Optional[pulumi.Input[Optional[Union['GetKubernetesClusterRoutingAgentArgs', 'GetKubernetesClusterRoutingAgentArgsDict']]]] = None,
@@ -388,6 +414,8 @@ def get_kubernetes_cluster_output(cluster_autoscaler_configurations: Optional[pu
     :param Sequence[_builtins.str] tags: A list of tag names applied to the node pool.
     """
     __args__ = dict()
+    __args__['amdGpuDeviceMetricsExporterPlugin'] = amd_gpu_device_metrics_exporter_plugin
+    __args__['amdGpuDevicePlugin'] = amd_gpu_device_plugin
     __args__['clusterAutoscalerConfigurations'] = cluster_autoscaler_configurations
     __args__['kubeconfigExpireSeconds'] = kubeconfig_expire_seconds
     __args__['name'] = name
@@ -396,6 +424,8 @@ def get_kubernetes_cluster_output(cluster_autoscaler_configurations: Optional[pu
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('digitalocean:index/getKubernetesCluster:getKubernetesCluster', __args__, opts=opts, typ=GetKubernetesClusterResult)
     return __ret__.apply(lambda __response__: GetKubernetesClusterResult(
+        amd_gpu_device_metrics_exporter_plugin=pulumi.get(__response__, 'amd_gpu_device_metrics_exporter_plugin'),
+        amd_gpu_device_plugin=pulumi.get(__response__, 'amd_gpu_device_plugin'),
         auto_upgrade=pulumi.get(__response__, 'auto_upgrade'),
         cluster_autoscaler_configurations=pulumi.get(__response__, 'cluster_autoscaler_configurations'),
         cluster_subnet=pulumi.get(__response__, 'cluster_subnet'),

pulumi_digitalocean/kubernetes_cluster.py

@@ -25,6 +25,8 @@ class KubernetesClusterArgs:
                  node_pool: pulumi.Input['KubernetesClusterNodePoolArgs'],
                  region: pulumi.Input[Union[_builtins.str, 'Region']],
                  version: pulumi.Input[_builtins.str],
+                 amd_gpu_device_metrics_exporter_plugin: Optional[pulumi.Input['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs']] = None,
+                 amd_gpu_device_plugin: Optional[pulumi.Input['KubernetesClusterAmdGpuDevicePluginArgs']] = None,
                  auto_upgrade: Optional[pulumi.Input[_builtins.bool]] = None,
                  cluster_autoscaler_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesClusterClusterAutoscalerConfigurationArgs']]]] = None,
                  cluster_subnet: Optional[pulumi.Input[_builtins.str]] = None,
@@ -45,6 +47,8 @@ class KubernetesClusterArgs:
         :param pulumi.Input['KubernetesClusterNodePoolArgs'] node_pool: A block representing the cluster's default node pool. Additional node pools may be added to the cluster using the `KubernetesNodePool` resource. The following arguments may be specified:
         :param pulumi.Input[Union[_builtins.str, 'Region']] region: The slug identifier for the region where the Kubernetes cluster will be created.
         :param pulumi.Input[_builtins.str] version: The slug identifier for the version of Kubernetes used for the cluster. Use [doctl](https://github.com/digitalocean/doctl) to find the available versions `doctl kubernetes options versions`. (**Note:** A cluster may only be upgraded to newer versions in-place. If the version is decreased, a new resource will be created.)
+        :param pulumi.Input['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs'] amd_gpu_device_metrics_exporter_plugin: Block containing options for the AMD GPU device metrics exporter component.
+        :param pulumi.Input['KubernetesClusterAmdGpuDevicePluginArgs'] amd_gpu_device_plugin: Block containing options for the AMD GPU device plugin component. If not specified, the component will be enabled by default for clusters with AMD GPU nodes.
         :param pulumi.Input[_builtins.bool] auto_upgrade: A boolean value indicating whether the cluster will be automatically upgraded to new patch releases during its maintenance window.
         :param pulumi.Input[Sequence[pulumi.Input['KubernetesClusterClusterAutoscalerConfigurationArgs']]] cluster_autoscaler_configurations: Block containing options for cluster auto-scaling.
         :param pulumi.Input[_builtins.str] cluster_subnet: The range of IP addresses in the overlay network of the Kubernetes cluster. For more information, see [here](https://docs.digitalocean.com/products/kubernetes/how-to/create-clusters/#create-with-vpc-native).
@@ -64,6 +68,10 @@ class KubernetesClusterArgs:
         pulumi.set(__self__, "node_pool", node_pool)
         pulumi.set(__self__, "region", region)
         pulumi.set(__self__, "version", version)
+        if amd_gpu_device_metrics_exporter_plugin is not None:
+            pulumi.set(__self__, "amd_gpu_device_metrics_exporter_plugin", amd_gpu_device_metrics_exporter_plugin)
+        if amd_gpu_device_plugin is not None:
+            pulumi.set(__self__, "amd_gpu_device_plugin", amd_gpu_device_plugin)
         if auto_upgrade is not None:
             pulumi.set(__self__, "auto_upgrade", auto_upgrade)
         if cluster_autoscaler_configurations is not None:
@@ -131,6 +139,30 @@ class KubernetesClusterArgs:
     def version(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "version", value)
 
+    @_builtins.property
+    @pulumi.getter(name="amdGpuDeviceMetricsExporterPlugin")
+    def amd_gpu_device_metrics_exporter_plugin(self) -> Optional[pulumi.Input['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs']]:
+        """
+        Block containing options for the AMD GPU device metrics exporter component.
+        """
+        return pulumi.get(self, "amd_gpu_device_metrics_exporter_plugin")
+
+    @amd_gpu_device_metrics_exporter_plugin.setter
+    def amd_gpu_device_metrics_exporter_plugin(self, value: Optional[pulumi.Input['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs']]):
+        pulumi.set(self, "amd_gpu_device_metrics_exporter_plugin", value)
+
+    @_builtins.property
+    @pulumi.getter(name="amdGpuDevicePlugin")
+    def amd_gpu_device_plugin(self) -> Optional[pulumi.Input['KubernetesClusterAmdGpuDevicePluginArgs']]:
+        """
+        Block containing options for the AMD GPU device plugin component. If not specified, the component will be enabled by default for clusters with AMD GPU nodes.
+        """
+        return pulumi.get(self, "amd_gpu_device_plugin")
+
+    @amd_gpu_device_plugin.setter
+    def amd_gpu_device_plugin(self, value: Optional[pulumi.Input['KubernetesClusterAmdGpuDevicePluginArgs']]):
+        pulumi.set(self, "amd_gpu_device_plugin", value)
+
     @_builtins.property
     @pulumi.getter(name="autoUpgrade")
     def auto_upgrade(self) -> Optional[pulumi.Input[_builtins.bool]]:
@@ -315,6 +347,8 @@ class KubernetesClusterArgs:
 @pulumi.input_type
 class _KubernetesClusterState:
     def __init__(__self__, *,
+                 amd_gpu_device_metrics_exporter_plugin: Optional[pulumi.Input['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs']] = None,
+                 amd_gpu_device_plugin: Optional[pulumi.Input['KubernetesClusterAmdGpuDevicePluginArgs']] = None,
                  auto_upgrade: Optional[pulumi.Input[_builtins.bool]] = None,
                  cluster_autoscaler_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesClusterClusterAutoscalerConfigurationArgs']]]] = None,
                  cluster_subnet: Optional[pulumi.Input[_builtins.str]] = None,
@@ -342,6 +376,8 @@ class _KubernetesClusterState:
                  vpc_uuid: Optional[pulumi.Input[_builtins.str]] = None):
         """
         Input properties used for looking up and filtering KubernetesCluster resources.
+        :param pulumi.Input['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs'] amd_gpu_device_metrics_exporter_plugin: Block containing options for the AMD GPU device metrics exporter component.
+        :param pulumi.Input['KubernetesClusterAmdGpuDevicePluginArgs'] amd_gpu_device_plugin: Block containing options for the AMD GPU device plugin component. If not specified, the component will be enabled by default for clusters with AMD GPU nodes.
         :param pulumi.Input[_builtins.bool] auto_upgrade: A boolean value indicating whether the cluster will be automatically upgraded to new patch releases during its maintenance window.
         :param pulumi.Input[Sequence[pulumi.Input['KubernetesClusterClusterAutoscalerConfigurationArgs']]] cluster_autoscaler_configurations: Block containing options for cluster auto-scaling.
         :param pulumi.Input[_builtins.str] cluster_subnet: The range of IP addresses in the overlay network of the Kubernetes cluster. For more information, see [here](https://docs.digitalocean.com/products/kubernetes/how-to/create-clusters/#create-with-vpc-native).
@@ -368,6 +404,10 @@ class _KubernetesClusterState:
         :param pulumi.Input[_builtins.str] version: The slug identifier for the version of Kubernetes used for the cluster. Use [doctl](https://github.com/digitalocean/doctl) to find the available versions `doctl kubernetes options versions`. (**Note:** A cluster may only be upgraded to newer versions in-place. If the version is decreased, a new resource will be created.)
         :param pulumi.Input[_builtins.str] vpc_uuid: The ID of the VPC where the Kubernetes cluster will be located.
         """
+        if amd_gpu_device_metrics_exporter_plugin is not None:
+            pulumi.set(__self__, "amd_gpu_device_metrics_exporter_plugin", amd_gpu_device_metrics_exporter_plugin)
+        if amd_gpu_device_plugin is not None:
+            pulumi.set(__self__, "amd_gpu_device_plugin", amd_gpu_device_plugin)
         if auto_upgrade is not None:
             pulumi.set(__self__, "auto_upgrade", auto_upgrade)
         if cluster_autoscaler_configurations is not None:
@@ -419,6 +459,30 @@ class _KubernetesClusterState:
         if vpc_uuid is not None:
             pulumi.set(__self__, "vpc_uuid", vpc_uuid)
 
+    @_builtins.property
+    @pulumi.getter(name="amdGpuDeviceMetricsExporterPlugin")
+    def amd_gpu_device_metrics_exporter_plugin(self) -> Optional[pulumi.Input['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs']]:
+        """
+        Block containing options for the AMD GPU device metrics exporter component.
+        """
+        return pulumi.get(self, "amd_gpu_device_metrics_exporter_plugin")
+
+    @amd_gpu_device_metrics_exporter_plugin.setter
+    def amd_gpu_device_metrics_exporter_plugin(self, value: Optional[pulumi.Input['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs']]):
+        pulumi.set(self, "amd_gpu_device_metrics_exporter_plugin", value)
+
+    @_builtins.property
+    @pulumi.getter(name="amdGpuDevicePlugin")
+    def amd_gpu_device_plugin(self) -> Optional[pulumi.Input['KubernetesClusterAmdGpuDevicePluginArgs']]:
+        """
+        Block containing options for the AMD GPU device plugin component. If not specified, the component will be enabled by default for clusters with AMD GPU nodes.
+        """
+        return pulumi.get(self, "amd_gpu_device_plugin")
+
+    @amd_gpu_device_plugin.setter
+    def amd_gpu_device_plugin(self, value: Optional[pulumi.Input['KubernetesClusterAmdGpuDevicePluginArgs']]):
+        pulumi.set(self, "amd_gpu_device_plugin", value)
+
     @_builtins.property
     @pulumi.getter(name="autoUpgrade")
     def auto_upgrade(self) -> Optional[pulumi.Input[_builtins.bool]]:
@@ -726,6 +790,8 @@ class KubernetesCluster(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 amd_gpu_device_metrics_exporter_plugin: Optional[pulumi.Input[Union['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs', 'KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgsDict']]] = None,
+                 amd_gpu_device_plugin: Optional[pulumi.Input[Union['KubernetesClusterAmdGpuDevicePluginArgs', 'KubernetesClusterAmdGpuDevicePluginArgsDict']]] = None,
                  auto_upgrade: Optional[pulumi.Input[_builtins.bool]] = None,
                  cluster_autoscaler_configurations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['KubernetesClusterClusterAutoscalerConfigurationArgs', 'KubernetesClusterClusterAutoscalerConfigurationArgsDict']]]]] = None,
                  cluster_subnet: Optional[pulumi.Input[_builtins.str]] = None,
@@ -774,6 +840,8 @@ class KubernetesCluster(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[Union['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs', 'KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgsDict']] amd_gpu_device_metrics_exporter_plugin: Block containing options for the AMD GPU device metrics exporter component.
+        :param pulumi.Input[Union['KubernetesClusterAmdGpuDevicePluginArgs', 'KubernetesClusterAmdGpuDevicePluginArgsDict']] amd_gpu_device_plugin: Block containing options for the AMD GPU device plugin component. If not specified, the component will be enabled by default for clusters with AMD GPU nodes.
         :param pulumi.Input[_builtins.bool] auto_upgrade: A boolean value indicating whether the cluster will be automatically upgraded to new patch releases during its maintenance window.
         :param pulumi.Input[Sequence[pulumi.Input[Union['KubernetesClusterClusterAutoscalerConfigurationArgs', 'KubernetesClusterClusterAutoscalerConfigurationArgsDict']]]] cluster_autoscaler_configurations: Block containing options for cluster auto-scaling.
         :param pulumi.Input[_builtins.str] cluster_subnet: The range of IP addresses in the overlay network of the Kubernetes cluster. For more information, see [here](https://docs.digitalocean.com/products/kubernetes/how-to/create-clusters/#create-with-vpc-native).
@@ -841,6 +909,8 @@ class KubernetesCluster(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 amd_gpu_device_metrics_exporter_plugin: Optional[pulumi.Input[Union['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs', 'KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgsDict']]] = None,
+                 amd_gpu_device_plugin: Optional[pulumi.Input[Union['KubernetesClusterAmdGpuDevicePluginArgs', 'KubernetesClusterAmdGpuDevicePluginArgsDict']]] = None,
                  auto_upgrade: Optional[pulumi.Input[_builtins.bool]] = None,
                  cluster_autoscaler_configurations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['KubernetesClusterClusterAutoscalerConfigurationArgs', 'KubernetesClusterClusterAutoscalerConfigurationArgsDict']]]]] = None,
                  cluster_subnet: Optional[pulumi.Input[_builtins.str]] = None,
@@ -868,6 +938,8 @@ class KubernetesCluster(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = KubernetesClusterArgs.__new__(KubernetesClusterArgs)
 
+            __props__.__dict__["amd_gpu_device_metrics_exporter_plugin"] = amd_gpu_device_metrics_exporter_plugin
+            __props__.__dict__["amd_gpu_device_plugin"] = amd_gpu_device_plugin
             __props__.__dict__["auto_upgrade"] = auto_upgrade
             __props__.__dict__["cluster_autoscaler_configurations"] = cluster_autoscaler_configurations
             __props__.__dict__["cluster_subnet"] = cluster_subnet
@@ -911,6 +983,8 @@ class KubernetesCluster(pulumi.CustomResource):
     def get(resource_name: str,
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
+            amd_gpu_device_metrics_exporter_plugin: Optional[pulumi.Input[Union['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs', 'KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgsDict']]] = None,
+            amd_gpu_device_plugin: Optional[pulumi.Input[Union['KubernetesClusterAmdGpuDevicePluginArgs', 'KubernetesClusterAmdGpuDevicePluginArgsDict']]] = None,
             auto_upgrade: Optional[pulumi.Input[_builtins.bool]] = None,
             cluster_autoscaler_configurations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['KubernetesClusterClusterAutoscalerConfigurationArgs', 'KubernetesClusterClusterAutoscalerConfigurationArgsDict']]]]] = None,
             cluster_subnet: Optional[pulumi.Input[_builtins.str]] = None,
@@ -943,6 +1017,8 @@ class KubernetesCluster(pulumi.CustomResource):
         :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[Union['KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgs', 'KubernetesClusterAmdGpuDeviceMetricsExporterPluginArgsDict']] amd_gpu_device_metrics_exporter_plugin: Block containing options for the AMD GPU device metrics exporter component.
+        :param pulumi.Input[Union['KubernetesClusterAmdGpuDevicePluginArgs', 'KubernetesClusterAmdGpuDevicePluginArgsDict']] amd_gpu_device_plugin: Block containing options for the AMD GPU device plugin component. If not specified, the component will be enabled by default for clusters with AMD GPU nodes.
         :param pulumi.Input[_builtins.bool] auto_upgrade: A boolean value indicating whether the cluster will be automatically upgraded to new patch releases during its maintenance window.
         :param pulumi.Input[Sequence[pulumi.Input[Union['KubernetesClusterClusterAutoscalerConfigurationArgs', 'KubernetesClusterClusterAutoscalerConfigurationArgsDict']]]] cluster_autoscaler_configurations: Block containing options for cluster auto-scaling.
         :param pulumi.Input[_builtins.str] cluster_subnet: The range of IP addresses in the overlay network of the Kubernetes cluster. For more information, see [here](https://docs.digitalocean.com/products/kubernetes/how-to/create-clusters/#create-with-vpc-native).
@@ -973,6 +1049,8 @@ class KubernetesCluster(pulumi.CustomResource):
 
         __props__ = _KubernetesClusterState.__new__(_KubernetesClusterState)
 
+        __props__.__dict__["amd_gpu_device_metrics_exporter_plugin"] = amd_gpu_device_metrics_exporter_plugin
+        __props__.__dict__["amd_gpu_device_plugin"] = amd_gpu_device_plugin
         __props__.__dict__["auto_upgrade"] = auto_upgrade
         __props__.__dict__["cluster_autoscaler_configurations"] = cluster_autoscaler_configurations
         __props__.__dict__["cluster_subnet"] = cluster_subnet
@@ -1000,6 +1078,22 @@ class KubernetesCluster(pulumi.CustomResource):
         __props__.__dict__["vpc_uuid"] = vpc_uuid
         return KubernetesCluster(resource_name, opts=opts, __props__=__props__)
 
+    @_builtins.property
+    @pulumi.getter(name="amdGpuDeviceMetricsExporterPlugin")
+    def amd_gpu_device_metrics_exporter_plugin(self) -> pulumi.Output['outputs.KubernetesClusterAmdGpuDeviceMetricsExporterPlugin']:
+        """
+        Block containing options for the AMD GPU device metrics exporter component.
+        """
+        return pulumi.get(self, "amd_gpu_device_metrics_exporter_plugin")
+
+    @_builtins.property
+    @pulumi.getter(name="amdGpuDevicePlugin")
+    def amd_gpu_device_plugin(self) -> pulumi.Output['outputs.KubernetesClusterAmdGpuDevicePlugin']:
+        """
+        Block containing options for the AMD GPU device plugin component. If not specified, the component will be enabled by default for clusters with AMD GPU nodes.
+        """
+        return pulumi.get(self, "amd_gpu_device_plugin")
+
     @_builtins.property
     @pulumi.getter(name="autoUpgrade")
     def auto_upgrade(self) -> pulumi.Output[Optional[_builtins.bool]]: