pulumi-gcp 8.42.0a1758133038__py3-none-any.whl → 9.0.0__py3-none-any.whl

pulumi_gcp/cloudrunv2/_inputs.py

@@ -85,6 +85,8 @@ __all__ = [
     'ServiceIamBindingConditionArgsDict',
     'ServiceIamMemberConditionArgs',
     'ServiceIamMemberConditionArgsDict',
+    'ServiceMultiRegionSettingsArgs',
+    'ServiceMultiRegionSettingsArgsDict',
     'ServiceScalingArgs',
     'ServiceScalingArgsDict',
     'ServiceTemplateArgs',
@@ -3452,12 +3454,71 @@ class ServiceIamMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class ServiceMultiRegionSettingsArgsDict(TypedDict):
+        multi_region_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Output)
+        System-generated unique id for the multi-region Service.
+        """
+        regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        The list of regions to deploy the multi-region Service.
+        """
+elif False:
+    ServiceMultiRegionSettingsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ServiceMultiRegionSettingsArgs:
+    def __init__(__self__, *,
+                 multi_region_id: Optional[pulumi.Input[_builtins.str]] = None,
+                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
+        """
+        :param pulumi.Input[_builtins.str] multi_region_id: (Output)
+               System-generated unique id for the multi-region Service.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] regions: The list of regions to deploy the multi-region Service.
+        """
+        if multi_region_id is not None:
+            pulumi.set(__self__, "multi_region_id", multi_region_id)
+        if regions is not None:
+            pulumi.set(__self__, "regions", regions)
+
+    @_builtins.property
+    @pulumi.getter(name="multiRegionId")
+    def multi_region_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Output)
+        System-generated unique id for the multi-region Service.
+        """
+        return pulumi.get(self, "multi_region_id")
+
+    @multi_region_id.setter
+    def multi_region_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "multi_region_id", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        """
+        The list of regions to deploy the multi-region Service.
+        """
+        return pulumi.get(self, "regions")
+
+    @regions.setter
+    def regions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "regions", value)
+
+
 if not MYPY:
     class ServiceScalingArgsDict(TypedDict):
         manual_instance_count: NotRequired[pulumi.Input[_builtins.int]]
         """
         Total instance count for the service in manual scaling mode. This number of instances is divided among all revisions with specified traffic based on the percent of traffic they are receiving.
         """
+        max_instance_count: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Combined maximum number of instances for all revisions receiving traffic.
+        """
         min_instance_count: NotRequired[pulumi.Input[_builtins.int]]
         """
         Minimum number of instances for the service, to be divided among all revisions receiving traffic.
@@ -3474,16 +3535,20 @@ elif False:
 class ServiceScalingArgs:
     def __init__(__self__, *,
                  manual_instance_count: Optional[pulumi.Input[_builtins.int]] = None,
+                 max_instance_count: Optional[pulumi.Input[_builtins.int]] = None,
                  min_instance_count: Optional[pulumi.Input[_builtins.int]] = None,
                  scaling_mode: Optional[pulumi.Input[_builtins.str]] = None):
         """
         :param pulumi.Input[_builtins.int] manual_instance_count: Total instance count for the service in manual scaling mode. This number of instances is divided among all revisions with specified traffic based on the percent of traffic they are receiving.
+        :param pulumi.Input[_builtins.int] max_instance_count: Combined maximum number of instances for all revisions receiving traffic.
         :param pulumi.Input[_builtins.int] min_instance_count: Minimum number of instances for the service, to be divided among all revisions receiving traffic.
         :param pulumi.Input[_builtins.str] scaling_mode: The [scaling mode](https://cloud.google.com/run/docs/reference/rest/v2/projects.locations.services#scalingmode) for the service.
                Possible values are: `AUTOMATIC`, `MANUAL`.
         """
         if manual_instance_count is not None:
             pulumi.set(__self__, "manual_instance_count", manual_instance_count)
+        if max_instance_count is not None:
+            pulumi.set(__self__, "max_instance_count", max_instance_count)
         if min_instance_count is not None:
             pulumi.set(__self__, "min_instance_count", min_instance_count)
         if scaling_mode is not None:
@@ -3501,6 +3566,18 @@ class ServiceScalingArgs:
     def manual_instance_count(self, value: Optional[pulumi.Input[_builtins.int]]):
         pulumi.set(self, "manual_instance_count", value)
 
+    @_builtins.property
+    @pulumi.getter(name="maxInstanceCount")
+    def max_instance_count(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Combined maximum number of instances for all revisions receiving traffic.
+        """
+        return pulumi.get(self, "max_instance_count")
+
+    @max_instance_count.setter
+    def max_instance_count(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "max_instance_count", value)
+
     @_builtins.property
     @pulumi.getter(name="minInstanceCount")
     def min_instance_count(self) -> Optional[pulumi.Input[_builtins.int]]:
@@ -5429,8 +5506,7 @@ if not MYPY:
     class ServiceTemplateScalingArgsDict(TypedDict):
         max_instance_count: NotRequired[pulumi.Input[_builtins.int]]
         """
-        Maximum number of serving instances that this resource should have. Must not be less than minimum instance count. If absent, Cloud Run will calculate
-        a default value based on the project's available container instances quota in the region and specified instance size.
+        Combined maximum number of instances for all revisions receiving traffic.
         """
         min_instance_count: NotRequired[pulumi.Input[_builtins.int]]
         """
@@ -5445,8 +5521,7 @@ class ServiceTemplateScalingArgs:
                  max_instance_count: Optional[pulumi.Input[_builtins.int]] = None,
                  min_instance_count: Optional[pulumi.Input[_builtins.int]] = None):
         """
-        :param pulumi.Input[_builtins.int] max_instance_count: Maximum number of serving instances that this resource should have. Must not be less than minimum instance count. If absent, Cloud Run will calculate
-               a default value based on the project's available container instances quota in the region and specified instance size.
+        :param pulumi.Input[_builtins.int] max_instance_count: Combined maximum number of instances for all revisions receiving traffic.
         :param pulumi.Input[_builtins.int] min_instance_count: Minimum number of instances for the service, to be divided among all revisions receiving traffic.
         """
         if max_instance_count is not None:
@@ -5458,8 +5533,7 @@ class ServiceTemplateScalingArgs:
     @pulumi.getter(name="maxInstanceCount")
     def max_instance_count(self) -> Optional[pulumi.Input[_builtins.int]]:
         """
-        Maximum number of serving instances that this resource should have. Must not be less than minimum instance count. If absent, Cloud Run will calculate
-        a default value based on the project's available container instances quota in the region and specified instance size.
+        Combined maximum number of instances for all revisions receiving traffic.
         """
         return pulumi.get(self, "max_instance_count")
 
@@ -7538,10 +7612,6 @@ if not MYPY:
         """
         Entrypoint array. Not executed within a shell. The docker image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
         """
-        depends_ons: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
-        """
-        Containers which should be started before this container. If specified the container will wait to start until all containers with the listed names are healthy.
-        """
         envs: NotRequired[pulumi.Input[Sequence[pulumi.Input['WorkerPoolTemplateContainerEnvArgsDict']]]]
         """
         List of environment variables to set in the container.
@@ -7574,7 +7644,6 @@ class WorkerPoolTemplateContainerArgs:
                  image: pulumi.Input[_builtins.str],
                  args: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  commands: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
-                 depends_ons: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  envs: Optional[pulumi.Input[Sequence[pulumi.Input['WorkerPoolTemplateContainerEnvArgs']]]] = None,
                  name: Optional[pulumi.Input[_builtins.str]] = None,
                  resources: Optional[pulumi.Input['WorkerPoolTemplateContainerResourcesArgs']] = None,
@@ -7584,7 +7653,6 @@ class WorkerPoolTemplateContainerArgs:
         :param pulumi.Input[_builtins.str] image: URL of the Container image in Google Container Registry or Google Artifact Registry. More info: https://kubernetes.io/docs/concepts/containers/images
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] args: Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references are not supported in Cloud Run.
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] commands: Entrypoint array. Not executed within a shell. The docker image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] depends_ons: Containers which should be started before this container. If specified the container will wait to start until all containers with the listed names are healthy.
         :param pulumi.Input[Sequence[pulumi.Input['WorkerPoolTemplateContainerEnvArgs']]] envs: List of environment variables to set in the container.
                Structure is documented below.
         :param pulumi.Input[_builtins.str] name: Name of the container specified as a DNS_LABEL.
@@ -7599,8 +7667,6 @@ class WorkerPoolTemplateContainerArgs:
             pulumi.set(__self__, "args", args)
         if commands is not None:
             pulumi.set(__self__, "commands", commands)
-        if depends_ons is not None:
-            pulumi.set(__self__, "depends_ons", depends_ons)
         if envs is not None:
             pulumi.set(__self__, "envs", envs)
         if name is not None:
@@ -7648,18 +7714,6 @@ class WorkerPoolTemplateContainerArgs:
     def commands(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
         pulumi.set(self, "commands", value)
 
-    @_builtins.property
-    @pulumi.getter(name="dependsOns")
-    def depends_ons(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
-        """
-        Containers which should be started before this container. If specified the container will wait to start until all containers with the listed names are healthy.
-        """
-        return pulumi.get(self, "depends_ons")
-
-    @depends_ons.setter
-    def depends_ons(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
-        pulumi.set(self, "depends_ons", value)
-
     @_builtins.property
     @pulumi.getter
     def envs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WorkerPoolTemplateContainerEnvArgs']]]]:

pulumi_gcp/cloudrunv2/get_service.py

@@ -27,7 +27,7 @@ class GetServiceResult:
     """
     A collection of values returned by getService.
     """
-    def __init__(__self__, annotations=None, binary_authorizations=None, build_configs=None, client=None, client_version=None, conditions=None, create_time=None, creator=None, custom_audiences=None, default_uri_disabled=None, delete_time=None, deletion_protection=None, description=None, effective_annotations=None, effective_labels=None, etag=None, expire_time=None, generation=None, iap_enabled=None, id=None, ingress=None, invoker_iam_disabled=None, labels=None, last_modifier=None, latest_created_revision=None, latest_ready_revision=None, launch_stage=None, location=None, name=None, observed_generation=None, project=None, pulumi_labels=None, reconciling=None, scalings=None, templates=None, terminal_conditions=None, traffic_statuses=None, traffics=None, uid=None, update_time=None, uri=None, urls=None):
+    def __init__(__self__, annotations=None, binary_authorizations=None, build_configs=None, client=None, client_version=None, conditions=None, create_time=None, creator=None, custom_audiences=None, default_uri_disabled=None, delete_time=None, deletion_protection=None, description=None, effective_annotations=None, effective_labels=None, etag=None, expire_time=None, generation=None, iap_enabled=None, id=None, ingress=None, invoker_iam_disabled=None, labels=None, last_modifier=None, latest_created_revision=None, latest_ready_revision=None, launch_stage=None, location=None, multi_region_settings=None, name=None, observed_generation=None, project=None, pulumi_labels=None, reconciling=None, scalings=None, templates=None, terminal_conditions=None, traffic_statuses=None, traffics=None, uid=None, update_time=None, uri=None, urls=None):
         if annotations and not isinstance(annotations, dict):
             raise TypeError("Expected argument 'annotations' to be a dict")
         pulumi.set(__self__, "annotations", annotations)
@@ -112,6 +112,9 @@ class GetServiceResult:
         if location and not isinstance(location, str):
             raise TypeError("Expected argument 'location' to be a str")
         pulumi.set(__self__, "location", location)
+        if multi_region_settings and not isinstance(multi_region_settings, list):
+            raise TypeError("Expected argument 'multi_region_settings' to be a list")
+        pulumi.set(__self__, "multi_region_settings", multi_region_settings)
         if name and not isinstance(name, str):
             raise TypeError("Expected argument 'name' to be a str")
         pulumi.set(__self__, "name", name)
@@ -298,6 +301,11 @@ class GetServiceResult:
     def location(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "location")
 
+    @_builtins.property
+    @pulumi.getter(name="multiRegionSettings")
+    def multi_region_settings(self) -> Sequence['outputs.GetServiceMultiRegionSettingResult']:
+        return pulumi.get(self, "multi_region_settings")
+
     @_builtins.property
     @pulumi.getter
     def name(self) -> _builtins.str:
@@ -403,6 +411,7 @@ class AwaitableGetServiceResult(GetServiceResult):
             latest_ready_revision=self.latest_ready_revision,
             launch_stage=self.launch_stage,
             location=self.location,
+            multi_region_settings=self.multi_region_settings,
             name=self.name,
             observed_generation=self.observed_generation,
             project=self.project,
@@ -482,6 +491,7 @@ def get_service(location: Optional[_builtins.str] = None,
         latest_ready_revision=pulumi.get(__ret__, 'latest_ready_revision'),
         launch_stage=pulumi.get(__ret__, 'launch_stage'),
         location=pulumi.get(__ret__, 'location'),
+        multi_region_settings=pulumi.get(__ret__, 'multi_region_settings'),
         name=pulumi.get(__ret__, 'name'),
         observed_generation=pulumi.get(__ret__, 'observed_generation'),
         project=pulumi.get(__ret__, 'project'),
@@ -558,6 +568,7 @@ def get_service_output(location: Optional[pulumi.Input[Optional[_builtins.str]]]
         latest_ready_revision=pulumi.get(__response__, 'latest_ready_revision'),
         launch_stage=pulumi.get(__response__, 'launch_stage'),
         location=pulumi.get(__response__, 'location'),
+        multi_region_settings=pulumi.get(__response__, 'multi_region_settings'),
         name=pulumi.get(__response__, 'name'),
         observed_generation=pulumi.get(__response__, 'observed_generation'),
         project=pulumi.get(__response__, 'project'),

pulumi_gcp/cloudrunv2/outputs.py

@@ -51,6 +51,7 @@ __all__ = [
     'ServiceCondition',
     'ServiceIamBindingCondition',
     'ServiceIamMemberCondition',
+    'ServiceMultiRegionSettings',
     'ServiceScaling',
     'ServiceTemplate',
     'ServiceTemplateContainer',
@@ -142,6 +143,7 @@ __all__ = [
     'GetServiceBinaryAuthorizationResult',
     'GetServiceBuildConfigResult',
     'GetServiceConditionResult',
+    'GetServiceMultiRegionSettingResult',
     'GetServiceScalingResult',
     'GetServiceTemplateResult',
     'GetServiceTemplateContainerResult',
@@ -2586,6 +2588,56 @@ class ServiceIamMemberCondition(dict):
         return pulumi.get(self, "description")
 
 
+@pulumi.output_type
+class ServiceMultiRegionSettings(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "multiRegionId":
+            suggest = "multi_region_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceMultiRegionSettings. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceMultiRegionSettings.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceMultiRegionSettings.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 multi_region_id: Optional[_builtins.str] = None,
+                 regions: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param _builtins.str multi_region_id: (Output)
+               System-generated unique id for the multi-region Service.
+        :param Sequence[_builtins.str] regions: The list of regions to deploy the multi-region Service.
+        """
+        if multi_region_id is not None:
+            pulumi.set(__self__, "multi_region_id", multi_region_id)
+        if regions is not None:
+            pulumi.set(__self__, "regions", regions)
+
+    @_builtins.property
+    @pulumi.getter(name="multiRegionId")
+    def multi_region_id(self) -> Optional[_builtins.str]:
+        """
+        (Output)
+        System-generated unique id for the multi-region Service.
+        """
+        return pulumi.get(self, "multi_region_id")
+
+    @_builtins.property
+    @pulumi.getter
+    def regions(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        The list of regions to deploy the multi-region Service.
+        """
+        return pulumi.get(self, "regions")
+
+
 @pulumi.output_type
 class ServiceScaling(dict):
     @staticmethod
@@ -2593,6 +2645,8 @@ class ServiceScaling(dict):
         suggest = None
         if key == "manualInstanceCount":
             suggest = "manual_instance_count"
+        elif key == "maxInstanceCount":
+            suggest = "max_instance_count"
         elif key == "minInstanceCount":
             suggest = "min_instance_count"
         elif key == "scalingMode":
@@ -2611,16 +2665,20 @@ class ServiceScaling(dict):
 
     def __init__(__self__, *,
                  manual_instance_count: Optional[_builtins.int] = None,
+                 max_instance_count: Optional[_builtins.int] = None,
                  min_instance_count: Optional[_builtins.int] = None,
                  scaling_mode: Optional[_builtins.str] = None):
         """
         :param _builtins.int manual_instance_count: Total instance count for the service in manual scaling mode. This number of instances is divided among all revisions with specified traffic based on the percent of traffic they are receiving.
+        :param _builtins.int max_instance_count: Combined maximum number of instances for all revisions receiving traffic.
         :param _builtins.int min_instance_count: Minimum number of instances for the service, to be divided among all revisions receiving traffic.
         :param _builtins.str scaling_mode: The [scaling mode](https://cloud.google.com/run/docs/reference/rest/v2/projects.locations.services#scalingmode) for the service.
                Possible values are: `AUTOMATIC`, `MANUAL`.
         """
         if manual_instance_count is not None:
             pulumi.set(__self__, "manual_instance_count", manual_instance_count)
+        if max_instance_count is not None:
+            pulumi.set(__self__, "max_instance_count", max_instance_count)
         if min_instance_count is not None:
             pulumi.set(__self__, "min_instance_count", min_instance_count)
         if scaling_mode is not None:
@@ -2634,6 +2692,14 @@ class ServiceScaling(dict):
         """
         return pulumi.get(self, "manual_instance_count")
 
+    @_builtins.property
+    @pulumi.getter(name="maxInstanceCount")
+    def max_instance_count(self) -> Optional[_builtins.int]:
+        """
+        Combined maximum number of instances for all revisions receiving traffic.
+        """
+        return pulumi.get(self, "max_instance_count")
+
     @_builtins.property
     @pulumi.getter(name="minInstanceCount")
     def min_instance_count(self) -> Optional[_builtins.int]:
@@ -4074,8 +4140,7 @@ class ServiceTemplateScaling(dict):
                  max_instance_count: Optional[_builtins.int] = None,
                  min_instance_count: Optional[_builtins.int] = None):
         """
-        :param _builtins.int max_instance_count: Maximum number of serving instances that this resource should have. Must not be less than minimum instance count. If absent, Cloud Run will calculate
-               a default value based on the project's available container instances quota in the region and specified instance size.
+        :param _builtins.int max_instance_count: Combined maximum number of instances for all revisions receiving traffic.
         :param _builtins.int min_instance_count: Minimum number of instances for the service, to be divided among all revisions receiving traffic.
         """
         if max_instance_count is not None:
@@ -4087,8 +4152,7 @@ class ServiceTemplateScaling(dict):
     @pulumi.getter(name="maxInstanceCount")
     def max_instance_count(self) -> Optional[_builtins.int]:
         """
-        Maximum number of serving instances that this resource should have. Must not be less than minimum instance count. If absent, Cloud Run will calculate
-        a default value based on the project's available container instances quota in the region and specified instance size.
+        Combined maximum number of instances for all revisions receiving traffic.
         """
         return pulumi.get(self, "max_instance_count")
 
@@ -5554,9 +5618,7 @@ class WorkerPoolTemplateContainer(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "dependsOns":
-            suggest = "depends_ons"
-        elif key == "volumeMounts":
+        if key == "volumeMounts":
             suggest = "volume_mounts"
         elif key == "workingDir":
             suggest = "working_dir"
@@ -5576,7 +5638,6 @@ class WorkerPoolTemplateContainer(dict):
                  image: _builtins.str,
                  args: Optional[Sequence[_builtins.str]] = None,
                  commands: Optional[Sequence[_builtins.str]] = None,
-                 depends_ons: Optional[Sequence[_builtins.str]] = None,
                  envs: Optional[Sequence['outputs.WorkerPoolTemplateContainerEnv']] = None,
                  name: Optional[_builtins.str] = None,
                  resources: Optional['outputs.WorkerPoolTemplateContainerResources'] = None,
@@ -5586,7 +5647,6 @@ class WorkerPoolTemplateContainer(dict):
         :param _builtins.str image: URL of the Container image in Google Container Registry or Google Artifact Registry. More info: https://kubernetes.io/docs/concepts/containers/images
         :param Sequence[_builtins.str] args: Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references are not supported in Cloud Run.
         :param Sequence[_builtins.str] commands: Entrypoint array. Not executed within a shell. The docker image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
-        :param Sequence[_builtins.str] depends_ons: Containers which should be started before this container. If specified the container will wait to start until all containers with the listed names are healthy.
         :param Sequence['WorkerPoolTemplateContainerEnvArgs'] envs: List of environment variables to set in the container.
                Structure is documented below.
         :param _builtins.str name: Name of the container specified as a DNS_LABEL.
@@ -5601,8 +5661,6 @@ class WorkerPoolTemplateContainer(dict):
             pulumi.set(__self__, "args", args)
         if commands is not None:
             pulumi.set(__self__, "commands", commands)
-        if depends_ons is not None:
-            pulumi.set(__self__, "depends_ons", depends_ons)
         if envs is not None:
             pulumi.set(__self__, "envs", envs)
         if name is not None:
@@ -5638,14 +5696,6 @@ class WorkerPoolTemplateContainer(dict):
         """
         return pulumi.get(self, "commands")
 
-    @_builtins.property
-    @pulumi.getter(name="dependsOns")
-    def depends_ons(self) -> Optional[Sequence[_builtins.str]]:
-        """
-        Containers which should be started before this container. If specified the container will wait to start until all containers with the listed names are healthy.
-        """
-        return pulumi.get(self, "depends_ons")
-
     @_builtins.property
     @pulumi.getter
     def envs(self) -> Optional[Sequence['outputs.WorkerPoolTemplateContainerEnv']]:
@@ -8192,18 +8242,50 @@ class GetServiceConditionResult(dict):
         return pulumi.get(self, "type")
 
 
+@pulumi.output_type
+class GetServiceMultiRegionSettingResult(dict):
+    def __init__(__self__, *,
+                 multi_region_id: _builtins.str,
+                 regions: Sequence[_builtins.str]):
+        """
+        :param _builtins.str multi_region_id: System-generated unique id for the multi-region Service.
+        :param Sequence[_builtins.str] regions: The list of regions to deploy the multi-region Service.
+        """
+        pulumi.set(__self__, "multi_region_id", multi_region_id)
+        pulumi.set(__self__, "regions", regions)
+
+    @_builtins.property
+    @pulumi.getter(name="multiRegionId")
+    def multi_region_id(self) -> _builtins.str:
+        """
+        System-generated unique id for the multi-region Service.
+        """
+        return pulumi.get(self, "multi_region_id")
+
+    @_builtins.property
+    @pulumi.getter
+    def regions(self) -> Sequence[_builtins.str]:
+        """
+        The list of regions to deploy the multi-region Service.
+        """
+        return pulumi.get(self, "regions")
+
+
 @pulumi.output_type
 class GetServiceScalingResult(dict):
     def __init__(__self__, *,
                  manual_instance_count: _builtins.int,
+                 max_instance_count: _builtins.int,
                  min_instance_count: _builtins.int,
                  scaling_mode: _builtins.str):
         """
         :param _builtins.int manual_instance_count: Total instance count for the service in manual scaling mode. This number of instances is divided among all revisions with specified traffic based on the percent of traffic they are receiving.
+        :param _builtins.int max_instance_count: Combined maximum number of instances for all revisions receiving traffic.
         :param _builtins.int min_instance_count: Minimum number of instances for the service, to be divided among all revisions receiving traffic.
         :param _builtins.str scaling_mode: The [scaling mode](https://cloud.google.com/run/docs/reference/rest/v2/projects.locations.services#scalingmode) for the service. Possible values: ["AUTOMATIC", "MANUAL"]
         """
         pulumi.set(__self__, "manual_instance_count", manual_instance_count)
+        pulumi.set(__self__, "max_instance_count", max_instance_count)
         pulumi.set(__self__, "min_instance_count", min_instance_count)
         pulumi.set(__self__, "scaling_mode", scaling_mode)
 
@@ -8215,6 +8297,14 @@ class GetServiceScalingResult(dict):
         """
         return pulumi.get(self, "manual_instance_count")
 
+    @_builtins.property
+    @pulumi.getter(name="maxInstanceCount")
+    def max_instance_count(self) -> _builtins.int:
+        """
+        Combined maximum number of instances for all revisions receiving traffic.
+        """
+        return pulumi.get(self, "max_instance_count")
+
     @_builtins.property
     @pulumi.getter(name="minInstanceCount")
     def min_instance_count(self) -> _builtins.int:
@@ -10323,7 +10413,6 @@ class GetWorkerPoolTemplateContainerResult(dict):
     def __init__(__self__, *,
                  args: Sequence[_builtins.str],
                  commands: Sequence[_builtins.str],
-                 depends_ons: Sequence[_builtins.str],
                  envs: Sequence['outputs.GetWorkerPoolTemplateContainerEnvResult'],
                  image: _builtins.str,
                  name: _builtins.str,
@@ -10333,7 +10422,6 @@ class GetWorkerPoolTemplateContainerResult(dict):
         """
         :param Sequence[_builtins.str] args: Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references are not supported in Cloud Run.
         :param Sequence[_builtins.str] commands: Entrypoint array. Not executed within a shell. The docker image's ENTRYPOINT is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
-        :param Sequence[_builtins.str] depends_ons: Containers which should be started before this container. If specified the container will wait to start until all containers with the listed names are healthy.
         :param Sequence['GetWorkerPoolTemplateContainerEnvArgs'] envs: List of environment variables to set in the container.
         :param _builtins.str image: URL of the Container image in Google Container Registry or Google Artifact Registry. More info: https://kubernetes.io/docs/concepts/containers/images
         :param _builtins.str name: The name of the Cloud Run v2 Worker Pool.
@@ -10343,7 +10431,6 @@ class GetWorkerPoolTemplateContainerResult(dict):
         """
         pulumi.set(__self__, "args", args)
         pulumi.set(__self__, "commands", commands)
-        pulumi.set(__self__, "depends_ons", depends_ons)
         pulumi.set(__self__, "envs", envs)
         pulumi.set(__self__, "image", image)
         pulumi.set(__self__, "name", name)
@@ -10367,14 +10454,6 @@ class GetWorkerPoolTemplateContainerResult(dict):
         """
         return pulumi.get(self, "commands")
 
-    @_builtins.property
-    @pulumi.getter(name="dependsOns")
-    def depends_ons(self) -> Sequence[_builtins.str]:
-        """
-        Containers which should be started before this container. If specified the container will wait to start until all containers with the listed names are healthy.
-        """
-        return pulumi.get(self, "depends_ons")
-
     @_builtins.property
     @pulumi.getter
     def envs(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerEnvResult']: