pulumi-gcp 8.18.0a1738650987__py3-none-any.whl → 8.19.0__py3-none-any.whl

pulumi_gcp/datastream/connection_profile.py

@@ -634,18 +634,23 @@ class ConnectionProfile(pulumi.CustomResource):
         import pulumi_gcp as gcp
         import pulumi_random as random
 
-        default = gcp.compute.Network("default", name="my-network")
+        default = gcp.compute.Network("default",
+            name="my-network",
+            auto_create_subnetworks=False)
+        default_subnetwork = gcp.compute.Subnetwork("default",
+            name="my-subnetwork",
+            ip_cidr_range="10.1.0.0/16",
+            region="us-central1",
+            network=default.id)
         private_connection = gcp.datastream.PrivateConnection("private_connection",
-            display_name="Connection profile",
+            display_name="Private connection",
             location="us-central1",
             private_connection_id="my-connection",
-            labels={
-                "key": "value",
-            },
             vpc_peering_config={
                 "vpc": default.id,
                 "subnet": "10.0.0.0/29",
             })
+        nat_vm_ip = gcp.compute.Address("nat_vm_ip", name="nat-vm-ip")
         instance = gcp.sql.DatabaseInstance("instance",
             name="my-instance",
             database_version="POSTGRES_14",
@@ -653,23 +658,9 @@ class ConnectionProfile(pulumi.CustomResource):
             settings={
                 "tier": "db-f1-micro",
                 "ip_configuration": {
-                    "authorized_networks": [
-                        {
-                            "value": "34.71.242.81",
-                        },
-                        {
-                            "value": "34.72.28.29",
-                        },
-                        {
-                            "value": "34.67.6.157",
-                        },
-                        {
-                            "value": "34.67.234.134",
-                        },
-                        {
-                            "value": "34.72.239.218",
-                        },
-                    ],
+                    "authorized_networks": [{
+                        "value": nat_vm_ip.address,
+                    }],
                 },
             },
             deletion_protection=True)
@@ -683,15 +674,61 @@ class ConnectionProfile(pulumi.CustomResource):
             name="user",
             instance=instance.name,
             password=pwd.result)
+        nat_vm = gcp.compute.Instance("nat_vm",
+            name="nat-vm",
+            machine_type="e2-medium",
+            zone="us-central1-a",
+            desired_status="RUNNING",
+            boot_disk={
+                "initialize_params": {
+                    "image": "debian-cloud/debian-12",
+                },
+            },
+            network_interfaces=[{
+                "network": private_connection.vpc_peering_config.vpc,
+                "subnetwork": default_subnetwork.self_link,
+                "access_configs": [{
+                    "nat_ip": nat_vm_ip.address,
+                }],
+            }],
+            metadata_startup_script=instance.public_ip_address.apply(lambda public_ip_address: f\"\"\"#! /bin/bash
+        # See https://cloud.google.com/datastream/docs/private-connectivity#set-up-reverse-proxy
+        export DB_ADDR={public_ip_address}
+        export DB_PORT=5432
+        echo 1 > /proc/sys/net/ipv4/ip_forward
+        md_url_prefix="http://169.254.169.254/computeMetadata/v1/instance"
+        vm_nic_ip="$(curl -H "Metadata-Flavor: Google" ${{md_url_prefix}}/network-interfaces/0/ip)"
+        iptables -t nat -F
+        iptables -t nat -A PREROUTING \\
+             -p tcp --dport $DB_PORT \\
+             -j DNAT \\
+             --to-destination $DB_ADDR
+        iptables -t nat -A POSTROUTING \\
+             -p tcp --dport $DB_PORT \\
+             -j SNAT \\
+             --to-source $vm_nic_ip
+        iptables-save
+        \"\"\"))
+        rules = gcp.compute.Firewall("rules",
+            name="ingress-rule",
+            network=private_connection.vpc_peering_config.vpc,
+            description="Allow traffic into NAT VM",
+            direction="INGRESS",
+            allows=[{
+                "protocol": "tcp",
+                "ports": ["5432"],
+            }],
+            source_ranges=[private_connection.vpc_peering_config.subnet])
         default_connection_profile = gcp.datastream.ConnectionProfile("default",
             display_name="Connection profile",
             location="us-central1",
             connection_profile_id="my-profile",
             postgresql_profile={
-                "hostname": instance.public_ip_address,
+                "hostname": nat_vm.network_interfaces[0].network_ip,
                 "username": user.name,
                 "password": user.password,
                 "database": db.name,
+                "port": 5432,
             },
             private_connectivity={
                 "private_connection": private_connection.id,
@@ -923,18 +960,23 @@ class ConnectionProfile(pulumi.CustomResource):
         import pulumi_gcp as gcp
         import pulumi_random as random
 
-        default = gcp.compute.Network("default", name="my-network")
+        default = gcp.compute.Network("default",
+            name="my-network",
+            auto_create_subnetworks=False)
+        default_subnetwork = gcp.compute.Subnetwork("default",
+            name="my-subnetwork",
+            ip_cidr_range="10.1.0.0/16",
+            region="us-central1",
+            network=default.id)
         private_connection = gcp.datastream.PrivateConnection("private_connection",
-            display_name="Connection profile",
+            display_name="Private connection",
             location="us-central1",
             private_connection_id="my-connection",
-            labels={
-                "key": "value",
-            },
             vpc_peering_config={
                 "vpc": default.id,
                 "subnet": "10.0.0.0/29",
             })
+        nat_vm_ip = gcp.compute.Address("nat_vm_ip", name="nat-vm-ip")
         instance = gcp.sql.DatabaseInstance("instance",
             name="my-instance",
             database_version="POSTGRES_14",
@@ -942,23 +984,9 @@ class ConnectionProfile(pulumi.CustomResource):
             settings={
                 "tier": "db-f1-micro",
                 "ip_configuration": {
-                    "authorized_networks": [
-                        {
-                            "value": "34.71.242.81",
-                        },
-                        {
-                            "value": "34.72.28.29",
-                        },
-                        {
-                            "value": "34.67.6.157",
-                        },
-                        {
-                            "value": "34.67.234.134",
-                        },
-                        {
-                            "value": "34.72.239.218",
-                        },
-                    ],
+                    "authorized_networks": [{
+                        "value": nat_vm_ip.address,
+                    }],
                 },
             },
             deletion_protection=True)
@@ -972,15 +1000,61 @@ class ConnectionProfile(pulumi.CustomResource):
             name="user",
             instance=instance.name,
             password=pwd.result)
+        nat_vm = gcp.compute.Instance("nat_vm",
+            name="nat-vm",
+            machine_type="e2-medium",
+            zone="us-central1-a",
+            desired_status="RUNNING",
+            boot_disk={
+                "initialize_params": {
+                    "image": "debian-cloud/debian-12",
+                },
+            },
+            network_interfaces=[{
+                "network": private_connection.vpc_peering_config.vpc,
+                "subnetwork": default_subnetwork.self_link,
+                "access_configs": [{
+                    "nat_ip": nat_vm_ip.address,
+                }],
+            }],
+            metadata_startup_script=instance.public_ip_address.apply(lambda public_ip_address: f\"\"\"#! /bin/bash
+        # See https://cloud.google.com/datastream/docs/private-connectivity#set-up-reverse-proxy
+        export DB_ADDR={public_ip_address}
+        export DB_PORT=5432
+        echo 1 > /proc/sys/net/ipv4/ip_forward
+        md_url_prefix="http://169.254.169.254/computeMetadata/v1/instance"
+        vm_nic_ip="$(curl -H "Metadata-Flavor: Google" ${{md_url_prefix}}/network-interfaces/0/ip)"
+        iptables -t nat -F
+        iptables -t nat -A PREROUTING \\
+             -p tcp --dport $DB_PORT \\
+             -j DNAT \\
+             --to-destination $DB_ADDR
+        iptables -t nat -A POSTROUTING \\
+             -p tcp --dport $DB_PORT \\
+             -j SNAT \\
+             --to-source $vm_nic_ip
+        iptables-save
+        \"\"\"))
+        rules = gcp.compute.Firewall("rules",
+            name="ingress-rule",
+            network=private_connection.vpc_peering_config.vpc,
+            description="Allow traffic into NAT VM",
+            direction="INGRESS",
+            allows=[{
+                "protocol": "tcp",
+                "ports": ["5432"],
+            }],
+            source_ranges=[private_connection.vpc_peering_config.subnet])
         default_connection_profile = gcp.datastream.ConnectionProfile("default",
             display_name="Connection profile",
             location="us-central1",
             connection_profile_id="my-profile",
             postgresql_profile={
-                "hostname": instance.public_ip_address,
+                "hostname": nat_vm.network_interfaces[0].network_ip,
                 "username": user.name,
                 "password": user.password,
                 "database": db.name,
+                "port": 5432,
             },
             private_connectivity={
                 "private_connection": private_connection.id,

pulumi_gcp/discoveryengine/chat_engine.py

@@ -35,7 +35,7 @@ class ChatEngineArgs:
         :param pulumi.Input['ChatEngineChatEngineConfigArgs'] chat_engine_config: Configurations for a chat Engine.
                Structure is documented below.
         :param pulumi.Input[str] collection_id: The collection ID.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] data_store_ids: The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`. Adding or removing data stores will force recreation.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] data_store_ids: The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`.
         :param pulumi.Input[str] display_name: The display name of the engine. Should be human readable. UTF-8 encoded string with limit of 1024 characters.
         :param pulumi.Input[str] engine_id: The ID to use for chat engine.
         :param pulumi.Input[str] location: Location.
@@ -85,7 +85,7 @@ class ChatEngineArgs:
     @pulumi.getter(name="dataStoreIds")
     def data_store_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
         """
-        The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`. Adding or removing data stores will force recreation.
+        The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`.
         """
         return pulumi.get(self, "data_store_ids")
 
@@ -189,7 +189,7 @@ class _ChatEngineState:
         :param pulumi.Input[str] collection_id: The collection ID.
         :param pulumi.Input['ChatEngineCommonConfigArgs'] common_config: Common config spec that specifies the metadata of the engine.
         :param pulumi.Input[str] create_time: Timestamp the Engine was created at.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] data_store_ids: The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`. Adding or removing data stores will force recreation.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] data_store_ids: The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`.
         :param pulumi.Input[str] display_name: The display name of the engine. Should be human readable. UTF-8 encoded string with limit of 1024 characters.
         :param pulumi.Input[str] engine_id: The ID to use for chat engine.
         :param pulumi.Input[str] industry_vertical: The industry vertical that the chat engine registers. Vertical on Engine has to match vertical of the DataStore linked
@@ -294,7 +294,7 @@ class _ChatEngineState:
     @pulumi.getter(name="dataStoreIds")
     def data_store_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
         """
-        The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`. Adding or removing data stores will force recreation.
+        The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`.
         """
         return pulumi.get(self, "data_store_ids")
 
@@ -518,7 +518,7 @@ class ChatEngine(pulumi.CustomResource):
                Structure is documented below.
         :param pulumi.Input[str] collection_id: The collection ID.
         :param pulumi.Input[Union['ChatEngineCommonConfigArgs', 'ChatEngineCommonConfigArgsDict']] common_config: Common config spec that specifies the metadata of the engine.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] data_store_ids: The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`. Adding or removing data stores will force recreation.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] data_store_ids: The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`.
         :param pulumi.Input[str] display_name: The display name of the engine. Should be human readable. UTF-8 encoded string with limit of 1024 characters.
         :param pulumi.Input[str] engine_id: The ID to use for chat engine.
         :param pulumi.Input[str] industry_vertical: The industry vertical that the chat engine registers. Vertical on Engine has to match vertical of the DataStore linked
@@ -735,7 +735,7 @@ class ChatEngine(pulumi.CustomResource):
         :param pulumi.Input[str] collection_id: The collection ID.
         :param pulumi.Input[Union['ChatEngineCommonConfigArgs', 'ChatEngineCommonConfigArgsDict']] common_config: Common config spec that specifies the metadata of the engine.
         :param pulumi.Input[str] create_time: Timestamp the Engine was created at.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] data_store_ids: The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`. Adding or removing data stores will force recreation.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] data_store_ids: The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`.
         :param pulumi.Input[str] display_name: The display name of the engine. Should be human readable. UTF-8 encoded string with limit of 1024 characters.
         :param pulumi.Input[str] engine_id: The ID to use for chat engine.
         :param pulumi.Input[str] industry_vertical: The industry vertical that the chat engine registers. Vertical on Engine has to match vertical of the DataStore linked
@@ -812,7 +812,7 @@ class ChatEngine(pulumi.CustomResource):
     @pulumi.getter(name="dataStoreIds")
     def data_store_ids(self) -> pulumi.Output[Sequence[str]]:
         """
-        The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`. Adding or removing data stores will force recreation.
+        The data stores associated with this engine. Multiple DataStores in the same Collection can be associated here. All listed DataStores must be `SOLUTION_TYPE_CHAT`.
         """
         return pulumi.get(self, "data_store_ids")
 

pulumi_gcp/filestore/_inputs.py

@@ -15,10 +15,18 @@ else:
 from .. import _utilities
 
 __all__ = [
+    'InstanceEffectiveReplicationArgs',
+    'InstanceEffectiveReplicationArgsDict',
+    'InstanceEffectiveReplicationReplicaArgs',
+    'InstanceEffectiveReplicationReplicaArgsDict',
     'InstanceFileSharesArgs',
     'InstanceFileSharesArgsDict',
     'InstanceFileSharesNfsExportOptionArgs',
     'InstanceFileSharesNfsExportOptionArgsDict',
+    'InstanceInitialReplicationArgs',
+    'InstanceInitialReplicationArgsDict',
+    'InstanceInitialReplicationReplicaArgs',
+    'InstanceInitialReplicationReplicaArgsDict',
     'InstanceNetworkArgs',
     'InstanceNetworkArgsDict',
     'InstancePerformanceConfigArgs',
@@ -31,6 +39,128 @@ __all__ = [
 
 MYPY = False
 
+if not MYPY:
+    class InstanceEffectiveReplicationArgsDict(TypedDict):
+        replicas: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceEffectiveReplicationReplicaArgsDict']]]]
+        """
+        The replication role.
+        Structure is documented below.
+        """
+elif False:
+    InstanceEffectiveReplicationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceEffectiveReplicationArgs:
+    def __init__(__self__, *,
+                 replicas: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceEffectiveReplicationReplicaArgs']]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input['InstanceEffectiveReplicationReplicaArgs']]] replicas: The replication role.
+               Structure is documented below.
+        """
+        if replicas is not None:
+            pulumi.set(__self__, "replicas", replicas)
+
+    @property
+    @pulumi.getter
+    def replicas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceEffectiveReplicationReplicaArgs']]]]:
+        """
+        The replication role.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "replicas")
+
+    @replicas.setter
+    def replicas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceEffectiveReplicationReplicaArgs']]]]):
+        pulumi.set(self, "replicas", value)
+
+
+if not MYPY:
+    class InstanceEffectiveReplicationReplicaArgsDict(TypedDict):
+        last_active_sync_time: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        Output only. The timestamp of the latest replication snapshot taken on the active instance and is already replicated safely.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
+        Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z"
+        """
+        state: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        Output only. The replica state
+        """
+        state_reasons: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        (Output)
+        Output only. Additional information about the replication state, if available.
+        """
+elif False:
+    InstanceEffectiveReplicationReplicaArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceEffectiveReplicationReplicaArgs:
+    def __init__(__self__, *,
+                 last_active_sync_time: Optional[pulumi.Input[str]] = None,
+                 state: Optional[pulumi.Input[str]] = None,
+                 state_reasons: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[str] last_active_sync_time: (Output)
+               Output only. The timestamp of the latest replication snapshot taken on the active instance and is already replicated safely.
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
+               Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z"
+        :param pulumi.Input[str] state: (Output)
+               Output only. The replica state
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] state_reasons: (Output)
+               Output only. Additional information about the replication state, if available.
+        """
+        if last_active_sync_time is not None:
+            pulumi.set(__self__, "last_active_sync_time", last_active_sync_time)
+        if state is not None:
+            pulumi.set(__self__, "state", state)
+        if state_reasons is not None:
+            pulumi.set(__self__, "state_reasons", state_reasons)
+
+    @property
+    @pulumi.getter(name="lastActiveSyncTime")
+    def last_active_sync_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        Output only. The timestamp of the latest replication snapshot taken on the active instance and is already replicated safely.
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits.
+        Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z"
+        """
+        return pulumi.get(self, "last_active_sync_time")
+
+    @last_active_sync_time.setter
+    def last_active_sync_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "last_active_sync_time", value)
+
+    @property
+    @pulumi.getter
+    def state(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        Output only. The replica state
+        """
+        return pulumi.get(self, "state")
+
+    @state.setter
+    def state(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "state", value)
+
+    @property
+    @pulumi.getter(name="stateReasons")
+    def state_reasons(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        (Output)
+        Output only. Additional information about the replication state, if available.
+        """
+        return pulumi.get(self, "state_reasons")
+
+    @state_reasons.setter
+    def state_reasons(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "state_reasons", value)
+
+
 if not MYPY:
     class InstanceFileSharesArgsDict(TypedDict):
         capacity_gb: pulumi.Input[int]
@@ -281,6 +411,98 @@ class InstanceFileSharesNfsExportOptionArgs:
         pulumi.set(self, "squash_mode", value)
 
 
+if not MYPY:
+    class InstanceInitialReplicationArgsDict(TypedDict):
+        replicas: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceInitialReplicationReplicaArgsDict']]]]
+        """
+        The replication role.
+        Structure is documented below.
+        """
+        role: NotRequired[pulumi.Input[str]]
+        """
+        The replication role.
+        Default value is `STANDBY`.
+        Possible values are: `ROLE_UNSPECIFIED`, `ACTIVE`, `STANDBY`.
+        """
+elif False:
+    InstanceInitialReplicationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceInitialReplicationArgs:
+    def __init__(__self__, *,
+                 replicas: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInitialReplicationReplicaArgs']]]] = None,
+                 role: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input['InstanceInitialReplicationReplicaArgs']]] replicas: The replication role.
+               Structure is documented below.
+        :param pulumi.Input[str] role: The replication role.
+               Default value is `STANDBY`.
+               Possible values are: `ROLE_UNSPECIFIED`, `ACTIVE`, `STANDBY`.
+        """
+        if replicas is not None:
+            pulumi.set(__self__, "replicas", replicas)
+        if role is not None:
+            pulumi.set(__self__, "role", role)
+
+    @property
+    @pulumi.getter
+    def replicas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInitialReplicationReplicaArgs']]]]:
+        """
+        The replication role.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "replicas")
+
+    @replicas.setter
+    def replicas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInitialReplicationReplicaArgs']]]]):
+        pulumi.set(self, "replicas", value)
+
+    @property
+    @pulumi.getter
+    def role(self) -> Optional[pulumi.Input[str]]:
+        """
+        The replication role.
+        Default value is `STANDBY`.
+        Possible values are: `ROLE_UNSPECIFIED`, `ACTIVE`, `STANDBY`.
+        """
+        return pulumi.get(self, "role")
+
+    @role.setter
+    def role(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "role", value)
+
+
+if not MYPY:
+    class InstanceInitialReplicationReplicaArgsDict(TypedDict):
+        peer_instance: pulumi.Input[str]
+        """
+        The peer instance.
+        """
+elif False:
+    InstanceInitialReplicationReplicaArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceInitialReplicationReplicaArgs:
+    def __init__(__self__, *,
+                 peer_instance: pulumi.Input[str]):
+        """
+        :param pulumi.Input[str] peer_instance: The peer instance.
+        """
+        pulumi.set(__self__, "peer_instance", peer_instance)
+
+    @property
+    @pulumi.getter(name="peerInstance")
+    def peer_instance(self) -> pulumi.Input[str]:
+        """
+        The peer instance.
+        """
+        return pulumi.get(self, "peer_instance")
+
+    @peer_instance.setter
+    def peer_instance(self, value: pulumi.Input[str]):
+        pulumi.set(self, "peer_instance", value)
+
+
 if not MYPY:
     class InstanceNetworkArgsDict(TypedDict):
         modes: pulumi.Input[Sequence[pulumi.Input[str]]]

pulumi_gcp/filestore/get_instance.py

@@ -27,7 +27,7 @@ class GetInstanceResult:
     """
     A collection of values returned by getInstance.
     """
-    def __init__(__self__, create_time=None, deletion_protection_enabled=None, deletion_protection_reason=None, description=None, effective_labels=None, etag=None, file_shares=None, id=None, kms_key_name=None, labels=None, location=None, name=None, networks=None, performance_configs=None, project=None, protocol=None, pulumi_labels=None, tags=None, tier=None, zone=None):
+    def __init__(__self__, create_time=None, deletion_protection_enabled=None, deletion_protection_reason=None, description=None, effective_labels=None, effective_replications=None, etag=None, file_shares=None, id=None, initial_replications=None, kms_key_name=None, labels=None, location=None, name=None, networks=None, performance_configs=None, project=None, protocol=None, pulumi_labels=None, tags=None, tier=None, zone=None):
         if create_time and not isinstance(create_time, str):
             raise TypeError("Expected argument 'create_time' to be a str")
         pulumi.set(__self__, "create_time", create_time)
@@ -43,6 +43,9 @@ class GetInstanceResult:
         if effective_labels and not isinstance(effective_labels, dict):
             raise TypeError("Expected argument 'effective_labels' to be a dict")
         pulumi.set(__self__, "effective_labels", effective_labels)
+        if effective_replications and not isinstance(effective_replications, list):
+            raise TypeError("Expected argument 'effective_replications' to be a list")
+        pulumi.set(__self__, "effective_replications", effective_replications)
         if etag and not isinstance(etag, str):
             raise TypeError("Expected argument 'etag' to be a str")
         pulumi.set(__self__, "etag", etag)
@@ -52,6 +55,9 @@ class GetInstanceResult:
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
+        if initial_replications and not isinstance(initial_replications, list):
+            raise TypeError("Expected argument 'initial_replications' to be a list")
+        pulumi.set(__self__, "initial_replications", initial_replications)
         if kms_key_name and not isinstance(kms_key_name, str):
             raise TypeError("Expected argument 'kms_key_name' to be a str")
         pulumi.set(__self__, "kms_key_name", kms_key_name)
@@ -114,6 +120,11 @@ class GetInstanceResult:
     def effective_labels(self) -> Mapping[str, str]:
         return pulumi.get(self, "effective_labels")
 
+    @property
+    @pulumi.getter(name="effectiveReplications")
+    def effective_replications(self) -> Sequence['outputs.GetInstanceEffectiveReplicationResult']:
+        return pulumi.get(self, "effective_replications")
+
     @property
     @pulumi.getter
     def etag(self) -> str:
@@ -132,6 +143,11 @@ class GetInstanceResult:
         """
         return pulumi.get(self, "id")
 
+    @property
+    @pulumi.getter(name="initialReplications")
+    def initial_replications(self) -> Sequence['outputs.GetInstanceInitialReplicationResult']:
+        return pulumi.get(self, "initial_replications")
+
     @property
     @pulumi.getter(name="kmsKeyName")
     def kms_key_name(self) -> str:
@@ -204,9 +220,11 @@ class AwaitableGetInstanceResult(GetInstanceResult):
             deletion_protection_reason=self.deletion_protection_reason,
             description=self.description,
             effective_labels=self.effective_labels,
+            effective_replications=self.effective_replications,
             etag=self.etag,
             file_shares=self.file_shares,
             id=self.id,
+            initial_replications=self.initial_replications,
             kms_key_name=self.kms_key_name,
             labels=self.labels,
             location=self.location,
@@ -263,9 +281,11 @@ def get_instance(location: Optional[str] = None,
         deletion_protection_reason=pulumi.get(__ret__, 'deletion_protection_reason'),
         description=pulumi.get(__ret__, 'description'),
         effective_labels=pulumi.get(__ret__, 'effective_labels'),
+        effective_replications=pulumi.get(__ret__, 'effective_replications'),
         etag=pulumi.get(__ret__, 'etag'),
         file_shares=pulumi.get(__ret__, 'file_shares'),
         id=pulumi.get(__ret__, 'id'),
+        initial_replications=pulumi.get(__ret__, 'initial_replications'),
         kms_key_name=pulumi.get(__ret__, 'kms_key_name'),
         labels=pulumi.get(__ret__, 'labels'),
         location=pulumi.get(__ret__, 'location'),
@@ -319,9 +339,11 @@ def get_instance_output(location: Optional[pulumi.Input[Optional[str]]] = None,
         deletion_protection_reason=pulumi.get(__response__, 'deletion_protection_reason'),
         description=pulumi.get(__response__, 'description'),
         effective_labels=pulumi.get(__response__, 'effective_labels'),
+        effective_replications=pulumi.get(__response__, 'effective_replications'),
         etag=pulumi.get(__response__, 'etag'),
         file_shares=pulumi.get(__response__, 'file_shares'),
         id=pulumi.get(__response__, 'id'),
+        initial_replications=pulumi.get(__response__, 'initial_replications'),
         kms_key_name=pulumi.get(__response__, 'kms_key_name'),
         labels=pulumi.get(__response__, 'labels'),
         location=pulumi.get(__response__, 'location'),