pulumi-gcp 9.3.0a1759387993__py3-none-any.whl → 9.3.0a1759868184__py3-none-any.whl

pulumi_gcp/cloudrunv2/outputs.py

@@ -99,7 +99,17 @@ __all__ = [
     'WorkerPoolTemplateContainerEnv',
     'WorkerPoolTemplateContainerEnvValueSource',
     'WorkerPoolTemplateContainerEnvValueSourceSecretKeyRef',
+    'WorkerPoolTemplateContainerLivenessProbe',
+    'WorkerPoolTemplateContainerLivenessProbeGrpc',
+    'WorkerPoolTemplateContainerLivenessProbeHttpGet',
+    'WorkerPoolTemplateContainerLivenessProbeHttpGetHttpHeaders',
+    'WorkerPoolTemplateContainerLivenessProbeTcpSocket',
     'WorkerPoolTemplateContainerResources',
+    'WorkerPoolTemplateContainerStartupProbe',
+    'WorkerPoolTemplateContainerStartupProbeGrpc',
+    'WorkerPoolTemplateContainerStartupProbeHttpGet',
+    'WorkerPoolTemplateContainerStartupProbeHttpGetHttpHeaders',
+    'WorkerPoolTemplateContainerStartupProbeTcpSocket',
     'WorkerPoolTemplateContainerVolumeMount',
     'WorkerPoolTemplateNodeSelector',
     'WorkerPoolTemplateVolume',
@@ -189,7 +199,17 @@ __all__ = [
     'GetWorkerPoolTemplateContainerEnvResult',
     'GetWorkerPoolTemplateContainerEnvValueSourceResult',
     'GetWorkerPoolTemplateContainerEnvValueSourceSecretKeyRefResult',
+    'GetWorkerPoolTemplateContainerLivenessProbeResult',
+    'GetWorkerPoolTemplateContainerLivenessProbeGrpcResult',
+    'GetWorkerPoolTemplateContainerLivenessProbeHttpGetResult',
+    'GetWorkerPoolTemplateContainerLivenessProbeHttpGetHttpHeaderResult',
+    'GetWorkerPoolTemplateContainerLivenessProbeTcpSocketResult',
     'GetWorkerPoolTemplateContainerResourceResult',
+    'GetWorkerPoolTemplateContainerStartupProbeResult',
+    'GetWorkerPoolTemplateContainerStartupProbeGrpcResult',
+    'GetWorkerPoolTemplateContainerStartupProbeHttpGetResult',
+    'GetWorkerPoolTemplateContainerStartupProbeHttpGetHttpHeaderResult',
+    'GetWorkerPoolTemplateContainerStartupProbeTcpSocketResult',
     'GetWorkerPoolTemplateContainerVolumeMountResult',
     'GetWorkerPoolTemplateNodeSelectorResult',
     'GetWorkerPoolTemplateVolumeResult',
@@ -5646,7 +5666,11 @@ class WorkerPoolTemplateContainer(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "volumeMounts":
+        if key == "livenessProbe":
+            suggest = "liveness_probe"
+        elif key == "startupProbe":
+            suggest = "startup_probe"
+        elif key == "volumeMounts":
             suggest = "volume_mounts"
         elif key == "workingDir":
             suggest = "working_dir"
@@ -5667,8 +5691,10 @@ class WorkerPoolTemplateContainer(dict):
                  args: Optional[Sequence[_builtins.str]] = None,
                  commands: Optional[Sequence[_builtins.str]] = None,
                  envs: Optional[Sequence['outputs.WorkerPoolTemplateContainerEnv']] = None,
+                 liveness_probe: Optional['outputs.WorkerPoolTemplateContainerLivenessProbe'] = None,
                  name: Optional[_builtins.str] = None,
                  resources: Optional['outputs.WorkerPoolTemplateContainerResources'] = None,
+                 startup_probe: Optional['outputs.WorkerPoolTemplateContainerStartupProbe'] = None,
                  volume_mounts: Optional[Sequence['outputs.WorkerPoolTemplateContainerVolumeMount']] = None,
                  working_dir: Optional[_builtins.str] = None):
         """
@@ -5677,9 +5703,13 @@ class WorkerPoolTemplateContainer(dict):
         :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['WorkerPoolTemplateContainerEnvArgs'] envs: List of environment variables to set in the container.
                Structure is documented below.
+        :param 'WorkerPoolTemplateContainerLivenessProbeArgs' liveness_probe: Periodic probe of container liveness. Container will be restarted if the probe fails.
+               Structure is documented below.
         :param _builtins.str name: Name of the container specified as a DNS_LABEL.
         :param 'WorkerPoolTemplateContainerResourcesArgs' resources: Compute Resource requirements by this container. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources
                Structure is documented below.
+        :param 'WorkerPoolTemplateContainerStartupProbeArgs' startup_probe: Startup probe of application within the container. All other probes are disabled if a startup probe is provided, until it succeeds. Container will not be added to service endpoints if the probe fails.
+               Structure is documented below.
         :param Sequence['WorkerPoolTemplateContainerVolumeMountArgs'] volume_mounts: Volume to mount into the container's filesystem.
                Structure is documented below.
         :param _builtins.str working_dir: Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image.
@@ -5691,10 +5721,14 @@ class WorkerPoolTemplateContainer(dict):
             pulumi.set(__self__, "commands", commands)
         if envs is not None:
             pulumi.set(__self__, "envs", envs)
+        if liveness_probe is not None:
+            pulumi.set(__self__, "liveness_probe", liveness_probe)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if resources is not None:
             pulumi.set(__self__, "resources", resources)
+        if startup_probe is not None:
+            pulumi.set(__self__, "startup_probe", startup_probe)
         if volume_mounts is not None:
             pulumi.set(__self__, "volume_mounts", volume_mounts)
         if working_dir is not None:
@@ -5733,6 +5767,15 @@ class WorkerPoolTemplateContainer(dict):
         """
         return pulumi.get(self, "envs")
 
+    @_builtins.property
+    @pulumi.getter(name="livenessProbe")
+    def liveness_probe(self) -> Optional['outputs.WorkerPoolTemplateContainerLivenessProbe']:
+        """
+        Periodic probe of container liveness. Container will be restarted if the probe fails.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "liveness_probe")
+
     @_builtins.property
     @pulumi.getter
     def name(self) -> Optional[_builtins.str]:
@@ -5750,6 +5793,15 @@ class WorkerPoolTemplateContainer(dict):
         """
         return pulumi.get(self, "resources")
 
+    @_builtins.property
+    @pulumi.getter(name="startupProbe")
+    def startup_probe(self) -> Optional['outputs.WorkerPoolTemplateContainerStartupProbe']:
+        """
+        Startup probe of application within the container. All other probes are disabled if a startup probe is provided, until it succeeds. Container will not be added to service endpoints if the probe fails.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "startup_probe")
+
     @_builtins.property
     @pulumi.getter(name="volumeMounts")
     def volume_mounts(self) -> Optional[Sequence['outputs.WorkerPoolTemplateContainerVolumeMount']]:
@@ -5898,457 +5950,989 @@ class WorkerPoolTemplateContainerEnvValueSourceSecretKeyRef(dict):
 
 
 @pulumi.output_type
-class WorkerPoolTemplateContainerResources(dict):
-    def __init__(__self__, *,
-                 limits: Optional[Mapping[str, _builtins.str]] = None):
-        """
-        :param Mapping[str, _builtins.str] limits: Only memory, CPU, and nvidia.com/gpu are supported. Use key `cpu` for CPU limit, `memory` for memory limit, `nvidia.com/gpu` for gpu limit. Note: The only supported values for CPU are '1', '2', '4', and '8'. Setting 4 CPU requires at least 2Gi of memory. The values of the map is string form of the 'quantity' k8s type: https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go
-        """
-        if limits is not None:
-            pulumi.set(__self__, "limits", limits)
-
-    @_builtins.property
-    @pulumi.getter
-    def limits(self) -> Optional[Mapping[str, _builtins.str]]:
-        """
-        Only memory, CPU, and nvidia.com/gpu are supported. Use key `cpu` for CPU limit, `memory` for memory limit, `nvidia.com/gpu` for gpu limit. Note: The only supported values for CPU are '1', '2', '4', and '8'. Setting 4 CPU requires at least 2Gi of memory. The values of the map is string form of the 'quantity' k8s type: https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go
-        """
-        return pulumi.get(self, "limits")
-
-
-@pulumi.output_type
-class WorkerPoolTemplateContainerVolumeMount(dict):
+class WorkerPoolTemplateContainerLivenessProbe(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "mountPath":
-            suggest = "mount_path"
-        elif key == "subPath":
-            suggest = "sub_path"
+        if key == "failureThreshold":
+            suggest = "failure_threshold"
+        elif key == "httpGet":
+            suggest = "http_get"
+        elif key == "initialDelaySeconds":
+            suggest = "initial_delay_seconds"
+        elif key == "periodSeconds":
+            suggest = "period_seconds"
+        elif key == "tcpSocket":
+            suggest = "tcp_socket"
+        elif key == "timeoutSeconds":
+            suggest = "timeout_seconds"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateContainerVolumeMount. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateContainerLivenessProbe. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        WorkerPoolTemplateContainerVolumeMount.__key_warning(key)
+        WorkerPoolTemplateContainerLivenessProbe.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        WorkerPoolTemplateContainerVolumeMount.__key_warning(key)
+        WorkerPoolTemplateContainerLivenessProbe.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 mount_path: _builtins.str,
-                 name: _builtins.str,
-                 sub_path: Optional[_builtins.str] = None):
+                 failure_threshold: Optional[_builtins.int] = None,
+                 grpc: Optional['outputs.WorkerPoolTemplateContainerLivenessProbeGrpc'] = None,
+                 http_get: Optional['outputs.WorkerPoolTemplateContainerLivenessProbeHttpGet'] = None,
+                 initial_delay_seconds: Optional[_builtins.int] = None,
+                 period_seconds: Optional[_builtins.int] = None,
+                 tcp_socket: Optional['outputs.WorkerPoolTemplateContainerLivenessProbeTcpSocket'] = None,
+                 timeout_seconds: Optional[_builtins.int] = None):
         """
-        :param _builtins.str mount_path: Path within the container at which the volume should be mounted. Must not contain ':'. For Cloud SQL volumes, it can be left empty, or must otherwise be /cloudsql. All instances defined in the Volume will be available as /cloudsql/[instance]. For more information on Cloud SQL volumes, visit https://cloud.google.com/sql/docs/mysql/connect-run
-        :param _builtins.str name: This must match the Name of a Volume.
-        :param _builtins.str sub_path: Path within the volume from which the container's volume should be mounted.
+        :param _builtins.int failure_threshold: Optional. Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.
+        :param 'WorkerPoolTemplateContainerLivenessProbeGrpcArgs' grpc: Optional. GRPC specifies an action involving a gRPC port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+               Structure is documented below.
+        :param 'WorkerPoolTemplateContainerLivenessProbeHttpGetArgs' http_get: Optional. HTTPGet specifies the http request to perform. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+               Structure is documented below.
+        :param _builtins.int initial_delay_seconds: Optional. Number of seconds after the container has started before the probe is initiated. Defaults to 0 seconds. Minimum value is 0. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240.
+        :param _builtins.int period_seconds: Optional. How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240. Must be greater or equal than timeout_seconds.
+        :param 'WorkerPoolTemplateContainerLivenessProbeTcpSocketArgs' tcp_socket: Optional. TCPSocket specifies an action involving a TCP port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+               Structure is documented below.
+        :param _builtins.int timeout_seconds: Optional. Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. Maximum value is 3600. Must be smaller than period_seconds.
         """
-        pulumi.set(__self__, "mount_path", mount_path)
-        pulumi.set(__self__, "name", name)
-        if sub_path is not None:
-            pulumi.set(__self__, "sub_path", sub_path)
+        if failure_threshold is not None:
+            pulumi.set(__self__, "failure_threshold", failure_threshold)
+        if grpc is not None:
+            pulumi.set(__self__, "grpc", grpc)
+        if http_get is not None:
+            pulumi.set(__self__, "http_get", http_get)
+        if initial_delay_seconds is not None:
+            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
+        if period_seconds is not None:
+            pulumi.set(__self__, "period_seconds", period_seconds)
+        if tcp_socket is not None:
+            pulumi.set(__self__, "tcp_socket", tcp_socket)
+        if timeout_seconds is not None:
+            pulumi.set(__self__, "timeout_seconds", timeout_seconds)
 
     @_builtins.property
-    @pulumi.getter(name="mountPath")
-    def mount_path(self) -> _builtins.str:
+    @pulumi.getter(name="failureThreshold")
+    def failure_threshold(self) -> Optional[_builtins.int]:
         """
-        Path within the container at which the volume should be mounted. Must not contain ':'. For Cloud SQL volumes, it can be left empty, or must otherwise be /cloudsql. All instances defined in the Volume will be available as /cloudsql/[instance]. For more information on Cloud SQL volumes, visit https://cloud.google.com/sql/docs/mysql/connect-run
+        Optional. Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.
         """
-        return pulumi.get(self, "mount_path")
+        return pulumi.get(self, "failure_threshold")
 
     @_builtins.property
     @pulumi.getter
-    def name(self) -> _builtins.str:
+    def grpc(self) -> Optional['outputs.WorkerPoolTemplateContainerLivenessProbeGrpc']:
         """
-        This must match the Name of a Volume.
+        Optional. GRPC specifies an action involving a gRPC port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        Structure is documented below.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "grpc")
 
     @_builtins.property
-    @pulumi.getter(name="subPath")
-    def sub_path(self) -> Optional[_builtins.str]:
+    @pulumi.getter(name="httpGet")
+    def http_get(self) -> Optional['outputs.WorkerPoolTemplateContainerLivenessProbeHttpGet']:
         """
-        Path within the volume from which the container's volume should be mounted.
+        Optional. HTTPGet specifies the http request to perform. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        Structure is documented below.
         """
-        return pulumi.get(self, "sub_path")
+        return pulumi.get(self, "http_get")
+
+    @_builtins.property
+    @pulumi.getter(name="initialDelaySeconds")
+    def initial_delay_seconds(self) -> Optional[_builtins.int]:
+        """
+        Optional. Number of seconds after the container has started before the probe is initiated. Defaults to 0 seconds. Minimum value is 0. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240.
+        """
+        return pulumi.get(self, "initial_delay_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="periodSeconds")
+    def period_seconds(self) -> Optional[_builtins.int]:
+        """
+        Optional. How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240. Must be greater or equal than timeout_seconds.
+        """
+        return pulumi.get(self, "period_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="tcpSocket")
+    def tcp_socket(self) -> Optional['outputs.WorkerPoolTemplateContainerLivenessProbeTcpSocket']:
+        """
+        Optional. TCPSocket specifies an action involving a TCP port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "tcp_socket")
+
+    @_builtins.property
+    @pulumi.getter(name="timeoutSeconds")
+    def timeout_seconds(self) -> Optional[_builtins.int]:
+        """
+        Optional. Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. Maximum value is 3600. Must be smaller than period_seconds.
+        """
+        return pulumi.get(self, "timeout_seconds")
 
 
 @pulumi.output_type
-class WorkerPoolTemplateNodeSelector(dict):
+class WorkerPoolTemplateContainerLivenessProbeGrpc(dict):
     def __init__(__self__, *,
-                 accelerator: _builtins.str):
+                 port: Optional[_builtins.int] = None,
+                 service: Optional[_builtins.str] = None):
         """
-        :param _builtins.str accelerator: The GPU to attach to an instance. See https://cloud.google.com/run/docs/configuring/services/gpu for configuring GPU.
+        :param _builtins.int port: Optional. Port number of the gRPC service. Number must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
+        :param _builtins.str service: Optional. Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md ). If this is not specified, the default behavior is defined by gRPC
         """
-        pulumi.set(__self__, "accelerator", accelerator)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if service is not None:
+            pulumi.set(__self__, "service", service)
 
     @_builtins.property
     @pulumi.getter
-    def accelerator(self) -> _builtins.str:
+    def port(self) -> Optional[_builtins.int]:
         """
-        The GPU to attach to an instance. See https://cloud.google.com/run/docs/configuring/services/gpu for configuring GPU.
+        Optional. Port number of the gRPC service. Number must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "accelerator")
+        return pulumi.get(self, "port")
+
+    @_builtins.property
+    @pulumi.getter
+    def service(self) -> Optional[_builtins.str]:
+        """
+        Optional. Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md ). If this is not specified, the default behavior is defined by gRPC
+        """
+        return pulumi.get(self, "service")
 
 
 @pulumi.output_type
-class WorkerPoolTemplateVolume(dict):
+class WorkerPoolTemplateContainerLivenessProbeHttpGet(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "cloudSqlInstance":
-            suggest = "cloud_sql_instance"
-        elif key == "emptyDir":
-            suggest = "empty_dir"
+        if key == "httpHeaders":
+            suggest = "http_headers"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateVolume. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateContainerLivenessProbeHttpGet. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        WorkerPoolTemplateVolume.__key_warning(key)
+        WorkerPoolTemplateContainerLivenessProbeHttpGet.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        WorkerPoolTemplateVolume.__key_warning(key)
+        WorkerPoolTemplateContainerLivenessProbeHttpGet.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 name: _builtins.str,
-                 cloud_sql_instance: Optional['outputs.WorkerPoolTemplateVolumeCloudSqlInstance'] = None,
-                 empty_dir: Optional['outputs.WorkerPoolTemplateVolumeEmptyDir'] = None,
-                 gcs: Optional['outputs.WorkerPoolTemplateVolumeGcs'] = None,
-                 nfs: Optional['outputs.WorkerPoolTemplateVolumeNfs'] = None,
-                 secret: Optional['outputs.WorkerPoolTemplateVolumeSecret'] = None):
+                 http_headers: Optional['outputs.WorkerPoolTemplateContainerLivenessProbeHttpGetHttpHeaders'] = None,
+                 path: Optional[_builtins.str] = None,
+                 port: Optional[_builtins.int] = None):
         """
-        :param _builtins.str name: Volume's name.
-        :param 'WorkerPoolTemplateVolumeCloudSqlInstanceArgs' cloud_sql_instance: For Cloud SQL volumes, contains the specific instances that should be mounted. Visit https://cloud.google.com/sql/docs/mysql/connect-run for more information on how to connect Cloud SQL and Cloud Run.
-               Structure is documented below.
-        :param 'WorkerPoolTemplateVolumeEmptyDirArgs' empty_dir: Ephemeral storage used as a shared volume.
-               Structure is documented below.
-        :param 'WorkerPoolTemplateVolumeGcsArgs' gcs: Cloud Storage bucket mounted as a volume using GCSFuse. This feature is only supported in the gen2 execution environment.
-               Structure is documented below.
-        :param 'WorkerPoolTemplateVolumeNfsArgs' nfs: Represents an NFS mount.
-               Structure is documented below.
-        :param 'WorkerPoolTemplateVolumeSecretArgs' secret: Secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret
+        :param 'WorkerPoolTemplateContainerLivenessProbeHttpGetHttpHeadersArgs' http_headers: Optional. Custom headers to set in the request. HTTP allows repeated headers.
                Structure is documented below.
+        :param _builtins.str path: Optional. Path to access on the HTTP server. Defaults to '/'.
+        :param _builtins.int port: Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        pulumi.set(__self__, "name", name)
-        if cloud_sql_instance is not None:
-            pulumi.set(__self__, "cloud_sql_instance", cloud_sql_instance)
-        if empty_dir is not None:
-            pulumi.set(__self__, "empty_dir", empty_dir)
-        if gcs is not None:
-            pulumi.set(__self__, "gcs", gcs)
-        if nfs is not None:
-            pulumi.set(__self__, "nfs", nfs)
-        if secret is not None:
-            pulumi.set(__self__, "secret", secret)
+        if http_headers is not None:
+            pulumi.set(__self__, "http_headers", http_headers)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
 
     @_builtins.property
-    @pulumi.getter
-    def name(self) -> _builtins.str:
+    @pulumi.getter(name="httpHeaders")
+    def http_headers(self) -> Optional['outputs.WorkerPoolTemplateContainerLivenessProbeHttpGetHttpHeaders']:
         """
-        Volume's name.
+        Optional. Custom headers to set in the request. HTTP allows repeated headers.
+        Structure is documented below.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "http_headers")
 
     @_builtins.property
-    @pulumi.getter(name="cloudSqlInstance")
-    def cloud_sql_instance(self) -> Optional['outputs.WorkerPoolTemplateVolumeCloudSqlInstance']:
+    @pulumi.getter
+    def path(self) -> Optional[_builtins.str]:
         """
-        For Cloud SQL volumes, contains the specific instances that should be mounted. Visit https://cloud.google.com/sql/docs/mysql/connect-run for more information on how to connect Cloud SQL and Cloud Run.
-        Structure is documented below.
+        Optional. Path to access on the HTTP server. Defaults to '/'.
         """
-        return pulumi.get(self, "cloud_sql_instance")
+        return pulumi.get(self, "path")
 
     @_builtins.property
-    @pulumi.getter(name="emptyDir")
-    def empty_dir(self) -> Optional['outputs.WorkerPoolTemplateVolumeEmptyDir']:
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
         """
-        Ephemeral storage used as a shared volume.
-        Structure is documented below.
+        Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "empty_dir")
+        return pulumi.get(self, "port")
 
-    @_builtins.property
-    @pulumi.getter
-    def gcs(self) -> Optional['outputs.WorkerPoolTemplateVolumeGcs']:
+
+@pulumi.output_type
+class WorkerPoolTemplateContainerLivenessProbeHttpGetHttpHeaders(dict):
+    def __init__(__self__, *,
+                 port: _builtins.int,
+                 value: Optional[_builtins.str] = None):
         """
-        Cloud Storage bucket mounted as a volume using GCSFuse. This feature is only supported in the gen2 execution environment.
-        Structure is documented below.
+        :param _builtins.int port: Required. The header field name
+        :param _builtins.str value: Optional. The header field value
         """
-        return pulumi.get(self, "gcs")
+        pulumi.set(__self__, "port", port)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
 
     @_builtins.property
     @pulumi.getter
-    def nfs(self) -> Optional['outputs.WorkerPoolTemplateVolumeNfs']:
+    def port(self) -> _builtins.int:
         """
-        Represents an NFS mount.
-        Structure is documented below.
+        Required. The header field name
         """
-        return pulumi.get(self, "nfs")
+        return pulumi.get(self, "port")
 
     @_builtins.property
     @pulumi.getter
-    def secret(self) -> Optional['outputs.WorkerPoolTemplateVolumeSecret']:
+    def value(self) -> Optional[_builtins.str]:
         """
-        Secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret
-        Structure is documented below.
+        Optional. The header field value
         """
-        return pulumi.get(self, "secret")
+        return pulumi.get(self, "value")
 
 
 @pulumi.output_type
-class WorkerPoolTemplateVolumeCloudSqlInstance(dict):
+class WorkerPoolTemplateContainerLivenessProbeTcpSocket(dict):
     def __init__(__self__, *,
-                 instances: Optional[Sequence[_builtins.str]] = None):
+                 port: Optional[_builtins.int] = None):
         """
-        :param Sequence[_builtins.str] instances: The Cloud SQL instance connection names, as can be found in https://console.cloud.google.com/sql/instances. Visit https://cloud.google.com/sql/docs/mysql/connect-run for more information on how to connect Cloud SQL and Cloud Run. Format: {project}:{location}:{instance}
+        :param _builtins.int port: Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        if instances is not None:
-            pulumi.set(__self__, "instances", instances)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
 
     @_builtins.property
     @pulumi.getter
-    def instances(self) -> Optional[Sequence[_builtins.str]]:
+    def port(self) -> Optional[_builtins.int]:
         """
-        The Cloud SQL instance connection names, as can be found in https://console.cloud.google.com/sql/instances. Visit https://cloud.google.com/sql/docs/mysql/connect-run for more information on how to connect Cloud SQL and Cloud Run. Format: {project}:{location}:{instance}
+        Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "instances")
+        return pulumi.get(self, "port")
 
 
 @pulumi.output_type
-class WorkerPoolTemplateVolumeEmptyDir(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "sizeLimit":
-            suggest = "size_limit"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateVolumeEmptyDir. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        WorkerPoolTemplateVolumeEmptyDir.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        WorkerPoolTemplateVolumeEmptyDir.__key_warning(key)
-        return super().get(key, default)
-
+class WorkerPoolTemplateContainerResources(dict):
     def __init__(__self__, *,
-                 medium: Optional[_builtins.str] = None,
-                 size_limit: Optional[_builtins.str] = None):
+                 limits: Optional[Mapping[str, _builtins.str]] = None):
         """
-        :param _builtins.str medium: The different types of medium supported for EmptyDir.
-               Default value is `MEMORY`.
-               Possible values are: `MEMORY`.
-        :param _builtins.str size_limit: Limit on the storage usable by this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. This field's values are of the 'Quantity' k8s type: https://kubernetes.io/docs/reference/kubernetes-api/common-definitions/quantity/. The default is nil which means that the limit is undefined. More info: https://kubernetes.io/docs/concepts/storage/volumes/#emptydir.
+        :param Mapping[str, _builtins.str] limits: Only memory, CPU, and nvidia.com/gpu are supported. Use key `cpu` for CPU limit, `memory` for memory limit, `nvidia.com/gpu` for gpu limit. Note: The only supported values for CPU are '1', '2', '4', and '8'. Setting 4 CPU requires at least 2Gi of memory. The values of the map is string form of the 'quantity' k8s type: https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go
         """
-        if medium is not None:
-            pulumi.set(__self__, "medium", medium)
-        if size_limit is not None:
-            pulumi.set(__self__, "size_limit", size_limit)
+        if limits is not None:
+            pulumi.set(__self__, "limits", limits)
 
     @_builtins.property
     @pulumi.getter
-    def medium(self) -> Optional[_builtins.str]:
-        """
-        The different types of medium supported for EmptyDir.
-        Default value is `MEMORY`.
-        Possible values are: `MEMORY`.
-        """
-        return pulumi.get(self, "medium")
-
-    @_builtins.property
-    @pulumi.getter(name="sizeLimit")
-    def size_limit(self) -> Optional[_builtins.str]:
+    def limits(self) -> Optional[Mapping[str, _builtins.str]]:
         """
-        Limit on the storage usable by this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. This field's values are of the 'Quantity' k8s type: https://kubernetes.io/docs/reference/kubernetes-api/common-definitions/quantity/. The default is nil which means that the limit is undefined. More info: https://kubernetes.io/docs/concepts/storage/volumes/#emptydir.
+        Only memory, CPU, and nvidia.com/gpu are supported. Use key `cpu` for CPU limit, `memory` for memory limit, `nvidia.com/gpu` for gpu limit. Note: The only supported values for CPU are '1', '2', '4', and '8'. Setting 4 CPU requires at least 2Gi of memory. The values of the map is string form of the 'quantity' k8s type: https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go
         """
-        return pulumi.get(self, "size_limit")
+        return pulumi.get(self, "limits")
 
 
 @pulumi.output_type
-class WorkerPoolTemplateVolumeGcs(dict):
+class WorkerPoolTemplateContainerStartupProbe(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "mountOptions":
-            suggest = "mount_options"
-        elif key == "readOnly":
-            suggest = "read_only"
+        if key == "failureThreshold":
+            suggest = "failure_threshold"
+        elif key == "httpGet":
+            suggest = "http_get"
+        elif key == "initialDelaySeconds":
+            suggest = "initial_delay_seconds"
+        elif key == "periodSeconds":
+            suggest = "period_seconds"
+        elif key == "tcpSocket":
+            suggest = "tcp_socket"
+        elif key == "timeoutSeconds":
+            suggest = "timeout_seconds"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateVolumeGcs. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateContainerStartupProbe. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        WorkerPoolTemplateVolumeGcs.__key_warning(key)
+        WorkerPoolTemplateContainerStartupProbe.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        WorkerPoolTemplateVolumeGcs.__key_warning(key)
+        WorkerPoolTemplateContainerStartupProbe.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 bucket: _builtins.str,
-                 mount_options: Optional[Sequence[_builtins.str]] = None,
-                 read_only: Optional[_builtins.bool] = None):
+                 failure_threshold: Optional[_builtins.int] = None,
+                 grpc: Optional['outputs.WorkerPoolTemplateContainerStartupProbeGrpc'] = None,
+                 http_get: Optional['outputs.WorkerPoolTemplateContainerStartupProbeHttpGet'] = None,
+                 initial_delay_seconds: Optional[_builtins.int] = None,
+                 period_seconds: Optional[_builtins.int] = None,
+                 tcp_socket: Optional['outputs.WorkerPoolTemplateContainerStartupProbeTcpSocket'] = None,
+                 timeout_seconds: Optional[_builtins.int] = None):
         """
-        :param _builtins.str bucket: GCS Bucket name
-        :param Sequence[_builtins.str] mount_options: A list of flags to pass to the gcsfuse command for configuring this volume.
-               Flags should be passed without leading dashes.
-        :param _builtins.bool read_only: If true, mount the GCS bucket as read-only
+        :param _builtins.int failure_threshold: Optional. Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.
+        :param 'WorkerPoolTemplateContainerStartupProbeGrpcArgs' grpc: Optional. GRPC specifies an action involving a gRPC port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+               Structure is documented below.
+        :param 'WorkerPoolTemplateContainerStartupProbeHttpGetArgs' http_get: Optional. HTTPGet specifies the http request to perform. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+               Structure is documented below.
+        :param _builtins.int initial_delay_seconds: Optional. Number of seconds after the container has started before the probe is initiated. Defaults to 0 seconds. Minimum value is 0. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240.
+        :param _builtins.int period_seconds: Optional. How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240. Must be greater or equal than timeout_seconds.
+        :param 'WorkerPoolTemplateContainerStartupProbeTcpSocketArgs' tcp_socket: Optional. TCPSocket specifies an action involving a TCP port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+               Structure is documented below.
+        :param _builtins.int timeout_seconds: Optional. Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. Maximum value is 3600. Must be smaller than period_seconds.
         """
-        pulumi.set(__self__, "bucket", bucket)
-        if mount_options is not None:
-            pulumi.set(__self__, "mount_options", mount_options)
-        if read_only is not None:
-            pulumi.set(__self__, "read_only", read_only)
+        if failure_threshold is not None:
+            pulumi.set(__self__, "failure_threshold", failure_threshold)
+        if grpc is not None:
+            pulumi.set(__self__, "grpc", grpc)
+        if http_get is not None:
+            pulumi.set(__self__, "http_get", http_get)
+        if initial_delay_seconds is not None:
+            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
+        if period_seconds is not None:
+            pulumi.set(__self__, "period_seconds", period_seconds)
+        if tcp_socket is not None:
+            pulumi.set(__self__, "tcp_socket", tcp_socket)
+        if timeout_seconds is not None:
+            pulumi.set(__self__, "timeout_seconds", timeout_seconds)
 
     @_builtins.property
-    @pulumi.getter
-    def bucket(self) -> _builtins.str:
+    @pulumi.getter(name="failureThreshold")
+    def failure_threshold(self) -> Optional[_builtins.int]:
         """
-        GCS Bucket name
+        Optional. Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.
         """
-        return pulumi.get(self, "bucket")
+        return pulumi.get(self, "failure_threshold")
 
     @_builtins.property
-    @pulumi.getter(name="mountOptions")
-    def mount_options(self) -> Optional[Sequence[_builtins.str]]:
+    @pulumi.getter
+    def grpc(self) -> Optional['outputs.WorkerPoolTemplateContainerStartupProbeGrpc']:
         """
-        A list of flags to pass to the gcsfuse command for configuring this volume.
-        Flags should be passed without leading dashes.
+        Optional. GRPC specifies an action involving a gRPC port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        Structure is documented below.
         """
-        return pulumi.get(self, "mount_options")
+        return pulumi.get(self, "grpc")
 
     @_builtins.property
-    @pulumi.getter(name="readOnly")
-    def read_only(self) -> Optional[_builtins.bool]:
+    @pulumi.getter(name="httpGet")
+    def http_get(self) -> Optional['outputs.WorkerPoolTemplateContainerStartupProbeHttpGet']:
         """
-        If true, mount the GCS bucket as read-only
+        Optional. HTTPGet specifies the http request to perform. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        Structure is documented below.
         """
-        return pulumi.get(self, "read_only")
+        return pulumi.get(self, "http_get")
 
+    @_builtins.property
+    @pulumi.getter(name="initialDelaySeconds")
+    def initial_delay_seconds(self) -> Optional[_builtins.int]:
+        """
+        Optional. Number of seconds after the container has started before the probe is initiated. Defaults to 0 seconds. Minimum value is 0. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240.
+        """
+        return pulumi.get(self, "initial_delay_seconds")
 
-@pulumi.output_type
-class WorkerPoolTemplateVolumeNfs(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "readOnly":
-            suggest = "read_only"
+    @_builtins.property
+    @pulumi.getter(name="periodSeconds")
+    def period_seconds(self) -> Optional[_builtins.int]:
+        """
+        Optional. How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240. Must be greater or equal than timeout_seconds.
+        """
+        return pulumi.get(self, "period_seconds")
 
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateVolumeNfs. Access the value via the '{suggest}' property getter instead.")
+    @_builtins.property
+    @pulumi.getter(name="tcpSocket")
+    def tcp_socket(self) -> Optional['outputs.WorkerPoolTemplateContainerStartupProbeTcpSocket']:
+        """
+        Optional. TCPSocket specifies an action involving a TCP port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "tcp_socket")
 
-    def __getitem__(self, key: str) -> Any:
-        WorkerPoolTemplateVolumeNfs.__key_warning(key)
-        return super().__getitem__(key)
+    @_builtins.property
+    @pulumi.getter(name="timeoutSeconds")
+    def timeout_seconds(self) -> Optional[_builtins.int]:
+        """
+        Optional. Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. Maximum value is 3600. Must be smaller than period_seconds.
+        """
+        return pulumi.get(self, "timeout_seconds")
 
-    def get(self, key: str, default = None) -> Any:
-        WorkerPoolTemplateVolumeNfs.__key_warning(key)
-        return super().get(key, default)
 
+@pulumi.output_type
+class WorkerPoolTemplateContainerStartupProbeGrpc(dict):
     def __init__(__self__, *,
-                 path: _builtins.str,
-                 server: _builtins.str,
-                 read_only: Optional[_builtins.bool] = None):
+                 port: Optional[_builtins.int] = None,
+                 service: Optional[_builtins.str] = None):
         """
-        :param _builtins.str path: Path that is exported by the NFS server.
-        :param _builtins.str server: Hostname or IP address of the NFS server
-        :param _builtins.bool read_only: If true, mount the NFS volume as read only
+        :param _builtins.int port: Optional. Port number of the gRPC service. Number must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
+        :param _builtins.str service: Optional. Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md ). If this is not specified, the default behavior is defined by gRPC
         """
-        pulumi.set(__self__, "path", path)
-        pulumi.set(__self__, "server", server)
-        if read_only is not None:
-            pulumi.set(__self__, "read_only", read_only)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if service is not None:
+            pulumi.set(__self__, "service", service)
 
     @_builtins.property
     @pulumi.getter
-    def path(self) -> _builtins.str:
+    def port(self) -> Optional[_builtins.int]:
         """
-        Path that is exported by the NFS server.
+        Optional. Port number of the gRPC service. Number must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "path")
+        return pulumi.get(self, "port")
 
     @_builtins.property
     @pulumi.getter
-    def server(self) -> _builtins.str:
-        """
-        Hostname or IP address of the NFS server
-        """
-        return pulumi.get(self, "server")
-
-    @_builtins.property
-    @pulumi.getter(name="readOnly")
-    def read_only(self) -> Optional[_builtins.bool]:
+    def service(self) -> Optional[_builtins.str]:
         """
-        If true, mount the NFS volume as read only
+        Optional. Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md ). If this is not specified, the default behavior is defined by gRPC
         """
-        return pulumi.get(self, "read_only")
+        return pulumi.get(self, "service")
 
 
 @pulumi.output_type
-class WorkerPoolTemplateVolumeSecret(dict):
+class WorkerPoolTemplateContainerStartupProbeHttpGet(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "defaultMode":
-            suggest = "default_mode"
+        if key == "httpHeaders":
+            suggest = "http_headers"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateVolumeSecret. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateContainerStartupProbeHttpGet. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        WorkerPoolTemplateVolumeSecret.__key_warning(key)
+        WorkerPoolTemplateContainerStartupProbeHttpGet.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        WorkerPoolTemplateVolumeSecret.__key_warning(key)
+        WorkerPoolTemplateContainerStartupProbeHttpGet.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 secret: _builtins.str,
-                 default_mode: Optional[_builtins.int] = None,
-                 items: Optional[Sequence['outputs.WorkerPoolTemplateVolumeSecretItem']] = None):
+                 http_headers: Optional['outputs.WorkerPoolTemplateContainerStartupProbeHttpGetHttpHeaders'] = None,
+                 path: Optional[_builtins.str] = None,
+                 port: Optional[_builtins.int] = None):
         """
-        :param _builtins.str secret: The name of the secret in Cloud Secret Manager. Format: {secret} if the secret is in the same project. projects/{project}/secrets/{secret} if the secret is in a different project.
-        :param _builtins.int default_mode: Integer representation of mode bits to use on created files by default. Must be a value between 0000 and 0777 (octal), defaulting to 0444. Directories within the path are not affected by this setting.
-        :param Sequence['WorkerPoolTemplateVolumeSecretItemArgs'] items: If unspecified, the volume will expose a file whose name is the secret, relative to VolumeMount.mount_path. If specified, the key will be used as the version to fetch from Cloud Secret Manager and the path will be the name of the file exposed in the volume. When items are defined, they must specify a path and a version.
+        :param 'WorkerPoolTemplateContainerStartupProbeHttpGetHttpHeadersArgs' http_headers: Optional. Custom headers to set in the request. HTTP allows repeated headers.
                Structure is documented below.
+        :param _builtins.str path: Optional. Path to access on the HTTP server. Defaults to '/'.
+        :param _builtins.int port: Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        pulumi.set(__self__, "secret", secret)
-        if default_mode is not None:
-            pulumi.set(__self__, "default_mode", default_mode)
-        if items is not None:
-            pulumi.set(__self__, "items", items)
+        if http_headers is not None:
+            pulumi.set(__self__, "http_headers", http_headers)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
 
     @_builtins.property
-    @pulumi.getter
-    def secret(self) -> _builtins.str:
+    @pulumi.getter(name="httpHeaders")
+    def http_headers(self) -> Optional['outputs.WorkerPoolTemplateContainerStartupProbeHttpGetHttpHeaders']:
         """
-        The name of the secret in Cloud Secret Manager. Format: {secret} if the secret is in the same project. projects/{project}/secrets/{secret} if the secret is in a different project.
+        Optional. Custom headers to set in the request. HTTP allows repeated headers.
+        Structure is documented below.
         """
-        return pulumi.get(self, "secret")
+        return pulumi.get(self, "http_headers")
 
     @_builtins.property
-    @pulumi.getter(name="defaultMode")
-    def default_mode(self) -> Optional[_builtins.int]:
+    @pulumi.getter
+    def path(self) -> Optional[_builtins.str]:
         """
-        Integer representation of mode bits to use on created files by default. Must be a value between 0000 and 0777 (octal), defaulting to 0444. Directories within the path are not affected by this setting.
+        Optional. Path to access on the HTTP server. Defaults to '/'.
         """
-        return pulumi.get(self, "default_mode")
+        return pulumi.get(self, "path")
 
     @_builtins.property
     @pulumi.getter
-    def items(self) -> Optional[Sequence['outputs.WorkerPoolTemplateVolumeSecretItem']]:
+    def port(self) -> Optional[_builtins.int]:
         """
-        If unspecified, the volume will expose a file whose name is the secret, relative to VolumeMount.mount_path. If specified, the key will be used as the version to fetch from Cloud Secret Manager and the path will be the name of the file exposed in the volume. When items are defined, they must specify a path and a version.
+        Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
+        """
+        return pulumi.get(self, "port")
+
+
+@pulumi.output_type
+class WorkerPoolTemplateContainerStartupProbeHttpGetHttpHeaders(dict):
+    def __init__(__self__, *,
+                 port: _builtins.int,
+                 value: Optional[_builtins.str] = None):
+        """
+        :param _builtins.int port: Required. The header field name
+        :param _builtins.str value: Optional. The header field value
+        """
+        pulumi.set(__self__, "port", port)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> _builtins.int:
+        """
+        Required. The header field name
+        """
+        return pulumi.get(self, "port")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[_builtins.str]:
+        """
+        Optional. The header field value
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class WorkerPoolTemplateContainerStartupProbeTcpSocket(dict):
+    def __init__(__self__, *,
+                 port: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int port: Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
+        """
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
+        """
+        Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
+        """
+        return pulumi.get(self, "port")
+
+
+@pulumi.output_type
+class WorkerPoolTemplateContainerVolumeMount(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "mountPath":
+            suggest = "mount_path"
+        elif key == "subPath":
+            suggest = "sub_path"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateContainerVolumeMount. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkerPoolTemplateContainerVolumeMount.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkerPoolTemplateContainerVolumeMount.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 mount_path: _builtins.str,
+                 name: _builtins.str,
+                 sub_path: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str mount_path: Path within the container at which the volume should be mounted. Must not contain ':'. For Cloud SQL volumes, it can be left empty, or must otherwise be /cloudsql. All instances defined in the Volume will be available as /cloudsql/[instance]. For more information on Cloud SQL volumes, visit https://cloud.google.com/sql/docs/mysql/connect-run
+        :param _builtins.str name: This must match the Name of a Volume.
+        :param _builtins.str sub_path: Path within the volume from which the container's volume should be mounted.
+        """
+        pulumi.set(__self__, "mount_path", mount_path)
+        pulumi.set(__self__, "name", name)
+        if sub_path is not None:
+            pulumi.set(__self__, "sub_path", sub_path)
+
+    @_builtins.property
+    @pulumi.getter(name="mountPath")
+    def mount_path(self) -> _builtins.str:
+        """
+        Path within the container at which the volume should be mounted. Must not contain ':'. For Cloud SQL volumes, it can be left empty, or must otherwise be /cloudsql. All instances defined in the Volume will be available as /cloudsql/[instance]. For more information on Cloud SQL volumes, visit https://cloud.google.com/sql/docs/mysql/connect-run
+        """
+        return pulumi.get(self, "mount_path")
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> _builtins.str:
+        """
+        This must match the Name of a Volume.
+        """
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter(name="subPath")
+    def sub_path(self) -> Optional[_builtins.str]:
+        """
+        Path within the volume from which the container's volume should be mounted.
+        """
+        return pulumi.get(self, "sub_path")
+
+
+@pulumi.output_type
+class WorkerPoolTemplateNodeSelector(dict):
+    def __init__(__self__, *,
+                 accelerator: _builtins.str):
+        """
+        :param _builtins.str accelerator: The GPU to attach to an instance. See https://cloud.google.com/run/docs/configuring/services/gpu for configuring GPU.
+        """
+        pulumi.set(__self__, "accelerator", accelerator)
+
+    @_builtins.property
+    @pulumi.getter
+    def accelerator(self) -> _builtins.str:
+        """
+        The GPU to attach to an instance. See https://cloud.google.com/run/docs/configuring/services/gpu for configuring GPU.
+        """
+        return pulumi.get(self, "accelerator")
+
+
+@pulumi.output_type
+class WorkerPoolTemplateVolume(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "cloudSqlInstance":
+            suggest = "cloud_sql_instance"
+        elif key == "emptyDir":
+            suggest = "empty_dir"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateVolume. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkerPoolTemplateVolume.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkerPoolTemplateVolume.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 name: _builtins.str,
+                 cloud_sql_instance: Optional['outputs.WorkerPoolTemplateVolumeCloudSqlInstance'] = None,
+                 empty_dir: Optional['outputs.WorkerPoolTemplateVolumeEmptyDir'] = None,
+                 gcs: Optional['outputs.WorkerPoolTemplateVolumeGcs'] = None,
+                 nfs: Optional['outputs.WorkerPoolTemplateVolumeNfs'] = None,
+                 secret: Optional['outputs.WorkerPoolTemplateVolumeSecret'] = None):
+        """
+        :param _builtins.str name: Volume's name.
+        :param 'WorkerPoolTemplateVolumeCloudSqlInstanceArgs' cloud_sql_instance: For Cloud SQL volumes, contains the specific instances that should be mounted. Visit https://cloud.google.com/sql/docs/mysql/connect-run for more information on how to connect Cloud SQL and Cloud Run.
+               Structure is documented below.
+        :param 'WorkerPoolTemplateVolumeEmptyDirArgs' empty_dir: Ephemeral storage used as a shared volume.
+               Structure is documented below.
+        :param 'WorkerPoolTemplateVolumeGcsArgs' gcs: Cloud Storage bucket mounted as a volume using GCSFuse. This feature is only supported in the gen2 execution environment.
+               Structure is documented below.
+        :param 'WorkerPoolTemplateVolumeNfsArgs' nfs: Represents an NFS mount.
+               Structure is documented below.
+        :param 'WorkerPoolTemplateVolumeSecretArgs' secret: Secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "name", name)
+        if cloud_sql_instance is not None:
+            pulumi.set(__self__, "cloud_sql_instance", cloud_sql_instance)
+        if empty_dir is not None:
+            pulumi.set(__self__, "empty_dir", empty_dir)
+        if gcs is not None:
+            pulumi.set(__self__, "gcs", gcs)
+        if nfs is not None:
+            pulumi.set(__self__, "nfs", nfs)
+        if secret is not None:
+            pulumi.set(__self__, "secret", secret)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> _builtins.str:
+        """
+        Volume's name.
+        """
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter(name="cloudSqlInstance")
+    def cloud_sql_instance(self) -> Optional['outputs.WorkerPoolTemplateVolumeCloudSqlInstance']:
+        """
+        For Cloud SQL volumes, contains the specific instances that should be mounted. Visit https://cloud.google.com/sql/docs/mysql/connect-run for more information on how to connect Cloud SQL and Cloud Run.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "cloud_sql_instance")
+
+    @_builtins.property
+    @pulumi.getter(name="emptyDir")
+    def empty_dir(self) -> Optional['outputs.WorkerPoolTemplateVolumeEmptyDir']:
+        """
+        Ephemeral storage used as a shared volume.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "empty_dir")
+
+    @_builtins.property
+    @pulumi.getter
+    def gcs(self) -> Optional['outputs.WorkerPoolTemplateVolumeGcs']:
+        """
+        Cloud Storage bucket mounted as a volume using GCSFuse. This feature is only supported in the gen2 execution environment.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "gcs")
+
+    @_builtins.property
+    @pulumi.getter
+    def nfs(self) -> Optional['outputs.WorkerPoolTemplateVolumeNfs']:
+        """
+        Represents an NFS mount.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "nfs")
+
+    @_builtins.property
+    @pulumi.getter
+    def secret(self) -> Optional['outputs.WorkerPoolTemplateVolumeSecret']:
+        """
+        Secret represents a secret that should populate this volume. More info: https://kubernetes.io/docs/concepts/storage/volumes#secret
+        Structure is documented below.
+        """
+        return pulumi.get(self, "secret")
+
+
+@pulumi.output_type
+class WorkerPoolTemplateVolumeCloudSqlInstance(dict):
+    def __init__(__self__, *,
+                 instances: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param Sequence[_builtins.str] instances: The Cloud SQL instance connection names, as can be found in https://console.cloud.google.com/sql/instances. Visit https://cloud.google.com/sql/docs/mysql/connect-run for more information on how to connect Cloud SQL and Cloud Run. Format: {project}:{location}:{instance}
+        """
+        if instances is not None:
+            pulumi.set(__self__, "instances", instances)
+
+    @_builtins.property
+    @pulumi.getter
+    def instances(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        The Cloud SQL instance connection names, as can be found in https://console.cloud.google.com/sql/instances. Visit https://cloud.google.com/sql/docs/mysql/connect-run for more information on how to connect Cloud SQL and Cloud Run. Format: {project}:{location}:{instance}
+        """
+        return pulumi.get(self, "instances")
+
+
+@pulumi.output_type
+class WorkerPoolTemplateVolumeEmptyDir(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "sizeLimit":
+            suggest = "size_limit"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateVolumeEmptyDir. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkerPoolTemplateVolumeEmptyDir.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkerPoolTemplateVolumeEmptyDir.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 medium: Optional[_builtins.str] = None,
+                 size_limit: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str medium: The different types of medium supported for EmptyDir.
+               Default value is `MEMORY`.
+               Possible values are: `MEMORY`.
+        :param _builtins.str size_limit: Limit on the storage usable by this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. This field's values are of the 'Quantity' k8s type: https://kubernetes.io/docs/reference/kubernetes-api/common-definitions/quantity/. The default is nil which means that the limit is undefined. More info: https://kubernetes.io/docs/concepts/storage/volumes/#emptydir.
+        """
+        if medium is not None:
+            pulumi.set(__self__, "medium", medium)
+        if size_limit is not None:
+            pulumi.set(__self__, "size_limit", size_limit)
+
+    @_builtins.property
+    @pulumi.getter
+    def medium(self) -> Optional[_builtins.str]:
+        """
+        The different types of medium supported for EmptyDir.
+        Default value is `MEMORY`.
+        Possible values are: `MEMORY`.
+        """
+        return pulumi.get(self, "medium")
+
+    @_builtins.property
+    @pulumi.getter(name="sizeLimit")
+    def size_limit(self) -> Optional[_builtins.str]:
+        """
+        Limit on the storage usable by this EmptyDir volume. The size limit is also applicable for memory medium. The maximum usage on memory medium EmptyDir would be the minimum value between the SizeLimit specified here and the sum of memory limits of all containers in a pod. This field's values are of the 'Quantity' k8s type: https://kubernetes.io/docs/reference/kubernetes-api/common-definitions/quantity/. The default is nil which means that the limit is undefined. More info: https://kubernetes.io/docs/concepts/storage/volumes/#emptydir.
+        """
+        return pulumi.get(self, "size_limit")
+
+
+@pulumi.output_type
+class WorkerPoolTemplateVolumeGcs(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "mountOptions":
+            suggest = "mount_options"
+        elif key == "readOnly":
+            suggest = "read_only"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateVolumeGcs. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkerPoolTemplateVolumeGcs.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkerPoolTemplateVolumeGcs.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bucket: _builtins.str,
+                 mount_options: Optional[Sequence[_builtins.str]] = None,
+                 read_only: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.str bucket: GCS Bucket name
+        :param Sequence[_builtins.str] mount_options: A list of flags to pass to the gcsfuse command for configuring this volume.
+               Flags should be passed without leading dashes.
+        :param _builtins.bool read_only: If true, mount the GCS bucket as read-only
+        """
+        pulumi.set(__self__, "bucket", bucket)
+        if mount_options is not None:
+            pulumi.set(__self__, "mount_options", mount_options)
+        if read_only is not None:
+            pulumi.set(__self__, "read_only", read_only)
+
+    @_builtins.property
+    @pulumi.getter
+    def bucket(self) -> _builtins.str:
+        """
+        GCS Bucket name
+        """
+        return pulumi.get(self, "bucket")
+
+    @_builtins.property
+    @pulumi.getter(name="mountOptions")
+    def mount_options(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        A list of flags to pass to the gcsfuse command for configuring this volume.
+        Flags should be passed without leading dashes.
+        """
+        return pulumi.get(self, "mount_options")
+
+    @_builtins.property
+    @pulumi.getter(name="readOnly")
+    def read_only(self) -> Optional[_builtins.bool]:
+        """
+        If true, mount the GCS bucket as read-only
+        """
+        return pulumi.get(self, "read_only")
+
+
+@pulumi.output_type
+class WorkerPoolTemplateVolumeNfs(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "readOnly":
+            suggest = "read_only"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateVolumeNfs. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkerPoolTemplateVolumeNfs.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkerPoolTemplateVolumeNfs.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 path: _builtins.str,
+                 server: _builtins.str,
+                 read_only: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.str path: Path that is exported by the NFS server.
+        :param _builtins.str server: Hostname or IP address of the NFS server
+        :param _builtins.bool read_only: If true, mount the NFS volume as read only
+        """
+        pulumi.set(__self__, "path", path)
+        pulumi.set(__self__, "server", server)
+        if read_only is not None:
+            pulumi.set(__self__, "read_only", read_only)
+
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> _builtins.str:
+        """
+        Path that is exported by the NFS server.
+        """
+        return pulumi.get(self, "path")
+
+    @_builtins.property
+    @pulumi.getter
+    def server(self) -> _builtins.str:
+        """
+        Hostname or IP address of the NFS server
+        """
+        return pulumi.get(self, "server")
+
+    @_builtins.property
+    @pulumi.getter(name="readOnly")
+    def read_only(self) -> Optional[_builtins.bool]:
+        """
+        If true, mount the NFS volume as read only
+        """
+        return pulumi.get(self, "read_only")
+
+
+@pulumi.output_type
+class WorkerPoolTemplateVolumeSecret(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "defaultMode":
+            suggest = "default_mode"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkerPoolTemplateVolumeSecret. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkerPoolTemplateVolumeSecret.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkerPoolTemplateVolumeSecret.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 secret: _builtins.str,
+                 default_mode: Optional[_builtins.int] = None,
+                 items: Optional[Sequence['outputs.WorkerPoolTemplateVolumeSecretItem']] = None):
+        """
+        :param _builtins.str secret: The name of the secret in Cloud Secret Manager. Format: {secret} if the secret is in the same project. projects/{project}/secrets/{secret} if the secret is in a different project.
+        :param _builtins.int default_mode: Integer representation of mode bits to use on created files by default. Must be a value between 0000 and 0777 (octal), defaulting to 0444. Directories within the path are not affected by this setting.
+        :param Sequence['WorkerPoolTemplateVolumeSecretItemArgs'] items: If unspecified, the volume will expose a file whose name is the secret, relative to VolumeMount.mount_path. If specified, the key will be used as the version to fetch from Cloud Secret Manager and the path will be the name of the file exposed in the volume. When items are defined, they must specify a path and a version.
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "secret", secret)
+        if default_mode is not None:
+            pulumi.set(__self__, "default_mode", default_mode)
+        if items is not None:
+            pulumi.set(__self__, "items", items)
+
+    @_builtins.property
+    @pulumi.getter
+    def secret(self) -> _builtins.str:
+        """
+        The name of the secret in Cloud Secret Manager. Format: {secret} if the secret is in the same project. projects/{project}/secrets/{secret} if the secret is in a different project.
+        """
+        return pulumi.get(self, "secret")
+
+    @_builtins.property
+    @pulumi.getter(name="defaultMode")
+    def default_mode(self) -> Optional[_builtins.int]:
+        """
+        Integer representation of mode bits to use on created files by default. Must be a value between 0000 and 0777 (octal), defaulting to 0444. Directories within the path are not affected by this setting.
+        """
+        return pulumi.get(self, "default_mode")
+
+    @_builtins.property
+    @pulumi.getter
+    def items(self) -> Optional[Sequence['outputs.WorkerPoolTemplateVolumeSecretItem']]:
+        """
+        If unspecified, the volume will expose a file whose name is the secret, relative to VolumeMount.mount_path. If specified, the key will be used as the version to fetch from Cloud Secret Manager and the path will be the name of the file exposed in the volume. When items are defined, they must specify a path and a version.
         Structure is documented below.
         """
         return pulumi.get(self, "items")
@@ -9792,61 +10376,309 @@ class GetServiceTemplateVpcAccessResult(dict):
     @pulumi.getter(name="networkInterfaces")
     def network_interfaces(self) -> Sequence['outputs.GetServiceTemplateVpcAccessNetworkInterfaceResult']:
         """
-        Direct VPC egress settings. Currently only single network interface is supported.
+        Direct VPC egress settings. Currently only single network interface is supported.
+        """
+        return pulumi.get(self, "network_interfaces")
+
+
+@pulumi.output_type
+class GetServiceTemplateVpcAccessNetworkInterfaceResult(dict):
+    def __init__(__self__, *,
+                 network: _builtins.str,
+                 subnetwork: _builtins.str,
+                 tags: Sequence[_builtins.str]):
+        """
+        :param _builtins.str network: The VPC network that the Cloud Run resource will be able to send traffic to. At least one of network or subnetwork must be specified. If both
+               network and subnetwork are specified, the given VPC subnetwork must belong to the given VPC network. If network is not specified, it will be
+               looked up from the subnetwork.
+        :param _builtins.str subnetwork: The VPC subnetwork that the Cloud Run resource will get IPs from. At least one of network or subnetwork must be specified. If both
+               network and subnetwork are specified, the given VPC subnetwork must belong to the given VPC network. If subnetwork is not specified, the
+               subnetwork with the same name with the network will be used.
+        :param Sequence[_builtins.str] tags: Network tags applied to this Cloud Run service.
+        """
+        pulumi.set(__self__, "network", network)
+        pulumi.set(__self__, "subnetwork", subnetwork)
+        pulumi.set(__self__, "tags", tags)
+
+    @_builtins.property
+    @pulumi.getter
+    def network(self) -> _builtins.str:
+        """
+        The VPC network that the Cloud Run resource will be able to send traffic to. At least one of network or subnetwork must be specified. If both
+        network and subnetwork are specified, the given VPC subnetwork must belong to the given VPC network. If network is not specified, it will be
+        looked up from the subnetwork.
+        """
+        return pulumi.get(self, "network")
+
+    @_builtins.property
+    @pulumi.getter
+    def subnetwork(self) -> _builtins.str:
+        """
+        The VPC subnetwork that the Cloud Run resource will get IPs from. At least one of network or subnetwork must be specified. If both
+        network and subnetwork are specified, the given VPC subnetwork must belong to the given VPC network. If subnetwork is not specified, the
+        subnetwork with the same name with the network will be used.
+        """
+        return pulumi.get(self, "subnetwork")
+
+    @_builtins.property
+    @pulumi.getter
+    def tags(self) -> Sequence[_builtins.str]:
+        """
+        Network tags applied to this Cloud Run service.
+        """
+        return pulumi.get(self, "tags")
+
+
+@pulumi.output_type
+class GetServiceTerminalConditionResult(dict):
+    def __init__(__self__, *,
+                 execution_reason: _builtins.str,
+                 last_transition_time: _builtins.str,
+                 message: _builtins.str,
+                 reason: _builtins.str,
+                 revision_reason: _builtins.str,
+                 severity: _builtins.str,
+                 state: _builtins.str,
+                 type: _builtins.str):
+        """
+        :param _builtins.str execution_reason: A reason for the execution condition.
+        :param _builtins.str last_transition_time: Last time the condition transitioned from one status to another.
+        :param _builtins.str message: Human readable message indicating details about the current status.
+        :param _builtins.str reason: A common (service-level) reason for this condition.
+        :param _builtins.str revision_reason: A reason for the revision condition.
+        :param _builtins.str severity: How to interpret failures of this condition, one of Error, Warning, Info
+        :param _builtins.str state: State of the condition.
+        :param _builtins.str type: type is used to communicate the status of the reconciliation process. See also: https://github.com/knative/serving/blob/main/docs/spec/errors.md#error-conditions-and-reporting Types common to all resources include: * "Ready": True when the Resource is ready.
+        """
+        pulumi.set(__self__, "execution_reason", execution_reason)
+        pulumi.set(__self__, "last_transition_time", last_transition_time)
+        pulumi.set(__self__, "message", message)
+        pulumi.set(__self__, "reason", reason)
+        pulumi.set(__self__, "revision_reason", revision_reason)
+        pulumi.set(__self__, "severity", severity)
+        pulumi.set(__self__, "state", state)
+        pulumi.set(__self__, "type", type)
+
+    @_builtins.property
+    @pulumi.getter(name="executionReason")
+    def execution_reason(self) -> _builtins.str:
+        """
+        A reason for the execution condition.
+        """
+        return pulumi.get(self, "execution_reason")
+
+    @_builtins.property
+    @pulumi.getter(name="lastTransitionTime")
+    def last_transition_time(self) -> _builtins.str:
+        """
+        Last time the condition transitioned from one status to another.
+        """
+        return pulumi.get(self, "last_transition_time")
+
+    @_builtins.property
+    @pulumi.getter
+    def message(self) -> _builtins.str:
+        """
+        Human readable message indicating details about the current status.
+        """
+        return pulumi.get(self, "message")
+
+    @_builtins.property
+    @pulumi.getter
+    def reason(self) -> _builtins.str:
+        """
+        A common (service-level) reason for this condition.
+        """
+        return pulumi.get(self, "reason")
+
+    @_builtins.property
+    @pulumi.getter(name="revisionReason")
+    def revision_reason(self) -> _builtins.str:
+        """
+        A reason for the revision condition.
+        """
+        return pulumi.get(self, "revision_reason")
+
+    @_builtins.property
+    @pulumi.getter
+    def severity(self) -> _builtins.str:
+        """
+        How to interpret failures of this condition, one of Error, Warning, Info
+        """
+        return pulumi.get(self, "severity")
+
+    @_builtins.property
+    @pulumi.getter
+    def state(self) -> _builtins.str:
+        """
+        State of the condition.
+        """
+        return pulumi.get(self, "state")
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> _builtins.str:
+        """
+        type is used to communicate the status of the reconciliation process. See also: https://github.com/knative/serving/blob/main/docs/spec/errors.md#error-conditions-and-reporting Types common to all resources include: * "Ready": True when the Resource is ready.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class GetServiceTrafficResult(dict):
+    def __init__(__self__, *,
+                 percent: _builtins.int,
+                 revision: _builtins.str,
+                 tag: _builtins.str,
+                 type: _builtins.str):
+        """
+        :param _builtins.int percent: Specifies percent of the traffic to this Revision. This defaults to zero if unspecified.
+        :param _builtins.str revision: Revision to which to send this portion of traffic, if traffic allocation is by revision.
+        :param _builtins.str tag: Indicates a string to be part of the URI to exclusively reference this target.
+        :param _builtins.str type: The allocation type for this traffic target. Possible values: ["TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST", "TRAFFIC_TARGET_ALLOCATION_TYPE_REVISION"]
+        """
+        pulumi.set(__self__, "percent", percent)
+        pulumi.set(__self__, "revision", revision)
+        pulumi.set(__self__, "tag", tag)
+        pulumi.set(__self__, "type", type)
+
+    @_builtins.property
+    @pulumi.getter
+    def percent(self) -> _builtins.int:
+        """
+        Specifies percent of the traffic to this Revision. This defaults to zero if unspecified.
+        """
+        return pulumi.get(self, "percent")
+
+    @_builtins.property
+    @pulumi.getter
+    def revision(self) -> _builtins.str:
+        """
+        Revision to which to send this portion of traffic, if traffic allocation is by revision.
+        """
+        return pulumi.get(self, "revision")
+
+    @_builtins.property
+    @pulumi.getter
+    def tag(self) -> _builtins.str:
+        """
+        Indicates a string to be part of the URI to exclusively reference this target.
+        """
+        return pulumi.get(self, "tag")
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> _builtins.str:
+        """
+        The allocation type for this traffic target. Possible values: ["TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST", "TRAFFIC_TARGET_ALLOCATION_TYPE_REVISION"]
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class GetServiceTrafficStatusResult(dict):
+    def __init__(__self__, *,
+                 percent: _builtins.int,
+                 revision: _builtins.str,
+                 tag: _builtins.str,
+                 type: _builtins.str,
+                 uri: _builtins.str):
+        """
+        :param _builtins.int percent: Specifies percent of the traffic to this Revision.
+        :param _builtins.str revision: Revision to which this traffic is sent.
+        :param _builtins.str tag: Indicates the string used in the URI to exclusively reference this target.
+        :param _builtins.str type: The allocation type for this traffic target.
+        :param _builtins.str uri: Displays the target URI.
+        """
+        pulumi.set(__self__, "percent", percent)
+        pulumi.set(__self__, "revision", revision)
+        pulumi.set(__self__, "tag", tag)
+        pulumi.set(__self__, "type", type)
+        pulumi.set(__self__, "uri", uri)
+
+    @_builtins.property
+    @pulumi.getter
+    def percent(self) -> _builtins.int:
+        """
+        Specifies percent of the traffic to this Revision.
+        """
+        return pulumi.get(self, "percent")
+
+    @_builtins.property
+    @pulumi.getter
+    def revision(self) -> _builtins.str:
+        """
+        Revision to which this traffic is sent.
+        """
+        return pulumi.get(self, "revision")
+
+    @_builtins.property
+    @pulumi.getter
+    def tag(self) -> _builtins.str:
+        """
+        Indicates the string used in the URI to exclusively reference this target.
+        """
+        return pulumi.get(self, "tag")
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> _builtins.str:
+        """
+        The allocation type for this traffic target.
+        """
+        return pulumi.get(self, "type")
+
+    @_builtins.property
+    @pulumi.getter
+    def uri(self) -> _builtins.str:
+        """
+        Displays the target URI.
         """
-        return pulumi.get(self, "network_interfaces")
+        return pulumi.get(self, "uri")
 
 
 @pulumi.output_type
-class GetServiceTemplateVpcAccessNetworkInterfaceResult(dict):
+class GetWorkerPoolBinaryAuthorizationResult(dict):
     def __init__(__self__, *,
-                 network: _builtins.str,
-                 subnetwork: _builtins.str,
-                 tags: Sequence[_builtins.str]):
+                 breakglass_justification: _builtins.str,
+                 policy: _builtins.str,
+                 use_default: _builtins.bool):
         """
-        :param _builtins.str network: The VPC network that the Cloud Run resource will be able to send traffic to. At least one of network or subnetwork must be specified. If both
-               network and subnetwork are specified, the given VPC subnetwork must belong to the given VPC network. If network is not specified, it will be
-               looked up from the subnetwork.
-        :param _builtins.str subnetwork: The VPC subnetwork that the Cloud Run resource will get IPs from. At least one of network or subnetwork must be specified. If both
-               network and subnetwork are specified, the given VPC subnetwork must belong to the given VPC network. If subnetwork is not specified, the
-               subnetwork with the same name with the network will be used.
-        :param Sequence[_builtins.str] tags: Network tags applied to this Cloud Run service.
+        :param _builtins.str breakglass_justification: If present, indicates to use Breakglass using this justification. If useDefault is False, then it must be empty. For more information on breakglass, see https://cloud.google.com/binary-authorization/docs/using-breakglass
+        :param _builtins.str policy: The path to a binary authorization policy. Format: projects/{project}/platforms/cloudRun/{policy-name}
+        :param _builtins.bool use_default: If True, indicates to use the default project's binary authorization policy. If False, binary authorization will be disabled.
         """
-        pulumi.set(__self__, "network", network)
-        pulumi.set(__self__, "subnetwork", subnetwork)
-        pulumi.set(__self__, "tags", tags)
+        pulumi.set(__self__, "breakglass_justification", breakglass_justification)
+        pulumi.set(__self__, "policy", policy)
+        pulumi.set(__self__, "use_default", use_default)
 
     @_builtins.property
-    @pulumi.getter
-    def network(self) -> _builtins.str:
+    @pulumi.getter(name="breakglassJustification")
+    def breakglass_justification(self) -> _builtins.str:
         """
-        The VPC network that the Cloud Run resource will be able to send traffic to. At least one of network or subnetwork must be specified. If both
-        network and subnetwork are specified, the given VPC subnetwork must belong to the given VPC network. If network is not specified, it will be
-        looked up from the subnetwork.
+        If present, indicates to use Breakglass using this justification. If useDefault is False, then it must be empty. For more information on breakglass, see https://cloud.google.com/binary-authorization/docs/using-breakglass
         """
-        return pulumi.get(self, "network")
+        return pulumi.get(self, "breakglass_justification")
 
     @_builtins.property
     @pulumi.getter
-    def subnetwork(self) -> _builtins.str:
+    def policy(self) -> _builtins.str:
         """
-        The VPC subnetwork that the Cloud Run resource will get IPs from. At least one of network or subnetwork must be specified. If both
-        network and subnetwork are specified, the given VPC subnetwork must belong to the given VPC network. If subnetwork is not specified, the
-        subnetwork with the same name with the network will be used.
+        The path to a binary authorization policy. Format: projects/{project}/platforms/cloudRun/{policy-name}
         """
-        return pulumi.get(self, "subnetwork")
+        return pulumi.get(self, "policy")
 
     @_builtins.property
-    @pulumi.getter
-    def tags(self) -> Sequence[_builtins.str]:
+    @pulumi.getter(name="useDefault")
+    def use_default(self) -> _builtins.bool:
         """
-        Network tags applied to this Cloud Run service.
+        If True, indicates to use the default project's binary authorization policy. If False, binary authorization will be disabled.
         """
-        return pulumi.get(self, "tags")
+        return pulumi.get(self, "use_default")
 
 
 @pulumi.output_type
-class GetServiceTerminalConditionResult(dict):
+class GetWorkerPoolConditionResult(dict):
     def __init__(__self__, *,
                  execution_reason: _builtins.str,
                  last_transition_time: _builtins.str,
@@ -9859,8 +10691,10 @@ class GetServiceTerminalConditionResult(dict):
         """
         :param _builtins.str execution_reason: A reason for the execution condition.
         :param _builtins.str last_transition_time: Last time the condition transitioned from one status to another.
+               
+               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
         :param _builtins.str message: Human readable message indicating details about the current status.
-        :param _builtins.str reason: A common (service-level) reason for this condition.
+        :param _builtins.str reason: A common (workerPool-level) reason for this condition.
         :param _builtins.str revision_reason: A reason for the revision condition.
         :param _builtins.str severity: How to interpret failures of this condition, one of Error, Warning, Info
         :param _builtins.str state: State of the condition.
@@ -9888,6 +10722,8 @@ class GetServiceTerminalConditionResult(dict):
     def last_transition_time(self) -> _builtins.str:
         """
         Last time the condition transitioned from one status to another.
+
+        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
         """
         return pulumi.get(self, "last_transition_time")
 
@@ -9903,7 +10739,7 @@ class GetServiceTerminalConditionResult(dict):
     @pulumi.getter
     def reason(self) -> _builtins.str:
         """
-        A common (service-level) reason for this condition.
+        A common (workerPool-level) reason for this condition.
         """
         return pulumi.get(self, "reason")
 
@@ -9933,755 +10769,925 @@ class GetServiceTerminalConditionResult(dict):
 
     @_builtins.property
     @pulumi.getter
-    def type(self) -> _builtins.str:
-        """
-        type is used to communicate the status of the reconciliation process. See also: https://github.com/knative/serving/blob/main/docs/spec/errors.md#error-conditions-and-reporting Types common to all resources include: * "Ready": True when the Resource is ready.
+    def type(self) -> _builtins.str:
+        """
+        type is used to communicate the status of the reconciliation process. See also: https://github.com/knative/serving/blob/main/docs/spec/errors.md#error-conditions-and-reporting Types common to all resources include: * "Ready": True when the Resource is ready.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class GetWorkerPoolInstanceSplitResult(dict):
+    def __init__(__self__, *,
+                 percent: _builtins.int,
+                 revision: _builtins.str,
+                 type: _builtins.str):
+        """
+        :param _builtins.int percent: Specifies percent of the instance split to this Revision. This defaults to zero if unspecified.
+        :param _builtins.str revision: Revision to which to assign this portion of instances, if split allocation is by revision.
+        :param _builtins.str type: The allocation type for this instance split. Possible values: ["INSTANCE_SPLIT_ALLOCATION_TYPE_LATEST", "INSTANCE_SPLIT_ALLOCATION_TYPE_REVISION"]
+        """
+        pulumi.set(__self__, "percent", percent)
+        pulumi.set(__self__, "revision", revision)
+        pulumi.set(__self__, "type", type)
+
+    @_builtins.property
+    @pulumi.getter
+    def percent(self) -> _builtins.int:
+        """
+        Specifies percent of the instance split to this Revision. This defaults to zero if unspecified.
+        """
+        return pulumi.get(self, "percent")
+
+    @_builtins.property
+    @pulumi.getter
+    def revision(self) -> _builtins.str:
+        """
+        Revision to which to assign this portion of instances, if split allocation is by revision.
+        """
+        return pulumi.get(self, "revision")
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> _builtins.str:
+        """
+        The allocation type for this instance split. Possible values: ["INSTANCE_SPLIT_ALLOCATION_TYPE_LATEST", "INSTANCE_SPLIT_ALLOCATION_TYPE_REVISION"]
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class GetWorkerPoolInstanceSplitStatusResult(dict):
+    def __init__(__self__, *,
+                 percent: _builtins.int,
+                 revision: _builtins.str,
+                 type: _builtins.str):
+        """
+        :param _builtins.int percent: Specifies percent of the instance split to this Revision.
+        :param _builtins.str revision: Revision to which this instance split is assigned.
+        :param _builtins.str type: The allocation type for this instance split.
+        """
+        pulumi.set(__self__, "percent", percent)
+        pulumi.set(__self__, "revision", revision)
+        pulumi.set(__self__, "type", type)
+
+    @_builtins.property
+    @pulumi.getter
+    def percent(self) -> _builtins.int:
+        """
+        Specifies percent of the instance split to this Revision.
+        """
+        return pulumi.get(self, "percent")
+
+    @_builtins.property
+    @pulumi.getter
+    def revision(self) -> _builtins.str:
+        """
+        Revision to which this instance split is assigned.
+        """
+        return pulumi.get(self, "revision")
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> _builtins.str:
+        """
+        The allocation type for this instance split.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class GetWorkerPoolScalingResult(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: The total number of instances in manual scaling mode.
+        :param _builtins.int max_instance_count: The maximum count of instances distributed among revisions based on the specified instance split percentages.
+        :param _builtins.int min_instance_count: The minimum count of instances distributed among revisions based on the specified instance split percentages.
+        :param _builtins.str scaling_mode: The scaling mode for the worker pool. It defaults to MANUAL. 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)
+
+    @_builtins.property
+    @pulumi.getter(name="manualInstanceCount")
+    def manual_instance_count(self) -> _builtins.int:
+        """
+        The total number of instances in manual scaling mode.
+        """
+        return pulumi.get(self, "manual_instance_count")
+
+    @_builtins.property
+    @pulumi.getter(name="maxInstanceCount")
+    def max_instance_count(self) -> _builtins.int:
+        """
+        The maximum count of instances distributed among revisions based on the specified instance split percentages.
+        """
+        return pulumi.get(self, "max_instance_count")
+
+    @_builtins.property
+    @pulumi.getter(name="minInstanceCount")
+    def min_instance_count(self) -> _builtins.int:
+        """
+        The minimum count of instances distributed among revisions based on the specified instance split percentages.
+        """
+        return pulumi.get(self, "min_instance_count")
+
+    @_builtins.property
+    @pulumi.getter(name="scalingMode")
+    def scaling_mode(self) -> _builtins.str:
+        """
+        The scaling mode for the worker pool. It defaults to MANUAL. Possible values: ["AUTOMATIC", "MANUAL"]
+        """
+        return pulumi.get(self, "scaling_mode")
+
+
+@pulumi.output_type
+class GetWorkerPoolTemplateResult(dict):
+    def __init__(__self__, *,
+                 annotations: Mapping[str, _builtins.str],
+                 containers: Sequence['outputs.GetWorkerPoolTemplateContainerResult'],
+                 encryption_key: _builtins.str,
+                 encryption_key_revocation_action: _builtins.str,
+                 encryption_key_shutdown_duration: _builtins.str,
+                 gpu_zonal_redundancy_disabled: _builtins.bool,
+                 labels: Mapping[str, _builtins.str],
+                 node_selectors: Sequence['outputs.GetWorkerPoolTemplateNodeSelectorResult'],
+                 revision: _builtins.str,
+                 service_account: _builtins.str,
+                 volumes: Sequence['outputs.GetWorkerPoolTemplateVolumeResult'],
+                 vpc_accesses: Sequence['outputs.GetWorkerPoolTemplateVpcAccessResult']):
+        """
+        :param Mapping[str, _builtins.str] annotations: Unstructured key value map that may be set by external tools to store and arbitrary metadata. They are not queryable and should be preserved when modifying objects.
+               
+               Cloud Run API v2 does not support annotations with 'run.googleapis.com', 'cloud.googleapis.com', 'serving.knative.dev', or 'autoscaling.knative.dev' namespaces, and they will be rejected.
+               All system annotations in v1 now have a corresponding field in v2 WorkerPoolRevisionTemplate.
+               
+               This field follows Kubernetes annotations' namespacing, limits, and rules.
+        :param Sequence['GetWorkerPoolTemplateContainerArgs'] containers: Holds the containers that define the unit of execution for this WorkerPool.
+        :param _builtins.str encryption_key: A reference to a customer managed encryption key (CMEK) to use to encrypt this container image. For more information, go to https://cloud.google.com/run/docs/securing/using-cmek
+        :param _builtins.str encryption_key_revocation_action: The action to take if the encryption key is revoked. Possible values: ["PREVENT_NEW", "SHUTDOWN"]
+        :param _builtins.str encryption_key_shutdown_duration: If encryptionKeyRevocationAction is SHUTDOWN, the duration before shutting down all instances. The minimum increment is 1 hour.
+               
+               A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
+        :param _builtins.bool gpu_zonal_redundancy_disabled: True if GPU zonal redundancy is disabled on this revision.
+        :param Mapping[str, _builtins.str] labels: Unstructured key value map that can be used to organize and categorize objects. User-provided labels are shared with Google's billing system, so they can be used to filter, or break down billing charges by team, component, environment, state, etc.
+               For more information, visit https://cloud.google.com/resource-manager/docs/creating-managing-labels or https://cloud.google.com/run/docs/configuring/labels.
+               
+               Cloud Run API v2 does not support labels with 'run.googleapis.com', 'cloud.googleapis.com', 'serving.knative.dev', or 'autoscaling.knative.dev' namespaces, and they will be rejected.
+               All system labels in v1 now have a corresponding field in v2 WorkerPoolRevisionTemplate.
+        :param Sequence['GetWorkerPoolTemplateNodeSelectorArgs'] node_selectors: Node Selector describes the hardware requirements of the resources.
+        :param _builtins.str revision: The unique name for the revision. If this field is omitted, it will be automatically generated based on the WorkerPool name.
+        :param _builtins.str service_account: Email address of the IAM service account associated with the revision of the WorkerPool. The service account represents the identity of the running revision, and determines what permissions the revision has. If not provided, the revision will use the project's default service account.
+        :param Sequence['GetWorkerPoolTemplateVolumeArgs'] volumes: A list of Volumes to make available to containers.
+        :param Sequence['GetWorkerPoolTemplateVpcAccessArgs'] vpc_accesses: VPC Access configuration to use for this Revision. For more information, visit https://cloud.google.com/run/docs/configuring/connecting-vpc.
+        """
+        pulumi.set(__self__, "annotations", annotations)
+        pulumi.set(__self__, "containers", containers)
+        pulumi.set(__self__, "encryption_key", encryption_key)
+        pulumi.set(__self__, "encryption_key_revocation_action", encryption_key_revocation_action)
+        pulumi.set(__self__, "encryption_key_shutdown_duration", encryption_key_shutdown_duration)
+        pulumi.set(__self__, "gpu_zonal_redundancy_disabled", gpu_zonal_redundancy_disabled)
+        pulumi.set(__self__, "labels", labels)
+        pulumi.set(__self__, "node_selectors", node_selectors)
+        pulumi.set(__self__, "revision", revision)
+        pulumi.set(__self__, "service_account", service_account)
+        pulumi.set(__self__, "volumes", volumes)
+        pulumi.set(__self__, "vpc_accesses", vpc_accesses)
+
+    @_builtins.property
+    @pulumi.getter
+    def annotations(self) -> Mapping[str, _builtins.str]:
         """
-        return pulumi.get(self, "type")
+        Unstructured key value map that may be set by external tools to store and arbitrary metadata. They are not queryable and should be preserved when modifying objects.
 
+        Cloud Run API v2 does not support annotations with 'run.googleapis.com', 'cloud.googleapis.com', 'serving.knative.dev', or 'autoscaling.knative.dev' namespaces, and they will be rejected.
+        All system annotations in v1 now have a corresponding field in v2 WorkerPoolRevisionTemplate.
 
-@pulumi.output_type
-class GetServiceTrafficResult(dict):
-    def __init__(__self__, *,
-                 percent: _builtins.int,
-                 revision: _builtins.str,
-                 tag: _builtins.str,
-                 type: _builtins.str):
-        """
-        :param _builtins.int percent: Specifies percent of the traffic to this Revision. This defaults to zero if unspecified.
-        :param _builtins.str revision: Revision to which to send this portion of traffic, if traffic allocation is by revision.
-        :param _builtins.str tag: Indicates a string to be part of the URI to exclusively reference this target.
-        :param _builtins.str type: The allocation type for this traffic target. Possible values: ["TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST", "TRAFFIC_TARGET_ALLOCATION_TYPE_REVISION"]
+        This field follows Kubernetes annotations' namespacing, limits, and rules.
         """
-        pulumi.set(__self__, "percent", percent)
-        pulumi.set(__self__, "revision", revision)
-        pulumi.set(__self__, "tag", tag)
-        pulumi.set(__self__, "type", type)
+        return pulumi.get(self, "annotations")
 
     @_builtins.property
     @pulumi.getter
-    def percent(self) -> _builtins.int:
+    def containers(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerResult']:
         """
-        Specifies percent of the traffic to this Revision. This defaults to zero if unspecified.
+        Holds the containers that define the unit of execution for this WorkerPool.
         """
-        return pulumi.get(self, "percent")
+        return pulumi.get(self, "containers")
 
     @_builtins.property
-    @pulumi.getter
-    def revision(self) -> _builtins.str:
+    @pulumi.getter(name="encryptionKey")
+    def encryption_key(self) -> _builtins.str:
         """
-        Revision to which to send this portion of traffic, if traffic allocation is by revision.
+        A reference to a customer managed encryption key (CMEK) to use to encrypt this container image. For more information, go to https://cloud.google.com/run/docs/securing/using-cmek
         """
-        return pulumi.get(self, "revision")
+        return pulumi.get(self, "encryption_key")
 
     @_builtins.property
-    @pulumi.getter
-    def tag(self) -> _builtins.str:
+    @pulumi.getter(name="encryptionKeyRevocationAction")
+    def encryption_key_revocation_action(self) -> _builtins.str:
         """
-        Indicates a string to be part of the URI to exclusively reference this target.
+        The action to take if the encryption key is revoked. Possible values: ["PREVENT_NEW", "SHUTDOWN"]
         """
-        return pulumi.get(self, "tag")
+        return pulumi.get(self, "encryption_key_revocation_action")
 
     @_builtins.property
-    @pulumi.getter
-    def type(self) -> _builtins.str:
-        """
-        The allocation type for this traffic target. Possible values: ["TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST", "TRAFFIC_TARGET_ALLOCATION_TYPE_REVISION"]
+    @pulumi.getter(name="encryptionKeyShutdownDuration")
+    def encryption_key_shutdown_duration(self) -> _builtins.str:
         """
-        return pulumi.get(self, "type")
+        If encryptionKeyRevocationAction is SHUTDOWN, the duration before shutting down all instances. The minimum increment is 1 hour.
 
+        A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
+        """
+        return pulumi.get(self, "encryption_key_shutdown_duration")
 
-@pulumi.output_type
-class GetServiceTrafficStatusResult(dict):
-    def __init__(__self__, *,
-                 percent: _builtins.int,
-                 revision: _builtins.str,
-                 tag: _builtins.str,
-                 type: _builtins.str,
-                 uri: _builtins.str):
+    @_builtins.property
+    @pulumi.getter(name="gpuZonalRedundancyDisabled")
+    def gpu_zonal_redundancy_disabled(self) -> _builtins.bool:
         """
-        :param _builtins.int percent: Specifies percent of the traffic to this Revision.
-        :param _builtins.str revision: Revision to which this traffic is sent.
-        :param _builtins.str tag: Indicates the string used in the URI to exclusively reference this target.
-        :param _builtins.str type: The allocation type for this traffic target.
-        :param _builtins.str uri: Displays the target URI.
+        True if GPU zonal redundancy is disabled on this revision.
         """
-        pulumi.set(__self__, "percent", percent)
-        pulumi.set(__self__, "revision", revision)
-        pulumi.set(__self__, "tag", tag)
-        pulumi.set(__self__, "type", type)
-        pulumi.set(__self__, "uri", uri)
+        return pulumi.get(self, "gpu_zonal_redundancy_disabled")
 
     @_builtins.property
     @pulumi.getter
-    def percent(self) -> _builtins.int:
+    def labels(self) -> Mapping[str, _builtins.str]:
         """
-        Specifies percent of the traffic to this Revision.
+        Unstructured key value map that can be used to organize and categorize objects. User-provided labels are shared with Google's billing system, so they can be used to filter, or break down billing charges by team, component, environment, state, etc.
+        For more information, visit https://cloud.google.com/resource-manager/docs/creating-managing-labels or https://cloud.google.com/run/docs/configuring/labels.
+
+        Cloud Run API v2 does not support labels with 'run.googleapis.com', 'cloud.googleapis.com', 'serving.knative.dev', or 'autoscaling.knative.dev' namespaces, and they will be rejected.
+        All system labels in v1 now have a corresponding field in v2 WorkerPoolRevisionTemplate.
         """
-        return pulumi.get(self, "percent")
+        return pulumi.get(self, "labels")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeSelectors")
+    def node_selectors(self) -> Sequence['outputs.GetWorkerPoolTemplateNodeSelectorResult']:
+        """
+        Node Selector describes the hardware requirements of the resources.
+        """
+        return pulumi.get(self, "node_selectors")
 
     @_builtins.property
     @pulumi.getter
     def revision(self) -> _builtins.str:
         """
-        Revision to which this traffic is sent.
+        The unique name for the revision. If this field is omitted, it will be automatically generated based on the WorkerPool name.
         """
         return pulumi.get(self, "revision")
 
     @_builtins.property
-    @pulumi.getter
-    def tag(self) -> _builtins.str:
+    @pulumi.getter(name="serviceAccount")
+    def service_account(self) -> _builtins.str:
         """
-        Indicates the string used in the URI to exclusively reference this target.
+        Email address of the IAM service account associated with the revision of the WorkerPool. The service account represents the identity of the running revision, and determines what permissions the revision has. If not provided, the revision will use the project's default service account.
         """
-        return pulumi.get(self, "tag")
+        return pulumi.get(self, "service_account")
 
     @_builtins.property
     @pulumi.getter
-    def type(self) -> _builtins.str:
+    def volumes(self) -> Sequence['outputs.GetWorkerPoolTemplateVolumeResult']:
         """
-        The allocation type for this traffic target.
+        A list of Volumes to make available to containers.
         """
-        return pulumi.get(self, "type")
+        return pulumi.get(self, "volumes")
 
     @_builtins.property
-    @pulumi.getter
-    def uri(self) -> _builtins.str:
+    @pulumi.getter(name="vpcAccesses")
+    def vpc_accesses(self) -> Sequence['outputs.GetWorkerPoolTemplateVpcAccessResult']:
         """
-        Displays the target URI.
+        VPC Access configuration to use for this Revision. For more information, visit https://cloud.google.com/run/docs/configuring/connecting-vpc.
         """
-        return pulumi.get(self, "uri")
+        return pulumi.get(self, "vpc_accesses")
 
 
 @pulumi.output_type
-class GetWorkerPoolBinaryAuthorizationResult(dict):
+class GetWorkerPoolTemplateContainerResult(dict):
     def __init__(__self__, *,
-                 breakglass_justification: _builtins.str,
-                 policy: _builtins.str,
-                 use_default: _builtins.bool):
+                 args: Sequence[_builtins.str],
+                 commands: Sequence[_builtins.str],
+                 envs: Sequence['outputs.GetWorkerPoolTemplateContainerEnvResult'],
+                 image: _builtins.str,
+                 liveness_probes: Sequence['outputs.GetWorkerPoolTemplateContainerLivenessProbeResult'],
+                 name: _builtins.str,
+                 resources: Sequence['outputs.GetWorkerPoolTemplateContainerResourceResult'],
+                 startup_probes: Sequence['outputs.GetWorkerPoolTemplateContainerStartupProbeResult'],
+                 volume_mounts: Sequence['outputs.GetWorkerPoolTemplateContainerVolumeMountResult'],
+                 working_dir: _builtins.str):
         """
-        :param _builtins.str breakglass_justification: If present, indicates to use Breakglass using this justification. If useDefault is False, then it must be empty. For more information on breakglass, see https://cloud.google.com/binary-authorization/docs/using-breakglass
-        :param _builtins.str policy: The path to a binary authorization policy. Format: projects/{project}/platforms/cloudRun/{policy-name}
-        :param _builtins.bool use_default: If True, indicates to use the default project's binary authorization policy. If False, binary authorization will be disabled.
+        :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['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 Sequence['GetWorkerPoolTemplateContainerLivenessProbeArgs'] liveness_probes: Periodic probe of container liveness. Container will be restarted if the probe fails.
+        :param _builtins.str name: The name of the Cloud Run v2 Worker Pool.
+        :param Sequence['GetWorkerPoolTemplateContainerResourceArgs'] resources: Compute Resource requirements by this container. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources
+        :param Sequence['GetWorkerPoolTemplateContainerStartupProbeArgs'] startup_probes: Startup probe of application within the container. All other probes are disabled if a startup probe is provided, until it succeeds. Container will not be added to service endpoints if the probe fails.
+        :param Sequence['GetWorkerPoolTemplateContainerVolumeMountArgs'] volume_mounts: Volume to mount into the container's filesystem.
+        :param _builtins.str working_dir: Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image.
         """
-        pulumi.set(__self__, "breakglass_justification", breakglass_justification)
-        pulumi.set(__self__, "policy", policy)
-        pulumi.set(__self__, "use_default", use_default)
+        pulumi.set(__self__, "args", args)
+        pulumi.set(__self__, "commands", commands)
+        pulumi.set(__self__, "envs", envs)
+        pulumi.set(__self__, "image", image)
+        pulumi.set(__self__, "liveness_probes", liveness_probes)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "resources", resources)
+        pulumi.set(__self__, "startup_probes", startup_probes)
+        pulumi.set(__self__, "volume_mounts", volume_mounts)
+        pulumi.set(__self__, "working_dir", working_dir)
 
     @_builtins.property
-    @pulumi.getter(name="breakglassJustification")
-    def breakglass_justification(self) -> _builtins.str:
+    @pulumi.getter
+    def args(self) -> Sequence[_builtins.str]:
         """
-        If present, indicates to use Breakglass using this justification. If useDefault is False, then it must be empty. For more information on breakglass, see https://cloud.google.com/binary-authorization/docs/using-breakglass
+        Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references are not supported in Cloud Run.
         """
-        return pulumi.get(self, "breakglass_justification")
+        return pulumi.get(self, "args")
 
     @_builtins.property
     @pulumi.getter
-    def policy(self) -> _builtins.str:
+    def commands(self) -> Sequence[_builtins.str]:
         """
-        The path to a binary authorization policy. Format: projects/{project}/platforms/cloudRun/{policy-name}
+        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
         """
-        return pulumi.get(self, "policy")
+        return pulumi.get(self, "commands")
 
     @_builtins.property
-    @pulumi.getter(name="useDefault")
-    def use_default(self) -> _builtins.bool:
-        """
-        If True, indicates to use the default project's binary authorization policy. If False, binary authorization will be disabled.
-        """
-        return pulumi.get(self, "use_default")
-
-
-@pulumi.output_type
-class GetWorkerPoolConditionResult(dict):
-    def __init__(__self__, *,
-                 execution_reason: _builtins.str,
-                 last_transition_time: _builtins.str,
-                 message: _builtins.str,
-                 reason: _builtins.str,
-                 revision_reason: _builtins.str,
-                 severity: _builtins.str,
-                 state: _builtins.str,
-                 type: _builtins.str):
+    @pulumi.getter
+    def envs(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerEnvResult']:
         """
-        :param _builtins.str execution_reason: A reason for the execution condition.
-        :param _builtins.str last_transition_time: Last time the condition transitioned from one status to another.
-               
-               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
-        :param _builtins.str message: Human readable message indicating details about the current status.
-        :param _builtins.str reason: A common (workerPool-level) reason for this condition.
-        :param _builtins.str revision_reason: A reason for the revision condition.
-        :param _builtins.str severity: How to interpret failures of this condition, one of Error, Warning, Info
-        :param _builtins.str state: State of the condition.
-        :param _builtins.str type: type is used to communicate the status of the reconciliation process. See also: https://github.com/knative/serving/blob/main/docs/spec/errors.md#error-conditions-and-reporting Types common to all resources include: * "Ready": True when the Resource is ready.
+        List of environment variables to set in the container.
         """
-        pulumi.set(__self__, "execution_reason", execution_reason)
-        pulumi.set(__self__, "last_transition_time", last_transition_time)
-        pulumi.set(__self__, "message", message)
-        pulumi.set(__self__, "reason", reason)
-        pulumi.set(__self__, "revision_reason", revision_reason)
-        pulumi.set(__self__, "severity", severity)
-        pulumi.set(__self__, "state", state)
-        pulumi.set(__self__, "type", type)
+        return pulumi.get(self, "envs")
 
     @_builtins.property
-    @pulumi.getter(name="executionReason")
-    def execution_reason(self) -> _builtins.str:
+    @pulumi.getter
+    def image(self) -> _builtins.str:
         """
-        A reason for the execution condition.
+        URL of the Container image in Google Container Registry or Google Artifact Registry. More info: https://kubernetes.io/docs/concepts/containers/images
         """
-        return pulumi.get(self, "execution_reason")
+        return pulumi.get(self, "image")
 
     @_builtins.property
-    @pulumi.getter(name="lastTransitionTime")
-    def last_transition_time(self) -> _builtins.str:
+    @pulumi.getter(name="livenessProbes")
+    def liveness_probes(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerLivenessProbeResult']:
         """
-        Last time the condition transitioned from one status to another.
-
-        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
+        Periodic probe of container liveness. Container will be restarted if the probe fails.
         """
-        return pulumi.get(self, "last_transition_time")
+        return pulumi.get(self, "liveness_probes")
 
     @_builtins.property
     @pulumi.getter
-    def message(self) -> _builtins.str:
+    def name(self) -> _builtins.str:
         """
-        Human readable message indicating details about the current status.
+        The name of the Cloud Run v2 Worker Pool.
         """
-        return pulumi.get(self, "message")
+        return pulumi.get(self, "name")
 
     @_builtins.property
     @pulumi.getter
-    def reason(self) -> _builtins.str:
-        """
-        A common (workerPool-level) reason for this condition.
-        """
-        return pulumi.get(self, "reason")
-
-    @_builtins.property
-    @pulumi.getter(name="revisionReason")
-    def revision_reason(self) -> _builtins.str:
+    def resources(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerResourceResult']:
         """
-        A reason for the revision condition.
+        Compute Resource requirements by this container. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources
         """
-        return pulumi.get(self, "revision_reason")
+        return pulumi.get(self, "resources")
 
-    @_builtins.property
-    @pulumi.getter
-    def severity(self) -> _builtins.str:
+    @_builtins.property
+    @pulumi.getter(name="startupProbes")
+    def startup_probes(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerStartupProbeResult']:
         """
-        How to interpret failures of this condition, one of Error, Warning, Info
+        Startup probe of application within the container. All other probes are disabled if a startup probe is provided, until it succeeds. Container will not be added to service endpoints if the probe fails.
         """
-        return pulumi.get(self, "severity")
+        return pulumi.get(self, "startup_probes")
 
     @_builtins.property
-    @pulumi.getter
-    def state(self) -> _builtins.str:
+    @pulumi.getter(name="volumeMounts")
+    def volume_mounts(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerVolumeMountResult']:
         """
-        State of the condition.
+        Volume to mount into the container's filesystem.
         """
-        return pulumi.get(self, "state")
+        return pulumi.get(self, "volume_mounts")
 
     @_builtins.property
-    @pulumi.getter
-    def type(self) -> _builtins.str:
+    @pulumi.getter(name="workingDir")
+    def working_dir(self) -> _builtins.str:
         """
-        type is used to communicate the status of the reconciliation process. See also: https://github.com/knative/serving/blob/main/docs/spec/errors.md#error-conditions-and-reporting Types common to all resources include: * "Ready": True when the Resource is ready.
+        Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image.
         """
-        return pulumi.get(self, "type")
+        return pulumi.get(self, "working_dir")
 
 
 @pulumi.output_type
-class GetWorkerPoolInstanceSplitResult(dict):
+class GetWorkerPoolTemplateContainerEnvResult(dict):
     def __init__(__self__, *,
-                 percent: _builtins.int,
-                 revision: _builtins.str,
-                 type: _builtins.str):
+                 name: _builtins.str,
+                 value: _builtins.str,
+                 value_sources: Sequence['outputs.GetWorkerPoolTemplateContainerEnvValueSourceResult']):
         """
-        :param _builtins.int percent: Specifies percent of the instance split to this Revision. This defaults to zero if unspecified.
-        :param _builtins.str revision: Revision to which to assign this portion of instances, if split allocation is by revision.
-        :param _builtins.str type: The allocation type for this instance split. Possible values: ["INSTANCE_SPLIT_ALLOCATION_TYPE_LATEST", "INSTANCE_SPLIT_ALLOCATION_TYPE_REVISION"]
+        :param _builtins.str name: The name of the Cloud Run v2 Worker Pool.
+        :param _builtins.str value: Literal value of the environment variable. Defaults to "" and the maximum allowed length is 32768 characters. Variable references are not supported in Cloud Run.
+        :param Sequence['GetWorkerPoolTemplateContainerEnvValueSourceArgs'] value_sources: Source for the environment variable's value.
         """
-        pulumi.set(__self__, "percent", percent)
-        pulumi.set(__self__, "revision", revision)
-        pulumi.set(__self__, "type", type)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "value", value)
+        pulumi.set(__self__, "value_sources", value_sources)
 
     @_builtins.property
     @pulumi.getter
-    def percent(self) -> _builtins.int:
+    def name(self) -> _builtins.str:
         """
-        Specifies percent of the instance split to this Revision. This defaults to zero if unspecified.
+        The name of the Cloud Run v2 Worker Pool.
         """
-        return pulumi.get(self, "percent")
+        return pulumi.get(self, "name")
 
     @_builtins.property
     @pulumi.getter
-    def revision(self) -> _builtins.str:
+    def value(self) -> _builtins.str:
         """
-        Revision to which to assign this portion of instances, if split allocation is by revision.
+        Literal value of the environment variable. Defaults to "" and the maximum allowed length is 32768 characters. Variable references are not supported in Cloud Run.
         """
-        return pulumi.get(self, "revision")
+        return pulumi.get(self, "value")
 
     @_builtins.property
-    @pulumi.getter
-    def type(self) -> _builtins.str:
+    @pulumi.getter(name="valueSources")
+    def value_sources(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerEnvValueSourceResult']:
         """
-        The allocation type for this instance split. Possible values: ["INSTANCE_SPLIT_ALLOCATION_TYPE_LATEST", "INSTANCE_SPLIT_ALLOCATION_TYPE_REVISION"]
+        Source for the environment variable's value.
         """
-        return pulumi.get(self, "type")
+        return pulumi.get(self, "value_sources")
 
 
 @pulumi.output_type
-class GetWorkerPoolInstanceSplitStatusResult(dict):
+class GetWorkerPoolTemplateContainerEnvValueSourceResult(dict):
     def __init__(__self__, *,
-                 percent: _builtins.int,
-                 revision: _builtins.str,
-                 type: _builtins.str):
+                 secret_key_reves: Sequence['outputs.GetWorkerPoolTemplateContainerEnvValueSourceSecretKeyRefResult']):
         """
-        :param _builtins.int percent: Specifies percent of the instance split to this Revision.
-        :param _builtins.str revision: Revision to which this instance split is assigned.
-        :param _builtins.str type: The allocation type for this instance split.
+        :param Sequence['GetWorkerPoolTemplateContainerEnvValueSourceSecretKeyRefArgs'] secret_key_reves: Selects a secret and a specific version from Cloud Secret Manager.
         """
-        pulumi.set(__self__, "percent", percent)
-        pulumi.set(__self__, "revision", revision)
-        pulumi.set(__self__, "type", type)
+        pulumi.set(__self__, "secret_key_reves", secret_key_reves)
 
     @_builtins.property
-    @pulumi.getter
-    def percent(self) -> _builtins.int:
+    @pulumi.getter(name="secretKeyReves")
+    def secret_key_reves(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerEnvValueSourceSecretKeyRefResult']:
         """
-        Specifies percent of the instance split to this Revision.
+        Selects a secret and a specific version from Cloud Secret Manager.
         """
-        return pulumi.get(self, "percent")
+        return pulumi.get(self, "secret_key_reves")
+
+
+@pulumi.output_type
+class GetWorkerPoolTemplateContainerEnvValueSourceSecretKeyRefResult(dict):
+    def __init__(__self__, *,
+                 secret: _builtins.str,
+                 version: _builtins.str):
+        """
+        :param _builtins.str secret: The name of the secret in Cloud Secret Manager. Format: {secretName} if the secret is in the same project. projects/{project}/secrets/{secretName} if the secret is in a different project.
+        :param _builtins.str version: The Cloud Secret Manager secret version. Can be 'latest' for the latest value or an integer for a specific version.
+        """
+        pulumi.set(__self__, "secret", secret)
+        pulumi.set(__self__, "version", version)
 
     @_builtins.property
     @pulumi.getter
-    def revision(self) -> _builtins.str:
+    def secret(self) -> _builtins.str:
         """
-        Revision to which this instance split is assigned.
+        The name of the secret in Cloud Secret Manager. Format: {secretName} if the secret is in the same project. projects/{project}/secrets/{secretName} if the secret is in a different project.
         """
-        return pulumi.get(self, "revision")
+        return pulumi.get(self, "secret")
 
     @_builtins.property
     @pulumi.getter
-    def type(self) -> _builtins.str:
+    def version(self) -> _builtins.str:
         """
-        The allocation type for this instance split.
+        The Cloud Secret Manager secret version. Can be 'latest' for the latest value or an integer for a specific version.
         """
-        return pulumi.get(self, "type")
+        return pulumi.get(self, "version")
 
 
 @pulumi.output_type
-class GetWorkerPoolScalingResult(dict):
+class GetWorkerPoolTemplateContainerLivenessProbeResult(dict):
     def __init__(__self__, *,
-                 manual_instance_count: _builtins.int,
-                 max_instance_count: _builtins.int,
-                 min_instance_count: _builtins.int,
-                 scaling_mode: _builtins.str):
+                 failure_threshold: _builtins.int,
+                 grpcs: Sequence['outputs.GetWorkerPoolTemplateContainerLivenessProbeGrpcResult'],
+                 http_gets: Sequence['outputs.GetWorkerPoolTemplateContainerLivenessProbeHttpGetResult'],
+                 initial_delay_seconds: _builtins.int,
+                 period_seconds: _builtins.int,
+                 tcp_sockets: Sequence['outputs.GetWorkerPoolTemplateContainerLivenessProbeTcpSocketResult'],
+                 timeout_seconds: _builtins.int):
         """
-        :param _builtins.int manual_instance_count: The total number of instances in manual scaling mode.
-        :param _builtins.int max_instance_count: The maximum count of instances distributed among revisions based on the specified instance split percentages.
-        :param _builtins.int min_instance_count: The minimum count of instances distributed among revisions based on the specified instance split percentages.
-        :param _builtins.str scaling_mode: The scaling mode for the worker pool. It defaults to MANUAL. Possible values: ["AUTOMATIC", "MANUAL"]
+        :param _builtins.int failure_threshold: Optional. Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.
+        :param Sequence['GetWorkerPoolTemplateContainerLivenessProbeGrpcArgs'] grpcs: Optional. GRPC specifies an action involving a gRPC port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        :param Sequence['GetWorkerPoolTemplateContainerLivenessProbeHttpGetArgs'] http_gets: Optional. HTTPGet specifies the http request to perform. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        :param _builtins.int initial_delay_seconds: Optional. Number of seconds after the container has started before the probe is initiated. Defaults to 0 seconds. Minimum value is 0. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240.
+        :param _builtins.int period_seconds: Optional. How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240. Must be greater or equal than timeout_seconds.
+        :param Sequence['GetWorkerPoolTemplateContainerLivenessProbeTcpSocketArgs'] tcp_sockets: Optional. TCPSocket specifies an action involving a TCP port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        :param _builtins.int timeout_seconds: Optional. Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. Maximum value is 3600. Must be smaller than period_seconds.
         """
-        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)
+        pulumi.set(__self__, "failure_threshold", failure_threshold)
+        pulumi.set(__self__, "grpcs", grpcs)
+        pulumi.set(__self__, "http_gets", http_gets)
+        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
+        pulumi.set(__self__, "period_seconds", period_seconds)
+        pulumi.set(__self__, "tcp_sockets", tcp_sockets)
+        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
 
     @_builtins.property
-    @pulumi.getter(name="manualInstanceCount")
-    def manual_instance_count(self) -> _builtins.int:
+    @pulumi.getter(name="failureThreshold")
+    def failure_threshold(self) -> _builtins.int:
         """
-        The total number of instances in manual scaling mode.
+        Optional. Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.
         """
-        return pulumi.get(self, "manual_instance_count")
+        return pulumi.get(self, "failure_threshold")
 
     @_builtins.property
-    @pulumi.getter(name="maxInstanceCount")
-    def max_instance_count(self) -> _builtins.int:
+    @pulumi.getter
+    def grpcs(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerLivenessProbeGrpcResult']:
         """
-        The maximum count of instances distributed among revisions based on the specified instance split percentages.
+        Optional. GRPC specifies an action involving a gRPC port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
         """
-        return pulumi.get(self, "max_instance_count")
+        return pulumi.get(self, "grpcs")
 
     @_builtins.property
-    @pulumi.getter(name="minInstanceCount")
-    def min_instance_count(self) -> _builtins.int:
+    @pulumi.getter(name="httpGets")
+    def http_gets(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerLivenessProbeHttpGetResult']:
         """
-        The minimum count of instances distributed among revisions based on the specified instance split percentages.
+        Optional. HTTPGet specifies the http request to perform. Exactly one of httpGet, tcpSocket, or grpc must be specified.
         """
-        return pulumi.get(self, "min_instance_count")
+        return pulumi.get(self, "http_gets")
 
     @_builtins.property
-    @pulumi.getter(name="scalingMode")
-    def scaling_mode(self) -> _builtins.str:
+    @pulumi.getter(name="initialDelaySeconds")
+    def initial_delay_seconds(self) -> _builtins.int:
         """
-        The scaling mode for the worker pool. It defaults to MANUAL. Possible values: ["AUTOMATIC", "MANUAL"]
+        Optional. Number of seconds after the container has started before the probe is initiated. Defaults to 0 seconds. Minimum value is 0. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240.
         """
-        return pulumi.get(self, "scaling_mode")
+        return pulumi.get(self, "initial_delay_seconds")
 
+    @_builtins.property
+    @pulumi.getter(name="periodSeconds")
+    def period_seconds(self) -> _builtins.int:
+        """
+        Optional. How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240. Must be greater or equal than timeout_seconds.
+        """
+        return pulumi.get(self, "period_seconds")
 
-@pulumi.output_type
-class GetWorkerPoolTemplateResult(dict):
-    def __init__(__self__, *,
-                 annotations: Mapping[str, _builtins.str],
-                 containers: Sequence['outputs.GetWorkerPoolTemplateContainerResult'],
-                 encryption_key: _builtins.str,
-                 encryption_key_revocation_action: _builtins.str,
-                 encryption_key_shutdown_duration: _builtins.str,
-                 gpu_zonal_redundancy_disabled: _builtins.bool,
-                 labels: Mapping[str, _builtins.str],
-                 node_selectors: Sequence['outputs.GetWorkerPoolTemplateNodeSelectorResult'],
-                 revision: _builtins.str,
-                 service_account: _builtins.str,
-                 volumes: Sequence['outputs.GetWorkerPoolTemplateVolumeResult'],
-                 vpc_accesses: Sequence['outputs.GetWorkerPoolTemplateVpcAccessResult']):
+    @_builtins.property
+    @pulumi.getter(name="tcpSockets")
+    def tcp_sockets(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerLivenessProbeTcpSocketResult']:
         """
-        :param Mapping[str, _builtins.str] annotations: Unstructured key value map that may be set by external tools to store and arbitrary metadata. They are not queryable and should be preserved when modifying objects.
-               
-               Cloud Run API v2 does not support annotations with 'run.googleapis.com', 'cloud.googleapis.com', 'serving.knative.dev', or 'autoscaling.knative.dev' namespaces, and they will be rejected.
-               All system annotations in v1 now have a corresponding field in v2 WorkerPoolRevisionTemplate.
-               
-               This field follows Kubernetes annotations' namespacing, limits, and rules.
-        :param Sequence['GetWorkerPoolTemplateContainerArgs'] containers: Holds the containers that define the unit of execution for this WorkerPool.
-        :param _builtins.str encryption_key: A reference to a customer managed encryption key (CMEK) to use to encrypt this container image. For more information, go to https://cloud.google.com/run/docs/securing/using-cmek
-        :param _builtins.str encryption_key_revocation_action: The action to take if the encryption key is revoked. Possible values: ["PREVENT_NEW", "SHUTDOWN"]
-        :param _builtins.str encryption_key_shutdown_duration: If encryptionKeyRevocationAction is SHUTDOWN, the duration before shutting down all instances. The minimum increment is 1 hour.
-               
-               A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
-        :param _builtins.bool gpu_zonal_redundancy_disabled: True if GPU zonal redundancy is disabled on this revision.
-        :param Mapping[str, _builtins.str] labels: Unstructured key value map that can be used to organize and categorize objects. User-provided labels are shared with Google's billing system, so they can be used to filter, or break down billing charges by team, component, environment, state, etc.
-               For more information, visit https://cloud.google.com/resource-manager/docs/creating-managing-labels or https://cloud.google.com/run/docs/configuring/labels.
-               
-               Cloud Run API v2 does not support labels with 'run.googleapis.com', 'cloud.googleapis.com', 'serving.knative.dev', or 'autoscaling.knative.dev' namespaces, and they will be rejected.
-               All system labels in v1 now have a corresponding field in v2 WorkerPoolRevisionTemplate.
-        :param Sequence['GetWorkerPoolTemplateNodeSelectorArgs'] node_selectors: Node Selector describes the hardware requirements of the resources.
-        :param _builtins.str revision: The unique name for the revision. If this field is omitted, it will be automatically generated based on the WorkerPool name.
-        :param _builtins.str service_account: Email address of the IAM service account associated with the revision of the WorkerPool. The service account represents the identity of the running revision, and determines what permissions the revision has. If not provided, the revision will use the project's default service account.
-        :param Sequence['GetWorkerPoolTemplateVolumeArgs'] volumes: A list of Volumes to make available to containers.
-        :param Sequence['GetWorkerPoolTemplateVpcAccessArgs'] vpc_accesses: VPC Access configuration to use for this Revision. For more information, visit https://cloud.google.com/run/docs/configuring/connecting-vpc.
+        Optional. TCPSocket specifies an action involving a TCP port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
         """
-        pulumi.set(__self__, "annotations", annotations)
-        pulumi.set(__self__, "containers", containers)
-        pulumi.set(__self__, "encryption_key", encryption_key)
-        pulumi.set(__self__, "encryption_key_revocation_action", encryption_key_revocation_action)
-        pulumi.set(__self__, "encryption_key_shutdown_duration", encryption_key_shutdown_duration)
-        pulumi.set(__self__, "gpu_zonal_redundancy_disabled", gpu_zonal_redundancy_disabled)
-        pulumi.set(__self__, "labels", labels)
-        pulumi.set(__self__, "node_selectors", node_selectors)
-        pulumi.set(__self__, "revision", revision)
-        pulumi.set(__self__, "service_account", service_account)
-        pulumi.set(__self__, "volumes", volumes)
-        pulumi.set(__self__, "vpc_accesses", vpc_accesses)
+        return pulumi.get(self, "tcp_sockets")
 
     @_builtins.property
-    @pulumi.getter
-    def annotations(self) -> Mapping[str, _builtins.str]:
+    @pulumi.getter(name="timeoutSeconds")
+    def timeout_seconds(self) -> _builtins.int:
         """
-        Unstructured key value map that may be set by external tools to store and arbitrary metadata. They are not queryable and should be preserved when modifying objects.
+        Optional. Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. Maximum value is 3600. Must be smaller than period_seconds.
+        """
+        return pulumi.get(self, "timeout_seconds")
 
-        Cloud Run API v2 does not support annotations with 'run.googleapis.com', 'cloud.googleapis.com', 'serving.knative.dev', or 'autoscaling.knative.dev' namespaces, and they will be rejected.
-        All system annotations in v1 now have a corresponding field in v2 WorkerPoolRevisionTemplate.
 
-        This field follows Kubernetes annotations' namespacing, limits, and rules.
+@pulumi.output_type
+class GetWorkerPoolTemplateContainerLivenessProbeGrpcResult(dict):
+    def __init__(__self__, *,
+                 port: _builtins.int,
+                 service: _builtins.str):
         """
-        return pulumi.get(self, "annotations")
+        :param _builtins.int port: Optional. Port number of the gRPC service. Number must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
+        :param _builtins.str service: Optional. Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md ). If this is not specified, the default behavior is defined by gRPC
+        """
+        pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "service", service)
 
     @_builtins.property
     @pulumi.getter
-    def containers(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerResult']:
+    def port(self) -> _builtins.int:
         """
-        Holds the containers that define the unit of execution for this WorkerPool.
+        Optional. Port number of the gRPC service. Number must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "containers")
+        return pulumi.get(self, "port")
 
     @_builtins.property
-    @pulumi.getter(name="encryptionKey")
-    def encryption_key(self) -> _builtins.str:
+    @pulumi.getter
+    def service(self) -> _builtins.str:
         """
-        A reference to a customer managed encryption key (CMEK) to use to encrypt this container image. For more information, go to https://cloud.google.com/run/docs/securing/using-cmek
+        Optional. Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md ). If this is not specified, the default behavior is defined by gRPC
         """
-        return pulumi.get(self, "encryption_key")
+        return pulumi.get(self, "service")
 
-    @_builtins.property
-    @pulumi.getter(name="encryptionKeyRevocationAction")
-    def encryption_key_revocation_action(self) -> _builtins.str:
+
+@pulumi.output_type
+class GetWorkerPoolTemplateContainerLivenessProbeHttpGetResult(dict):
+    def __init__(__self__, *,
+                 http_headers: Sequence['outputs.GetWorkerPoolTemplateContainerLivenessProbeHttpGetHttpHeaderResult'],
+                 path: _builtins.str,
+                 port: _builtins.int):
         """
-        The action to take if the encryption key is revoked. Possible values: ["PREVENT_NEW", "SHUTDOWN"]
+        :param Sequence['GetWorkerPoolTemplateContainerLivenessProbeHttpGetHttpHeaderArgs'] http_headers: Optional. Custom headers to set in the request. HTTP allows repeated headers.
+        :param _builtins.str path: Optional. Path to access on the HTTP server. Defaults to '/'.
+        :param _builtins.int port: Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "encryption_key_revocation_action")
+        pulumi.set(__self__, "http_headers", http_headers)
+        pulumi.set(__self__, "path", path)
+        pulumi.set(__self__, "port", port)
 
     @_builtins.property
-    @pulumi.getter(name="encryptionKeyShutdownDuration")
-    def encryption_key_shutdown_duration(self) -> _builtins.str:
+    @pulumi.getter(name="httpHeaders")
+    def http_headers(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerLivenessProbeHttpGetHttpHeaderResult']:
         """
-        If encryptionKeyRevocationAction is SHUTDOWN, the duration before shutting down all instances. The minimum increment is 1 hour.
-
-        A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
+        Optional. Custom headers to set in the request. HTTP allows repeated headers.
         """
-        return pulumi.get(self, "encryption_key_shutdown_duration")
+        return pulumi.get(self, "http_headers")
 
     @_builtins.property
-    @pulumi.getter(name="gpuZonalRedundancyDisabled")
-    def gpu_zonal_redundancy_disabled(self) -> _builtins.bool:
+    @pulumi.getter
+    def path(self) -> _builtins.str:
         """
-        True if GPU zonal redundancy is disabled on this revision.
+        Optional. Path to access on the HTTP server. Defaults to '/'.
         """
-        return pulumi.get(self, "gpu_zonal_redundancy_disabled")
+        return pulumi.get(self, "path")
 
     @_builtins.property
     @pulumi.getter
-    def labels(self) -> Mapping[str, _builtins.str]:
+    def port(self) -> _builtins.int:
         """
-        Unstructured key value map that can be used to organize and categorize objects. User-provided labels are shared with Google's billing system, so they can be used to filter, or break down billing charges by team, component, environment, state, etc.
-        For more information, visit https://cloud.google.com/resource-manager/docs/creating-managing-labels or https://cloud.google.com/run/docs/configuring/labels.
-
-        Cloud Run API v2 does not support labels with 'run.googleapis.com', 'cloud.googleapis.com', 'serving.knative.dev', or 'autoscaling.knative.dev' namespaces, and they will be rejected.
-        All system labels in v1 now have a corresponding field in v2 WorkerPoolRevisionTemplate.
+        Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "labels")
+        return pulumi.get(self, "port")
 
-    @_builtins.property
-    @pulumi.getter(name="nodeSelectors")
-    def node_selectors(self) -> Sequence['outputs.GetWorkerPoolTemplateNodeSelectorResult']:
+
+@pulumi.output_type
+class GetWorkerPoolTemplateContainerLivenessProbeHttpGetHttpHeaderResult(dict):
+    def __init__(__self__, *,
+                 port: _builtins.int,
+                 value: _builtins.str):
         """
-        Node Selector describes the hardware requirements of the resources.
+        :param _builtins.int port: Required. The header field name
+        :param _builtins.str value: Optional. The header field value
         """
-        return pulumi.get(self, "node_selectors")
+        pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "value", value)
 
     @_builtins.property
     @pulumi.getter
-    def revision(self) -> _builtins.str:
+    def port(self) -> _builtins.int:
         """
-        The unique name for the revision. If this field is omitted, it will be automatically generated based on the WorkerPool name.
+        Required. The header field name
         """
-        return pulumi.get(self, "revision")
+        return pulumi.get(self, "port")
 
     @_builtins.property
-    @pulumi.getter(name="serviceAccount")
-    def service_account(self) -> _builtins.str:
+    @pulumi.getter
+    def value(self) -> _builtins.str:
         """
-        Email address of the IAM service account associated with the revision of the WorkerPool. The service account represents the identity of the running revision, and determines what permissions the revision has. If not provided, the revision will use the project's default service account.
+        Optional. The header field value
         """
-        return pulumi.get(self, "service_account")
+        return pulumi.get(self, "value")
 
-    @_builtins.property
-    @pulumi.getter
-    def volumes(self) -> Sequence['outputs.GetWorkerPoolTemplateVolumeResult']:
+
+@pulumi.output_type
+class GetWorkerPoolTemplateContainerLivenessProbeTcpSocketResult(dict):
+    def __init__(__self__, *,
+                 port: _builtins.int):
         """
-        A list of Volumes to make available to containers.
+        :param _builtins.int port: Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "volumes")
+        pulumi.set(__self__, "port", port)
 
     @_builtins.property
-    @pulumi.getter(name="vpcAccesses")
-    def vpc_accesses(self) -> Sequence['outputs.GetWorkerPoolTemplateVpcAccessResult']:
+    @pulumi.getter
+    def port(self) -> _builtins.int:
         """
-        VPC Access configuration to use for this Revision. For more information, visit https://cloud.google.com/run/docs/configuring/connecting-vpc.
+        Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "vpc_accesses")
+        return pulumi.get(self, "port")
 
 
 @pulumi.output_type
-class GetWorkerPoolTemplateContainerResult(dict):
+class GetWorkerPoolTemplateContainerResourceResult(dict):
     def __init__(__self__, *,
-                 args: Sequence[_builtins.str],
-                 commands: Sequence[_builtins.str],
-                 envs: Sequence['outputs.GetWorkerPoolTemplateContainerEnvResult'],
-                 image: _builtins.str,
-                 name: _builtins.str,
-                 resources: Sequence['outputs.GetWorkerPoolTemplateContainerResourceResult'],
-                 volume_mounts: Sequence['outputs.GetWorkerPoolTemplateContainerVolumeMountResult'],
-                 working_dir: _builtins.str):
+                 limits: Mapping[str, _builtins.str]):
         """
-        :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['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.
-        :param Sequence['GetWorkerPoolTemplateContainerResourceArgs'] resources: Compute Resource requirements by this container. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources
-        :param Sequence['GetWorkerPoolTemplateContainerVolumeMountArgs'] volume_mounts: Volume to mount into the container's filesystem.
-        :param _builtins.str working_dir: Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image.
+        :param Mapping[str, _builtins.str] limits: Only memory, CPU, and nvidia.com/gpu are supported. Use key 'cpu' for CPU limit, 'memory' for memory limit, 'nvidia.com/gpu' for gpu limit. Note: The only supported values for CPU are '1', '2', '4', and '8'. Setting 4 CPU requires at least 2Gi of memory. The values of the map is string form of the 'quantity' k8s type: https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go
         """
-        pulumi.set(__self__, "args", args)
-        pulumi.set(__self__, "commands", commands)
-        pulumi.set(__self__, "envs", envs)
-        pulumi.set(__self__, "image", image)
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "resources", resources)
-        pulumi.set(__self__, "volume_mounts", volume_mounts)
-        pulumi.set(__self__, "working_dir", working_dir)
+        pulumi.set(__self__, "limits", limits)
 
     @_builtins.property
     @pulumi.getter
-    def args(self) -> Sequence[_builtins.str]:
+    def limits(self) -> Mapping[str, _builtins.str]:
         """
-        Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references are not supported in Cloud Run.
+        Only memory, CPU, and nvidia.com/gpu are supported. Use key 'cpu' for CPU limit, 'memory' for memory limit, 'nvidia.com/gpu' for gpu limit. Note: The only supported values for CPU are '1', '2', '4', and '8'. Setting 4 CPU requires at least 2Gi of memory. The values of the map is string form of the 'quantity' k8s type: https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go
         """
-        return pulumi.get(self, "args")
+        return pulumi.get(self, "limits")
+
+
+@pulumi.output_type
+class GetWorkerPoolTemplateContainerStartupProbeResult(dict):
+    def __init__(__self__, *,
+                 failure_threshold: _builtins.int,
+                 grpcs: Sequence['outputs.GetWorkerPoolTemplateContainerStartupProbeGrpcResult'],
+                 http_gets: Sequence['outputs.GetWorkerPoolTemplateContainerStartupProbeHttpGetResult'],
+                 initial_delay_seconds: _builtins.int,
+                 period_seconds: _builtins.int,
+                 tcp_sockets: Sequence['outputs.GetWorkerPoolTemplateContainerStartupProbeTcpSocketResult'],
+                 timeout_seconds: _builtins.int):
+        """
+        :param _builtins.int failure_threshold: Optional. Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.
+        :param Sequence['GetWorkerPoolTemplateContainerStartupProbeGrpcArgs'] grpcs: Optional. GRPC specifies an action involving a gRPC port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        :param Sequence['GetWorkerPoolTemplateContainerStartupProbeHttpGetArgs'] http_gets: Optional. HTTPGet specifies the http request to perform. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        :param _builtins.int initial_delay_seconds: Optional. Number of seconds after the container has started before the probe is initiated. Defaults to 0 seconds. Minimum value is 0. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240.
+        :param _builtins.int period_seconds: Optional. How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240. Must be greater or equal than timeout_seconds.
+        :param Sequence['GetWorkerPoolTemplateContainerStartupProbeTcpSocketArgs'] tcp_sockets: Optional. TCPSocket specifies an action involving a TCP port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
+        :param _builtins.int timeout_seconds: Optional. Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. Maximum value is 3600. Must be smaller than period_seconds.
+        """
+        pulumi.set(__self__, "failure_threshold", failure_threshold)
+        pulumi.set(__self__, "grpcs", grpcs)
+        pulumi.set(__self__, "http_gets", http_gets)
+        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
+        pulumi.set(__self__, "period_seconds", period_seconds)
+        pulumi.set(__self__, "tcp_sockets", tcp_sockets)
+        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
 
     @_builtins.property
-    @pulumi.getter
-    def commands(self) -> Sequence[_builtins.str]:
+    @pulumi.getter(name="failureThreshold")
+    def failure_threshold(self) -> _builtins.int:
         """
-        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
+        Optional. Minimum consecutive failures for the probe to be considered failed after having succeeded. Defaults to 3. Minimum value is 1.
         """
-        return pulumi.get(self, "commands")
+        return pulumi.get(self, "failure_threshold")
 
     @_builtins.property
     @pulumi.getter
-    def envs(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerEnvResult']:
+    def grpcs(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerStartupProbeGrpcResult']:
         """
-        List of environment variables to set in the container.
+        Optional. GRPC specifies an action involving a gRPC port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
         """
-        return pulumi.get(self, "envs")
+        return pulumi.get(self, "grpcs")
 
     @_builtins.property
-    @pulumi.getter
-    def image(self) -> _builtins.str:
+    @pulumi.getter(name="httpGets")
+    def http_gets(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerStartupProbeHttpGetResult']:
         """
-        URL of the Container image in Google Container Registry or Google Artifact Registry. More info: https://kubernetes.io/docs/concepts/containers/images
+        Optional. HTTPGet specifies the http request to perform. Exactly one of httpGet, tcpSocket, or grpc must be specified.
         """
-        return pulumi.get(self, "image")
+        return pulumi.get(self, "http_gets")
 
     @_builtins.property
-    @pulumi.getter
-    def name(self) -> _builtins.str:
+    @pulumi.getter(name="initialDelaySeconds")
+    def initial_delay_seconds(self) -> _builtins.int:
         """
-        The name of the Cloud Run v2 Worker Pool.
+        Optional. Number of seconds after the container has started before the probe is initiated. Defaults to 0 seconds. Minimum value is 0. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "initial_delay_seconds")
 
     @_builtins.property
-    @pulumi.getter
-    def resources(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerResourceResult']:
+    @pulumi.getter(name="periodSeconds")
+    def period_seconds(self) -> _builtins.int:
         """
-        Compute Resource requirements by this container. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources
+        Optional. How often (in seconds) to perform the probe. Default to 10 seconds. Minimum value is 1. Maximum value for liveness probe is 3600. Maximum value for startup probe is 240. Must be greater or equal than timeout_seconds.
         """
-        return pulumi.get(self, "resources")
+        return pulumi.get(self, "period_seconds")
 
     @_builtins.property
-    @pulumi.getter(name="volumeMounts")
-    def volume_mounts(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerVolumeMountResult']:
+    @pulumi.getter(name="tcpSockets")
+    def tcp_sockets(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerStartupProbeTcpSocketResult']:
         """
-        Volume to mount into the container's filesystem.
+        Optional. TCPSocket specifies an action involving a TCP port. Exactly one of httpGet, tcpSocket, or grpc must be specified.
         """
-        return pulumi.get(self, "volume_mounts")
+        return pulumi.get(self, "tcp_sockets")
 
     @_builtins.property
-    @pulumi.getter(name="workingDir")
-    def working_dir(self) -> _builtins.str:
+    @pulumi.getter(name="timeoutSeconds")
+    def timeout_seconds(self) -> _builtins.int:
         """
-        Container's working directory. If not specified, the container runtime's default will be used, which might be configured in the container image.
+        Optional. Number of seconds after which the probe times out. Defaults to 1 second. Minimum value is 1. Maximum value is 3600. Must be smaller than period_seconds.
         """
-        return pulumi.get(self, "working_dir")
+        return pulumi.get(self, "timeout_seconds")
 
 
 @pulumi.output_type
-class GetWorkerPoolTemplateContainerEnvResult(dict):
+class GetWorkerPoolTemplateContainerStartupProbeGrpcResult(dict):
     def __init__(__self__, *,
-                 name: _builtins.str,
-                 value: _builtins.str,
-                 value_sources: Sequence['outputs.GetWorkerPoolTemplateContainerEnvValueSourceResult']):
+                 port: _builtins.int,
+                 service: _builtins.str):
         """
-        :param _builtins.str name: The name of the Cloud Run v2 Worker Pool.
-        :param _builtins.str value: Literal value of the environment variable. Defaults to "" and the maximum allowed length is 32768 characters. Variable references are not supported in Cloud Run.
-        :param Sequence['GetWorkerPoolTemplateContainerEnvValueSourceArgs'] value_sources: Source for the environment variable's value.
+        :param _builtins.int port: Optional. Port number of the gRPC service. Number must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
+        :param _builtins.str service: Optional. Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md ). If this is not specified, the default behavior is defined by gRPC
         """
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "value", value)
-        pulumi.set(__self__, "value_sources", value_sources)
+        pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "service", service)
 
     @_builtins.property
     @pulumi.getter
-    def name(self) -> _builtins.str:
+    def port(self) -> _builtins.int:
         """
-        The name of the Cloud Run v2 Worker Pool.
+        Optional. Port number of the gRPC service. Number must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "port")
 
     @_builtins.property
     @pulumi.getter
-    def value(self) -> _builtins.str:
+    def service(self) -> _builtins.str:
         """
-        Literal value of the environment variable. Defaults to "" and the maximum allowed length is 32768 characters. Variable references are not supported in Cloud Run.
+        Optional. Service is the name of the service to place in the gRPC HealthCheckRequest (see https://github.com/grpc/grpc/blob/master/doc/health-checking.md ). If this is not specified, the default behavior is defined by gRPC
         """
-        return pulumi.get(self, "value")
+        return pulumi.get(self, "service")
 
-    @_builtins.property
-    @pulumi.getter(name="valueSources")
-    def value_sources(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerEnvValueSourceResult']:
+
+@pulumi.output_type
+class GetWorkerPoolTemplateContainerStartupProbeHttpGetResult(dict):
+    def __init__(__self__, *,
+                 http_headers: Sequence['outputs.GetWorkerPoolTemplateContainerStartupProbeHttpGetHttpHeaderResult'],
+                 path: _builtins.str,
+                 port: _builtins.int):
         """
-        Source for the environment variable's value.
+        :param Sequence['GetWorkerPoolTemplateContainerStartupProbeHttpGetHttpHeaderArgs'] http_headers: Optional. Custom headers to set in the request. HTTP allows repeated headers.
+        :param _builtins.str path: Optional. Path to access on the HTTP server. Defaults to '/'.
+        :param _builtins.int port: Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "value_sources")
+        pulumi.set(__self__, "http_headers", http_headers)
+        pulumi.set(__self__, "path", path)
+        pulumi.set(__self__, "port", port)
 
+    @_builtins.property
+    @pulumi.getter(name="httpHeaders")
+    def http_headers(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerStartupProbeHttpGetHttpHeaderResult']:
+        """
+        Optional. Custom headers to set in the request. HTTP allows repeated headers.
+        """
+        return pulumi.get(self, "http_headers")
 
-@pulumi.output_type
-class GetWorkerPoolTemplateContainerEnvValueSourceResult(dict):
-    def __init__(__self__, *,
-                 secret_key_reves: Sequence['outputs.GetWorkerPoolTemplateContainerEnvValueSourceSecretKeyRefResult']):
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> _builtins.str:
         """
-        :param Sequence['GetWorkerPoolTemplateContainerEnvValueSourceSecretKeyRefArgs'] secret_key_reves: Selects a secret and a specific version from Cloud Secret Manager.
+        Optional. Path to access on the HTTP server. Defaults to '/'.
         """
-        pulumi.set(__self__, "secret_key_reves", secret_key_reves)
+        return pulumi.get(self, "path")
 
     @_builtins.property
-    @pulumi.getter(name="secretKeyReves")
-    def secret_key_reves(self) -> Sequence['outputs.GetWorkerPoolTemplateContainerEnvValueSourceSecretKeyRefResult']:
+    @pulumi.getter
+    def port(self) -> _builtins.int:
         """
-        Selects a secret and a specific version from Cloud Secret Manager.
+        Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "secret_key_reves")
+        return pulumi.get(self, "port")
 
 
 @pulumi.output_type
-class GetWorkerPoolTemplateContainerEnvValueSourceSecretKeyRefResult(dict):
+class GetWorkerPoolTemplateContainerStartupProbeHttpGetHttpHeaderResult(dict):
     def __init__(__self__, *,
-                 secret: _builtins.str,
-                 version: _builtins.str):
+                 port: _builtins.int,
+                 value: _builtins.str):
         """
-        :param _builtins.str secret: The name of the secret in Cloud Secret Manager. Format: {secretName} if the secret is in the same project. projects/{project}/secrets/{secretName} if the secret is in a different project.
-        :param _builtins.str version: The Cloud Secret Manager secret version. Can be 'latest' for the latest value or an integer for a specific version.
+        :param _builtins.int port: Required. The header field name
+        :param _builtins.str value: Optional. The header field value
         """
-        pulumi.set(__self__, "secret", secret)
-        pulumi.set(__self__, "version", version)
+        pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "value", value)
 
     @_builtins.property
     @pulumi.getter
-    def secret(self) -> _builtins.str:
+    def port(self) -> _builtins.int:
         """
-        The name of the secret in Cloud Secret Manager. Format: {secretName} if the secret is in the same project. projects/{project}/secrets/{secretName} if the secret is in a different project.
+        Required. The header field name
         """
-        return pulumi.get(self, "secret")
+        return pulumi.get(self, "port")
 
     @_builtins.property
     @pulumi.getter
-    def version(self) -> _builtins.str:
+    def value(self) -> _builtins.str:
         """
-        The Cloud Secret Manager secret version. Can be 'latest' for the latest value or an integer for a specific version.
+        Optional. The header field value
         """
-        return pulumi.get(self, "version")
+        return pulumi.get(self, "value")
 
 
 @pulumi.output_type
-class GetWorkerPoolTemplateContainerResourceResult(dict):
+class GetWorkerPoolTemplateContainerStartupProbeTcpSocketResult(dict):
     def __init__(__self__, *,
-                 limits: Mapping[str, _builtins.str]):
+                 port: _builtins.int):
         """
-        :param Mapping[str, _builtins.str] limits: Only memory, CPU, and nvidia.com/gpu are supported. Use key 'cpu' for CPU limit, 'memory' for memory limit, 'nvidia.com/gpu' for gpu limit. Note: The only supported values for CPU are '1', '2', '4', and '8'. Setting 4 CPU requires at least 2Gi of memory. The values of the map is string form of the 'quantity' k8s type: https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go
+        :param _builtins.int port: Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        pulumi.set(__self__, "limits", limits)
+        pulumi.set(__self__, "port", port)
 
     @_builtins.property
     @pulumi.getter
-    def limits(self) -> Mapping[str, _builtins.str]:
+    def port(self) -> _builtins.int:
         """
-        Only memory, CPU, and nvidia.com/gpu are supported. Use key 'cpu' for CPU limit, 'memory' for memory limit, 'nvidia.com/gpu' for gpu limit. Note: The only supported values for CPU are '1', '2', '4', and '8'. Setting 4 CPU requires at least 2Gi of memory. The values of the map is string form of the 'quantity' k8s type: https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/api/resource/quantity.go
+        Optional. Port number to access on the container. Must be in the range 1 to 65535. If not specified, defaults to the exposed port of the container, which is the value of container.ports[0].containerPort.
         """
-        return pulumi.get(self, "limits")
+        return pulumi.get(self, "port")
 
 
 @pulumi.output_type