pulumi-gcp 8.26.0a1744267117__py3-none-any.whl → 8.27.0__py3-none-any.whl

pulumi_gcp/managedkafka/connector.py

@@ -296,25 +296,37 @@ class Connector(pulumi.CustomResource):
         ```python
         import pulumi
         import pulumi_gcp as gcp
-
-        mkc_network = gcp.compute.Network("mkc_network",
-            name="my-network-0",
-            auto_create_subnetworks=False)
-        mkc_subnet = gcp.compute.Subnetwork("mkc_subnet",
-            name="my-subnetwork-0",
-            ip_cidr_range="10.4.0.0/16",
-            region="us-central1",
-            network=mkc_network.id)
-        mkc_additional_subnet = gcp.compute.Subnetwork("mkc_additional_subnet",
-            name="my-additional-subnetwork-0",
+        import pulumi_time as time
+
+        project = gcp.organizations.Project("project",
+            project_id="tf-test_80332",
+            name="tf-test_13293",
+            org_id="123456789",
+            billing_account="000000-0000000-0000000-000000",
+            deletion_policy="DELETE")
+        wait60_seconds = time.index.Sleep("wait_60_seconds", create_duration=60s,
+        opts = pulumi.ResourceOptions(depends_on=[project]))
+        compute = gcp.projects.Service("compute",
+            project=project.project_id,
+            service="compute.googleapis.com",
+            opts = pulumi.ResourceOptions(depends_on=[wait60_seconds]))
+        managedkafka = gcp.projects.Service("managedkafka",
+            project=project.project_id,
+            service="managedkafka.googleapis.com",
+            opts = pulumi.ResourceOptions(depends_on=[wait60_seconds]))
+        mkc_secondary_subnet = gcp.compute.Subnetwork("mkc_secondary_subnet",
+            project=project.project_id,
+            name="my-secondary-subnetwork-00",
             ip_cidr_range="10.5.0.0/16",
             region="us-central1",
-            network=mkc_network.id)
+            network="default",
+            opts = pulumi.ResourceOptions(depends_on=[compute]))
         cps_topic = gcp.pubsub.Topic("cps_topic",
+            project=project.project_id,
             name="my-cps-topic",
             message_retention_duration="86600s")
-        project = gcp.organizations.get_project()
         gmk_cluster = gcp.managedkafka.Cluster("gmk_cluster",
+            project=project.project_id,
             cluster_id="my-cluster",
             location="us-central1",
             capacity_config={
@@ -324,19 +336,27 @@ class Connector(pulumi.CustomResource):
             gcp_config={
                 "access_config": {
                     "network_configs": [{
-                        "subnet": mkc_subnet.id.apply(lambda id: f"projects/{project.project_id}/regions/us-central1/subnetworks/{id}"),
+                        "subnet": project.project_id.apply(lambda project_id: f"projects/{project_id}/regions/us-central1/subnetworks/default"),
                     }],
                 },
-            })
+            },
+            opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
         gmk_topic = gcp.managedkafka.Topic("gmk_topic",
+            project=project.project_id,
             topic_id="my-topic",
             cluster=gmk_cluster.cluster_id,
             location="us-central1",
             partition_count=2,
-            replication_factor=3)
+            replication_factor=3,
+            opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
         mkc_cluster = gcp.managedkafka.ConnectCluster("mkc_cluster",
+            project=project.project_id,
             connect_cluster_id="my-connect-cluster",
-            kafka_cluster=gmk_cluster.cluster_id.apply(lambda cluster_id: f"projects/{project.project_id}/locations/us-central1/clusters/{cluster_id}"),
+            kafka_cluster=pulumi.Output.all(
+                project_id=project.project_id,
+                cluster_id=gmk_cluster.cluster_id
+        ).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project_id']}/locations/us-central1/clusters/{resolved_outputs['cluster_id']}")
+        ,
             location="us-central1",
             capacity_config={
                 "vcpu_count": "12",
@@ -345,16 +365,22 @@ class Connector(pulumi.CustomResource):
             gcp_config={
                 "access_config": {
                     "network_configs": [{
-                        "primary_subnet": mkc_subnet.id.apply(lambda id: f"projects/{project.project_id}/regions/us-central1/subnetworks/{id}"),
-                        "additional_subnets": [mkc_additional_subnet.id],
-                        "dns_domain_names": [gmk_cluster.cluster_id.apply(lambda cluster_id: f"{cluster_id}.us-central1.managedkafka-staging.{project.project_id}.cloud-staging.goog")],
+                        "primary_subnet": project.project_id.apply(lambda project_id: f"projects/{project_id}/regions/us-central1/subnetworks/default"),
+                        "additional_subnets": [mkc_secondary_subnet.id],
+                        "dns_domain_names": [pulumi.Output.all(
+                            cluster_id=gmk_cluster.cluster_id,
+                            project_id=project.project_id
+        ).apply(lambda resolved_outputs: f"{resolved_outputs['cluster_id']}.us-central1.managedkafka.{resolved_outputs['project_id']}.cloud.goog")
+        ],
                     }],
                 },
             },
             labels={
                 "key": "value",
-            })
+            },
+            opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
         example = gcp.managedkafka.Connector("example",
+            project=project.project_id,
             connector_id="my-connector",
             connect_cluster=mkc_cluster.connect_cluster_id,
             location="us-central1",
@@ -371,7 +397,8 @@ class Connector(pulumi.CustomResource):
             task_restart_policy={
                 "minimum_backoff": "60s",
                 "maximum_backoff": "1800s",
-            })
+            },
+            opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
         ```
 
         ## Import
@@ -426,25 +453,37 @@ class Connector(pulumi.CustomResource):
         ```python
         import pulumi
         import pulumi_gcp as gcp
-
-        mkc_network = gcp.compute.Network("mkc_network",
-            name="my-network-0",
-            auto_create_subnetworks=False)
-        mkc_subnet = gcp.compute.Subnetwork("mkc_subnet",
-            name="my-subnetwork-0",
-            ip_cidr_range="10.4.0.0/16",
-            region="us-central1",
-            network=mkc_network.id)
-        mkc_additional_subnet = gcp.compute.Subnetwork("mkc_additional_subnet",
-            name="my-additional-subnetwork-0",
+        import pulumi_time as time
+
+        project = gcp.organizations.Project("project",
+            project_id="tf-test_80332",
+            name="tf-test_13293",
+            org_id="123456789",
+            billing_account="000000-0000000-0000000-000000",
+            deletion_policy="DELETE")
+        wait60_seconds = time.index.Sleep("wait_60_seconds", create_duration=60s,
+        opts = pulumi.ResourceOptions(depends_on=[project]))
+        compute = gcp.projects.Service("compute",
+            project=project.project_id,
+            service="compute.googleapis.com",
+            opts = pulumi.ResourceOptions(depends_on=[wait60_seconds]))
+        managedkafka = gcp.projects.Service("managedkafka",
+            project=project.project_id,
+            service="managedkafka.googleapis.com",
+            opts = pulumi.ResourceOptions(depends_on=[wait60_seconds]))
+        mkc_secondary_subnet = gcp.compute.Subnetwork("mkc_secondary_subnet",
+            project=project.project_id,
+            name="my-secondary-subnetwork-00",
             ip_cidr_range="10.5.0.0/16",
             region="us-central1",
-            network=mkc_network.id)
+            network="default",
+            opts = pulumi.ResourceOptions(depends_on=[compute]))
         cps_topic = gcp.pubsub.Topic("cps_topic",
+            project=project.project_id,
             name="my-cps-topic",
             message_retention_duration="86600s")
-        project = gcp.organizations.get_project()
         gmk_cluster = gcp.managedkafka.Cluster("gmk_cluster",
+            project=project.project_id,
             cluster_id="my-cluster",
             location="us-central1",
             capacity_config={
@@ -454,19 +493,27 @@ class Connector(pulumi.CustomResource):
             gcp_config={
                 "access_config": {
                     "network_configs": [{
-                        "subnet": mkc_subnet.id.apply(lambda id: f"projects/{project.project_id}/regions/us-central1/subnetworks/{id}"),
+                        "subnet": project.project_id.apply(lambda project_id: f"projects/{project_id}/regions/us-central1/subnetworks/default"),
                     }],
                 },
-            })
+            },
+            opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
         gmk_topic = gcp.managedkafka.Topic("gmk_topic",
+            project=project.project_id,
             topic_id="my-topic",
             cluster=gmk_cluster.cluster_id,
             location="us-central1",
             partition_count=2,
-            replication_factor=3)
+            replication_factor=3,
+            opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
         mkc_cluster = gcp.managedkafka.ConnectCluster("mkc_cluster",
+            project=project.project_id,
             connect_cluster_id="my-connect-cluster",
-            kafka_cluster=gmk_cluster.cluster_id.apply(lambda cluster_id: f"projects/{project.project_id}/locations/us-central1/clusters/{cluster_id}"),
+            kafka_cluster=pulumi.Output.all(
+                project_id=project.project_id,
+                cluster_id=gmk_cluster.cluster_id
+        ).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project_id']}/locations/us-central1/clusters/{resolved_outputs['cluster_id']}")
+        ,
             location="us-central1",
             capacity_config={
                 "vcpu_count": "12",
@@ -475,16 +522,22 @@ class Connector(pulumi.CustomResource):
             gcp_config={
                 "access_config": {
                     "network_configs": [{
-                        "primary_subnet": mkc_subnet.id.apply(lambda id: f"projects/{project.project_id}/regions/us-central1/subnetworks/{id}"),
-                        "additional_subnets": [mkc_additional_subnet.id],
-                        "dns_domain_names": [gmk_cluster.cluster_id.apply(lambda cluster_id: f"{cluster_id}.us-central1.managedkafka-staging.{project.project_id}.cloud-staging.goog")],
+                        "primary_subnet": project.project_id.apply(lambda project_id: f"projects/{project_id}/regions/us-central1/subnetworks/default"),
+                        "additional_subnets": [mkc_secondary_subnet.id],
+                        "dns_domain_names": [pulumi.Output.all(
+                            cluster_id=gmk_cluster.cluster_id,
+                            project_id=project.project_id
+        ).apply(lambda resolved_outputs: f"{resolved_outputs['cluster_id']}.us-central1.managedkafka.{resolved_outputs['project_id']}.cloud.goog")
+        ],
                     }],
                 },
             },
             labels={
                 "key": "value",
-            })
+            },
+            opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
         example = gcp.managedkafka.Connector("example",
+            project=project.project_id,
             connector_id="my-connector",
             connect_cluster=mkc_cluster.connect_cluster_id,
             location="us-central1",
@@ -501,7 +554,8 @@ class Connector(pulumi.CustomResource):
             task_restart_policy={
                 "minimum_backoff": "60s",
                 "maximum_backoff": "1800s",
-            })
+            },
+            opts = pulumi.ResourceOptions(depends_on=[managedkafka]))
         ```
 
         ## Import

pulumi_gcp/managedkafka/outputs.py

@@ -154,7 +154,7 @@ class ClusterGcpConfigAccessConfig(dict):
     def __init__(__self__, *,
                  network_configs: Sequence['outputs.ClusterGcpConfigAccessConfigNetworkConfig']):
         """
-        :param Sequence['ClusterGcpConfigAccessConfigNetworkConfigArgs'] network_configs: Virtual Private Cloud (VPC) subnets where IP addresses for the Kafka cluster are allocated. To make the 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.
+        :param Sequence['ClusterGcpConfigAccessConfigNetworkConfigArgs'] network_configs: Virtual Private Cloud (VPC) subnets where IP addresses for the Kafka cluster are allocated. To make the cluster available in a VPC, you must specify at least one `network_configs` block. Max of 10 subnets per cluster. Additional subnets may be specified with additional `network_configs` blocks.
                Structure is documented below.
         """
         pulumi.set(__self__, "network_configs", network_configs)
@@ -163,7 +163,7 @@ class ClusterGcpConfigAccessConfig(dict):
     @pulumi.getter(name="networkConfigs")
     def network_configs(self) -> Sequence['outputs.ClusterGcpConfigAccessConfigNetworkConfig']:
         """
-        Virtual Private Cloud (VPC) subnets where IP addresses for the Kafka cluster are allocated. To make the 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.
+        Virtual Private Cloud (VPC) subnets where IP addresses for the Kafka cluster are allocated. To make the cluster available in a VPC, you must specify at least one `network_configs` block. Max of 10 subnets per cluster. Additional subnets may be specified with additional `network_configs` blocks.
         Structure is documented below.
         """
         return pulumi.get(self, "network_configs")
@@ -174,7 +174,7 @@ class ClusterGcpConfigAccessConfigNetworkConfig(dict):
     def __init__(__self__, *,
                  subnet: builtins.str):
         """
-        :param builtins.str subnet: Name of the VPC subnet from which the cluster is accessible. Both broker and bootstrap server IP addresses and DNS entries are automatically created in the subnet. The subnet must be located in the same region as the cluster. The project may differ. The name of the subnet must be in the format `projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET`.
+        :param builtins.str subnet: Name of the VPC subnet from which the cluster is accessible. Both broker and bootstrap server IP addresses and DNS entries are automatically created in the subnet. There can only be one subnet per network, and the subnet must be located in the same region as the cluster. The project may differ. The name of the subnet must be in the format `projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET`.
         """
         pulumi.set(__self__, "subnet", subnet)
 
@@ -182,7 +182,7 @@ class ClusterGcpConfigAccessConfigNetworkConfig(dict):
     @pulumi.getter
     def subnet(self) -> builtins.str:
         """
-        Name of the VPC subnet from which the cluster is accessible. Both broker and bootstrap server IP addresses and DNS entries are automatically created in the subnet. The subnet must be located in the same region as the cluster. The project may differ. The name of the subnet must be in the format `projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET`.
+        Name of the VPC subnet from which the cluster is accessible. Both broker and bootstrap server IP addresses and DNS entries are automatically created in the subnet. There can only be one subnet per network, and the subnet must be located in the same region as the cluster. The project may differ. The name of the subnet must be in the format `projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET`.
         """
         return pulumi.get(self, "subnet")
 

pulumi_gcp/memorystore/_inputs.py

@@ -16,6 +16,12 @@ else:
 from .. import _utilities
 
 __all__ = [
+    'InstanceAutomatedBackupConfigArgs',
+    'InstanceAutomatedBackupConfigArgsDict',
+    'InstanceAutomatedBackupConfigFixedFrequencyScheduleArgs',
+    'InstanceAutomatedBackupConfigFixedFrequencyScheduleArgsDict',
+    'InstanceAutomatedBackupConfigFixedFrequencyScheduleStartTimeArgs',
+    'InstanceAutomatedBackupConfigFixedFrequencyScheduleStartTimeArgsDict',
     'InstanceCrossInstanceReplicationConfigArgs',
     'InstanceCrossInstanceReplicationConfigArgsDict',
     'InstanceCrossInstanceReplicationConfigMembershipArgs',
@@ -44,6 +50,8 @@ __all__ = [
     'InstanceEndpointConnectionArgsDict',
     'InstanceEndpointConnectionPscAutoConnectionArgs',
     'InstanceEndpointConnectionPscAutoConnectionArgsDict',
+    'InstanceGcsSourceArgs',
+    'InstanceGcsSourceArgsDict',
     'InstanceMaintenancePolicyArgs',
     'InstanceMaintenancePolicyArgsDict',
     'InstanceMaintenancePolicyWeeklyMaintenanceWindowArgs',
@@ -52,6 +60,8 @@ __all__ = [
     'InstanceMaintenancePolicyWeeklyMaintenanceWindowStartTimeArgsDict',
     'InstanceMaintenanceScheduleArgs',
     'InstanceMaintenanceScheduleArgsDict',
+    'InstanceManagedBackupSourceArgs',
+    'InstanceManagedBackupSourceArgsDict',
     'InstanceNodeConfigArgs',
     'InstanceNodeConfigArgsDict',
     'InstancePersistenceConfigArgs',
@@ -74,6 +84,136 @@ __all__ = [
 
 MYPY = False
 
+if not MYPY:
+    class InstanceAutomatedBackupConfigArgsDict(TypedDict):
+        fixed_frequency_schedule: pulumi.Input['InstanceAutomatedBackupConfigFixedFrequencyScheduleArgsDict']
+        """
+        Trigger automated backups at a fixed frequency.
+        Structure is documented below.
+        """
+        retention: pulumi.Input[builtins.str]
+        """
+        How long to keep automated backups before the backups are deleted.
+        The value should be between 1 day and 365 days. If not specified, the default value is 35 days.
+        A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s". The default_value is "3024000s"
+        """
+elif False:
+    InstanceAutomatedBackupConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceAutomatedBackupConfigArgs:
+    def __init__(__self__, *,
+                 fixed_frequency_schedule: pulumi.Input['InstanceAutomatedBackupConfigFixedFrequencyScheduleArgs'],
+                 retention: pulumi.Input[builtins.str]):
+        """
+        :param pulumi.Input['InstanceAutomatedBackupConfigFixedFrequencyScheduleArgs'] fixed_frequency_schedule: Trigger automated backups at a fixed frequency.
+               Structure is documented below.
+        :param pulumi.Input[builtins.str] retention: How long to keep automated backups before the backups are deleted.
+               The value should be between 1 day and 365 days. If not specified, the default value is 35 days.
+               A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s". The default_value is "3024000s"
+        """
+        pulumi.set(__self__, "fixed_frequency_schedule", fixed_frequency_schedule)
+        pulumi.set(__self__, "retention", retention)
+
+    @property
+    @pulumi.getter(name="fixedFrequencySchedule")
+    def fixed_frequency_schedule(self) -> pulumi.Input['InstanceAutomatedBackupConfigFixedFrequencyScheduleArgs']:
+        """
+        Trigger automated backups at a fixed frequency.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "fixed_frequency_schedule")
+
+    @fixed_frequency_schedule.setter
+    def fixed_frequency_schedule(self, value: pulumi.Input['InstanceAutomatedBackupConfigFixedFrequencyScheduleArgs']):
+        pulumi.set(self, "fixed_frequency_schedule", value)
+
+    @property
+    @pulumi.getter
+    def retention(self) -> pulumi.Input[builtins.str]:
+        """
+        How long to keep automated backups before the backups are deleted.
+        The value should be between 1 day and 365 days. If not specified, the default value is 35 days.
+        A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s". The default_value is "3024000s"
+        """
+        return pulumi.get(self, "retention")
+
+    @retention.setter
+    def retention(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "retention", value)
+
+
+if not MYPY:
+    class InstanceAutomatedBackupConfigFixedFrequencyScheduleArgsDict(TypedDict):
+        start_time: pulumi.Input['InstanceAutomatedBackupConfigFixedFrequencyScheduleStartTimeArgsDict']
+        """
+        The start time of every automated backup in UTC.
+        It must be set to the start of an hour. This field is required.
+        Structure is documented below.
+        """
+elif False:
+    InstanceAutomatedBackupConfigFixedFrequencyScheduleArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceAutomatedBackupConfigFixedFrequencyScheduleArgs:
+    def __init__(__self__, *,
+                 start_time: pulumi.Input['InstanceAutomatedBackupConfigFixedFrequencyScheduleStartTimeArgs']):
+        """
+        :param pulumi.Input['InstanceAutomatedBackupConfigFixedFrequencyScheduleStartTimeArgs'] start_time: The start time of every automated backup in UTC.
+               It must be set to the start of an hour. This field is required.
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "start_time", start_time)
+
+    @property
+    @pulumi.getter(name="startTime")
+    def start_time(self) -> pulumi.Input['InstanceAutomatedBackupConfigFixedFrequencyScheduleStartTimeArgs']:
+        """
+        The start time of every automated backup in UTC.
+        It must be set to the start of an hour. This field is required.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "start_time")
+
+    @start_time.setter
+    def start_time(self, value: pulumi.Input['InstanceAutomatedBackupConfigFixedFrequencyScheduleStartTimeArgs']):
+        pulumi.set(self, "start_time", value)
+
+
+if not MYPY:
+    class InstanceAutomatedBackupConfigFixedFrequencyScheduleStartTimeArgsDict(TypedDict):
+        hours: pulumi.Input[builtins.int]
+        """
+        Hours of day in 24 hour format. Should be from 0 to 23.
+        An API may choose to allow the value "24:00:00" for scenarios like business closing time.
+        """
+elif False:
+    InstanceAutomatedBackupConfigFixedFrequencyScheduleStartTimeArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceAutomatedBackupConfigFixedFrequencyScheduleStartTimeArgs:
+    def __init__(__self__, *,
+                 hours: pulumi.Input[builtins.int]):
+        """
+        :param pulumi.Input[builtins.int] hours: Hours of day in 24 hour format. Should be from 0 to 23.
+               An API may choose to allow the value "24:00:00" for scenarios like business closing time.
+        """
+        pulumi.set(__self__, "hours", hours)
+
+    @property
+    @pulumi.getter
+    def hours(self) -> pulumi.Input[builtins.int]:
+        """
+        Hours of day in 24 hour format. Should be from 0 to 23.
+        An API may choose to allow the value "24:00:00" for scenarios like business closing time.
+        """
+        return pulumi.get(self, "hours")
+
+    @hours.setter
+    def hours(self, value: pulumi.Input[builtins.int]):
+        pulumi.set(self, "hours", value)
+
+
 if not MYPY:
     class InstanceCrossInstanceReplicationConfigArgsDict(TypedDict):
         instance_role: NotRequired[pulumi.Input[builtins.str]]
@@ -1197,6 +1337,40 @@ class InstanceEndpointConnectionPscAutoConnectionArgs:
         pulumi.set(self, "service_attachment", value)
 
 
+if not MYPY:
+    class InstanceGcsSourceArgsDict(TypedDict):
+        uris: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
+        """
+        URIs of the GCS objects to import.
+        Example: gs://bucket1/object1, gs//bucket2/folder2/object2
+        """
+elif False:
+    InstanceGcsSourceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceGcsSourceArgs:
+    def __init__(__self__, *,
+                 uris: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] uris: URIs of the GCS objects to import.
+               Example: gs://bucket1/object1, gs//bucket2/folder2/object2
+        """
+        pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
+        """
+        URIs of the GCS objects to import.
+        Example: gs://bucket1/object1, gs//bucket2/folder2/object2
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
+        pulumi.set(self, "uris", value)
+
+
 if not MYPY:
     class InstanceMaintenancePolicyArgsDict(TypedDict):
         create_time: NotRequired[pulumi.Input[builtins.str]]
@@ -1608,6 +1782,37 @@ class InstanceMaintenanceScheduleArgs:
         pulumi.set(self, "start_time", value)
 
 
+if not MYPY:
+    class InstanceManagedBackupSourceArgsDict(TypedDict):
+        backup: pulumi.Input[builtins.str]
+        """
+        Example: //memorystore.googleapis.com/projects/{project}/locations/{location}/backups/{backupId}. In this case, it assumes the backup is under memorystore.googleapis.com.
+        """
+elif False:
+    InstanceManagedBackupSourceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceManagedBackupSourceArgs:
+    def __init__(__self__, *,
+                 backup: pulumi.Input[builtins.str]):
+        """
+        :param pulumi.Input[builtins.str] backup: Example: //memorystore.googleapis.com/projects/{project}/locations/{location}/backups/{backupId}. In this case, it assumes the backup is under memorystore.googleapis.com.
+        """
+        pulumi.set(__self__, "backup", backup)
+
+    @property
+    @pulumi.getter
+    def backup(self) -> pulumi.Input[builtins.str]:
+        """
+        Example: //memorystore.googleapis.com/projects/{project}/locations/{location}/backups/{backupId}. In this case, it assumes the backup is under memorystore.googleapis.com.
+        """
+        return pulumi.get(self, "backup")
+
+    @backup.setter
+    def backup(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "backup", value)
+
+
 if not MYPY:
     class InstanceNodeConfigArgsDict(TypedDict):
         size_gb: NotRequired[pulumi.Input[builtins.float]]