pulumi-gcp 8.22.0a1741888019__py3-none-any.whl → 8.23.0__py3-none-any.whl

pulumi_gcp/firebase/hosting_version.py

@@ -309,7 +309,7 @@ class HostingVersion(pulumi.CustomResource):
             project="my-project-name",
             name="cloud-function-via-hosting",
             description="A Cloud Function connected to Firebase Hosing",
-            runtime="nodejs16",
+            runtime="nodejs20",
             available_memory_mb=128,
             source_archive_bucket=bucket.name,
             source_archive_object=object.name,
@@ -516,7 +516,7 @@ class HostingVersion(pulumi.CustomResource):
             project="my-project-name",
             name="cloud-function-via-hosting",
             description="A Cloud Function connected to Firebase Hosing",
-            runtime="nodejs16",
+            runtime="nodejs20",
             available_memory_mb=128,
             source_archive_bucket=bucket.name,
             source_archive_object=object.name,

pulumi_gcp/firebase/outputs.py

@@ -16,6 +16,9 @@ from .. import _utilities
 from . import outputs
 
 __all__ = [
+    'AppHostingBackendCodebase',
+    'AppHostingBackendManagedResource',
+    'AppHostingBackendManagedResourceRunService',
     'ExtensionsInstanceConfig',
     'ExtensionsInstanceErrorStatus',
     'ExtensionsInstanceRuntimeData',
@@ -42,6 +45,130 @@ __all__ = [
     'HostingVersionConfigRewriteRun',
 ]
 
+@pulumi.output_type
+class AppHostingBackendCodebase(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "rootDirectory":
+            suggest = "root_directory"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AppHostingBackendCodebase. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AppHostingBackendCodebase.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AppHostingBackendCodebase.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 repository: str,
+                 root_directory: Optional[str] = None):
+        """
+        :param str repository: The resource name for the Developer Connect
+               [`gitRepositoryLink`](https://cloud.google.com/developer-connect/docs/api/reference/rest/v1/projects.locations.connections.gitRepositoryLinks)
+               connected to this backend, in the format:
+               projects/{project}/locations/{location}/connections/{connection}/gitRepositoryLinks/{repositoryLink}
+        :param str root_directory: If `repository` is provided, the directory relative to the root of the
+               repository to use as the root for the deployed web app.
+        """
+        pulumi.set(__self__, "repository", repository)
+        if root_directory is not None:
+            pulumi.set(__self__, "root_directory", root_directory)
+
+    @property
+    @pulumi.getter
+    def repository(self) -> str:
+        """
+        The resource name for the Developer Connect
+        [`gitRepositoryLink`](https://cloud.google.com/developer-connect/docs/api/reference/rest/v1/projects.locations.connections.gitRepositoryLinks)
+        connected to this backend, in the format:
+        projects/{project}/locations/{location}/connections/{connection}/gitRepositoryLinks/{repositoryLink}
+        """
+        return pulumi.get(self, "repository")
+
+    @property
+    @pulumi.getter(name="rootDirectory")
+    def root_directory(self) -> Optional[str]:
+        """
+        If `repository` is provided, the directory relative to the root of the
+        repository to use as the root for the deployed web app.
+        """
+        return pulumi.get(self, "root_directory")
+
+
+@pulumi.output_type
+class AppHostingBackendManagedResource(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "runServices":
+            suggest = "run_services"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AppHostingBackendManagedResource. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AppHostingBackendManagedResource.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AppHostingBackendManagedResource.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 run_services: Optional[Sequence['outputs.AppHostingBackendManagedResourceRunService']] = None):
+        """
+        :param Sequence['AppHostingBackendManagedResourceRunServiceArgs'] run_services: (Output)
+               A managed Cloud Run
+               [`service`](https://cloud.google.com/run/docs/reference/rest/v2/projects.locations.services#resource:-service).
+               Structure is documented below.
+        """
+        if run_services is not None:
+            pulumi.set(__self__, "run_services", run_services)
+
+    @property
+    @pulumi.getter(name="runServices")
+    def run_services(self) -> Optional[Sequence['outputs.AppHostingBackendManagedResourceRunService']]:
+        """
+        (Output)
+        A managed Cloud Run
+        [`service`](https://cloud.google.com/run/docs/reference/rest/v2/projects.locations.services#resource:-service).
+        Structure is documented below.
+        """
+        return pulumi.get(self, "run_services")
+
+
+@pulumi.output_type
+class AppHostingBackendManagedResourceRunService(dict):
+    def __init__(__self__, *,
+                 service: Optional[str] = None):
+        """
+        :param str service: (Output)
+               The name of the Cloud Run
+               [`service`](https://cloud.google.com/run/docs/reference/rest/v2/projects.locations.services#resource:-service),
+               in the format:
+               projects/{project}/locations/{location}/services/{serviceId}
+        """
+        if service is not None:
+            pulumi.set(__self__, "service", service)
+
+    @property
+    @pulumi.getter
+    def service(self) -> Optional[str]:
+        """
+        (Output)
+        The name of the Cloud Run
+        [`service`](https://cloud.google.com/run/docs/reference/rest/v2/projects.locations.services#resource:-service),
+        in the format:
+        projects/{project}/locations/{location}/services/{serviceId}
+        """
+        return pulumi.get(self, "service")
+
+
 @pulumi.output_type
 class ExtensionsInstanceConfig(dict):
     @staticmethod

pulumi_gcp/kms/get_key_rings.py

@@ -60,6 +60,9 @@ class GetKeyRingsResult:
     @property
     @pulumi.getter(name="keyRings")
     def key_rings(self) -> Sequence['outputs.GetKeyRingsKeyRingResult']:
+        """
+        A list of all the retrieved key rings from the provided location. This list is influenced by the provided filter argument.
+        """
         return pulumi.get(self, "key_rings")
 
     @property
@@ -91,7 +94,24 @@ def get_key_rings(filter: Optional[str] = None,
                   project: Optional[str] = None,
                   opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetKeyRingsResult:
     """
-    Use this data source to access information about an existing resource.
+    Provides access to all Google Cloud Platform KMS CryptoKeyRings in a set location. For more information see
+    [the official documentation](https://cloud.google.com/kms/docs/resource-hierarchy#key_rings)
+    and
+    [API](https://cloud.google.com/kms/docs/reference/rest/v1/projects.locations.keyRings).
+
+    A key ring organizes keys in a specific Google Cloud location and lets you manage access control on groups of keys. A key ring's name does not need to be unique across a Google Cloud project, but must be unique within a given location. After creation, a key ring cannot be deleted. Key rings don't incur any costs.
+
+
+    :param str filter: The filter argument is used to add a filter query parameter that limits which key rings are retrieved by the data source: ?filter={{filter}}. When no value is provided there is no filtering.
+           
+           Example filter values if filtering on name. Note: names take the form projects/{{project}}/locations/{{location}}/keyRings/{{keyRing}}.
+           
+           * `"name:my-key-"` will retrieve key rings that contain "my-key-" anywhere in their name.
+           * `"name=projects/my-project/locations/global/keyRings/my-key-ring"` will only retrieve a key with that exact name.
+           
+           [See the documentation about using filters](https://cloud.google.com/kms/docs/sorting-and-filtering)
+    :param str location: The location that the underlying key ring resides in. e.g us-west1
+    :param str project: The Project ID of the project.
     """
     __args__ = dict()
     __args__['filter'] = filter
@@ -111,7 +131,24 @@ def get_key_rings_output(filter: Optional[pulumi.Input[Optional[str]]] = None,
                          project: Optional[pulumi.Input[Optional[str]]] = None,
                          opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetKeyRingsResult]:
     """
-    Use this data source to access information about an existing resource.
+    Provides access to all Google Cloud Platform KMS CryptoKeyRings in a set location. For more information see
+    [the official documentation](https://cloud.google.com/kms/docs/resource-hierarchy#key_rings)
+    and
+    [API](https://cloud.google.com/kms/docs/reference/rest/v1/projects.locations.keyRings).
+
+    A key ring organizes keys in a specific Google Cloud location and lets you manage access control on groups of keys. A key ring's name does not need to be unique across a Google Cloud project, but must be unique within a given location. After creation, a key ring cannot be deleted. Key rings don't incur any costs.
+
+
+    :param str filter: The filter argument is used to add a filter query parameter that limits which key rings are retrieved by the data source: ?filter={{filter}}. When no value is provided there is no filtering.
+           
+           Example filter values if filtering on name. Note: names take the form projects/{{project}}/locations/{{location}}/keyRings/{{keyRing}}.
+           
+           * `"name:my-key-"` will retrieve key rings that contain "my-key-" anywhere in their name.
+           * `"name=projects/my-project/locations/global/keyRings/my-key-ring"` will only retrieve a key with that exact name.
+           
+           [See the documentation about using filters](https://cloud.google.com/kms/docs/sorting-and-filtering)
+    :param str location: The location that the underlying key ring resides in. e.g us-west1
+    :param str project: The Project ID of the project.
     """
     __args__ = dict()
     __args__['filter'] = filter

pulumi_gcp/managedkafka/__init__.py

@@ -6,6 +6,8 @@ from .. import _utilities
 import typing
 # Export this package's modules as members:
 from .cluster import *
+from .connect_cluster import *
+from .connector import *
 from .topic import *
 from ._inputs import *
 from . import outputs

pulumi_gcp/managedkafka/_inputs.py

@@ -25,6 +25,16 @@ __all__ = [
     'ClusterGcpConfigAccessConfigNetworkConfigArgsDict',
     'ClusterRebalanceConfigArgs',
     'ClusterRebalanceConfigArgsDict',
+    'ConnectClusterCapacityConfigArgs',
+    'ConnectClusterCapacityConfigArgsDict',
+    'ConnectClusterGcpConfigArgs',
+    'ConnectClusterGcpConfigArgsDict',
+    'ConnectClusterGcpConfigAccessConfigArgs',
+    'ConnectClusterGcpConfigAccessConfigArgsDict',
+    'ConnectClusterGcpConfigAccessConfigNetworkConfigArgs',
+    'ConnectClusterGcpConfigAccessConfigNetworkConfigArgsDict',
+    'ConnectorTaskRestartPolicyArgs',
+    'ConnectorTaskRestartPolicyArgsDict',
 ]
 
 MYPY = False
@@ -236,3 +246,256 @@ class ClusterRebalanceConfigArgs:
         pulumi.set(self, "mode", value)
 
 
+if not MYPY:
+    class ConnectClusterCapacityConfigArgsDict(TypedDict):
+        memory_bytes: pulumi.Input[str]
+        """
+        The memory to provision for the cluster in bytes. The CPU:memory ratio (vCPU:GiB) must be between 1:1 and 1:8. Minimum: 3221225472 (3 GiB).
+        """
+        vcpu_count: pulumi.Input[str]
+        """
+        The number of vCPUs to provision for the cluster. The minimum is 3.
+        """
+elif False:
+    ConnectClusterCapacityConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectClusterCapacityConfigArgs:
+    def __init__(__self__, *,
+                 memory_bytes: pulumi.Input[str],
+                 vcpu_count: pulumi.Input[str]):
+        """
+        :param pulumi.Input[str] memory_bytes: The memory to provision for the cluster in bytes. The CPU:memory ratio (vCPU:GiB) must be between 1:1 and 1:8. Minimum: 3221225472 (3 GiB).
+        :param pulumi.Input[str] vcpu_count: The number of vCPUs to provision for the cluster. The minimum is 3.
+        """
+        pulumi.set(__self__, "memory_bytes", memory_bytes)
+        pulumi.set(__self__, "vcpu_count", vcpu_count)
+
+    @property
+    @pulumi.getter(name="memoryBytes")
+    def memory_bytes(self) -> pulumi.Input[str]:
+        """
+        The memory to provision for the cluster in bytes. The CPU:memory ratio (vCPU:GiB) must be between 1:1 and 1:8. Minimum: 3221225472 (3 GiB).
+        """
+        return pulumi.get(self, "memory_bytes")
+
+    @memory_bytes.setter
+    def memory_bytes(self, value: pulumi.Input[str]):
+        pulumi.set(self, "memory_bytes", value)
+
+    @property
+    @pulumi.getter(name="vcpuCount")
+    def vcpu_count(self) -> pulumi.Input[str]:
+        """
+        The number of vCPUs to provision for the cluster. The minimum is 3.
+        """
+        return pulumi.get(self, "vcpu_count")
+
+    @vcpu_count.setter
+    def vcpu_count(self, value: pulumi.Input[str]):
+        pulumi.set(self, "vcpu_count", value)
+
+
+if not MYPY:
+    class ConnectClusterGcpConfigArgsDict(TypedDict):
+        access_config: pulumi.Input['ConnectClusterGcpConfigAccessConfigArgsDict']
+        """
+        The configuration of access to the Kafka Connect cluster.
+        Structure is documented below.
+        """
+elif False:
+    ConnectClusterGcpConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectClusterGcpConfigArgs:
+    def __init__(__self__, *,
+                 access_config: pulumi.Input['ConnectClusterGcpConfigAccessConfigArgs']):
+        """
+        :param pulumi.Input['ConnectClusterGcpConfigAccessConfigArgs'] access_config: The configuration of access to the Kafka Connect cluster.
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "access_config", access_config)
+
+    @property
+    @pulumi.getter(name="accessConfig")
+    def access_config(self) -> pulumi.Input['ConnectClusterGcpConfigAccessConfigArgs']:
+        """
+        The configuration of access to the Kafka Connect cluster.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "access_config")
+
+    @access_config.setter
+    def access_config(self, value: pulumi.Input['ConnectClusterGcpConfigAccessConfigArgs']):
+        pulumi.set(self, "access_config", value)
+
+
+if not MYPY:
+    class ConnectClusterGcpConfigAccessConfigArgsDict(TypedDict):
+        network_configs: pulumi.Input[Sequence[pulumi.Input['ConnectClusterGcpConfigAccessConfigNetworkConfigArgsDict']]]
+        """
+        Virtual Private Cloud (VPC) subnets where IP addresses for the Kafka Connect cluster are allocated. To make the connect cluster available in a VPC, you must specify at least one subnet per network. You must specify between 1 and 10 subnets. Additional subnets may be specified with additional `network_configs` blocks.
+        Structure is documented below.
+        """
+elif False:
+    ConnectClusterGcpConfigAccessConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectClusterGcpConfigAccessConfigArgs:
+    def __init__(__self__, *,
+                 network_configs: pulumi.Input[Sequence[pulumi.Input['ConnectClusterGcpConfigAccessConfigNetworkConfigArgs']]]):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input['ConnectClusterGcpConfigAccessConfigNetworkConfigArgs']]] network_configs: Virtual Private Cloud (VPC) subnets where IP addresses for the Kafka Connect cluster are allocated. To make the connect cluster available in a VPC, you must specify at least one subnet per network. You must specify between 1 and 10 subnets. Additional subnets may be specified with additional `network_configs` blocks.
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "network_configs", network_configs)
+
+    @property
+    @pulumi.getter(name="networkConfigs")
+    def network_configs(self) -> pulumi.Input[Sequence[pulumi.Input['ConnectClusterGcpConfigAccessConfigNetworkConfigArgs']]]:
+        """
+        Virtual Private Cloud (VPC) subnets where IP addresses for the Kafka Connect cluster are allocated. To make the connect cluster available in a VPC, you must specify at least one subnet per network. You must specify between 1 and 10 subnets. Additional subnets may be specified with additional `network_configs` blocks.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "network_configs")
+
+    @network_configs.setter
+    def network_configs(self, value: pulumi.Input[Sequence[pulumi.Input['ConnectClusterGcpConfigAccessConfigNetworkConfigArgs']]]):
+        pulumi.set(self, "network_configs", value)
+
+
+if not MYPY:
+    class ConnectClusterGcpConfigAccessConfigNetworkConfigArgsDict(TypedDict):
+        primary_subnet: pulumi.Input[str]
+        """
+        VPC subnet to make available to the Kafka Connect cluster. Structured like: projects/{project}/regions/{region}/subnetworks/{subnet_id}. It is used to create a Private Service Connect (PSC) interface for the Kafka Connect workers. It must be located in the same region as the Kafka Connect cluster. The CIDR range of the subnet must be within the IPv4 address ranges for private networks, as specified in RFC 1918. The primary subnet CIDR range must have a minimum size of /22 (1024 addresses).
+        """
+        additional_subnets: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Additional subnets may be specified. They may be in another region, but must be in the same VPC network. The Connect workers can communicate with network endpoints in either the primary or additional subnets.
+        """
+        dns_domain_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Additional DNS domain names from the subnet's network to be made visible to the Connect Cluster. When using MirrorMaker2, it's necessary to add the bootstrap address's dns domain name of the target cluster to make it visible to the connector. For example: my-kafka-cluster.us-central1.managedkafka.my-project.cloud.goog
+
+        - - -
+        """
+elif False:
+    ConnectClusterGcpConfigAccessConfigNetworkConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectClusterGcpConfigAccessConfigNetworkConfigArgs:
+    def __init__(__self__, *,
+                 primary_subnet: pulumi.Input[str],
+                 additional_subnets: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 dns_domain_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[str] primary_subnet: VPC subnet to make available to the Kafka Connect cluster. Structured like: projects/{project}/regions/{region}/subnetworks/{subnet_id}. It is used to create a Private Service Connect (PSC) interface for the Kafka Connect workers. It must be located in the same region as the Kafka Connect cluster. The CIDR range of the subnet must be within the IPv4 address ranges for private networks, as specified in RFC 1918. The primary subnet CIDR range must have a minimum size of /22 (1024 addresses).
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] additional_subnets: Additional subnets may be specified. They may be in another region, but must be in the same VPC network. The Connect workers can communicate with network endpoints in either the primary or additional subnets.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] dns_domain_names: Additional DNS domain names from the subnet's network to be made visible to the Connect Cluster. When using MirrorMaker2, it's necessary to add the bootstrap address's dns domain name of the target cluster to make it visible to the connector. For example: my-kafka-cluster.us-central1.managedkafka.my-project.cloud.goog
+               
+               - - -
+        """
+        pulumi.set(__self__, "primary_subnet", primary_subnet)
+        if additional_subnets is not None:
+            pulumi.set(__self__, "additional_subnets", additional_subnets)
+        if dns_domain_names is not None:
+            pulumi.set(__self__, "dns_domain_names", dns_domain_names)
+
+    @property
+    @pulumi.getter(name="primarySubnet")
+    def primary_subnet(self) -> pulumi.Input[str]:
+        """
+        VPC subnet to make available to the Kafka Connect cluster. Structured like: projects/{project}/regions/{region}/subnetworks/{subnet_id}. It is used to create a Private Service Connect (PSC) interface for the Kafka Connect workers. It must be located in the same region as the Kafka Connect cluster. The CIDR range of the subnet must be within the IPv4 address ranges for private networks, as specified in RFC 1918. The primary subnet CIDR range must have a minimum size of /22 (1024 addresses).
+        """
+        return pulumi.get(self, "primary_subnet")
+
+    @primary_subnet.setter
+    def primary_subnet(self, value: pulumi.Input[str]):
+        pulumi.set(self, "primary_subnet", value)
+
+    @property
+    @pulumi.getter(name="additionalSubnets")
+    def additional_subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Additional subnets may be specified. They may be in another region, but must be in the same VPC network. The Connect workers can communicate with network endpoints in either the primary or additional subnets.
+        """
+        return pulumi.get(self, "additional_subnets")
+
+    @additional_subnets.setter
+    def additional_subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "additional_subnets", value)
+
+    @property
+    @pulumi.getter(name="dnsDomainNames")
+    def dns_domain_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Additional DNS domain names from the subnet's network to be made visible to the Connect Cluster. When using MirrorMaker2, it's necessary to add the bootstrap address's dns domain name of the target cluster to make it visible to the connector. For example: my-kafka-cluster.us-central1.managedkafka.my-project.cloud.goog
+
+        - - -
+        """
+        return pulumi.get(self, "dns_domain_names")
+
+    @dns_domain_names.setter
+    def dns_domain_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "dns_domain_names", value)
+
+
+if not MYPY:
+    class ConnectorTaskRestartPolicyArgsDict(TypedDict):
+        maximum_backoff: NotRequired[pulumi.Input[str]]
+        """
+        The maximum amount of time to wait before retrying a failed task. This sets an upper bound for the backoff delay.
+        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+        """
+        minimum_backoff: NotRequired[pulumi.Input[str]]
+        """
+        The minimum amount of time to wait before retrying a failed task. This sets a lower bound for the backoff delay.
+        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+        """
+elif False:
+    ConnectorTaskRestartPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectorTaskRestartPolicyArgs:
+    def __init__(__self__, *,
+                 maximum_backoff: Optional[pulumi.Input[str]] = None,
+                 minimum_backoff: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] maximum_backoff: The maximum amount of time to wait before retrying a failed task. This sets an upper bound for the backoff delay.
+               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+        :param pulumi.Input[str] minimum_backoff: The minimum amount of time to wait before retrying a failed task. This sets a lower bound for the backoff delay.
+               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+        """
+        if maximum_backoff is not None:
+            pulumi.set(__self__, "maximum_backoff", maximum_backoff)
+        if minimum_backoff is not None:
+            pulumi.set(__self__, "minimum_backoff", minimum_backoff)
+
+    @property
+    @pulumi.getter(name="maximumBackoff")
+    def maximum_backoff(self) -> Optional[pulumi.Input[str]]:
+        """
+        The maximum amount of time to wait before retrying a failed task. This sets an upper bound for the backoff delay.
+        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+        """
+        return pulumi.get(self, "maximum_backoff")
+
+    @maximum_backoff.setter
+    def maximum_backoff(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "maximum_backoff", value)
+
+    @property
+    @pulumi.getter(name="minimumBackoff")
+    def minimum_backoff(self) -> Optional[pulumi.Input[str]]:
+        """
+        The minimum amount of time to wait before retrying a failed task. This sets a lower bound for the backoff delay.
+        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
+        """
+        return pulumi.get(self, "minimum_backoff")
+
+    @minimum_backoff.setter
+    def minimum_backoff(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "minimum_backoff", value)
+
+