pulumi-gcp 8.32.0a1747377897__py3-none-any.whl → 8.32.0a1747834582__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, 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, 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):
         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,6 +71,12 @@ 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)
@@ -226,6 +232,16 @@ 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:
@@ -394,6 +410,8 @@ 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,
@@ -467,6 +485,8 @@ 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'),
@@ -537,6 +557,8 @@ 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, 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, 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):
         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,6 +41,12 @@ 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)
@@ -131,6 +137,16 @@ 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:
@@ -260,6 +276,8 @@ 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,
@@ -318,6 +336,8 @@ 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'),
@@ -373,6 +393,8 @@ 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, 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, 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):
         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,6 +101,9 @@ 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)
@@ -338,6 +341,11 @@ 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]:
@@ -478,6 +486,7 @@ 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,
@@ -553,6 +562,7 @@ 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'),
@@ -625,6 +635,7 @@ 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,13 +27,16 @@ class GetNetworkEndpointGroupResult:
     """
     A collection of values returned by getNetworkEndpointGroup.
     """
-    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):
+    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):
         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)
@@ -78,6 +81,11 @@ 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:
@@ -147,6 +155,7 @@ 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,
@@ -198,6 +207,7 @@ 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'),
@@ -246,6 +256,7 @@ 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,6 +25,8 @@ 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,
@@ -58,6 +60,23 @@ 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`.
@@ -189,6 +208,10 @@ 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:
@@ -269,6 +292,45 @@ 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]]:
@@ -567,6 +629,8 @@ 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,
@@ -596,6 +660,23 @@ 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
@@ -751,6 +832,10 @@ 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:
@@ -845,6 +930,45 @@ 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]]:
@@ -1242,6 +1366,8 @@ 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,
@@ -1638,6 +1764,23 @@ 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`.
@@ -2174,6 +2317,8 @@ 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,
@@ -2201,6 +2346,8 @@ 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
@@ -2243,6 +2390,8 @@ 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,
@@ -2277,6 +2426,23 @@ 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
@@ -2432,6 +2598,8 @@ 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
@@ -2489,6 +2657,37 @@ 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]: