pulumi-gcp 8.32.0__py3-none-any.whl → 8.32.0a1747459264__py3-none-any.whl

pulumi_gcp/compute/get_backend_service.py

@@ -28,7 +28,7 @@ class GetBackendServiceResult:
     """
     A collection of values returned by getBackendService.
     """
-    def __init__(__self__, affinity_cookie_ttl_sec=None, backends=None, cdn_policies=None, circuit_breakers=None, compression_mode=None, connection_draining_timeout_sec=None, consistent_hash=None, creation_timestamp=None, custom_metrics=None, custom_request_headers=None, custom_response_headers=None, description=None, edge_security_policy=None, enable_cdn=None, external_managed_migration_state=None, external_managed_migration_testing_percentage=None, fingerprint=None, generated_id=None, health_checks=None, iaps=None, id=None, ip_address_selection_policy=None, load_balancing_scheme=None, locality_lb_policies=None, locality_lb_policy=None, log_configs=None, max_stream_durations=None, name=None, outlier_detections=None, port_name=None, project=None, protocol=None, security_policy=None, security_settings=None, self_link=None, service_lb_policy=None, session_affinity=None, strong_session_affinity_cookies=None, timeout_sec=None, tls_settings=None):
+    def __init__(__self__, affinity_cookie_ttl_sec=None, backends=None, cdn_policies=None, circuit_breakers=None, compression_mode=None, connection_draining_timeout_sec=None, consistent_hash=None, creation_timestamp=None, custom_metrics=None, custom_request_headers=None, custom_response_headers=None, description=None, edge_security_policy=None, enable_cdn=None, fingerprint=None, generated_id=None, health_checks=None, iaps=None, id=None, ip_address_selection_policy=None, load_balancing_scheme=None, locality_lb_policies=None, locality_lb_policy=None, log_configs=None, max_stream_durations=None, name=None, outlier_detections=None, port_name=None, project=None, protocol=None, security_policy=None, security_settings=None, self_link=None, service_lb_policy=None, session_affinity=None, strong_session_affinity_cookies=None, timeout_sec=None, tls_settings=None):
         if affinity_cookie_ttl_sec and not isinstance(affinity_cookie_ttl_sec, int):
             raise TypeError("Expected argument 'affinity_cookie_ttl_sec' to be a int")
         pulumi.set(__self__, "affinity_cookie_ttl_sec", affinity_cookie_ttl_sec)
@@ -71,12 +71,6 @@ class GetBackendServiceResult:
         if enable_cdn and not isinstance(enable_cdn, bool):
             raise TypeError("Expected argument 'enable_cdn' to be a bool")
         pulumi.set(__self__, "enable_cdn", enable_cdn)
-        if external_managed_migration_state and not isinstance(external_managed_migration_state, str):
-            raise TypeError("Expected argument 'external_managed_migration_state' to be a str")
-        pulumi.set(__self__, "external_managed_migration_state", external_managed_migration_state)
-        if external_managed_migration_testing_percentage and not isinstance(external_managed_migration_testing_percentage, float):
-            raise TypeError("Expected argument 'external_managed_migration_testing_percentage' to be a float")
-        pulumi.set(__self__, "external_managed_migration_testing_percentage", external_managed_migration_testing_percentage)
         if fingerprint and not isinstance(fingerprint, str):
             raise TypeError("Expected argument 'fingerprint' to be a str")
         pulumi.set(__self__, "fingerprint", fingerprint)
@@ -232,16 +226,6 @@ class GetBackendServiceResult:
         """
         return pulumi.get(self, "enable_cdn")
 
-    @property
-    @pulumi.getter(name="externalManagedMigrationState")
-    def external_managed_migration_state(self) -> builtins.str:
-        return pulumi.get(self, "external_managed_migration_state")
-
-    @property
-    @pulumi.getter(name="externalManagedMigrationTestingPercentage")
-    def external_managed_migration_testing_percentage(self) -> builtins.float:
-        return pulumi.get(self, "external_managed_migration_testing_percentage")
-
     @property
     @pulumi.getter
     def fingerprint(self) -> builtins.str:
@@ -410,8 +394,6 @@ class AwaitableGetBackendServiceResult(GetBackendServiceResult):
             description=self.description,
             edge_security_policy=self.edge_security_policy,
             enable_cdn=self.enable_cdn,
-            external_managed_migration_state=self.external_managed_migration_state,
-            external_managed_migration_testing_percentage=self.external_managed_migration_testing_percentage,
             fingerprint=self.fingerprint,
             generated_id=self.generated_id,
             health_checks=self.health_checks,
@@ -485,8 +467,6 @@ def get_backend_service(name: Optional[builtins.str] = None,
         description=pulumi.get(__ret__, 'description'),
         edge_security_policy=pulumi.get(__ret__, 'edge_security_policy'),
         enable_cdn=pulumi.get(__ret__, 'enable_cdn'),
-        external_managed_migration_state=pulumi.get(__ret__, 'external_managed_migration_state'),
-        external_managed_migration_testing_percentage=pulumi.get(__ret__, 'external_managed_migration_testing_percentage'),
         fingerprint=pulumi.get(__ret__, 'fingerprint'),
         generated_id=pulumi.get(__ret__, 'generated_id'),
         health_checks=pulumi.get(__ret__, 'health_checks'),
@@ -557,8 +537,6 @@ def get_backend_service_output(name: Optional[pulumi.Input[builtins.str]] = None
         description=pulumi.get(__response__, 'description'),
         edge_security_policy=pulumi.get(__response__, 'edge_security_policy'),
         enable_cdn=pulumi.get(__response__, 'enable_cdn'),
-        external_managed_migration_state=pulumi.get(__response__, 'external_managed_migration_state'),
-        external_managed_migration_testing_percentage=pulumi.get(__response__, 'external_managed_migration_testing_percentage'),
         fingerprint=pulumi.get(__response__, 'fingerprint'),
         generated_id=pulumi.get(__response__, 'generated_id'),
         health_checks=pulumi.get(__response__, 'health_checks'),

pulumi_gcp/compute/get_global_forwarding_rule.py

@@ -28,7 +28,7 @@ class GetGlobalForwardingRuleResult:
     """
     A collection of values returned by getGlobalForwardingRule.
     """
-    def __init__(__self__, allow_psc_global_access=None, base_forwarding_rule=None, description=None, effective_labels=None, external_managed_backend_bucket_migration_state=None, external_managed_backend_bucket_migration_testing_percentage=None, forwarding_rule_id=None, id=None, ip_address=None, ip_protocol=None, ip_version=None, label_fingerprint=None, labels=None, load_balancing_scheme=None, metadata_filters=None, name=None, network=None, network_tier=None, no_automate_dns_zone=None, port_range=None, project=None, psc_connection_id=None, psc_connection_status=None, pulumi_labels=None, self_link=None, service_directory_registrations=None, source_ip_ranges=None, subnetwork=None, target=None):
+    def __init__(__self__, allow_psc_global_access=None, base_forwarding_rule=None, description=None, effective_labels=None, forwarding_rule_id=None, id=None, ip_address=None, ip_protocol=None, ip_version=None, label_fingerprint=None, labels=None, load_balancing_scheme=None, metadata_filters=None, name=None, network=None, network_tier=None, no_automate_dns_zone=None, port_range=None, project=None, psc_connection_id=None, psc_connection_status=None, pulumi_labels=None, self_link=None, service_directory_registrations=None, source_ip_ranges=None, subnetwork=None, target=None):
         if allow_psc_global_access and not isinstance(allow_psc_global_access, bool):
             raise TypeError("Expected argument 'allow_psc_global_access' to be a bool")
         pulumi.set(__self__, "allow_psc_global_access", allow_psc_global_access)
@@ -41,12 +41,6 @@ class GetGlobalForwardingRuleResult:
         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 external_managed_backend_bucket_migration_state and not isinstance(external_managed_backend_bucket_migration_state, str):
-            raise TypeError("Expected argument 'external_managed_backend_bucket_migration_state' to be a str")
-        pulumi.set(__self__, "external_managed_backend_bucket_migration_state", external_managed_backend_bucket_migration_state)
-        if external_managed_backend_bucket_migration_testing_percentage and not isinstance(external_managed_backend_bucket_migration_testing_percentage, float):
-            raise TypeError("Expected argument 'external_managed_backend_bucket_migration_testing_percentage' to be a float")
-        pulumi.set(__self__, "external_managed_backend_bucket_migration_testing_percentage", external_managed_backend_bucket_migration_testing_percentage)
         if forwarding_rule_id and not isinstance(forwarding_rule_id, int):
             raise TypeError("Expected argument 'forwarding_rule_id' to be a int")
         pulumi.set(__self__, "forwarding_rule_id", forwarding_rule_id)
@@ -137,16 +131,6 @@ class GetGlobalForwardingRuleResult:
     def effective_labels(self) -> Mapping[str, builtins.str]:
         return pulumi.get(self, "effective_labels")
 
-    @property
-    @pulumi.getter(name="externalManagedBackendBucketMigrationState")
-    def external_managed_backend_bucket_migration_state(self) -> builtins.str:
-        return pulumi.get(self, "external_managed_backend_bucket_migration_state")
-
-    @property
-    @pulumi.getter(name="externalManagedBackendBucketMigrationTestingPercentage")
-    def external_managed_backend_bucket_migration_testing_percentage(self) -> builtins.float:
-        return pulumi.get(self, "external_managed_backend_bucket_migration_testing_percentage")
-
     @property
     @pulumi.getter(name="forwardingRuleId")
     def forwarding_rule_id(self) -> builtins.int:
@@ -276,8 +260,6 @@ class AwaitableGetGlobalForwardingRuleResult(GetGlobalForwardingRuleResult):
             base_forwarding_rule=self.base_forwarding_rule,
             description=self.description,
             effective_labels=self.effective_labels,
-            external_managed_backend_bucket_migration_state=self.external_managed_backend_bucket_migration_state,
-            external_managed_backend_bucket_migration_testing_percentage=self.external_managed_backend_bucket_migration_testing_percentage,
             forwarding_rule_id=self.forwarding_rule_id,
             id=self.id,
             ip_address=self.ip_address,
@@ -336,8 +318,6 @@ def get_global_forwarding_rule(name: Optional[builtins.str] = None,
         base_forwarding_rule=pulumi.get(__ret__, 'base_forwarding_rule'),
         description=pulumi.get(__ret__, 'description'),
         effective_labels=pulumi.get(__ret__, 'effective_labels'),
-        external_managed_backend_bucket_migration_state=pulumi.get(__ret__, 'external_managed_backend_bucket_migration_state'),
-        external_managed_backend_bucket_migration_testing_percentage=pulumi.get(__ret__, 'external_managed_backend_bucket_migration_testing_percentage'),
         forwarding_rule_id=pulumi.get(__ret__, 'forwarding_rule_id'),
         id=pulumi.get(__ret__, 'id'),
         ip_address=pulumi.get(__ret__, 'ip_address'),
@@ -393,8 +373,6 @@ def get_global_forwarding_rule_output(name: Optional[pulumi.Input[builtins.str]]
         base_forwarding_rule=pulumi.get(__response__, 'base_forwarding_rule'),
         description=pulumi.get(__response__, 'description'),
         effective_labels=pulumi.get(__response__, 'effective_labels'),
-        external_managed_backend_bucket_migration_state=pulumi.get(__response__, 'external_managed_backend_bucket_migration_state'),
-        external_managed_backend_bucket_migration_testing_percentage=pulumi.get(__response__, 'external_managed_backend_bucket_migration_testing_percentage'),
         forwarding_rule_id=pulumi.get(__response__, 'forwarding_rule_id'),
         id=pulumi.get(__response__, 'id'),
         ip_address=pulumi.get(__response__, 'ip_address'),

pulumi_gcp/compute/get_instance_template.py

@@ -28,7 +28,7 @@ class GetInstanceTemplateResult:
     """
     A collection of values returned by getInstanceTemplate.
     """
-    def __init__(__self__, advanced_machine_features=None, can_ip_forward=None, confidential_instance_configs=None, creation_timestamp=None, description=None, disks=None, effective_labels=None, enable_display=None, filter=None, guest_accelerators=None, id=None, instance_description=None, key_revocation_action_type=None, labels=None, machine_type=None, metadata=None, metadata_fingerprint=None, metadata_startup_script=None, min_cpu_platform=None, most_recent=None, name=None, name_prefix=None, network_interfaces=None, network_performance_configs=None, numeric_id=None, partner_metadata=None, project=None, pulumi_labels=None, region=None, reservation_affinities=None, resource_manager_tags=None, resource_policies=None, schedulings=None, self_link=None, self_link_unique=None, service_accounts=None, shielded_instance_configs=None, tags=None, tags_fingerprint=None):
+    def __init__(__self__, advanced_machine_features=None, can_ip_forward=None, confidential_instance_configs=None, creation_timestamp=None, description=None, disks=None, effective_labels=None, enable_display=None, filter=None, guest_accelerators=None, id=None, instance_description=None, key_revocation_action_type=None, labels=None, machine_type=None, metadata=None, metadata_fingerprint=None, metadata_startup_script=None, min_cpu_platform=None, most_recent=None, name=None, name_prefix=None, network_interfaces=None, network_performance_configs=None, partner_metadata=None, project=None, pulumi_labels=None, region=None, reservation_affinities=None, resource_manager_tags=None, resource_policies=None, schedulings=None, self_link=None, self_link_unique=None, service_accounts=None, shielded_instance_configs=None, tags=None, tags_fingerprint=None):
         if advanced_machine_features and not isinstance(advanced_machine_features, list):
             raise TypeError("Expected argument 'advanced_machine_features' to be a list")
         pulumi.set(__self__, "advanced_machine_features", advanced_machine_features)
@@ -101,9 +101,6 @@ class GetInstanceTemplateResult:
         if network_performance_configs and not isinstance(network_performance_configs, list):
             raise TypeError("Expected argument 'network_performance_configs' to be a list")
         pulumi.set(__self__, "network_performance_configs", network_performance_configs)
-        if numeric_id and not isinstance(numeric_id, str):
-            raise TypeError("Expected argument 'numeric_id' to be a str")
-        pulumi.set(__self__, "numeric_id", numeric_id)
         if partner_metadata and not isinstance(partner_metadata, dict):
             raise TypeError("Expected argument 'partner_metadata' to be a dict")
         pulumi.set(__self__, "partner_metadata", partner_metadata)
@@ -341,11 +338,6 @@ class GetInstanceTemplateResult:
         """
         return pulumi.get(self, "network_performance_configs")
 
-    @property
-    @pulumi.getter(name="numericId")
-    def numeric_id(self) -> builtins.str:
-        return pulumi.get(self, "numeric_id")
-
     @property
     @pulumi.getter(name="partnerMetadata")
     def partner_metadata(self) -> Mapping[str, builtins.str]:
@@ -486,7 +478,6 @@ class AwaitableGetInstanceTemplateResult(GetInstanceTemplateResult):
             name_prefix=self.name_prefix,
             network_interfaces=self.network_interfaces,
             network_performance_configs=self.network_performance_configs,
-            numeric_id=self.numeric_id,
             partner_metadata=self.partner_metadata,
             project=self.project,
             pulumi_labels=self.pulumi_labels,
@@ -562,7 +553,6 @@ def get_instance_template(filter: Optional[builtins.str] = None,
         name_prefix=pulumi.get(__ret__, 'name_prefix'),
         network_interfaces=pulumi.get(__ret__, 'network_interfaces'),
         network_performance_configs=pulumi.get(__ret__, 'network_performance_configs'),
-        numeric_id=pulumi.get(__ret__, 'numeric_id'),
         partner_metadata=pulumi.get(__ret__, 'partner_metadata'),
         project=pulumi.get(__ret__, 'project'),
         pulumi_labels=pulumi.get(__ret__, 'pulumi_labels'),
@@ -635,7 +625,6 @@ def get_instance_template_output(filter: Optional[pulumi.Input[Optional[builtins
         name_prefix=pulumi.get(__response__, 'name_prefix'),
         network_interfaces=pulumi.get(__response__, 'network_interfaces'),
         network_performance_configs=pulumi.get(__response__, 'network_performance_configs'),
-        numeric_id=pulumi.get(__response__, 'numeric_id'),
         partner_metadata=pulumi.get(__response__, 'partner_metadata'),
         project=pulumi.get(__response__, 'project'),
         pulumi_labels=pulumi.get(__response__, 'pulumi_labels'),

pulumi_gcp/compute/get_network_endpoint_group.py

@@ -27,16 +27,13 @@ class GetNetworkEndpointGroupResult:
     """
     A collection of values returned by getNetworkEndpointGroup.
     """
-    def __init__(__self__, default_port=None, description=None, generated_id=None, id=None, name=None, network=None, network_endpoint_type=None, project=None, self_link=None, size=None, subnetwork=None, zone=None):
+    def __init__(__self__, default_port=None, description=None, id=None, name=None, network=None, network_endpoint_type=None, project=None, self_link=None, size=None, subnetwork=None, zone=None):
         if default_port and not isinstance(default_port, int):
             raise TypeError("Expected argument 'default_port' to be a int")
         pulumi.set(__self__, "default_port", default_port)
         if description and not isinstance(description, str):
             raise TypeError("Expected argument 'description' to be a str")
         pulumi.set(__self__, "description", description)
-        if generated_id and not isinstance(generated_id, int):
-            raise TypeError("Expected argument 'generated_id' to be a int")
-        pulumi.set(__self__, "generated_id", generated_id)
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
@@ -81,11 +78,6 @@ class GetNetworkEndpointGroupResult:
         """
         return pulumi.get(self, "description")
 
-    @property
-    @pulumi.getter(name="generatedId")
-    def generated_id(self) -> builtins.int:
-        return pulumi.get(self, "generated_id")
-
     @property
     @pulumi.getter
     def id(self) -> builtins.str:
@@ -155,7 +147,6 @@ class AwaitableGetNetworkEndpointGroupResult(GetNetworkEndpointGroupResult):
         return GetNetworkEndpointGroupResult(
             default_port=self.default_port,
             description=self.description,
-            generated_id=self.generated_id,
             id=self.id,
             name=self.name,
             network=self.network,
@@ -207,7 +198,6 @@ def get_network_endpoint_group(name: Optional[builtins.str] = None,
     return AwaitableGetNetworkEndpointGroupResult(
         default_port=pulumi.get(__ret__, 'default_port'),
         description=pulumi.get(__ret__, 'description'),
-        generated_id=pulumi.get(__ret__, 'generated_id'),
         id=pulumi.get(__ret__, 'id'),
         name=pulumi.get(__ret__, 'name'),
         network=pulumi.get(__ret__, 'network'),
@@ -256,7 +246,6 @@ def get_network_endpoint_group_output(name: Optional[pulumi.Input[Optional[built
     return __ret__.apply(lambda __response__: GetNetworkEndpointGroupResult(
         default_port=pulumi.get(__response__, 'default_port'),
         description=pulumi.get(__response__, 'description'),
-        generated_id=pulumi.get(__response__, 'generated_id'),
         id=pulumi.get(__response__, 'id'),
         name=pulumi.get(__response__, 'name'),
         network=pulumi.get(__response__, 'network'),

pulumi_gcp/compute/global_forwarding_rule.py

@@ -25,8 +25,6 @@ class GlobalForwardingRuleArgs:
                  target: pulumi.Input[builtins.str],
                  allow_psc_global_access: Optional[pulumi.Input[builtins.bool]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
-                 external_managed_backend_bucket_migration_state: Optional[pulumi.Input[builtins.str]] = None,
-                 external_managed_backend_bucket_migration_testing_percentage: Optional[pulumi.Input[builtins.float]] = None,
                  ip_address: Optional[pulumi.Input[builtins.str]] = None,
                  ip_protocol: Optional[pulumi.Input[builtins.str]] = None,
                  ip_version: Optional[pulumi.Input[builtins.str]] = None,
@@ -60,23 +58,6 @@ class GlobalForwardingRuleArgs:
         :param pulumi.Input[builtins.bool] allow_psc_global_access: This is used in PSC consumer ForwardingRule to control whether the PSC endpoint can be accessed from another region.
         :param pulumi.Input[builtins.str] description: An optional description of this resource. Provide this property when
                you create the resource.
-        :param pulumi.Input[builtins.str] external_managed_backend_bucket_migration_state: Specifies the canary migration state for the backend buckets attached to this forwarding rule.
-               Possible values are PREPARE, TEST_BY_PERCENTAGE, and TEST_ALL_TRAFFIC.
-               To begin the migration from EXTERNAL to EXTERNAL_MANAGED, the state must be changed to
-               PREPARE. The state must be changed to TEST_ALL_TRAFFIC before the loadBalancingScheme can be
-               changed to EXTERNAL_MANAGED. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate
-               traffic to backend buckets attached to this forwarding rule by percentage using
-               externalManagedBackendBucketMigrationTestingPercentage.
-               Rolling back a migration requires the states to be set in reverse order. So changing the
-               scheme from EXTERNAL_MANAGED to EXTERNAL requires the state to be set to TEST_ALL_TRAFFIC at
-               the same time. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate some traffic
-               back to EXTERNAL or PREPARE can be used to migrate all traffic back to EXTERNAL.
-               Possible values are: `PREPARE`, `TEST_BY_PERCENTAGE`, `TEST_ALL_TRAFFIC`.
-        :param pulumi.Input[builtins.float] external_managed_backend_bucket_migration_testing_percentage: Determines the fraction of requests to backend buckets that should be processed by the Global
-               external Application Load Balancer.
-               The value of this field must be in the range [0, 100].
-               This value can only be set if the loadBalancingScheme in the forwarding rule is set to
-               EXTERNAL (when using the Classic ALB) and the migration state is TEST_BY_PERCENTAGE.
         :param pulumi.Input[builtins.str] ip_address: IP address for which this forwarding rule accepts traffic. When a client
                sends traffic to this IP address, the forwarding rule directs the traffic
                to the referenced `target`.
@@ -208,10 +189,6 @@ class GlobalForwardingRuleArgs:
             pulumi.set(__self__, "allow_psc_global_access", allow_psc_global_access)
         if description is not None:
             pulumi.set(__self__, "description", description)
-        if external_managed_backend_bucket_migration_state is not None:
-            pulumi.set(__self__, "external_managed_backend_bucket_migration_state", external_managed_backend_bucket_migration_state)
-        if external_managed_backend_bucket_migration_testing_percentage is not None:
-            pulumi.set(__self__, "external_managed_backend_bucket_migration_testing_percentage", external_managed_backend_bucket_migration_testing_percentage)
         if ip_address is not None:
             pulumi.set(__self__, "ip_address", ip_address)
         if ip_protocol is not None:
@@ -292,45 +269,6 @@ class GlobalForwardingRuleArgs:
     def description(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "description", value)
 
-    @property
-    @pulumi.getter(name="externalManagedBackendBucketMigrationState")
-    def external_managed_backend_bucket_migration_state(self) -> Optional[pulumi.Input[builtins.str]]:
-        """
-        Specifies the canary migration state for the backend buckets attached to this forwarding rule.
-        Possible values are PREPARE, TEST_BY_PERCENTAGE, and TEST_ALL_TRAFFIC.
-        To begin the migration from EXTERNAL to EXTERNAL_MANAGED, the state must be changed to
-        PREPARE. The state must be changed to TEST_ALL_TRAFFIC before the loadBalancingScheme can be
-        changed to EXTERNAL_MANAGED. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate
-        traffic to backend buckets attached to this forwarding rule by percentage using
-        externalManagedBackendBucketMigrationTestingPercentage.
-        Rolling back a migration requires the states to be set in reverse order. So changing the
-        scheme from EXTERNAL_MANAGED to EXTERNAL requires the state to be set to TEST_ALL_TRAFFIC at
-        the same time. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate some traffic
-        back to EXTERNAL or PREPARE can be used to migrate all traffic back to EXTERNAL.
-        Possible values are: `PREPARE`, `TEST_BY_PERCENTAGE`, `TEST_ALL_TRAFFIC`.
-        """
-        return pulumi.get(self, "external_managed_backend_bucket_migration_state")
-
-    @external_managed_backend_bucket_migration_state.setter
-    def external_managed_backend_bucket_migration_state(self, value: Optional[pulumi.Input[builtins.str]]):
-        pulumi.set(self, "external_managed_backend_bucket_migration_state", value)
-
-    @property
-    @pulumi.getter(name="externalManagedBackendBucketMigrationTestingPercentage")
-    def external_managed_backend_bucket_migration_testing_percentage(self) -> Optional[pulumi.Input[builtins.float]]:
-        """
-        Determines the fraction of requests to backend buckets that should be processed by the Global
-        external Application Load Balancer.
-        The value of this field must be in the range [0, 100].
-        This value can only be set if the loadBalancingScheme in the forwarding rule is set to
-        EXTERNAL (when using the Classic ALB) and the migration state is TEST_BY_PERCENTAGE.
-        """
-        return pulumi.get(self, "external_managed_backend_bucket_migration_testing_percentage")
-
-    @external_managed_backend_bucket_migration_testing_percentage.setter
-    def external_managed_backend_bucket_migration_testing_percentage(self, value: Optional[pulumi.Input[builtins.float]]):
-        pulumi.set(self, "external_managed_backend_bucket_migration_testing_percentage", value)
-
     @property
     @pulumi.getter(name="ipAddress")
     def ip_address(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -629,8 +567,6 @@ class _GlobalForwardingRuleState:
                  base_forwarding_rule: Optional[pulumi.Input[builtins.str]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
                  effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
-                 external_managed_backend_bucket_migration_state: Optional[pulumi.Input[builtins.str]] = None,
-                 external_managed_backend_bucket_migration_testing_percentage: Optional[pulumi.Input[builtins.float]] = None,
                  forwarding_rule_id: Optional[pulumi.Input[builtins.int]] = None,
                  ip_address: Optional[pulumi.Input[builtins.str]] = None,
                  ip_protocol: Optional[pulumi.Input[builtins.str]] = None,
@@ -660,23 +596,6 @@ class _GlobalForwardingRuleState:
         :param pulumi.Input[builtins.str] description: An optional description of this resource. Provide this property when
                you create the 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[builtins.str] external_managed_backend_bucket_migration_state: Specifies the canary migration state for the backend buckets attached to this forwarding rule.
-               Possible values are PREPARE, TEST_BY_PERCENTAGE, and TEST_ALL_TRAFFIC.
-               To begin the migration from EXTERNAL to EXTERNAL_MANAGED, the state must be changed to
-               PREPARE. The state must be changed to TEST_ALL_TRAFFIC before the loadBalancingScheme can be
-               changed to EXTERNAL_MANAGED. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate
-               traffic to backend buckets attached to this forwarding rule by percentage using
-               externalManagedBackendBucketMigrationTestingPercentage.
-               Rolling back a migration requires the states to be set in reverse order. So changing the
-               scheme from EXTERNAL_MANAGED to EXTERNAL requires the state to be set to TEST_ALL_TRAFFIC at
-               the same time. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate some traffic
-               back to EXTERNAL or PREPARE can be used to migrate all traffic back to EXTERNAL.
-               Possible values are: `PREPARE`, `TEST_BY_PERCENTAGE`, `TEST_ALL_TRAFFIC`.
-        :param pulumi.Input[builtins.float] external_managed_backend_bucket_migration_testing_percentage: Determines the fraction of requests to backend buckets that should be processed by the Global
-               external Application Load Balancer.
-               The value of this field must be in the range [0, 100].
-               This value can only be set if the loadBalancingScheme in the forwarding rule is set to
-               EXTERNAL (when using the Classic ALB) and the migration state is TEST_BY_PERCENTAGE.
         :param pulumi.Input[builtins.int] forwarding_rule_id: The unique identifier number for the resource. This identifier is defined by the server.
         :param pulumi.Input[builtins.str] ip_address: IP address for which this forwarding rule accepts traffic. When a client
                sends traffic to this IP address, the forwarding rule directs the traffic
@@ -832,10 +751,6 @@ class _GlobalForwardingRuleState:
             pulumi.set(__self__, "description", description)
         if effective_labels is not None:
             pulumi.set(__self__, "effective_labels", effective_labels)
-        if external_managed_backend_bucket_migration_state is not None:
-            pulumi.set(__self__, "external_managed_backend_bucket_migration_state", external_managed_backend_bucket_migration_state)
-        if external_managed_backend_bucket_migration_testing_percentage is not None:
-            pulumi.set(__self__, "external_managed_backend_bucket_migration_testing_percentage", external_managed_backend_bucket_migration_testing_percentage)
         if forwarding_rule_id is not None:
             pulumi.set(__self__, "forwarding_rule_id", forwarding_rule_id)
         if ip_address is not None:
@@ -930,45 +845,6 @@ class _GlobalForwardingRuleState:
     def effective_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
         pulumi.set(self, "effective_labels", value)
 
-    @property
-    @pulumi.getter(name="externalManagedBackendBucketMigrationState")
-    def external_managed_backend_bucket_migration_state(self) -> Optional[pulumi.Input[builtins.str]]:
-        """
-        Specifies the canary migration state for the backend buckets attached to this forwarding rule.
-        Possible values are PREPARE, TEST_BY_PERCENTAGE, and TEST_ALL_TRAFFIC.
-        To begin the migration from EXTERNAL to EXTERNAL_MANAGED, the state must be changed to
-        PREPARE. The state must be changed to TEST_ALL_TRAFFIC before the loadBalancingScheme can be
-        changed to EXTERNAL_MANAGED. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate
-        traffic to backend buckets attached to this forwarding rule by percentage using
-        externalManagedBackendBucketMigrationTestingPercentage.
-        Rolling back a migration requires the states to be set in reverse order. So changing the
-        scheme from EXTERNAL_MANAGED to EXTERNAL requires the state to be set to TEST_ALL_TRAFFIC at
-        the same time. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate some traffic
-        back to EXTERNAL or PREPARE can be used to migrate all traffic back to EXTERNAL.
-        Possible values are: `PREPARE`, `TEST_BY_PERCENTAGE`, `TEST_ALL_TRAFFIC`.
-        """
-        return pulumi.get(self, "external_managed_backend_bucket_migration_state")
-
-    @external_managed_backend_bucket_migration_state.setter
-    def external_managed_backend_bucket_migration_state(self, value: Optional[pulumi.Input[builtins.str]]):
-        pulumi.set(self, "external_managed_backend_bucket_migration_state", value)
-
-    @property
-    @pulumi.getter(name="externalManagedBackendBucketMigrationTestingPercentage")
-    def external_managed_backend_bucket_migration_testing_percentage(self) -> Optional[pulumi.Input[builtins.float]]:
-        """
-        Determines the fraction of requests to backend buckets that should be processed by the Global
-        external Application Load Balancer.
-        The value of this field must be in the range [0, 100].
-        This value can only be set if the loadBalancingScheme in the forwarding rule is set to
-        EXTERNAL (when using the Classic ALB) and the migration state is TEST_BY_PERCENTAGE.
-        """
-        return pulumi.get(self, "external_managed_backend_bucket_migration_testing_percentage")
-
-    @external_managed_backend_bucket_migration_testing_percentage.setter
-    def external_managed_backend_bucket_migration_testing_percentage(self, value: Optional[pulumi.Input[builtins.float]]):
-        pulumi.set(self, "external_managed_backend_bucket_migration_testing_percentage", value)
-
     @property
     @pulumi.getter(name="forwardingRuleId")
     def forwarding_rule_id(self) -> Optional[pulumi.Input[builtins.int]]:
@@ -1366,8 +1242,6 @@ class GlobalForwardingRule(pulumi.CustomResource):
                  opts: Optional[pulumi.ResourceOptions] = None,
                  allow_psc_global_access: Optional[pulumi.Input[builtins.bool]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
-                 external_managed_backend_bucket_migration_state: Optional[pulumi.Input[builtins.str]] = None,
-                 external_managed_backend_bucket_migration_testing_percentage: Optional[pulumi.Input[builtins.float]] = None,
                  ip_address: Optional[pulumi.Input[builtins.str]] = None,
                  ip_protocol: Optional[pulumi.Input[builtins.str]] = None,
                  ip_version: Optional[pulumi.Input[builtins.str]] = None,
@@ -1764,23 +1638,6 @@ class GlobalForwardingRule(pulumi.CustomResource):
         :param pulumi.Input[builtins.bool] allow_psc_global_access: This is used in PSC consumer ForwardingRule to control whether the PSC endpoint can be accessed from another region.
         :param pulumi.Input[builtins.str] description: An optional description of this resource. Provide this property when
                you create the resource.
-        :param pulumi.Input[builtins.str] external_managed_backend_bucket_migration_state: Specifies the canary migration state for the backend buckets attached to this forwarding rule.
-               Possible values are PREPARE, TEST_BY_PERCENTAGE, and TEST_ALL_TRAFFIC.
-               To begin the migration from EXTERNAL to EXTERNAL_MANAGED, the state must be changed to
-               PREPARE. The state must be changed to TEST_ALL_TRAFFIC before the loadBalancingScheme can be
-               changed to EXTERNAL_MANAGED. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate
-               traffic to backend buckets attached to this forwarding rule by percentage using
-               externalManagedBackendBucketMigrationTestingPercentage.
-               Rolling back a migration requires the states to be set in reverse order. So changing the
-               scheme from EXTERNAL_MANAGED to EXTERNAL requires the state to be set to TEST_ALL_TRAFFIC at
-               the same time. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate some traffic
-               back to EXTERNAL or PREPARE can be used to migrate all traffic back to EXTERNAL.
-               Possible values are: `PREPARE`, `TEST_BY_PERCENTAGE`, `TEST_ALL_TRAFFIC`.
-        :param pulumi.Input[builtins.float] external_managed_backend_bucket_migration_testing_percentage: Determines the fraction of requests to backend buckets that should be processed by the Global
-               external Application Load Balancer.
-               The value of this field must be in the range [0, 100].
-               This value can only be set if the loadBalancingScheme in the forwarding rule is set to
-               EXTERNAL (when using the Classic ALB) and the migration state is TEST_BY_PERCENTAGE.
         :param pulumi.Input[builtins.str] ip_address: IP address for which this forwarding rule accepts traffic. When a client
                sends traffic to this IP address, the forwarding rule directs the traffic
                to the referenced `target`.
@@ -2317,8 +2174,6 @@ class GlobalForwardingRule(pulumi.CustomResource):
                  opts: Optional[pulumi.ResourceOptions] = None,
                  allow_psc_global_access: Optional[pulumi.Input[builtins.bool]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
-                 external_managed_backend_bucket_migration_state: Optional[pulumi.Input[builtins.str]] = None,
-                 external_managed_backend_bucket_migration_testing_percentage: Optional[pulumi.Input[builtins.float]] = None,
                  ip_address: Optional[pulumi.Input[builtins.str]] = None,
                  ip_protocol: Optional[pulumi.Input[builtins.str]] = None,
                  ip_version: Optional[pulumi.Input[builtins.str]] = None,
@@ -2346,8 +2201,6 @@ class GlobalForwardingRule(pulumi.CustomResource):
 
             __props__.__dict__["allow_psc_global_access"] = allow_psc_global_access
             __props__.__dict__["description"] = description
-            __props__.__dict__["external_managed_backend_bucket_migration_state"] = external_managed_backend_bucket_migration_state
-            __props__.__dict__["external_managed_backend_bucket_migration_testing_percentage"] = external_managed_backend_bucket_migration_testing_percentage
             __props__.__dict__["ip_address"] = ip_address
             __props__.__dict__["ip_protocol"] = ip_protocol
             __props__.__dict__["ip_version"] = ip_version
@@ -2390,8 +2243,6 @@ class GlobalForwardingRule(pulumi.CustomResource):
             base_forwarding_rule: Optional[pulumi.Input[builtins.str]] = None,
             description: Optional[pulumi.Input[builtins.str]] = None,
             effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
-            external_managed_backend_bucket_migration_state: Optional[pulumi.Input[builtins.str]] = None,
-            external_managed_backend_bucket_migration_testing_percentage: Optional[pulumi.Input[builtins.float]] = None,
             forwarding_rule_id: Optional[pulumi.Input[builtins.int]] = None,
             ip_address: Optional[pulumi.Input[builtins.str]] = None,
             ip_protocol: Optional[pulumi.Input[builtins.str]] = None,
@@ -2426,23 +2277,6 @@ class GlobalForwardingRule(pulumi.CustomResource):
         :param pulumi.Input[builtins.str] description: An optional description of this resource. Provide this property when
                you create the 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[builtins.str] external_managed_backend_bucket_migration_state: Specifies the canary migration state for the backend buckets attached to this forwarding rule.
-               Possible values are PREPARE, TEST_BY_PERCENTAGE, and TEST_ALL_TRAFFIC.
-               To begin the migration from EXTERNAL to EXTERNAL_MANAGED, the state must be changed to
-               PREPARE. The state must be changed to TEST_ALL_TRAFFIC before the loadBalancingScheme can be
-               changed to EXTERNAL_MANAGED. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate
-               traffic to backend buckets attached to this forwarding rule by percentage using
-               externalManagedBackendBucketMigrationTestingPercentage.
-               Rolling back a migration requires the states to be set in reverse order. So changing the
-               scheme from EXTERNAL_MANAGED to EXTERNAL requires the state to be set to TEST_ALL_TRAFFIC at
-               the same time. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate some traffic
-               back to EXTERNAL or PREPARE can be used to migrate all traffic back to EXTERNAL.
-               Possible values are: `PREPARE`, `TEST_BY_PERCENTAGE`, `TEST_ALL_TRAFFIC`.
-        :param pulumi.Input[builtins.float] external_managed_backend_bucket_migration_testing_percentage: Determines the fraction of requests to backend buckets that should be processed by the Global
-               external Application Load Balancer.
-               The value of this field must be in the range [0, 100].
-               This value can only be set if the loadBalancingScheme in the forwarding rule is set to
-               EXTERNAL (when using the Classic ALB) and the migration state is TEST_BY_PERCENTAGE.
         :param pulumi.Input[builtins.int] forwarding_rule_id: The unique identifier number for the resource. This identifier is defined by the server.
         :param pulumi.Input[builtins.str] ip_address: IP address for which this forwarding rule accepts traffic. When a client
                sends traffic to this IP address, the forwarding rule directs the traffic
@@ -2598,8 +2432,6 @@ class GlobalForwardingRule(pulumi.CustomResource):
         __props__.__dict__["base_forwarding_rule"] = base_forwarding_rule
         __props__.__dict__["description"] = description
         __props__.__dict__["effective_labels"] = effective_labels
-        __props__.__dict__["external_managed_backend_bucket_migration_state"] = external_managed_backend_bucket_migration_state
-        __props__.__dict__["external_managed_backend_bucket_migration_testing_percentage"] = external_managed_backend_bucket_migration_testing_percentage
         __props__.__dict__["forwarding_rule_id"] = forwarding_rule_id
         __props__.__dict__["ip_address"] = ip_address
         __props__.__dict__["ip_protocol"] = ip_protocol
@@ -2657,37 +2489,6 @@ class GlobalForwardingRule(pulumi.CustomResource):
         """
         return pulumi.get(self, "effective_labels")
 
-    @property
-    @pulumi.getter(name="externalManagedBackendBucketMigrationState")
-    def external_managed_backend_bucket_migration_state(self) -> pulumi.Output[Optional[builtins.str]]:
-        """
-        Specifies the canary migration state for the backend buckets attached to this forwarding rule.
-        Possible values are PREPARE, TEST_BY_PERCENTAGE, and TEST_ALL_TRAFFIC.
-        To begin the migration from EXTERNAL to EXTERNAL_MANAGED, the state must be changed to
-        PREPARE. The state must be changed to TEST_ALL_TRAFFIC before the loadBalancingScheme can be
-        changed to EXTERNAL_MANAGED. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate
-        traffic to backend buckets attached to this forwarding rule by percentage using
-        externalManagedBackendBucketMigrationTestingPercentage.
-        Rolling back a migration requires the states to be set in reverse order. So changing the
-        scheme from EXTERNAL_MANAGED to EXTERNAL requires the state to be set to TEST_ALL_TRAFFIC at
-        the same time. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate some traffic
-        back to EXTERNAL or PREPARE can be used to migrate all traffic back to EXTERNAL.
-        Possible values are: `PREPARE`, `TEST_BY_PERCENTAGE`, `TEST_ALL_TRAFFIC`.
-        """
-        return pulumi.get(self, "external_managed_backend_bucket_migration_state")
-
-    @property
-    @pulumi.getter(name="externalManagedBackendBucketMigrationTestingPercentage")
-    def external_managed_backend_bucket_migration_testing_percentage(self) -> pulumi.Output[Optional[builtins.float]]:
-        """
-        Determines the fraction of requests to backend buckets that should be processed by the Global
-        external Application Load Balancer.
-        The value of this field must be in the range [0, 100].
-        This value can only be set if the loadBalancingScheme in the forwarding rule is set to
-        EXTERNAL (when using the Classic ALB) and the migration state is TEST_BY_PERCENTAGE.
-        """
-        return pulumi.get(self, "external_managed_backend_bucket_migration_testing_percentage")
-
     @property
     @pulumi.getter(name="forwardingRuleId")
     def forwarding_rule_id(self) -> pulumi.Output[builtins.int]: