pulumi-gcp 8.10.0a1731950704__py3-none-any.whl → 8.10.1__py3-none-any.whl

pulumi_gcp/redis/cluster.py

@@ -28,6 +28,7 @@ class ClusterArgs:
                  maintenance_policy: Optional[pulumi.Input['ClusterMaintenancePolicyArgs']] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  node_type: Optional[pulumi.Input[str]] = None,
+                 persistence_config: Optional[pulumi.Input['ClusterPersistenceConfigArgs']] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  redis_configs: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  region: Optional[pulumi.Input[str]] = None,
@@ -51,6 +52,7 @@ class ClusterArgs:
                projects/{projectId}/locations/{locationId}/clusters/{clusterId}
         :param pulumi.Input[str] node_type: The nodeType for the Redis cluster. If not provided, REDIS_HIGHMEM_MEDIUM will be used as default Possible values:
                ["REDIS_SHARED_CORE_NANO", "REDIS_HIGHMEM_MEDIUM", "REDIS_HIGHMEM_XLARGE", "REDIS_STANDARD_SMALL"]
+        :param pulumi.Input['ClusterPersistenceConfigArgs'] persistence_config: Persistence config (RDB, AOF) for the cluster.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] redis_configs: Configure Redis Cluster behavior using a subset of native Redis configuration parameters. Please check Memorystore
                documentation for the list of supported parameters:
                https://cloud.google.com/memorystore/docs/cluster/supported-instance-configurations
@@ -73,6 +75,8 @@ class ClusterArgs:
             pulumi.set(__self__, "name", name)
         if node_type is not None:
             pulumi.set(__self__, "node_type", node_type)
+        if persistence_config is not None:
+            pulumi.set(__self__, "persistence_config", persistence_config)
         if project is not None:
             pulumi.set(__self__, "project", project)
         if redis_configs is not None:
@@ -178,6 +182,18 @@ class ClusterArgs:
     def node_type(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "node_type", value)
 
+    @property
+    @pulumi.getter(name="persistenceConfig")
+    def persistence_config(self) -> Optional[pulumi.Input['ClusterPersistenceConfigArgs']]:
+        """
+        Persistence config (RDB, AOF) for the cluster.
+        """
+        return pulumi.get(self, "persistence_config")
+
+    @persistence_config.setter
+    def persistence_config(self, value: Optional[pulumi.Input['ClusterPersistenceConfigArgs']]):
+        pulumi.set(self, "persistence_config", value)
+
     @property
     @pulumi.getter
     def project(self) -> Optional[pulumi.Input[str]]:
@@ -263,6 +279,7 @@ class _ClusterState:
                  maintenance_schedules: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterMaintenanceScheduleArgs']]]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  node_type: Optional[pulumi.Input[str]] = None,
+                 persistence_config: Optional[pulumi.Input['ClusterPersistenceConfigArgs']] = None,
                  precise_size_gb: Optional[pulumi.Input[float]] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  psc_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterPscConfigArgs']]]] = None,
@@ -298,6 +315,7 @@ class _ClusterState:
                projects/{projectId}/locations/{locationId}/clusters/{clusterId}
         :param pulumi.Input[str] node_type: The nodeType for the Redis cluster. If not provided, REDIS_HIGHMEM_MEDIUM will be used as default Possible values:
                ["REDIS_SHARED_CORE_NANO", "REDIS_HIGHMEM_MEDIUM", "REDIS_HIGHMEM_XLARGE", "REDIS_STANDARD_SMALL"]
+        :param pulumi.Input['ClusterPersistenceConfigArgs'] persistence_config: Persistence config (RDB, AOF) for the cluster.
         :param pulumi.Input[float] precise_size_gb: Output only. Redis memory precise size in GB for the entire cluster.
         :param pulumi.Input[Sequence[pulumi.Input['ClusterPscConfigArgs']]] psc_configs: Required. Each PscConfig configures the consumer network where two
                network addresses will be designated to the cluster for client access.
@@ -337,6 +355,8 @@ class _ClusterState:
             pulumi.set(__self__, "name", name)
         if node_type is not None:
             pulumi.set(__self__, "node_type", node_type)
+        if persistence_config is not None:
+            pulumi.set(__self__, "persistence_config", persistence_config)
         if precise_size_gb is not None:
             pulumi.set(__self__, "precise_size_gb", precise_size_gb)
         if project is not None:
@@ -473,6 +493,18 @@ class _ClusterState:
     def node_type(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "node_type", value)
 
+    @property
+    @pulumi.getter(name="persistenceConfig")
+    def persistence_config(self) -> Optional[pulumi.Input['ClusterPersistenceConfigArgs']]:
+        """
+        Persistence config (RDB, AOF) for the cluster.
+        """
+        return pulumi.get(self, "persistence_config")
+
+    @persistence_config.setter
+    def persistence_config(self, value: Optional[pulumi.Input['ClusterPersistenceConfigArgs']]):
+        pulumi.set(self, "persistence_config", value)
+
     @property
     @pulumi.getter(name="preciseSizeGb")
     def precise_size_gb(self) -> Optional[pulumi.Input[float]]:
@@ -658,6 +690,7 @@ class Cluster(pulumi.CustomResource):
                  maintenance_policy: Optional[pulumi.Input[Union['ClusterMaintenancePolicyArgs', 'ClusterMaintenancePolicyArgsDict']]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  node_type: Optional[pulumi.Input[str]] = None,
+                 persistence_config: Optional[pulumi.Input[Union['ClusterPersistenceConfigArgs', 'ClusterPersistenceConfigArgsDict']]] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  psc_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ClusterPscConfigArgs', 'ClusterPscConfigArgsDict']]]]] = None,
                  redis_configs: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -780,6 +813,127 @@ class Cluster(pulumi.CustomResource):
             deletion_protection_enabled=True,
             opts = pulumi.ResourceOptions(depends_on=[default]))
         ```
+        ### Redis Cluster Rdb
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        producer_net = gcp.compute.Network("producer_net",
+            name="mynetwork",
+            auto_create_subnetworks=False)
+        producer_subnet = gcp.compute.Subnetwork("producer_subnet",
+            name="mysubnet",
+            ip_cidr_range="10.0.0.248/29",
+            region="us-central1",
+            network=producer_net.id)
+        default = gcp.networkconnectivity.ServiceConnectionPolicy("default",
+            name="mypolicy",
+            location="us-central1",
+            service_class="gcp-memorystore-redis",
+            description="my basic service connection policy",
+            network=producer_net.id,
+            psc_config={
+                "subnetworks": [producer_subnet.id],
+            })
+        cluster_rdb = gcp.redis.Cluster("cluster-rdb",
+            name="rdb-cluster",
+            shard_count=3,
+            psc_configs=[{
+                "network": producer_net.id,
+            }],
+            region="us-central1",
+            replica_count=0,
+            node_type="REDIS_SHARED_CORE_NANO",
+            transit_encryption_mode="TRANSIT_ENCRYPTION_MODE_DISABLED",
+            authorization_mode="AUTH_MODE_DISABLED",
+            redis_configs={
+                "maxmemory-policy": "volatile-ttl",
+            },
+            deletion_protection_enabled=True,
+            zone_distribution_config={
+                "mode": "MULTI_ZONE",
+            },
+            maintenance_policy={
+                "weekly_maintenance_windows": [{
+                    "day": "MONDAY",
+                    "start_time": {
+                        "hours": 1,
+                        "minutes": 0,
+                        "seconds": 0,
+                        "nanos": 0,
+                    },
+                }],
+            },
+            persistence_config={
+                "mode": "RDB",
+                "rdb_config": {
+                    "rdb_snapshot_period": "ONE_HOUR",
+                    "rdb_snapshot_start_time": "2024-10-02T15:01:23Z",
+                },
+            },
+            opts = pulumi.ResourceOptions(depends_on=[default]))
+        ```
+        ### Redis Cluster Aof
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        producer_net = gcp.compute.Network("producer_net",
+            name="mynetwork",
+            auto_create_subnetworks=False)
+        producer_subnet = gcp.compute.Subnetwork("producer_subnet",
+            name="mysubnet",
+            ip_cidr_range="10.0.0.248/29",
+            region="us-central1",
+            network=producer_net.id)
+        default = gcp.networkconnectivity.ServiceConnectionPolicy("default",
+            name="mypolicy",
+            location="us-central1",
+            service_class="gcp-memorystore-redis",
+            description="my basic service connection policy",
+            network=producer_net.id,
+            psc_config={
+                "subnetworks": [producer_subnet.id],
+            })
+        cluster_aof = gcp.redis.Cluster("cluster-aof",
+            name="aof-cluster",
+            shard_count=3,
+            psc_configs=[{
+                "network": producer_net.id,
+            }],
+            region="us-central1",
+            replica_count=0,
+            node_type="REDIS_SHARED_CORE_NANO",
+            transit_encryption_mode="TRANSIT_ENCRYPTION_MODE_DISABLED",
+            authorization_mode="AUTH_MODE_DISABLED",
+            redis_configs={
+                "maxmemory-policy": "volatile-ttl",
+            },
+            deletion_protection_enabled=True,
+            zone_distribution_config={
+                "mode": "MULTI_ZONE",
+            },
+            maintenance_policy={
+                "weekly_maintenance_windows": [{
+                    "day": "MONDAY",
+                    "start_time": {
+                        "hours": 1,
+                        "minutes": 0,
+                        "seconds": 0,
+                        "nanos": 0,
+                    },
+                }],
+            },
+            persistence_config={
+                "mode": "AOF",
+                "aof_config": {
+                    "append_fsync": "EVERYSEC",
+                },
+            },
+            opts = pulumi.ResourceOptions(depends_on=[default]))
+        ```
 
         ## Import
 
@@ -823,6 +977,7 @@ class Cluster(pulumi.CustomResource):
                projects/{projectId}/locations/{locationId}/clusters/{clusterId}
         :param pulumi.Input[str] node_type: The nodeType for the Redis cluster. If not provided, REDIS_HIGHMEM_MEDIUM will be used as default Possible values:
                ["REDIS_SHARED_CORE_NANO", "REDIS_HIGHMEM_MEDIUM", "REDIS_HIGHMEM_XLARGE", "REDIS_STANDARD_SMALL"]
+        :param pulumi.Input[Union['ClusterPersistenceConfigArgs', 'ClusterPersistenceConfigArgsDict']] persistence_config: Persistence config (RDB, AOF) for the cluster.
         :param pulumi.Input[Sequence[pulumi.Input[Union['ClusterPscConfigArgs', 'ClusterPscConfigArgsDict']]]] psc_configs: Required. Each PscConfig configures the consumer network where two
                network addresses will be designated to the cluster for client access.
                Currently, only one PscConfig is supported.
@@ -957,6 +1112,127 @@ class Cluster(pulumi.CustomResource):
             deletion_protection_enabled=True,
             opts = pulumi.ResourceOptions(depends_on=[default]))
         ```
+        ### Redis Cluster Rdb
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        producer_net = gcp.compute.Network("producer_net",
+            name="mynetwork",
+            auto_create_subnetworks=False)
+        producer_subnet = gcp.compute.Subnetwork("producer_subnet",
+            name="mysubnet",
+            ip_cidr_range="10.0.0.248/29",
+            region="us-central1",
+            network=producer_net.id)
+        default = gcp.networkconnectivity.ServiceConnectionPolicy("default",
+            name="mypolicy",
+            location="us-central1",
+            service_class="gcp-memorystore-redis",
+            description="my basic service connection policy",
+            network=producer_net.id,
+            psc_config={
+                "subnetworks": [producer_subnet.id],
+            })
+        cluster_rdb = gcp.redis.Cluster("cluster-rdb",
+            name="rdb-cluster",
+            shard_count=3,
+            psc_configs=[{
+                "network": producer_net.id,
+            }],
+            region="us-central1",
+            replica_count=0,
+            node_type="REDIS_SHARED_CORE_NANO",
+            transit_encryption_mode="TRANSIT_ENCRYPTION_MODE_DISABLED",
+            authorization_mode="AUTH_MODE_DISABLED",
+            redis_configs={
+                "maxmemory-policy": "volatile-ttl",
+            },
+            deletion_protection_enabled=True,
+            zone_distribution_config={
+                "mode": "MULTI_ZONE",
+            },
+            maintenance_policy={
+                "weekly_maintenance_windows": [{
+                    "day": "MONDAY",
+                    "start_time": {
+                        "hours": 1,
+                        "minutes": 0,
+                        "seconds": 0,
+                        "nanos": 0,
+                    },
+                }],
+            },
+            persistence_config={
+                "mode": "RDB",
+                "rdb_config": {
+                    "rdb_snapshot_period": "ONE_HOUR",
+                    "rdb_snapshot_start_time": "2024-10-02T15:01:23Z",
+                },
+            },
+            opts = pulumi.ResourceOptions(depends_on=[default]))
+        ```
+        ### Redis Cluster Aof
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        producer_net = gcp.compute.Network("producer_net",
+            name="mynetwork",
+            auto_create_subnetworks=False)
+        producer_subnet = gcp.compute.Subnetwork("producer_subnet",
+            name="mysubnet",
+            ip_cidr_range="10.0.0.248/29",
+            region="us-central1",
+            network=producer_net.id)
+        default = gcp.networkconnectivity.ServiceConnectionPolicy("default",
+            name="mypolicy",
+            location="us-central1",
+            service_class="gcp-memorystore-redis",
+            description="my basic service connection policy",
+            network=producer_net.id,
+            psc_config={
+                "subnetworks": [producer_subnet.id],
+            })
+        cluster_aof = gcp.redis.Cluster("cluster-aof",
+            name="aof-cluster",
+            shard_count=3,
+            psc_configs=[{
+                "network": producer_net.id,
+            }],
+            region="us-central1",
+            replica_count=0,
+            node_type="REDIS_SHARED_CORE_NANO",
+            transit_encryption_mode="TRANSIT_ENCRYPTION_MODE_DISABLED",
+            authorization_mode="AUTH_MODE_DISABLED",
+            redis_configs={
+                "maxmemory-policy": "volatile-ttl",
+            },
+            deletion_protection_enabled=True,
+            zone_distribution_config={
+                "mode": "MULTI_ZONE",
+            },
+            maintenance_policy={
+                "weekly_maintenance_windows": [{
+                    "day": "MONDAY",
+                    "start_time": {
+                        "hours": 1,
+                        "minutes": 0,
+                        "seconds": 0,
+                        "nanos": 0,
+                    },
+                }],
+            },
+            persistence_config={
+                "mode": "AOF",
+                "aof_config": {
+                    "append_fsync": "EVERYSEC",
+                },
+            },
+            opts = pulumi.ResourceOptions(depends_on=[default]))
+        ```
 
         ## Import
 
@@ -1008,6 +1284,7 @@ class Cluster(pulumi.CustomResource):
                  maintenance_policy: Optional[pulumi.Input[Union['ClusterMaintenancePolicyArgs', 'ClusterMaintenancePolicyArgsDict']]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  node_type: Optional[pulumi.Input[str]] = None,
+                 persistence_config: Optional[pulumi.Input[Union['ClusterPersistenceConfigArgs', 'ClusterPersistenceConfigArgsDict']]] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  psc_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ClusterPscConfigArgs', 'ClusterPscConfigArgsDict']]]]] = None,
                  redis_configs: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -1030,6 +1307,7 @@ class Cluster(pulumi.CustomResource):
             __props__.__dict__["maintenance_policy"] = maintenance_policy
             __props__.__dict__["name"] = name
             __props__.__dict__["node_type"] = node_type
+            __props__.__dict__["persistence_config"] = persistence_config
             __props__.__dict__["project"] = project
             if psc_configs is None and not opts.urn:
                 raise TypeError("Missing required property 'psc_configs'")
@@ -1069,6 +1347,7 @@ class Cluster(pulumi.CustomResource):
             maintenance_schedules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ClusterMaintenanceScheduleArgs', 'ClusterMaintenanceScheduleArgsDict']]]]] = None,
             name: Optional[pulumi.Input[str]] = None,
             node_type: Optional[pulumi.Input[str]] = None,
+            persistence_config: Optional[pulumi.Input[Union['ClusterPersistenceConfigArgs', 'ClusterPersistenceConfigArgsDict']]] = None,
             precise_size_gb: Optional[pulumi.Input[float]] = None,
             project: Optional[pulumi.Input[str]] = None,
             psc_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ClusterPscConfigArgs', 'ClusterPscConfigArgsDict']]]]] = None,
@@ -1109,6 +1388,7 @@ class Cluster(pulumi.CustomResource):
                projects/{projectId}/locations/{locationId}/clusters/{clusterId}
         :param pulumi.Input[str] node_type: The nodeType for the Redis cluster. If not provided, REDIS_HIGHMEM_MEDIUM will be used as default Possible values:
                ["REDIS_SHARED_CORE_NANO", "REDIS_HIGHMEM_MEDIUM", "REDIS_HIGHMEM_XLARGE", "REDIS_STANDARD_SMALL"]
+        :param pulumi.Input[Union['ClusterPersistenceConfigArgs', 'ClusterPersistenceConfigArgsDict']] persistence_config: Persistence config (RDB, AOF) for the cluster.
         :param pulumi.Input[float] precise_size_gb: Output only. Redis memory precise size in GB for the entire cluster.
         :param pulumi.Input[Sequence[pulumi.Input[Union['ClusterPscConfigArgs', 'ClusterPscConfigArgsDict']]]] psc_configs: Required. Each PscConfig configures the consumer network where two
                network addresses will be designated to the cluster for client access.
@@ -1144,6 +1424,7 @@ class Cluster(pulumi.CustomResource):
         __props__.__dict__["maintenance_schedules"] = maintenance_schedules
         __props__.__dict__["name"] = name
         __props__.__dict__["node_type"] = node_type
+        __props__.__dict__["persistence_config"] = persistence_config
         __props__.__dict__["precise_size_gb"] = precise_size_gb
         __props__.__dict__["project"] = project
         __props__.__dict__["psc_configs"] = psc_configs
@@ -1235,6 +1516,14 @@ class Cluster(pulumi.CustomResource):
         """
         return pulumi.get(self, "node_type")
 
+    @property
+    @pulumi.getter(name="persistenceConfig")
+    def persistence_config(self) -> pulumi.Output['outputs.ClusterPersistenceConfig']:
+        """
+        Persistence config (RDB, AOF) for the cluster.
+        """
+        return pulumi.get(self, "persistence_config")
+
     @property
     @pulumi.getter(name="preciseSizeGb")
     def precise_size_gb(self) -> pulumi.Output[float]:

pulumi_gcp/redis/get_instance.py

@@ -450,7 +450,7 @@ def get_instance(name: Optional[str] = None,
 def get_instance_output(name: Optional[pulumi.Input[str]] = None,
                         project: Optional[pulumi.Input[Optional[str]]] = None,
                         region: Optional[pulumi.Input[Optional[str]]] = None,
-                        opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetInstanceResult]:
+                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetInstanceResult]:
     """
     Get info about a Google Cloud Redis instance.
 
@@ -479,7 +479,7 @@ def get_instance_output(name: Optional[pulumi.Input[str]] = None,
     __args__['name'] = name
     __args__['project'] = project
     __args__['region'] = region
-    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('gcp:redis/getInstance:getInstance', __args__, opts=opts, typ=GetInstanceResult)
     return __ret__.apply(lambda __response__: GetInstanceResult(
         alternative_location_id=pulumi.get(__response__, 'alternative_location_id'),

pulumi_gcp/redis/outputs.py

@@ -22,6 +22,9 @@ __all__ = [
     'ClusterMaintenancePolicyWeeklyMaintenanceWindow',
     'ClusterMaintenancePolicyWeeklyMaintenanceWindowStartTime',
     'ClusterMaintenanceSchedule',
+    'ClusterPersistenceConfig',
+    'ClusterPersistenceConfigAofConfig',
+    'ClusterPersistenceConfigRdbConfig',
     'ClusterPscConfig',
     'ClusterPscConnection',
     'ClusterStateInfo',
@@ -437,6 +440,188 @@ class ClusterMaintenanceSchedule(dict):
         return pulumi.get(self, "start_time")
 
 
+@pulumi.output_type
+class ClusterPersistenceConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "aofConfig":
+            suggest = "aof_config"
+        elif key == "rdbConfig":
+            suggest = "rdb_config"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterPersistenceConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterPersistenceConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterPersistenceConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 aof_config: Optional['outputs.ClusterPersistenceConfigAofConfig'] = None,
+                 mode: Optional[str] = None,
+                 rdb_config: Optional['outputs.ClusterPersistenceConfigRdbConfig'] = None):
+        """
+        :param 'ClusterPersistenceConfigAofConfigArgs' aof_config: AOF configuration. This field will be ignored if mode is not AOF.
+               Structure is documented below.
+        :param str mode: Optional. Controls whether Persistence features are enabled. If not provided, the existing value will be used.
+               - DISABLED: 	Persistence (both backup and restore) is disabled for the cluster.
+               - RDB: RDB based Persistence is enabled.
+               - AOF: AOF based Persistence is enabled.
+               Possible values are: `PERSISTENCE_MODE_UNSPECIFIED`, `DISABLED`, `RDB`, `AOF`.
+        :param 'ClusterPersistenceConfigRdbConfigArgs' rdb_config: RDB configuration. This field will be ignored if mode is not RDB.
+               Structure is documented below.
+        """
+        if aof_config is not None:
+            pulumi.set(__self__, "aof_config", aof_config)
+        if mode is not None:
+            pulumi.set(__self__, "mode", mode)
+        if rdb_config is not None:
+            pulumi.set(__self__, "rdb_config", rdb_config)
+
+    @property
+    @pulumi.getter(name="aofConfig")
+    def aof_config(self) -> Optional['outputs.ClusterPersistenceConfigAofConfig']:
+        """
+        AOF configuration. This field will be ignored if mode is not AOF.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "aof_config")
+
+    @property
+    @pulumi.getter
+    def mode(self) -> Optional[str]:
+        """
+        Optional. Controls whether Persistence features are enabled. If not provided, the existing value will be used.
+        - DISABLED: 	Persistence (both backup and restore) is disabled for the cluster.
+        - RDB: RDB based Persistence is enabled.
+        - AOF: AOF based Persistence is enabled.
+        Possible values are: `PERSISTENCE_MODE_UNSPECIFIED`, `DISABLED`, `RDB`, `AOF`.
+        """
+        return pulumi.get(self, "mode")
+
+    @property
+    @pulumi.getter(name="rdbConfig")
+    def rdb_config(self) -> Optional['outputs.ClusterPersistenceConfigRdbConfig']:
+        """
+        RDB configuration. This field will be ignored if mode is not RDB.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "rdb_config")
+
+
+@pulumi.output_type
+class ClusterPersistenceConfigAofConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "appendFsync":
+            suggest = "append_fsync"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterPersistenceConfigAofConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterPersistenceConfigAofConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterPersistenceConfigAofConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 append_fsync: Optional[str] = None):
+        """
+        :param str append_fsync: Optional. Available fsync modes.
+               - NO - Do not explicilty call fsync(). Rely on OS defaults.
+               - EVERYSEC - Call fsync() once per second in a background thread. A balance between performance and durability.
+               - ALWAYS - Call fsync() for earch write command.
+               Possible values are: `APPEND_FSYNC_UNSPECIFIED`, `NO`, `EVERYSEC`, `ALWAYS`.
+        """
+        if append_fsync is not None:
+            pulumi.set(__self__, "append_fsync", append_fsync)
+
+    @property
+    @pulumi.getter(name="appendFsync")
+    def append_fsync(self) -> Optional[str]:
+        """
+        Optional. Available fsync modes.
+        - NO - Do not explicilty call fsync(). Rely on OS defaults.
+        - EVERYSEC - Call fsync() once per second in a background thread. A balance between performance and durability.
+        - ALWAYS - Call fsync() for earch write command.
+        Possible values are: `APPEND_FSYNC_UNSPECIFIED`, `NO`, `EVERYSEC`, `ALWAYS`.
+        """
+        return pulumi.get(self, "append_fsync")
+
+
+@pulumi.output_type
+class ClusterPersistenceConfigRdbConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "rdbSnapshotPeriod":
+            suggest = "rdb_snapshot_period"
+        elif key == "rdbSnapshotStartTime":
+            suggest = "rdb_snapshot_start_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterPersistenceConfigRdbConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterPersistenceConfigRdbConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterPersistenceConfigRdbConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 rdb_snapshot_period: Optional[str] = None,
+                 rdb_snapshot_start_time: Optional[str] = None):
+        """
+        :param str rdb_snapshot_period: Optional. Available snapshot periods for scheduling.
+               - ONE_HOUR:	Snapshot every 1 hour.
+               - SIX_HOURS:	Snapshot every 6 hours.
+               - TWELVE_HOURS:	Snapshot every 12 hours.
+               - TWENTY_FOUR_HOURS:	Snapshot every 24 hours.
+               Possible values are: `SNAPSHOT_PERIOD_UNSPECIFIED`, `ONE_HOUR`, `SIX_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`.
+        :param str rdb_snapshot_start_time: The time that the first snapshot was/will be attempted, and to which
+               future snapshots will be aligned.
+               If not provided, the current time will be used.
+        """
+        if rdb_snapshot_period is not None:
+            pulumi.set(__self__, "rdb_snapshot_period", rdb_snapshot_period)
+        if rdb_snapshot_start_time is not None:
+            pulumi.set(__self__, "rdb_snapshot_start_time", rdb_snapshot_start_time)
+
+    @property
+    @pulumi.getter(name="rdbSnapshotPeriod")
+    def rdb_snapshot_period(self) -> Optional[str]:
+        """
+        Optional. Available snapshot periods for scheduling.
+        - ONE_HOUR:	Snapshot every 1 hour.
+        - SIX_HOURS:	Snapshot every 6 hours.
+        - TWELVE_HOURS:	Snapshot every 12 hours.
+        - TWENTY_FOUR_HOURS:	Snapshot every 24 hours.
+        Possible values are: `SNAPSHOT_PERIOD_UNSPECIFIED`, `ONE_HOUR`, `SIX_HOURS`, `TWELVE_HOURS`, `TWENTY_FOUR_HOURS`.
+        """
+        return pulumi.get(self, "rdb_snapshot_period")
+
+    @property
+    @pulumi.getter(name="rdbSnapshotStartTime")
+    def rdb_snapshot_start_time(self) -> Optional[str]:
+        """
+        The time that the first snapshot was/will be attempted, and to which
+        future snapshots will be aligned.
+        If not provided, the current time will be used.
+        """
+        return pulumi.get(self, "rdb_snapshot_start_time")
+
+
 @pulumi.output_type
 class ClusterPscConfig(dict):
     def __init__(__self__, *,

pulumi_gcp/runtimeconfig/get_config.py

@@ -109,7 +109,7 @@ def get_config(name: Optional[str] = None,
         project=pulumi.get(__ret__, 'project'))
 def get_config_output(name: Optional[pulumi.Input[str]] = None,
                       project: Optional[pulumi.Input[Optional[str]]] = None,
-                      opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetConfigResult]:
+                      opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetConfigResult]:
     """
     ## Example Usage
 
@@ -130,7 +130,7 @@ def get_config_output(name: Optional[pulumi.Input[str]] = None,
     __args__ = dict()
     __args__['name'] = name
     __args__['project'] = project
-    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('gcp:runtimeconfig/getConfig:getConfig', __args__, opts=opts, typ=GetConfigResult)
     return __ret__.apply(lambda __response__: GetConfigResult(
         description=pulumi.get(__response__, 'description'),

pulumi_gcp/runtimeconfig/get_config_iam_policy.py

@@ -116,7 +116,7 @@ def get_config_iam_policy(config: Optional[str] = None,
         project=pulumi.get(__ret__, 'project'))
 def get_config_iam_policy_output(config: Optional[pulumi.Input[str]] = None,
                                  project: Optional[pulumi.Input[Optional[str]]] = None,
-                                 opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetConfigIamPolicyResult]:
+                                 opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetConfigIamPolicyResult]:
     """
     Use this data source to access information about an existing resource.
 
@@ -127,7 +127,7 @@ def get_config_iam_policy_output(config: Optional[pulumi.Input[str]] = None,
     __args__ = dict()
     __args__['config'] = config
     __args__['project'] = project
-    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('gcp:runtimeconfig/getConfigIamPolicy:getConfigIamPolicy', __args__, opts=opts, typ=GetConfigIamPolicyResult)
     return __ret__.apply(lambda __response__: GetConfigIamPolicyResult(
         config=pulumi.get(__response__, 'config'),