pulumi-gcp 8.40.0a1754721948__py3-none-any.whl → 8.41.0__py3-none-any.whl

pulumi_gcp/networkconnectivity/_inputs.py

@@ -19,6 +19,8 @@ __all__ = [
     'GroupAutoAcceptArgsDict',
     'HubRoutingVpcArgs',
     'HubRoutingVpcArgsDict',
+    'InternalRangeAllocationOptionsArgs',
+    'InternalRangeAllocationOptionsArgsDict',
     'InternalRangeMigrationArgs',
     'InternalRangeMigrationArgsDict',
     'PolicyBasedRouteFilterArgs',
@@ -118,6 +120,64 @@ class HubRoutingVpcArgs:
         pulumi.set(self, "uri", value)
 
 
+if not MYPY:
+    class InternalRangeAllocationOptionsArgsDict(TypedDict):
+        allocation_strategy: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Optional. Sets the strategy used to automatically find a free range of a size given by prefixLength. Can be set only when trying to create a reservation that automatically finds the free range to reserve.
+        Possible values are: `RANDOM`, `FIRST_AVAILABLE`, `RANDOM_FIRST_N_AVAILABLE`, `FIRST_SMALLEST_FITTING`.
+        """
+        first_available_ranges_lookup_size: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Must be set when allocation_strategy is RANDOM_FIRST_N_AVAILABLE, otherwise must remain unset. Defines the size of the set of free ranges from which RANDOM_FIRST_N_AVAILABLE strategy randomy selects one,
+        in other words it sets the N in the RANDOM_FIRST_N_AVAILABLE.
+        """
+elif False:
+    InternalRangeAllocationOptionsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InternalRangeAllocationOptionsArgs:
+    def __init__(__self__, *,
+                 allocation_strategy: Optional[pulumi.Input[_builtins.str]] = None,
+                 first_available_ranges_lookup_size: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.str] allocation_strategy: Optional. Sets the strategy used to automatically find a free range of a size given by prefixLength. Can be set only when trying to create a reservation that automatically finds the free range to reserve.
+               Possible values are: `RANDOM`, `FIRST_AVAILABLE`, `RANDOM_FIRST_N_AVAILABLE`, `FIRST_SMALLEST_FITTING`.
+        :param pulumi.Input[_builtins.int] first_available_ranges_lookup_size: Must be set when allocation_strategy is RANDOM_FIRST_N_AVAILABLE, otherwise must remain unset. Defines the size of the set of free ranges from which RANDOM_FIRST_N_AVAILABLE strategy randomy selects one,
+               in other words it sets the N in the RANDOM_FIRST_N_AVAILABLE.
+        """
+        if allocation_strategy is not None:
+            pulumi.set(__self__, "allocation_strategy", allocation_strategy)
+        if first_available_ranges_lookup_size is not None:
+            pulumi.set(__self__, "first_available_ranges_lookup_size", first_available_ranges_lookup_size)
+
+    @_builtins.property
+    @pulumi.getter(name="allocationStrategy")
+    def allocation_strategy(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Optional. Sets the strategy used to automatically find a free range of a size given by prefixLength. Can be set only when trying to create a reservation that automatically finds the free range to reserve.
+        Possible values are: `RANDOM`, `FIRST_AVAILABLE`, `RANDOM_FIRST_N_AVAILABLE`, `FIRST_SMALLEST_FITTING`.
+        """
+        return pulumi.get(self, "allocation_strategy")
+
+    @allocation_strategy.setter
+    def allocation_strategy(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "allocation_strategy", value)
+
+    @_builtins.property
+    @pulumi.getter(name="firstAvailableRangesLookupSize")
+    def first_available_ranges_lookup_size(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Must be set when allocation_strategy is RANDOM_FIRST_N_AVAILABLE, otherwise must remain unset. Defines the size of the set of free ranges from which RANDOM_FIRST_N_AVAILABLE strategy randomy selects one,
+        in other words it sets the N in the RANDOM_FIRST_N_AVAILABLE.
+        """
+        return pulumi.get(self, "first_available_ranges_lookup_size")
+
+    @first_available_ranges_lookup_size.setter
+    def first_available_ranges_lookup_size(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "first_available_ranges_lookup_size", value)
+
+
 if not MYPY:
     class InternalRangeMigrationArgsDict(TypedDict):
         source: pulumi.Input[_builtins.str]

pulumi_gcp/networkconnectivity/internal_range.py

@@ -24,6 +24,7 @@ class InternalRangeArgs:
                  network: pulumi.Input[_builtins.str],
                  peering: pulumi.Input[_builtins.str],
                  usage: pulumi.Input[_builtins.str],
+                 allocation_options: Optional[pulumi.Input['InternalRangeAllocationOptionsArgs']] = None,
                  description: Optional[pulumi.Input[_builtins.str]] = None,
                  exclude_cidr_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  immutable: Optional[pulumi.Input[_builtins.bool]] = None,
@@ -42,6 +43,8 @@ class InternalRangeArgs:
                Possible values are: `FOR_SELF`, `FOR_PEER`, `NOT_SHARED`.
         :param pulumi.Input[_builtins.str] usage: The type of usage set for this InternalRange.
                Possible values are: `FOR_VPC`, `EXTERNAL_TO_VPC`, `FOR_MIGRATION`.
+        :param pulumi.Input['InternalRangeAllocationOptionsArgs'] allocation_options: Options for automatically allocating a free range with a size given by prefixLength.
+               Structure is documented below.
         :param pulumi.Input[_builtins.str] description: An optional description of this resource.
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_cidr_ranges: Optional. List of IP CIDR ranges to be excluded. Resulting reserved Internal Range will not overlap with any CIDR blocks mentioned in this list.
                Only IPv4 CIDR ranges are supported.
@@ -70,6 +73,8 @@ class InternalRangeArgs:
         pulumi.set(__self__, "network", network)
         pulumi.set(__self__, "peering", peering)
         pulumi.set(__self__, "usage", usage)
+        if allocation_options is not None:
+            pulumi.set(__self__, "allocation_options", allocation_options)
         if description is not None:
             pulumi.set(__self__, "description", description)
         if exclude_cidr_ranges is not None:
@@ -131,6 +136,19 @@ class InternalRangeArgs:
     def usage(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "usage", value)
 
+    @_builtins.property
+    @pulumi.getter(name="allocationOptions")
+    def allocation_options(self) -> Optional[pulumi.Input['InternalRangeAllocationOptionsArgs']]:
+        """
+        Options for automatically allocating a free range with a size given by prefixLength.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "allocation_options")
+
+    @allocation_options.setter
+    def allocation_options(self, value: Optional[pulumi.Input['InternalRangeAllocationOptionsArgs']]):
+        pulumi.set(self, "allocation_options", value)
+
     @_builtins.property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -280,6 +298,7 @@ class InternalRangeArgs:
 @pulumi.input_type
 class _InternalRangeState:
     def __init__(__self__, *,
+                 allocation_options: Optional[pulumi.Input['InternalRangeAllocationOptionsArgs']] = None,
                  description: Optional[pulumi.Input[_builtins.str]] = None,
                  effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                  exclude_cidr_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
@@ -299,6 +318,8 @@ class _InternalRangeState:
                  users: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
         """
         Input properties used for looking up and filtering InternalRange resources.
+        :param pulumi.Input['InternalRangeAllocationOptionsArgs'] allocation_options: Options for automatically allocating a free range with a size given by prefixLength.
+               Structure is documented below.
         :param pulumi.Input[_builtins.str] description: An optional description of this resource.
         :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] effective_labels: All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_cidr_ranges: Optional. List of IP CIDR ranges to be excluded. Resulting reserved Internal Range will not overlap with any CIDR blocks mentioned in this list.
@@ -335,6 +356,8 @@ class _InternalRangeState:
                Resources that use the internal range for their range allocation are referred to as users of the range.
                Other resources mark themselves as users while doing so by creating a reference to this internal range. Having a user, based on this reference, prevents deletion of the internal range referred to. Can be empty.
         """
+        if allocation_options is not None:
+            pulumi.set(__self__, "allocation_options", allocation_options)
         if description is not None:
             pulumi.set(__self__, "description", description)
         if effective_labels is not None:
@@ -370,6 +393,19 @@ class _InternalRangeState:
         if users is not None:
             pulumi.set(__self__, "users", users)
 
+    @_builtins.property
+    @pulumi.getter(name="allocationOptions")
+    def allocation_options(self) -> Optional[pulumi.Input['InternalRangeAllocationOptionsArgs']]:
+        """
+        Options for automatically allocating a free range with a size given by prefixLength.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "allocation_options")
+
+    @allocation_options.setter
+    def allocation_options(self, value: Optional[pulumi.Input['InternalRangeAllocationOptionsArgs']]):
+        pulumi.set(self, "allocation_options", value)
+
     @_builtins.property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -599,6 +635,7 @@ class InternalRange(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 allocation_options: Optional[pulumi.Input[Union['InternalRangeAllocationOptionsArgs', 'InternalRangeAllocationOptionsArgsDict']]] = None,
                  description: Optional[pulumi.Input[_builtins.str]] = None,
                  exclude_cidr_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  immutable: Optional[pulumi.Input[_builtins.bool]] = None,
@@ -732,6 +769,47 @@ class InternalRange(pulumi.CustomResource):
                 "target": f"projects/{target_project.project_id}/regions/us-central1/subnetworks/target-subnet",
             })
         ```
+        ### Network Connectivity Internal Ranges Allocation Algoritms
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default_network = gcp.compute.Network("default",
+            name="internal-ranges",
+            auto_create_subnetworks=False)
+        default = gcp.networkconnectivity.InternalRange("default",
+            name="allocation-algorithms",
+            network=default_network.id,
+            usage="FOR_VPC",
+            peering="FOR_SELF",
+            prefix_length=24,
+            target_cidr_ranges=["192.16.0.0/16"],
+            allocation_options={
+                "allocation_strategy": "FIRST_SMALLEST_FITTING",
+            })
+        ```
+        ### Network Connectivity Internal Ranges Allocation Algoritms Random First N
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default_network = gcp.compute.Network("default",
+            name="internal-ranges",
+            auto_create_subnetworks=False)
+        default = gcp.networkconnectivity.InternalRange("default",
+            name="allocation-algorithms-random-first-n",
+            network=default_network.id,
+            usage="FOR_VPC",
+            peering="FOR_SELF",
+            prefix_length=24,
+            target_cidr_ranges=["192.16.0.0/16"],
+            allocation_options={
+                "allocation_strategy": "RANDOM_FIRST_N_AVAILABLE",
+                "first_available_ranges_lookup_size": 20,
+            })
+        ```
 
         ## Import
 
@@ -759,6 +837,8 @@ class InternalRange(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[Union['InternalRangeAllocationOptionsArgs', 'InternalRangeAllocationOptionsArgsDict']] allocation_options: Options for automatically allocating a free range with a size given by prefixLength.
+               Structure is documented below.
         :param pulumi.Input[_builtins.str] description: An optional description of this resource.
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_cidr_ranges: Optional. List of IP CIDR ranges to be excluded. Resulting reserved Internal Range will not overlap with any CIDR blocks mentioned in this list.
                Only IPv4 CIDR ranges are supported.
@@ -913,6 +993,47 @@ class InternalRange(pulumi.CustomResource):
                 "target": f"projects/{target_project.project_id}/regions/us-central1/subnetworks/target-subnet",
             })
         ```
+        ### Network Connectivity Internal Ranges Allocation Algoritms
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default_network = gcp.compute.Network("default",
+            name="internal-ranges",
+            auto_create_subnetworks=False)
+        default = gcp.networkconnectivity.InternalRange("default",
+            name="allocation-algorithms",
+            network=default_network.id,
+            usage="FOR_VPC",
+            peering="FOR_SELF",
+            prefix_length=24,
+            target_cidr_ranges=["192.16.0.0/16"],
+            allocation_options={
+                "allocation_strategy": "FIRST_SMALLEST_FITTING",
+            })
+        ```
+        ### Network Connectivity Internal Ranges Allocation Algoritms Random First N
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default_network = gcp.compute.Network("default",
+            name="internal-ranges",
+            auto_create_subnetworks=False)
+        default = gcp.networkconnectivity.InternalRange("default",
+            name="allocation-algorithms-random-first-n",
+            network=default_network.id,
+            usage="FOR_VPC",
+            peering="FOR_SELF",
+            prefix_length=24,
+            target_cidr_ranges=["192.16.0.0/16"],
+            allocation_options={
+                "allocation_strategy": "RANDOM_FIRST_N_AVAILABLE",
+                "first_available_ranges_lookup_size": 20,
+            })
+        ```
 
         ## Import
 
@@ -953,6 +1074,7 @@ class InternalRange(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 allocation_options: Optional[pulumi.Input[Union['InternalRangeAllocationOptionsArgs', 'InternalRangeAllocationOptionsArgsDict']]] = None,
                  description: Optional[pulumi.Input[_builtins.str]] = None,
                  exclude_cidr_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  immutable: Optional[pulumi.Input[_builtins.bool]] = None,
@@ -976,6 +1098,7 @@ class InternalRange(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = InternalRangeArgs.__new__(InternalRangeArgs)
 
+            __props__.__dict__["allocation_options"] = allocation_options
             __props__.__dict__["description"] = description
             __props__.__dict__["exclude_cidr_ranges"] = exclude_cidr_ranges
             __props__.__dict__["immutable"] = immutable
@@ -1011,6 +1134,7 @@ class InternalRange(pulumi.CustomResource):
     def get(resource_name: str,
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
+            allocation_options: Optional[pulumi.Input[Union['InternalRangeAllocationOptionsArgs', 'InternalRangeAllocationOptionsArgsDict']]] = None,
             description: Optional[pulumi.Input[_builtins.str]] = None,
             effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
             exclude_cidr_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
@@ -1035,6 +1159,8 @@ class InternalRange(pulumi.CustomResource):
         :param str resource_name: The unique name of the resulting resource.
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[Union['InternalRangeAllocationOptionsArgs', 'InternalRangeAllocationOptionsArgsDict']] allocation_options: Options for automatically allocating a free range with a size given by prefixLength.
+               Structure is documented below.
         :param pulumi.Input[_builtins.str] description: An optional description of this resource.
         :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] effective_labels: All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_cidr_ranges: Optional. List of IP CIDR ranges to be excluded. Resulting reserved Internal Range will not overlap with any CIDR blocks mentioned in this list.
@@ -1075,6 +1201,7 @@ class InternalRange(pulumi.CustomResource):
 
         __props__ = _InternalRangeState.__new__(_InternalRangeState)
 
+        __props__.__dict__["allocation_options"] = allocation_options
         __props__.__dict__["description"] = description
         __props__.__dict__["effective_labels"] = effective_labels
         __props__.__dict__["exclude_cidr_ranges"] = exclude_cidr_ranges
@@ -1094,6 +1221,15 @@ class InternalRange(pulumi.CustomResource):
         __props__.__dict__["users"] = users
         return InternalRange(resource_name, opts=opts, __props__=__props__)
 
+    @_builtins.property
+    @pulumi.getter(name="allocationOptions")
+    def allocation_options(self) -> pulumi.Output[Optional['outputs.InternalRangeAllocationOptions']]:
+        """
+        Options for automatically allocating a free range with a size given by prefixLength.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "allocation_options")
+
     @_builtins.property
     @pulumi.getter
     def description(self) -> pulumi.Output[Optional[_builtins.str]]:

pulumi_gcp/networkconnectivity/outputs.py

@@ -18,6 +18,7 @@ from . import outputs
 __all__ = [
     'GroupAutoAccept',
     'HubRoutingVpc',
+    'InternalRangeAllocationOptions',
     'InternalRangeMigration',
     'PolicyBasedRouteFilter',
     'PolicyBasedRouteInterconnectAttachment',
@@ -90,6 +91,60 @@ class HubRoutingVpc(dict):
         return pulumi.get(self, "uri")
 
 
+@pulumi.output_type
+class InternalRangeAllocationOptions(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "allocationStrategy":
+            suggest = "allocation_strategy"
+        elif key == "firstAvailableRangesLookupSize":
+            suggest = "first_available_ranges_lookup_size"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InternalRangeAllocationOptions. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InternalRangeAllocationOptions.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InternalRangeAllocationOptions.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 allocation_strategy: Optional[_builtins.str] = None,
+                 first_available_ranges_lookup_size: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str allocation_strategy: Optional. Sets the strategy used to automatically find a free range of a size given by prefixLength. Can be set only when trying to create a reservation that automatically finds the free range to reserve.
+               Possible values are: `RANDOM`, `FIRST_AVAILABLE`, `RANDOM_FIRST_N_AVAILABLE`, `FIRST_SMALLEST_FITTING`.
+        :param _builtins.int first_available_ranges_lookup_size: Must be set when allocation_strategy is RANDOM_FIRST_N_AVAILABLE, otherwise must remain unset. Defines the size of the set of free ranges from which RANDOM_FIRST_N_AVAILABLE strategy randomy selects one,
+               in other words it sets the N in the RANDOM_FIRST_N_AVAILABLE.
+        """
+        if allocation_strategy is not None:
+            pulumi.set(__self__, "allocation_strategy", allocation_strategy)
+        if first_available_ranges_lookup_size is not None:
+            pulumi.set(__self__, "first_available_ranges_lookup_size", first_available_ranges_lookup_size)
+
+    @_builtins.property
+    @pulumi.getter(name="allocationStrategy")
+    def allocation_strategy(self) -> Optional[_builtins.str]:
+        """
+        Optional. Sets the strategy used to automatically find a free range of a size given by prefixLength. Can be set only when trying to create a reservation that automatically finds the free range to reserve.
+        Possible values are: `RANDOM`, `FIRST_AVAILABLE`, `RANDOM_FIRST_N_AVAILABLE`, `FIRST_SMALLEST_FITTING`.
+        """
+        return pulumi.get(self, "allocation_strategy")
+
+    @_builtins.property
+    @pulumi.getter(name="firstAvailableRangesLookupSize")
+    def first_available_ranges_lookup_size(self) -> Optional[_builtins.int]:
+        """
+        Must be set when allocation_strategy is RANDOM_FIRST_N_AVAILABLE, otherwise must remain unset. Defines the size of the set of free ranges from which RANDOM_FIRST_N_AVAILABLE strategy randomy selects one,
+        in other words it sets the N in the RANDOM_FIRST_N_AVAILABLE.
+        """
+        return pulumi.get(self, "first_available_ranges_lookup_size")
+
+
 @pulumi.output_type
 class InternalRangeMigration(dict):
     def __init__(__self__, *,

pulumi_gcp/networkconnectivity/spoke.py

@@ -676,15 +676,15 @@ class Spoke(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         network = gcp.compute.Network("network",
-            name="tf-test-network_60365",
+            name="tf-test-network_59033",
             auto_create_subnetworks=False)
         subnetwork = gcp.compute.Subnetwork("subnetwork",
-            name="tf-test-subnet_80215",
+            name="tf-test-subnet_32081",
             ip_cidr_range="10.0.0.0/28",
             region="us-central1",
             network=network.self_link)
         instance = gcp.compute.Instance("instance",
-            name="tf-test-instance_59033",
+            name="tf-test-instance_10393",
             machine_type="e2-medium",
             can_ip_forward=True,
             zone="us-central1-a",
@@ -701,13 +701,13 @@ class Spoke(pulumi.CustomResource):
                 }],
             }])
         basic_hub = gcp.networkconnectivity.Hub("basic_hub",
-            name="tf-test-hub_32081",
+            name="tf-test-hub_33052",
             description="A sample hub",
             labels={
                 "label-two": "value-one",
             })
         primary = gcp.networkconnectivity.Spoke("primary",
-            name="tf-test-name_10393",
+            name="tf-test-name_3684",
             location="us-central1",
             description="A sample spoke with a linked routher appliance instance",
             labels={
@@ -939,8 +939,8 @@ class Spoke(pulumi.CustomResource):
             hub=star_hub.id,
             auto_accept={
                 "auto_accept_projects": [
-                    "foo_33052",
-                    "bar_3684",
+                    "foo_10719",
+                    "bar_1443",
                 ],
             })
         primary = gcp.networkconnectivity.Spoke("primary",
@@ -1134,15 +1134,15 @@ class Spoke(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         network = gcp.compute.Network("network",
-            name="tf-test-network_60365",
+            name="tf-test-network_59033",
             auto_create_subnetworks=False)
         subnetwork = gcp.compute.Subnetwork("subnetwork",
-            name="tf-test-subnet_80215",
+            name="tf-test-subnet_32081",
             ip_cidr_range="10.0.0.0/28",
             region="us-central1",
             network=network.self_link)
         instance = gcp.compute.Instance("instance",
-            name="tf-test-instance_59033",
+            name="tf-test-instance_10393",
             machine_type="e2-medium",
             can_ip_forward=True,
             zone="us-central1-a",
@@ -1159,13 +1159,13 @@ class Spoke(pulumi.CustomResource):
                 }],
             }])
         basic_hub = gcp.networkconnectivity.Hub("basic_hub",
-            name="tf-test-hub_32081",
+            name="tf-test-hub_33052",
             description="A sample hub",
             labels={
                 "label-two": "value-one",
             })
         primary = gcp.networkconnectivity.Spoke("primary",
-            name="tf-test-name_10393",
+            name="tf-test-name_3684",
             location="us-central1",
             description="A sample spoke with a linked routher appliance instance",
             labels={
@@ -1397,8 +1397,8 @@ class Spoke(pulumi.CustomResource):
             hub=star_hub.id,
             auto_accept={
                 "auto_accept_projects": [
-                    "foo_33052",
-                    "bar_3684",
+                    "foo_10719",
+                    "bar_1443",
                 ],
             })
         primary = gcp.networkconnectivity.Spoke("primary",