pulumi-gcp 8.31.0a1747205151__py3-none-any.whl → 8.32.0__py3-none-any.whl

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]:

pulumi_gcp/compute/health_check.py

@@ -25,6 +25,7 @@ class HealthCheckArgs:
                  check_interval_sec: Optional[pulumi.Input[builtins.int]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
                  grpc_health_check: Optional[pulumi.Input['HealthCheckGrpcHealthCheckArgs']] = None,
+                 grpc_tls_health_check: Optional[pulumi.Input['HealthCheckGrpcTlsHealthCheckArgs']] = None,
                  healthy_threshold: Optional[pulumi.Input[builtins.int]] = None,
                  http2_health_check: Optional[pulumi.Input['HealthCheckHttp2HealthCheckArgs']] = None,
                  http_health_check: Optional[pulumi.Input['HealthCheckHttpHealthCheckArgs']] = None,
@@ -45,6 +46,8 @@ class HealthCheckArgs:
                you create the resource.
         :param pulumi.Input['HealthCheckGrpcHealthCheckArgs'] grpc_health_check: A nested object resource.
                Structure is documented below.
+        :param pulumi.Input['HealthCheckGrpcTlsHealthCheckArgs'] grpc_tls_health_check: A nested object resource.
+               Structure is documented below.
         :param pulumi.Input[builtins.int] healthy_threshold: A so-far unhealthy instance will be marked healthy after this many
                consecutive successes. The default value is 2.
         :param pulumi.Input['HealthCheckHttp2HealthCheckArgs'] http2_health_check: A nested object resource.
@@ -95,6 +98,8 @@ class HealthCheckArgs:
             pulumi.set(__self__, "description", description)
         if grpc_health_check is not None:
             pulumi.set(__self__, "grpc_health_check", grpc_health_check)
+        if grpc_tls_health_check is not None:
+            pulumi.set(__self__, "grpc_tls_health_check", grpc_tls_health_check)
         if healthy_threshold is not None:
             pulumi.set(__self__, "healthy_threshold", healthy_threshold)
         if http2_health_check is not None:
@@ -159,6 +164,19 @@ class HealthCheckArgs:
     def grpc_health_check(self, value: Optional[pulumi.Input['HealthCheckGrpcHealthCheckArgs']]):
         pulumi.set(self, "grpc_health_check", value)
 
+    @property
+    @pulumi.getter(name="grpcTlsHealthCheck")
+    def grpc_tls_health_check(self) -> Optional[pulumi.Input['HealthCheckGrpcTlsHealthCheckArgs']]:
+        """
+        A nested object resource.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "grpc_tls_health_check")
+
+    @grpc_tls_health_check.setter
+    def grpc_tls_health_check(self, value: Optional[pulumi.Input['HealthCheckGrpcTlsHealthCheckArgs']]):
+        pulumi.set(self, "grpc_tls_health_check", value)
+
     @property
     @pulumi.getter(name="healthyThreshold")
     def healthy_threshold(self) -> Optional[pulumi.Input[builtins.int]]:
@@ -342,6 +360,7 @@ class _HealthCheckState:
                  creation_timestamp: Optional[pulumi.Input[builtins.str]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
                  grpc_health_check: Optional[pulumi.Input['HealthCheckGrpcHealthCheckArgs']] = None,
+                 grpc_tls_health_check: Optional[pulumi.Input['HealthCheckGrpcTlsHealthCheckArgs']] = None,
                  healthy_threshold: Optional[pulumi.Input[builtins.int]] = None,
                  http2_health_check: Optional[pulumi.Input['HealthCheckHttp2HealthCheckArgs']] = None,
                  http_health_check: Optional[pulumi.Input['HealthCheckHttpHealthCheckArgs']] = None,
@@ -365,6 +384,8 @@ class _HealthCheckState:
                you create the resource.
         :param pulumi.Input['HealthCheckGrpcHealthCheckArgs'] grpc_health_check: A nested object resource.
                Structure is documented below.
+        :param pulumi.Input['HealthCheckGrpcTlsHealthCheckArgs'] grpc_tls_health_check: A nested object resource.
+               Structure is documented below.
         :param pulumi.Input[builtins.int] healthy_threshold: A so-far unhealthy instance will be marked healthy after this many
                consecutive successes. The default value is 2.
         :param pulumi.Input['HealthCheckHttp2HealthCheckArgs'] http2_health_check: A nested object resource.
@@ -419,6 +440,8 @@ class _HealthCheckState:
             pulumi.set(__self__, "description", description)
         if grpc_health_check is not None:
             pulumi.set(__self__, "grpc_health_check", grpc_health_check)
+        if grpc_tls_health_check is not None:
+            pulumi.set(__self__, "grpc_tls_health_check", grpc_tls_health_check)
         if healthy_threshold is not None:
             pulumi.set(__self__, "healthy_threshold", healthy_threshold)
         if http2_health_check is not None:
@@ -499,6 +522,19 @@ class _HealthCheckState:
     def grpc_health_check(self, value: Optional[pulumi.Input['HealthCheckGrpcHealthCheckArgs']]):
         pulumi.set(self, "grpc_health_check", value)
 
+    @property
+    @pulumi.getter(name="grpcTlsHealthCheck")
+    def grpc_tls_health_check(self) -> Optional[pulumi.Input['HealthCheckGrpcTlsHealthCheckArgs']]:
+        """
+        A nested object resource.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "grpc_tls_health_check")
+
+    @grpc_tls_health_check.setter
+    def grpc_tls_health_check(self, value: Optional[pulumi.Input['HealthCheckGrpcTlsHealthCheckArgs']]):
+        pulumi.set(self, "grpc_tls_health_check", value)
+
     @property
     @pulumi.getter(name="healthyThreshold")
     def healthy_threshold(self) -> Optional[pulumi.Input[builtins.int]]:
@@ -708,6 +744,7 @@ class HealthCheck(pulumi.CustomResource):
                  check_interval_sec: Optional[pulumi.Input[builtins.int]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
                  grpc_health_check: Optional[pulumi.Input[Union['HealthCheckGrpcHealthCheckArgs', 'HealthCheckGrpcHealthCheckArgsDict']]] = None,
+                 grpc_tls_health_check: Optional[pulumi.Input[Union['HealthCheckGrpcTlsHealthCheckArgs', 'HealthCheckGrpcTlsHealthCheckArgsDict']]] = None,
                  healthy_threshold: Optional[pulumi.Input[builtins.int]] = None,
                  http2_health_check: Optional[pulumi.Input[Union['HealthCheckHttp2HealthCheckArgs', 'HealthCheckHttp2HealthCheckArgsDict']]] = None,
                  http_health_check: Optional[pulumi.Input[Union['HealthCheckHttpHealthCheckArgs', 'HealthCheckHttpHealthCheckArgsDict']]] = None,
@@ -954,6 +991,39 @@ class HealthCheck(pulumi.CustomResource):
                 "grpc_service_name": "testservice",
             })
         ```
+        ### Health Check Grpc With Tls
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        grpc_with_tls_health_check = gcp.compute.HealthCheck("grpc-with-tls-health-check",
+            name="grpc-with-tls-health-check",
+            timeout_sec=1,
+            check_interval_sec=1,
+            grpc_tls_health_check={
+                "port": 443,
+            })
+        ```
+        ### Health Check Grpc With Tls Full
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        grpc_with_tls_health_check = gcp.compute.HealthCheck("grpc-with-tls-health-check",
+            name="grpc-with-tls-health-check",
+            description="Health check via grpc with TLS",
+            timeout_sec=1,
+            check_interval_sec=1,
+            healthy_threshold=4,
+            unhealthy_threshold=5,
+            grpc_tls_health_check={
+                "port_specification": "USE_FIXED_PORT",
+                "port": 443,
+                "grpc_service_name": "testservice",
+            })
+        ```
         ### Health Check With Logging
 
         ```python
@@ -1061,6 +1131,8 @@ class HealthCheck(pulumi.CustomResource):
                you create the resource.
         :param pulumi.Input[Union['HealthCheckGrpcHealthCheckArgs', 'HealthCheckGrpcHealthCheckArgsDict']] grpc_health_check: A nested object resource.
                Structure is documented below.
+        :param pulumi.Input[Union['HealthCheckGrpcTlsHealthCheckArgs', 'HealthCheckGrpcTlsHealthCheckArgsDict']] grpc_tls_health_check: A nested object resource.
+               Structure is documented below.
         :param pulumi.Input[builtins.int] healthy_threshold: A so-far unhealthy instance will be marked healthy after this many
                consecutive successes. The default value is 2.
         :param pulumi.Input[Union['HealthCheckHttp2HealthCheckArgs', 'HealthCheckHttp2HealthCheckArgsDict']] http2_health_check: A nested object resource.
@@ -1344,6 +1416,39 @@ class HealthCheck(pulumi.CustomResource):
                 "grpc_service_name": "testservice",
             })
         ```
+        ### Health Check Grpc With Tls
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        grpc_with_tls_health_check = gcp.compute.HealthCheck("grpc-with-tls-health-check",
+            name="grpc-with-tls-health-check",
+            timeout_sec=1,
+            check_interval_sec=1,
+            grpc_tls_health_check={
+                "port": 443,
+            })
+        ```
+        ### Health Check Grpc With Tls Full
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        grpc_with_tls_health_check = gcp.compute.HealthCheck("grpc-with-tls-health-check",
+            name="grpc-with-tls-health-check",
+            description="Health check via grpc with TLS",
+            timeout_sec=1,
+            check_interval_sec=1,
+            healthy_threshold=4,
+            unhealthy_threshold=5,
+            grpc_tls_health_check={
+                "port_specification": "USE_FIXED_PORT",
+                "port": 443,
+                "grpc_service_name": "testservice",
+            })
+        ```
         ### Health Check With Logging
 
         ```python
@@ -1461,6 +1566,7 @@ class HealthCheck(pulumi.CustomResource):
                  check_interval_sec: Optional[pulumi.Input[builtins.int]] = None,
                  description: Optional[pulumi.Input[builtins.str]] = None,
                  grpc_health_check: Optional[pulumi.Input[Union['HealthCheckGrpcHealthCheckArgs', 'HealthCheckGrpcHealthCheckArgsDict']]] = None,
+                 grpc_tls_health_check: Optional[pulumi.Input[Union['HealthCheckGrpcTlsHealthCheckArgs', 'HealthCheckGrpcTlsHealthCheckArgsDict']]] = None,
                  healthy_threshold: Optional[pulumi.Input[builtins.int]] = None,
                  http2_health_check: Optional[pulumi.Input[Union['HealthCheckHttp2HealthCheckArgs', 'HealthCheckHttp2HealthCheckArgsDict']]] = None,
                  http_health_check: Optional[pulumi.Input[Union['HealthCheckHttpHealthCheckArgs', 'HealthCheckHttpHealthCheckArgsDict']]] = None,
@@ -1485,6 +1591,7 @@ class HealthCheck(pulumi.CustomResource):
             __props__.__dict__["check_interval_sec"] = check_interval_sec
             __props__.__dict__["description"] = description
             __props__.__dict__["grpc_health_check"] = grpc_health_check
+            __props__.__dict__["grpc_tls_health_check"] = grpc_tls_health_check
             __props__.__dict__["healthy_threshold"] = healthy_threshold
             __props__.__dict__["http2_health_check"] = http2_health_check
             __props__.__dict__["http_health_check"] = http_health_check
@@ -1514,6 +1621,7 @@ class HealthCheck(pulumi.CustomResource):
             creation_timestamp: Optional[pulumi.Input[builtins.str]] = None,
             description: Optional[pulumi.Input[builtins.str]] = None,
             grpc_health_check: Optional[pulumi.Input[Union['HealthCheckGrpcHealthCheckArgs', 'HealthCheckGrpcHealthCheckArgsDict']]] = None,
+            grpc_tls_health_check: Optional[pulumi.Input[Union['HealthCheckGrpcTlsHealthCheckArgs', 'HealthCheckGrpcTlsHealthCheckArgsDict']]] = None,
             healthy_threshold: Optional[pulumi.Input[builtins.int]] = None,
             http2_health_check: Optional[pulumi.Input[Union['HealthCheckHttp2HealthCheckArgs', 'HealthCheckHttp2HealthCheckArgsDict']]] = None,
             http_health_check: Optional[pulumi.Input[Union['HealthCheckHttpHealthCheckArgs', 'HealthCheckHttpHealthCheckArgsDict']]] = None,
@@ -1542,6 +1650,8 @@ class HealthCheck(pulumi.CustomResource):
                you create the resource.
         :param pulumi.Input[Union['HealthCheckGrpcHealthCheckArgs', 'HealthCheckGrpcHealthCheckArgsDict']] grpc_health_check: A nested object resource.
                Structure is documented below.
+        :param pulumi.Input[Union['HealthCheckGrpcTlsHealthCheckArgs', 'HealthCheckGrpcTlsHealthCheckArgsDict']] grpc_tls_health_check: A nested object resource.
+               Structure is documented below.
         :param pulumi.Input[builtins.int] healthy_threshold: A so-far unhealthy instance will be marked healthy after this many
                consecutive successes. The default value is 2.
         :param pulumi.Input[Union['HealthCheckHttp2HealthCheckArgs', 'HealthCheckHttp2HealthCheckArgsDict']] http2_health_check: A nested object resource.
@@ -1596,6 +1706,7 @@ class HealthCheck(pulumi.CustomResource):
         __props__.__dict__["creation_timestamp"] = creation_timestamp
         __props__.__dict__["description"] = description
         __props__.__dict__["grpc_health_check"] = grpc_health_check
+        __props__.__dict__["grpc_tls_health_check"] = grpc_tls_health_check
         __props__.__dict__["healthy_threshold"] = healthy_threshold
         __props__.__dict__["http2_health_check"] = http2_health_check
         __props__.__dict__["http_health_check"] = http_health_check
@@ -1647,6 +1758,15 @@ class HealthCheck(pulumi.CustomResource):
         """
         return pulumi.get(self, "grpc_health_check")
 
+    @property
+    @pulumi.getter(name="grpcTlsHealthCheck")
+    def grpc_tls_health_check(self) -> pulumi.Output[Optional['outputs.HealthCheckGrpcTlsHealthCheck']]:
+        """
+        A nested object resource.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "grpc_tls_health_check")
+
     @property
     @pulumi.getter(name="healthyThreshold")
     def healthy_threshold(self) -> pulumi.Output[Optional[builtins.int]]: