pulumi-gcp 7.7.0a1706207981__py3-none-any.whl → 7.8.0__py3-none-any.whl

pulumi_gcp/cloudrun/outputs.py

@@ -47,6 +47,7 @@ __all__ = [
     'ServiceTemplateSpecContainerStartupProbeTcpSocket',
     'ServiceTemplateSpecContainerVolumeMount',
     'ServiceTemplateSpecVolume',
+    'ServiceTemplateSpecVolumeCsi',
     'ServiceTemplateSpecVolumeEmptyDir',
     'ServiceTemplateSpecVolumeSecret',
     'ServiceTemplateSpecVolumeSecretItem',
@@ -80,6 +81,7 @@ __all__ = [
     'GetServiceTemplateSpecContainerStartupProbeTcpSocketResult',
     'GetServiceTemplateSpecContainerVolumeMountResult',
     'GetServiceTemplateSpecVolumeResult',
+    'GetServiceTemplateSpecVolumeCsiResult',
     'GetServiceTemplateSpecVolumeEmptyDirResult',
     'GetServiceTemplateSpecVolumeSecretResult',
     'GetServiceTemplateSpecVolumeSecretItemResult',
@@ -2795,16 +2797,23 @@ class ServiceTemplateSpecVolume(dict):
 
     def __init__(__self__, *,
                  name: str,
+                 csi: Optional['outputs.ServiceTemplateSpecVolumeCsi'] = None,
                  empty_dir: Optional['outputs.ServiceTemplateSpecVolumeEmptyDir'] = None,
                  secret: Optional['outputs.ServiceTemplateSpecVolumeSecret'] = None):
         """
         :param str name: Volume's name.
+        :param 'ServiceTemplateSpecVolumeCsiArgs' csi: A filesystem specified by the Container Storage Interface (CSI).
+               Structure is documented below.
+        :param 'ServiceTemplateSpecVolumeEmptyDirArgs' empty_dir: Ephemeral storage which can be backed by real disks (HD, SSD), network storage or memory (i.e. tmpfs). For now only in memory (tmpfs) is supported. It is ephemeral in the sense that when the sandbox is taken down, the data is destroyed with it (it does not persist across sandbox runs).
+               Structure is documented below.
         :param 'ServiceTemplateSpecVolumeSecretArgs' secret: The secret's value will be presented as the content of a file whose
                name is defined in the item path. If no items are defined, the name of
                the file is the secret_name.
                Structure is documented below.
         """
         pulumi.set(__self__, "name", name)
+        if csi is not None:
+            pulumi.set(__self__, "csi", csi)
         if empty_dir is not None:
             pulumi.set(__self__, "empty_dir", empty_dir)
         if secret is not None:
@@ -2818,9 +2827,22 @@ class ServiceTemplateSpecVolume(dict):
         """
         return pulumi.get(self, "name")
 
+    @property
+    @pulumi.getter
+    def csi(self) -> Optional['outputs.ServiceTemplateSpecVolumeCsi']:
+        """
+        A filesystem specified by the Container Storage Interface (CSI).
+        Structure is documented below.
+        """
+        return pulumi.get(self, "csi")
+
     @property
     @pulumi.getter(name="emptyDir")
     def empty_dir(self) -> Optional['outputs.ServiceTemplateSpecVolumeEmptyDir']:
+        """
+        Ephemeral storage which can be backed by real disks (HD, SSD), network storage or memory (i.e. tmpfs). For now only in memory (tmpfs) is supported. It is ephemeral in the sense that when the sandbox is taken down, the data is destroyed with it (it does not persist across sandbox runs).
+        Structure is documented below.
+        """
         return pulumi.get(self, "empty_dir")
 
     @property
@@ -2835,6 +2857,81 @@ class ServiceTemplateSpecVolume(dict):
         return pulumi.get(self, "secret")
 
 
+@pulumi.output_type
+class ServiceTemplateSpecVolumeCsi(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "readOnly":
+            suggest = "read_only"
+        elif key == "volumeAttributes":
+            suggest = "volume_attributes"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceTemplateSpecVolumeCsi. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceTemplateSpecVolumeCsi.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceTemplateSpecVolumeCsi.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 driver: str,
+                 read_only: Optional[bool] = None,
+                 volume_attributes: Optional[Mapping[str, str]] = None):
+        """
+        :param str driver: Unique name representing the type of file system to be created. Cloud Run supports the following values:
+               * gcsfuse.run.googleapis.com: Mount a Google Cloud Storage bucket using GCSFuse. This driver requires the
+               run.googleapis.com/execution-environment annotation to be set to "gen2" and
+               run.googleapis.com/launch-stage set to "BETA" or "ALPHA".
+        :param bool read_only: If true, all mounts created from this volume will be read-only.
+        :param Mapping[str, str] volume_attributes: Driver-specific attributes. The following options are supported for available drivers:
+               * gcsfuse.run.googleapis.com
+               * bucketName: The name of the Cloud Storage Bucket that backs this volume. The Cloud Run Service identity must have access to this bucket.
+               
+               - - -
+        """
+        pulumi.set(__self__, "driver", driver)
+        if read_only is not None:
+            pulumi.set(__self__, "read_only", read_only)
+        if volume_attributes is not None:
+            pulumi.set(__self__, "volume_attributes", volume_attributes)
+
+    @property
+    @pulumi.getter
+    def driver(self) -> str:
+        """
+        Unique name representing the type of file system to be created. Cloud Run supports the following values:
+        * gcsfuse.run.googleapis.com: Mount a Google Cloud Storage bucket using GCSFuse. This driver requires the
+        run.googleapis.com/execution-environment annotation to be set to "gen2" and
+        run.googleapis.com/launch-stage set to "BETA" or "ALPHA".
+        """
+        return pulumi.get(self, "driver")
+
+    @property
+    @pulumi.getter(name="readOnly")
+    def read_only(self) -> Optional[bool]:
+        """
+        If true, all mounts created from this volume will be read-only.
+        """
+        return pulumi.get(self, "read_only")
+
+    @property
+    @pulumi.getter(name="volumeAttributes")
+    def volume_attributes(self) -> Optional[Mapping[str, str]]:
+        """
+        Driver-specific attributes. The following options are supported for available drivers:
+        * gcsfuse.run.googleapis.com
+        * bucketName: The name of the Cloud Storage Bucket that backs this volume. The Cloud Run Service identity must have access to this bucket.
+
+        - - -
+        """
+        return pulumi.get(self, "volume_attributes")
+
+
 @pulumi.output_type
 class ServiceTemplateSpecVolumeEmptyDir(dict):
     @staticmethod
@@ -2860,8 +2957,6 @@ class ServiceTemplateSpecVolumeEmptyDir(dict):
         """
         :param str medium: The medium on which the data is stored. The default is "" which means to use the node's default medium. Must be an empty string (default) or Memory.
         :param 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)
@@ -2881,8 +2976,6 @@ class ServiceTemplateSpecVolumeEmptyDir(dict):
     def size_limit(self) -> Optional[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")
 
@@ -3145,6 +3238,27 @@ class GetServiceMetadataResult(dict):
                  resource_version: str,
                  self_link: str,
                  uid: str):
+        """
+        :param int generation: A sequence number representing a specific generation of the desired state.
+        :param Mapping[str, str] labels: Map of string keys and values that can be used to organize and categorize
+               (scope and select) objects. May match selectors of replication controllers
+               and routes.
+               
+               **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
+               Please refer to the field 'effective_labels' for all of the labels present on the resource.
+        :param str namespace: In Cloud Run the namespace must be equal to either the
+               project ID or project number.
+        :param Mapping[str, str] pulumi_labels: The combination of labels configured directly on the resource
+                and default labels configured on the provider.
+        :param str resource_version: An opaque value that represents the internal version of this object that
+               can be used by clients to determine when objects have changed. May be used
+               for optimistic concurrency, change detection, and the watch operation on a
+               resource or set of resources. They may only be valid for a
+               particular resource or set of resources.
+        :param str self_link: SelfLink is a URL representing this object.
+        :param str uid: UID is a unique id generated by the server on successful creation of a resource and is not
+               allowed to change on PUT operations.
+        """
         pulumi.set(__self__, "annotations", annotations)
         pulumi.set(__self__, "effective_annotations", effective_annotations)
         pulumi.set(__self__, "effective_labels", effective_labels)
@@ -3174,36 +3288,69 @@ class GetServiceMetadataResult(dict):
     @property
     @pulumi.getter
     def generation(self) -> int:
+        """
+        A sequence number representing a specific generation of the desired state.
+        """
         return pulumi.get(self, "generation")
 
     @property
     @pulumi.getter
     def labels(self) -> Mapping[str, str]:
+        """
+        Map of string keys and values that can be used to organize and categorize
+        (scope and select) objects. May match selectors of replication controllers
+        and routes.
+
+        **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
+        Please refer to the field 'effective_labels' for all of the labels present on the resource.
+        """
         return pulumi.get(self, "labels")
 
     @property
     @pulumi.getter
     def namespace(self) -> str:
+        """
+        In Cloud Run the namespace must be equal to either the
+        project ID or project number.
+        """
         return pulumi.get(self, "namespace")
 
     @property
     @pulumi.getter(name="pulumiLabels")
     def pulumi_labels(self) -> Mapping[str, str]:
+        """
+        The combination of labels configured directly on the resource
+         and default labels configured on the provider.
+        """
         return pulumi.get(self, "pulumi_labels")
 
     @property
     @pulumi.getter(name="resourceVersion")
     def resource_version(self) -> str:
+        """
+        An opaque value that represents the internal version of this object that
+        can be used by clients to determine when objects have changed. May be used
+        for optimistic concurrency, change detection, and the watch operation on a
+        resource or set of resources. They may only be valid for a
+        particular resource or set of resources.
+        """
         return pulumi.get(self, "resource_version")
 
     @property
     @pulumi.getter(name="selfLink")
     def self_link(self) -> str:
+        """
+        SelfLink is a URL representing this object.
+        """
         return pulumi.get(self, "self_link")
 
     @property
     @pulumi.getter
     def uid(self) -> str:
+        """
+        UID is a unique id generated by the server on successful creation of a resource and is not
+        allowed to change on PUT operations.
+        """
         return pulumi.get(self, "uid")
 
 
@@ -3216,6 +3363,25 @@ class GetServiceStatusResult(dict):
                  observed_generation: int,
                  traffics: Sequence['outputs.GetServiceStatusTrafficResult'],
                  url: str):
+        """
+        :param Sequence['GetServiceStatusConditionArgs'] conditions: Array of observed Service Conditions, indicating the current ready state of the service.
+        :param str latest_created_revision_name: From ConfigurationStatus. LatestCreatedRevisionName is the last revision that was created
+               from this Service's Configuration. It might not be ready yet, for that use
+               LatestReadyRevisionName.
+        :param str latest_ready_revision_name: From ConfigurationStatus. LatestReadyRevisionName holds the name of the latest Revision
+               stamped out from this Service's Configuration that has had its "Ready" condition become
+               "True".
+        :param int observed_generation: ObservedGeneration is the 'Generation' of the Route that was last processed by the
+               controller.
+               
+               Clients polling for completed reconciliation should poll until observedGeneration =
+               metadata.generation and the Ready condition's status is True or False.
+        :param Sequence['GetServiceStatusTrafficArgs'] traffics: Traffic specifies how to distribute traffic over a collection of Knative Revisions
+               and Configurations
+        :param str url: From RouteStatus. URL holds the url that will distribute traffic over the provided traffic
+               targets. It generally has the form
+               https://{route-hash}-{project-hash}-{cluster-level-suffix}.a.run.app
+        """
         pulumi.set(__self__, "conditions", conditions)
         pulumi.set(__self__, "latest_created_revision_name", latest_created_revision_name)
         pulumi.set(__self__, "latest_ready_revision_name", latest_ready_revision_name)
@@ -3226,31 +3392,60 @@ class GetServiceStatusResult(dict):
     @property
     @pulumi.getter
     def conditions(self) -> Sequence['outputs.GetServiceStatusConditionResult']:
+        """
+        Array of observed Service Conditions, indicating the current ready state of the service.
+        """
         return pulumi.get(self, "conditions")
 
     @property
     @pulumi.getter(name="latestCreatedRevisionName")
     def latest_created_revision_name(self) -> str:
+        """
+        From ConfigurationStatus. LatestCreatedRevisionName is the last revision that was created
+        from this Service's Configuration. It might not be ready yet, for that use
+        LatestReadyRevisionName.
+        """
         return pulumi.get(self, "latest_created_revision_name")
 
     @property
     @pulumi.getter(name="latestReadyRevisionName")
     def latest_ready_revision_name(self) -> str:
+        """
+        From ConfigurationStatus. LatestReadyRevisionName holds the name of the latest Revision
+        stamped out from this Service's Configuration that has had its "Ready" condition become
+        "True".
+        """
         return pulumi.get(self, "latest_ready_revision_name")
 
     @property
     @pulumi.getter(name="observedGeneration")
     def observed_generation(self) -> int:
+        """
+        ObservedGeneration is the 'Generation' of the Route that was last processed by the
+        controller.
+
+        Clients polling for completed reconciliation should poll until observedGeneration =
+        metadata.generation and the Ready condition's status is True or False.
+        """
         return pulumi.get(self, "observed_generation")
 
     @property
     @pulumi.getter
     def traffics(self) -> Sequence['outputs.GetServiceStatusTrafficResult']:
+        """
+        Traffic specifies how to distribute traffic over a collection of Knative Revisions
+        and Configurations
+        """
         return pulumi.get(self, "traffics")
 
     @property
     @pulumi.getter
     def url(self) -> str:
+        """
+        From RouteStatus. URL holds the url that will distribute traffic over the provided traffic
+        targets. It generally has the form
+        https://{route-hash}-{project-hash}-{cluster-level-suffix}.a.run.app
+        """
         return pulumi.get(self, "url")
 
 
@@ -3261,6 +3456,12 @@ class GetServiceStatusConditionResult(dict):
                  reason: str,
                  status: str,
                  type: str):
+        """
+        :param str message: Human readable message indicating details about the current status.
+        :param str reason: One-word CamelCase reason for the condition's current status.
+        :param str status: Status of the condition, one of True, False, Unknown.
+        :param str type: Type of domain mapping condition.
+        """
         pulumi.set(__self__, "message", message)
         pulumi.set(__self__, "reason", reason)
         pulumi.set(__self__, "status", status)
@@ -3269,21 +3470,33 @@ class GetServiceStatusConditionResult(dict):
     @property
     @pulumi.getter
     def message(self) -> str:
+        """
+        Human readable message indicating details about the current status.
+        """
         return pulumi.get(self, "message")
 
     @property
     @pulumi.getter
     def reason(self) -> str:
+        """
+        One-word CamelCase reason for the condition's current status.
+        """
         return pulumi.get(self, "reason")
 
     @property
     @pulumi.getter
     def status(self) -> str:
+        """
+        Status of the condition, one of True, False, Unknown.
+        """
         return pulumi.get(self, "status")
 
     @property
     @pulumi.getter
     def type(self) -> str:
+        """
+        Type of domain mapping condition.
+        """
         return pulumi.get(self, "type")
 
 
@@ -3295,6 +3508,18 @@ class GetServiceStatusTrafficResult(dict):
                  revision_name: str,
                  tag: str,
                  url: str):
+        """
+        :param bool latest_revision: LatestRevision may be optionally provided to indicate that the latest ready
+               Revision of the Configuration should be used for this traffic target. When
+               provided LatestRevision must be true if RevisionName is empty; it must be
+               false when RevisionName is non-empty.
+        :param int percent: Percent specifies percent of the traffic to this Revision or Configuration.
+        :param str revision_name: RevisionName of a specific revision to which to send this portion of traffic.
+        :param str tag: Tag is optionally used to expose a dedicated url for referencing this target exclusively.
+        :param str url: URL displays the URL for accessing tagged traffic targets. URL is displayed in status,
+               and is disallowed on spec. URL must contain a scheme (e.g. http://) and a hostname,
+               but may not contain anything else (e.g. basic auth, url path, etc.)
+        """
         pulumi.set(__self__, "latest_revision", latest_revision)
         pulumi.set(__self__, "percent", percent)
         pulumi.set(__self__, "revision_name", revision_name)
@@ -3304,26 +3529,46 @@ class GetServiceStatusTrafficResult(dict):
     @property
     @pulumi.getter(name="latestRevision")
     def latest_revision(self) -> bool:
+        """
+        LatestRevision may be optionally provided to indicate that the latest ready
+        Revision of the Configuration should be used for this traffic target. When
+        provided LatestRevision must be true if RevisionName is empty; it must be
+        false when RevisionName is non-empty.
+        """
         return pulumi.get(self, "latest_revision")
 
     @property
     @pulumi.getter
     def percent(self) -> int:
+        """
+        Percent specifies percent of the traffic to this Revision or Configuration.
+        """
         return pulumi.get(self, "percent")
 
     @property
     @pulumi.getter(name="revisionName")
     def revision_name(self) -> str:
+        """
+        RevisionName of a specific revision to which to send this portion of traffic.
+        """
         return pulumi.get(self, "revision_name")
 
     @property
     @pulumi.getter
     def tag(self) -> str:
+        """
+        Tag is optionally used to expose a dedicated url for referencing this target exclusively.
+        """
         return pulumi.get(self, "tag")
 
     @property
     @pulumi.getter
     def url(self) -> str:
+        """
+        URL displays the URL for accessing tagged traffic targets. URL is displayed in status,
+        and is disallowed on spec. URL must contain a scheme (e.g. http://) and a hostname,
+        but may not contain anything else (e.g. basic auth, url path, etc.)
+        """
         return pulumi.get(self, "url")
 
 
@@ -3332,17 +3577,39 @@ class GetServiceTemplateResult(dict):
     def __init__(__self__, *,
                  metadatas: Sequence['outputs.GetServiceTemplateMetadataResult'],
                  specs: Sequence['outputs.GetServiceTemplateSpecResult']):
+        """
+        :param Sequence['GetServiceTemplateMetadataArgs'] metadatas: Optional metadata for this Revision, including labels and annotations.
+               Name will be generated by the Configuration. To set minimum instances
+               for this revision, use the "autoscaling.knative.dev/minScale" annotation
+               key. To set maximum instances for this revision, use the
+               "autoscaling.knative.dev/maxScale" annotation key. To set Cloud SQL
+               connections for the revision, use the "run.googleapis.com/cloudsql-instances"
+               annotation key.
+        :param Sequence['GetServiceTemplateSpecArgs'] specs: RevisionSpec holds the desired state of the Revision (from the client).
+        """
         pulumi.set(__self__, "metadatas", metadatas)
         pulumi.set(__self__, "specs", specs)
 
     @property
     @pulumi.getter
     def metadatas(self) -> Sequence['outputs.GetServiceTemplateMetadataResult']:
+        """
+        Optional metadata for this Revision, including labels and annotations.
+        Name will be generated by the Configuration. To set minimum instances
+        for this revision, use the "autoscaling.knative.dev/minScale" annotation
+        key. To set maximum instances for this revision, use the
+        "autoscaling.knative.dev/maxScale" annotation key. To set Cloud SQL
+        connections for the revision, use the "run.googleapis.com/cloudsql-instances"
+        annotation key.
+        """
         return pulumi.get(self, "metadatas")
 
     @property
     @pulumi.getter
     def specs(self) -> Sequence['outputs.GetServiceTemplateSpecResult']:
+        """
+        RevisionSpec holds the desired state of the Revision (from the client).
+        """
         return pulumi.get(self, "specs")
 
 
@@ -3358,7 +3625,20 @@ class GetServiceTemplateMetadataResult(dict):
                  self_link: str,
                  uid: str):
         """
+        :param int generation: A sequence number representing a specific generation of the desired state.
+        :param Mapping[str, str] labels: Map of string keys and values that can be used to organize and categorize
+               (scope and select) objects.
         :param str name: The name of the Cloud Run Service.
+        :param str namespace: In Cloud Run the namespace must be equal to either the
+               project ID or project number. It will default to the resource's project.
+        :param str resource_version: An opaque value that represents the internal version of this object that
+               can be used by clients to determine when objects have changed. May be used
+               for optimistic concurrency, change detection, and the watch operation on a
+               resource or set of resources. They may only be valid for a
+               particular resource or set of resources.
+        :param str self_link: SelfLink is a URL representing this object.
+        :param str uid: UID is a unique id generated by the server on successful creation of a resource and is not
+               allowed to change on PUT operations.
         """
         pulumi.set(__self__, "annotations", annotations)
         pulumi.set(__self__, "generation", generation)
@@ -3377,11 +3657,18 @@ class GetServiceTemplateMetadataResult(dict):
     @property
     @pulumi.getter
     def generation(self) -> int:
+        """
+        A sequence number representing a specific generation of the desired state.
+        """
         return pulumi.get(self, "generation")
 
     @property
     @pulumi.getter
     def labels(self) -> Mapping[str, str]:
+        """
+        Map of string keys and values that can be used to organize and categorize
+        (scope and select) objects.
+        """
         return pulumi.get(self, "labels")
 
     @property
@@ -3395,21 +3682,39 @@ class GetServiceTemplateMetadataResult(dict):
     @property
     @pulumi.getter
     def namespace(self) -> str:
+        """
+        In Cloud Run the namespace must be equal to either the
+        project ID or project number. It will default to the resource's project.
+        """
         return pulumi.get(self, "namespace")
 
     @property
     @pulumi.getter(name="resourceVersion")
     def resource_version(self) -> str:
+        """
+        An opaque value that represents the internal version of this object that
+        can be used by clients to determine when objects have changed. May be used
+        for optimistic concurrency, change detection, and the watch operation on a
+        resource or set of resources. They may only be valid for a
+        particular resource or set of resources.
+        """
         return pulumi.get(self, "resource_version")
 
     @property
     @pulumi.getter(name="selfLink")
     def self_link(self) -> str:
+        """
+        SelfLink is a URL representing this object.
+        """
         return pulumi.get(self, "self_link")
 
     @property
     @pulumi.getter
     def uid(self) -> str:
+        """
+        UID is a unique id generated by the server on successful creation of a resource and is not
+        allowed to change on PUT operations.
+        """
         return pulumi.get(self, "uid")
 
 
@@ -3422,6 +3727,25 @@ class GetServiceTemplateSpecResult(dict):
                  serving_state: str,
                  timeout_seconds: int,
                  volumes: Sequence['outputs.GetServiceTemplateSpecVolumeResult']):
+        """
+        :param int container_concurrency: ContainerConcurrency specifies the maximum allowed in-flight (concurrent)
+               requests per container of the Revision. Values are:
+               - '0' thread-safe, the system should manage the max concurrency. This is
+                   the default value.
+               - '1' not-thread-safe. Single concurrency
+               - '2-N' thread-safe, max concurrency of N
+        :param Sequence['GetServiceTemplateSpecContainerArgs'] containers: Containers defines the unit of execution for this Revision.
+        :param str service_account_name: Email address of the IAM service account associated with the revision of the
+               service. 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 str serving_state: ServingState holds a value describing the state the resources
+               are in for this Revision.
+               It is expected
+               that the system will manipulate this based on routability and load.
+        :param int timeout_seconds: TimeoutSeconds holds the max duration the instance is allowed for responding to a request.
+        :param Sequence['GetServiceTemplateSpecVolumeArgs'] volumes: Volume represents a named volume in a container.
+        """
         pulumi.set(__self__, "container_concurrency", container_concurrency)
         pulumi.set(__self__, "containers", containers)
         pulumi.set(__self__, "service_account_name", service_account_name)
@@ -3432,31 +3756,60 @@ class GetServiceTemplateSpecResult(dict):
     @property
     @pulumi.getter(name="containerConcurrency")
     def container_concurrency(self) -> int:
+        """
+        ContainerConcurrency specifies the maximum allowed in-flight (concurrent)
+        requests per container of the Revision. Values are:
+        - '0' thread-safe, the system should manage the max concurrency. This is
+            the default value.
+        - '1' not-thread-safe. Single concurrency
+        - '2-N' thread-safe, max concurrency of N
+        """
         return pulumi.get(self, "container_concurrency")
 
     @property
     @pulumi.getter
     def containers(self) -> Sequence['outputs.GetServiceTemplateSpecContainerResult']:
+        """
+        Containers defines the unit of execution for this Revision.
+        """
         return pulumi.get(self, "containers")
 
     @property
     @pulumi.getter(name="serviceAccountName")
     def service_account_name(self) -> str:
+        """
+        Email address of the IAM service account associated with the revision of the
+        service. 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, "service_account_name")
 
     @property
     @pulumi.getter(name="servingState")
     def serving_state(self) -> str:
-        return pulumi.get(self, "serving_state")
-
-    @property
-    @pulumi.getter(name="timeoutSeconds")
-    def timeout_seconds(self) -> int:
+        """
+        ServingState holds a value describing the state the resources
+        are in for this Revision.
+        It is expected
+        that the system will manipulate this based on routability and load.
+        """
+        return pulumi.get(self, "serving_state")
+
+    @property
+    @pulumi.getter(name="timeoutSeconds")
+    def timeout_seconds(self) -> int:
+        """
+        TimeoutSeconds holds the max duration the instance is allowed for responding to a request.
+        """
         return pulumi.get(self, "timeout_seconds")
 
     @property
     @pulumi.getter
     def volumes(self) -> Sequence['outputs.GetServiceTemplateSpecVolumeResult']:
+        """
+        Volume represents a named volume in a container.
+        """
         return pulumi.get(self, "volumes")
 
 
@@ -3476,7 +3829,30 @@ class GetServiceTemplateSpecContainerResult(dict):
                  volume_mounts: Sequence['outputs.GetServiceTemplateSpecContainerVolumeMountResult'],
                  working_dir: str):
         """
+        :param Sequence[str] args: Arguments to the entrypoint.
+               The docker image's CMD is used if this is not provided.
+        :param Sequence[str] commands: Entrypoint array. Not executed within a shell.
+               The docker image's ENTRYPOINT is used if this is not provided.
+        :param Sequence['GetServiceTemplateSpecContainerEnvFromArgs'] env_froms: List of sources to populate environment variables in the container.
+               All invalid keys will be reported as an event when the container is starting.
+               When a key exists in multiple sources, the value associated with the last source will
+               take precedence. Values defined by an Env with a duplicate key will take
+               precedence.
+        :param Sequence['GetServiceTemplateSpecContainerEnvArgs'] envs: List of environment variables to set in the container.
+        :param str image: Docker image name. This is most often a reference to a container located
+               in the container registry, such as gcr.io/cloudrun/hello
+        :param Sequence['GetServiceTemplateSpecContainerLivenessProbeArgs'] liveness_probes: Periodic probe of container liveness. Container will be restarted if the probe fails.
         :param str name: The name of the Cloud Run Service.
+        :param Sequence['GetServiceTemplateSpecContainerPortArgs'] ports: List of open ports in the container.
+        :param Sequence['GetServiceTemplateSpecContainerResourceArgs'] resources: Compute Resources required by this container. Used to set values such as max memory
+        :param Sequence['GetServiceTemplateSpecContainerStartupProbeArgs'] 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['GetServiceTemplateSpecContainerVolumeMountArgs'] volume_mounts: Volume to mount into the container's filesystem.
+               Only supports SecretVolumeSources.
+        :param 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__, "args", args)
         pulumi.set(__self__, "commands", commands)
@@ -3494,31 +3870,56 @@ class GetServiceTemplateSpecContainerResult(dict):
     @property
     @pulumi.getter
     def args(self) -> Sequence[str]:
+        """
+        Arguments to the entrypoint.
+        The docker image's CMD is used if this is not provided.
+        """
         return pulumi.get(self, "args")
 
     @property
     @pulumi.getter
     def commands(self) -> Sequence[str]:
+        """
+        Entrypoint array. Not executed within a shell.
+        The docker image's ENTRYPOINT is used if this is not provided.
+        """
         return pulumi.get(self, "commands")
 
     @property
     @pulumi.getter(name="envFroms")
     def env_froms(self) -> Sequence['outputs.GetServiceTemplateSpecContainerEnvFromResult']:
+        """
+        List of sources to populate environment variables in the container.
+        All invalid keys will be reported as an event when the container is starting.
+        When a key exists in multiple sources, the value associated with the last source will
+        take precedence. Values defined by an Env with a duplicate key will take
+        precedence.
+        """
         return pulumi.get(self, "env_froms")
 
     @property
     @pulumi.getter
     def envs(self) -> Sequence['outputs.GetServiceTemplateSpecContainerEnvResult']:
+        """
+        List of environment variables to set in the container.
+        """
         return pulumi.get(self, "envs")
 
     @property
     @pulumi.getter
     def image(self) -> str:
+        """
+        Docker image name. This is most often a reference to a container located
+        in the container registry, such as gcr.io/cloudrun/hello
+        """
         return pulumi.get(self, "image")
 
     @property
     @pulumi.getter(name="livenessProbes")
     def liveness_probes(self) -> Sequence['outputs.GetServiceTemplateSpecContainerLivenessProbeResult']:
+        """
+        Periodic probe of container liveness. Container will be restarted if the probe fails.
+        """
         return pulumi.get(self, "liveness_probes")
 
     @property
@@ -3532,26 +3933,46 @@ class GetServiceTemplateSpecContainerResult(dict):
     @property
     @pulumi.getter
     def ports(self) -> Sequence['outputs.GetServiceTemplateSpecContainerPortResult']:
+        """
+        List of open ports in the container.
+        """
         return pulumi.get(self, "ports")
 
     @property
     @pulumi.getter
     def resources(self) -> Sequence['outputs.GetServiceTemplateSpecContainerResourceResult']:
+        """
+        Compute Resources required by this container. Used to set values such as max memory
+        """
         return pulumi.get(self, "resources")
 
     @property
     @pulumi.getter(name="startupProbes")
     def startup_probes(self) -> Sequence['outputs.GetServiceTemplateSpecContainerStartupProbeResult']:
+        """
+        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, "startup_probes")
 
     @property
     @pulumi.getter(name="volumeMounts")
     def volume_mounts(self) -> Sequence['outputs.GetServiceTemplateSpecContainerVolumeMountResult']:
+        """
+        Volume to mount into the container's filesystem.
+        Only supports SecretVolumeSources.
+        """
         return pulumi.get(self, "volume_mounts")
 
     @property
     @pulumi.getter(name="workingDir")
     def working_dir(self) -> str:
+        """
+        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, "working_dir")
 
 
@@ -3563,6 +3984,8 @@ class GetServiceTemplateSpecContainerEnvResult(dict):
                  value_froms: Sequence['outputs.GetServiceTemplateSpecContainerEnvValueFromResult']):
         """
         :param str name: The name of the Cloud Run Service.
+        :param str value: Defaults to "".
+        :param Sequence['GetServiceTemplateSpecContainerEnvValueFromArgs'] value_froms: Source for the environment variable's value. Only supports secret_key_ref.
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "value", value)
@@ -3579,11 +4002,17 @@ class GetServiceTemplateSpecContainerEnvResult(dict):
     @property
     @pulumi.getter
     def value(self) -> str:
+        """
+        Defaults to "".
+        """
         return pulumi.get(self, "value")
 
     @property
     @pulumi.getter(name="valueFroms")
     def value_froms(self) -> Sequence['outputs.GetServiceTemplateSpecContainerEnvValueFromResult']:
+        """
+        Source for the environment variable's value. Only supports secret_key_ref.
+        """
         return pulumi.get(self, "value_froms")
 
 
@@ -3593,6 +4022,11 @@ class GetServiceTemplateSpecContainerEnvFromResult(dict):
                  config_map_reves: Sequence['outputs.GetServiceTemplateSpecContainerEnvFromConfigMapRefResult'],
                  prefix: str,
                  secret_reves: Sequence['outputs.GetServiceTemplateSpecContainerEnvFromSecretRefResult']):
+        """
+        :param Sequence['GetServiceTemplateSpecContainerEnvFromConfigMapRefArgs'] config_map_reves: The ConfigMap to select from.
+        :param str prefix: An optional identifier to prepend to each key in the ConfigMap.
+        :param Sequence['GetServiceTemplateSpecContainerEnvFromSecretRefArgs'] secret_reves: The Secret to select from.
+        """
         pulumi.set(__self__, "config_map_reves", config_map_reves)
         pulumi.set(__self__, "prefix", prefix)
         pulumi.set(__self__, "secret_reves", secret_reves)
@@ -3600,16 +4034,25 @@ class GetServiceTemplateSpecContainerEnvFromResult(dict):
     @property
     @pulumi.getter(name="configMapReves")
     def config_map_reves(self) -> Sequence['outputs.GetServiceTemplateSpecContainerEnvFromConfigMapRefResult']:
+        """
+        The ConfigMap to select from.
+        """
         return pulumi.get(self, "config_map_reves")
 
     @property
     @pulumi.getter
     def prefix(self) -> str:
+        """
+        An optional identifier to prepend to each key in the ConfigMap.
+        """
         return pulumi.get(self, "prefix")
 
     @property
     @pulumi.getter(name="secretReves")
     def secret_reves(self) -> Sequence['outputs.GetServiceTemplateSpecContainerEnvFromSecretRefResult']:
+        """
+        The Secret to select from.
+        """
         return pulumi.get(self, "secret_reves")
 
 
@@ -3618,17 +4061,27 @@ class GetServiceTemplateSpecContainerEnvFromConfigMapRefResult(dict):
     def __init__(__self__, *,
                  local_object_references: Sequence['outputs.GetServiceTemplateSpecContainerEnvFromConfigMapRefLocalObjectReferenceResult'],
                  optional: bool):
+        """
+        :param Sequence['GetServiceTemplateSpecContainerEnvFromConfigMapRefLocalObjectReferenceArgs'] local_object_references: The ConfigMap to select from.
+        :param bool optional: Specify whether the ConfigMap must be defined
+        """
         pulumi.set(__self__, "local_object_references", local_object_references)
         pulumi.set(__self__, "optional", optional)
 
     @property
     @pulumi.getter(name="localObjectReferences")
     def local_object_references(self) -> Sequence['outputs.GetServiceTemplateSpecContainerEnvFromConfigMapRefLocalObjectReferenceResult']:
+        """
+        The ConfigMap to select from.
+        """
         return pulumi.get(self, "local_object_references")
 
     @property
     @pulumi.getter
     def optional(self) -> bool:
+        """
+        Specify whether the ConfigMap must be defined
+        """
         return pulumi.get(self, "optional")
 
 
@@ -3655,17 +4108,27 @@ class GetServiceTemplateSpecContainerEnvFromSecretRefResult(dict):
     def __init__(__self__, *,
                  local_object_references: Sequence['outputs.GetServiceTemplateSpecContainerEnvFromSecretRefLocalObjectReferenceResult'],
                  optional: bool):
+        """
+        :param Sequence['GetServiceTemplateSpecContainerEnvFromSecretRefLocalObjectReferenceArgs'] local_object_references: The Secret to select from.
+        :param bool optional: Specify whether the Secret must be defined
+        """
         pulumi.set(__self__, "local_object_references", local_object_references)
         pulumi.set(__self__, "optional", optional)
 
     @property
     @pulumi.getter(name="localObjectReferences")
     def local_object_references(self) -> Sequence['outputs.GetServiceTemplateSpecContainerEnvFromSecretRefLocalObjectReferenceResult']:
+        """
+        The Secret to select from.
+        """
         return pulumi.get(self, "local_object_references")
 
     @property
     @pulumi.getter
     def optional(self) -> bool:
+        """
+        Specify whether the Secret must be defined
+        """
         return pulumi.get(self, "optional")
 
 
@@ -3691,11 +4154,17 @@ class GetServiceTemplateSpecContainerEnvFromSecretRefLocalObjectReferenceResult(
 class GetServiceTemplateSpecContainerEnvValueFromResult(dict):
     def __init__(__self__, *,
                  secret_key_reves: Sequence['outputs.GetServiceTemplateSpecContainerEnvValueFromSecretKeyRefResult']):
+        """
+        :param Sequence['GetServiceTemplateSpecContainerEnvValueFromSecretKeyRefArgs'] secret_key_reves: Selects a key (version) of a secret in Secret Manager.
+        """
         pulumi.set(__self__, "secret_key_reves", secret_key_reves)
 
     @property
     @pulumi.getter(name="secretKeyReves")
     def secret_key_reves(self) -> Sequence['outputs.GetServiceTemplateSpecContainerEnvValueFromSecretKeyRefResult']:
+        """
+        Selects a key (version) of a secret in Secret Manager.
+        """
         return pulumi.get(self, "secret_key_reves")
 
 
@@ -3705,6 +4174,8 @@ class GetServiceTemplateSpecContainerEnvValueFromSecretKeyRefResult(dict):
                  key: str,
                  name: str):
         """
+        :param str key: A Cloud Secret Manager secret version. Must be 'latest' for the latest
+               version or an integer for a specific version.
         :param str name: The name of the Cloud Run Service.
         """
         pulumi.set(__self__, "key", key)
@@ -3713,6 +4184,10 @@ class GetServiceTemplateSpecContainerEnvValueFromSecretKeyRefResult(dict):
     @property
     @pulumi.getter
     def key(self) -> str:
+        """
+        A Cloud Secret Manager secret version. Must be 'latest' for the latest
+        version or an integer for a specific version.
+        """
         return pulumi.get(self, "key")
 
     @property
@@ -3733,6 +4208,20 @@ class GetServiceTemplateSpecContainerLivenessProbeResult(dict):
                  initial_delay_seconds: int,
                  period_seconds: int,
                  timeout_seconds: int):
+        """
+        :param int failure_threshold: Minimum consecutive failures for the probe to be considered failed after
+               having succeeded. Defaults to 3. Minimum value is 1.
+        :param Sequence['GetServiceTemplateSpecContainerLivenessProbeGrpcArgs'] grpcs: GRPC specifies an action involving a GRPC port.
+        :param Sequence['GetServiceTemplateSpecContainerLivenessProbeHttpGetArgs'] http_gets: HttpGet specifies the http request to perform.
+        :param int initial_delay_seconds: Number of seconds after the container has started before the probe is
+               initiated.
+               Defaults to 0 seconds. Minimum value is 0. Maximum value is 3600.
+        :param int period_seconds: How often (in seconds) to perform the probe.
+               Default to 10 seconds. Minimum value is 1. Maximum value is 3600.
+        :param int timeout_seconds: 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)
@@ -3743,31 +4232,55 @@ class GetServiceTemplateSpecContainerLivenessProbeResult(dict):
     @property
     @pulumi.getter(name="failureThreshold")
     def failure_threshold(self) -> int:
+        """
+        Minimum consecutive failures for the probe to be considered failed after
+        having succeeded. Defaults to 3. Minimum value is 1.
+        """
         return pulumi.get(self, "failure_threshold")
 
     @property
     @pulumi.getter
     def grpcs(self) -> Sequence['outputs.GetServiceTemplateSpecContainerLivenessProbeGrpcResult']:
+        """
+        GRPC specifies an action involving a GRPC port.
+        """
         return pulumi.get(self, "grpcs")
 
     @property
     @pulumi.getter(name="httpGets")
     def http_gets(self) -> Sequence['outputs.GetServiceTemplateSpecContainerLivenessProbeHttpGetResult']:
+        """
+        HttpGet specifies the http request to perform.
+        """
         return pulumi.get(self, "http_gets")
 
     @property
     @pulumi.getter(name="initialDelaySeconds")
     def initial_delay_seconds(self) -> int:
+        """
+        Number of seconds after the container has started before the probe is
+        initiated.
+        Defaults to 0 seconds. Minimum value is 0. Maximum value is 3600.
+        """
         return pulumi.get(self, "initial_delay_seconds")
 
     @property
     @pulumi.getter(name="periodSeconds")
     def period_seconds(self) -> int:
+        """
+        How often (in seconds) to perform the probe.
+        Default to 10 seconds. Minimum value is 1. Maximum value is 3600.
+        """
         return pulumi.get(self, "period_seconds")
 
     @property
     @pulumi.getter(name="timeoutSeconds")
     def timeout_seconds(self) -> int:
+        """
+        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")
 
 
@@ -3776,17 +4289,33 @@ class GetServiceTemplateSpecContainerLivenessProbeGrpcResult(dict):
     def __init__(__self__, *,
                  port: int,
                  service: str):
+        """
+        :param int port: Port number to access on the container. Number must be in the range 1 to 65535.
+               If not specified, defaults to the same value as container.ports[0].containerPort.
+        :param str service: 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)
 
     @property
     @pulumi.getter
     def port(self) -> int:
+        """
+        Port number to access on the container. Number must be in the range 1 to 65535.
+        If not specified, defaults to the same value as container.ports[0].containerPort.
+        """
         return pulumi.get(self, "port")
 
     @property
     @pulumi.getter
     def service(self) -> str:
+        """
+        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")
 
 
@@ -3796,6 +4325,12 @@ class GetServiceTemplateSpecContainerLivenessProbeHttpGetResult(dict):
                  http_headers: Sequence['outputs.GetServiceTemplateSpecContainerLivenessProbeHttpGetHttpHeaderResult'],
                  path: str,
                  port: int):
+        """
+        :param Sequence['GetServiceTemplateSpecContainerLivenessProbeHttpGetHttpHeaderArgs'] http_headers: Custom headers to set in the request. HTTP allows repeated headers.
+        :param str path: Path to access on the HTTP server. If set, it should not be empty string.
+        :param int port: Port number to access on the container. Number must be in the range 1 to 65535.
+               If not specified, defaults to the same value as container.ports[0].containerPort.
+        """
         pulumi.set(__self__, "http_headers", http_headers)
         pulumi.set(__self__, "path", path)
         pulumi.set(__self__, "port", port)
@@ -3803,16 +4338,26 @@ class GetServiceTemplateSpecContainerLivenessProbeHttpGetResult(dict):
     @property
     @pulumi.getter(name="httpHeaders")
     def http_headers(self) -> Sequence['outputs.GetServiceTemplateSpecContainerLivenessProbeHttpGetHttpHeaderResult']:
+        """
+        Custom headers to set in the request. HTTP allows repeated headers.
+        """
         return pulumi.get(self, "http_headers")
 
     @property
     @pulumi.getter
     def path(self) -> str:
+        """
+        Path to access on the HTTP server. If set, it should not be empty string.
+        """
         return pulumi.get(self, "path")
 
     @property
     @pulumi.getter
     def port(self) -> int:
+        """
+        Port number to access on the container. Number must be in the range 1 to 65535.
+        If not specified, defaults to the same value as container.ports[0].containerPort.
+        """
         return pulumi.get(self, "port")
 
 
@@ -3823,6 +4368,7 @@ class GetServiceTemplateSpecContainerLivenessProbeHttpGetHttpHeaderResult(dict):
                  value: str):
         """
         :param str name: The name of the Cloud Run Service.
+        :param str value: The header field value.
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "value", value)
@@ -3838,6 +4384,9 @@ class GetServiceTemplateSpecContainerLivenessProbeHttpGetHttpHeaderResult(dict):
     @property
     @pulumi.getter
     def value(self) -> str:
+        """
+        The header field value.
+        """
         return pulumi.get(self, "value")
 
 
@@ -3848,7 +4397,9 @@ class GetServiceTemplateSpecContainerPortResult(dict):
                  name: str,
                  protocol: str):
         """
+        :param int container_port: Port number the container listens on. This must be a valid port number (between 1 and 65535). Defaults to "8080".
         :param str name: The name of the Cloud Run Service.
+        :param str protocol: Protocol for port. Must be "TCP". Defaults to "TCP".
         """
         pulumi.set(__self__, "container_port", container_port)
         pulumi.set(__self__, "name", name)
@@ -3857,6 +4408,9 @@ class GetServiceTemplateSpecContainerPortResult(dict):
     @property
     @pulumi.getter(name="containerPort")
     def container_port(self) -> int:
+        """
+        Port number the container listens on. This must be a valid port number (between 1 and 65535). Defaults to "8080".
+        """
         return pulumi.get(self, "container_port")
 
     @property
@@ -3870,6 +4424,9 @@ class GetServiceTemplateSpecContainerPortResult(dict):
     @property
     @pulumi.getter
     def protocol(self) -> str:
+        """
+        Protocol for port. Must be "TCP". Defaults to "TCP".
+        """
         return pulumi.get(self, "protocol")
 
 
@@ -3878,17 +4435,39 @@ class GetServiceTemplateSpecContainerResourceResult(dict):
     def __init__(__self__, *,
                  limits: Mapping[str, str],
                  requests: Mapping[str, str]):
+        """
+        :param Mapping[str, str] limits: Limits describes the maximum amount of compute resources allowed.
+               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 Mapping[str, str] requests: Requests describes the minimum amount of compute resources required.
+               If Requests is omitted for a container, it defaults to Limits if that is
+               explicitly specified, otherwise to an implementation-defined value.
+               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__, "limits", limits)
         pulumi.set(__self__, "requests", requests)
 
     @property
     @pulumi.getter
     def limits(self) -> Mapping[str, str]:
+        """
+        Limits describes the maximum amount of compute resources allowed.
+        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")
 
     @property
     @pulumi.getter
     def requests(self) -> Mapping[str, str]:
+        """
+        Requests describes the minimum amount of compute resources required.
+        If Requests is omitted for a container, it defaults to Limits if that is
+        explicitly specified, otherwise to an implementation-defined value.
+        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, "requests")
 
 
@@ -3902,6 +4481,21 @@ class GetServiceTemplateSpecContainerStartupProbeResult(dict):
                  period_seconds: int,
                  tcp_sockets: Sequence['outputs.GetServiceTemplateSpecContainerStartupProbeTcpSocketResult'],
                  timeout_seconds: int):
+        """
+        :param int failure_threshold: Minimum consecutive failures for the probe to be considered failed after
+               having succeeded. Defaults to 3. Minimum value is 1.
+        :param Sequence['GetServiceTemplateSpecContainerStartupProbeGrpcArgs'] grpcs: GRPC specifies an action involving a GRPC port.
+        :param Sequence['GetServiceTemplateSpecContainerStartupProbeHttpGetArgs'] http_gets: HttpGet specifies the http request to perform.
+        :param int initial_delay_seconds: Number of seconds after the container has started before the probe is
+               initiated.
+               Defaults to 0 seconds. Minimum value is 0. Maximum value is 240.
+        :param int period_seconds: How often (in seconds) to perform the probe.
+               Default to 10 seconds. Minimum value is 1. Maximum value is 240.
+        :param Sequence['GetServiceTemplateSpecContainerStartupProbeTcpSocketArgs'] tcp_sockets: TcpSocket specifies an action involving a TCP port.
+        :param int timeout_seconds: 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 periodSeconds.
+        """
         pulumi.set(__self__, "failure_threshold", failure_threshold)
         pulumi.set(__self__, "grpcs", grpcs)
         pulumi.set(__self__, "http_gets", http_gets)
@@ -3913,36 +4507,63 @@ class GetServiceTemplateSpecContainerStartupProbeResult(dict):
     @property
     @pulumi.getter(name="failureThreshold")
     def failure_threshold(self) -> int:
+        """
+        Minimum consecutive failures for the probe to be considered failed after
+        having succeeded. Defaults to 3. Minimum value is 1.
+        """
         return pulumi.get(self, "failure_threshold")
 
     @property
     @pulumi.getter
     def grpcs(self) -> Sequence['outputs.GetServiceTemplateSpecContainerStartupProbeGrpcResult']:
+        """
+        GRPC specifies an action involving a GRPC port.
+        """
         return pulumi.get(self, "grpcs")
 
     @property
     @pulumi.getter(name="httpGets")
     def http_gets(self) -> Sequence['outputs.GetServiceTemplateSpecContainerStartupProbeHttpGetResult']:
+        """
+        HttpGet specifies the http request to perform.
+        """
         return pulumi.get(self, "http_gets")
 
     @property
     @pulumi.getter(name="initialDelaySeconds")
     def initial_delay_seconds(self) -> int:
+        """
+        Number of seconds after the container has started before the probe is
+        initiated.
+        Defaults to 0 seconds. Minimum value is 0. Maximum value is 240.
+        """
         return pulumi.get(self, "initial_delay_seconds")
 
     @property
     @pulumi.getter(name="periodSeconds")
     def period_seconds(self) -> int:
+        """
+        How often (in seconds) to perform the probe.
+        Default to 10 seconds. Minimum value is 1. Maximum value is 240.
+        """
         return pulumi.get(self, "period_seconds")
 
     @property
     @pulumi.getter(name="tcpSockets")
     def tcp_sockets(self) -> Sequence['outputs.GetServiceTemplateSpecContainerStartupProbeTcpSocketResult']:
+        """
+        TcpSocket specifies an action involving a TCP port.
+        """
         return pulumi.get(self, "tcp_sockets")
 
     @property
     @pulumi.getter(name="timeoutSeconds")
     def timeout_seconds(self) -> int:
+        """
+        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 periodSeconds.
+        """
         return pulumi.get(self, "timeout_seconds")
 
 
@@ -3951,17 +4572,33 @@ class GetServiceTemplateSpecContainerStartupProbeGrpcResult(dict):
     def __init__(__self__, *,
                  port: int,
                  service: str):
+        """
+        :param int port: Port number to access on the container. Number must be in the range 1 to 65535.
+               If not specified, defaults to the same value as container.ports[0].containerPort.
+        :param str service: 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)
 
     @property
     @pulumi.getter
     def port(self) -> int:
+        """
+        Port number to access on the container. Number must be in the range 1 to 65535.
+        If not specified, defaults to the same value as container.ports[0].containerPort.
+        """
         return pulumi.get(self, "port")
 
     @property
     @pulumi.getter
     def service(self) -> str:
+        """
+        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")
 
 
@@ -3971,6 +4608,12 @@ class GetServiceTemplateSpecContainerStartupProbeHttpGetResult(dict):
                  http_headers: Sequence['outputs.GetServiceTemplateSpecContainerStartupProbeHttpGetHttpHeaderResult'],
                  path: str,
                  port: int):
+        """
+        :param Sequence['GetServiceTemplateSpecContainerStartupProbeHttpGetHttpHeaderArgs'] http_headers: Custom headers to set in the request. HTTP allows repeated headers.
+        :param str path: Path to access on the HTTP server. If set, it should not be empty string.
+        :param int port: Port number to access on the container. Number must be in the range 1 to 65535.
+               If not specified, defaults to the same value as container.ports[0].containerPort.
+        """
         pulumi.set(__self__, "http_headers", http_headers)
         pulumi.set(__self__, "path", path)
         pulumi.set(__self__, "port", port)
@@ -3978,16 +4621,26 @@ class GetServiceTemplateSpecContainerStartupProbeHttpGetResult(dict):
     @property
     @pulumi.getter(name="httpHeaders")
     def http_headers(self) -> Sequence['outputs.GetServiceTemplateSpecContainerStartupProbeHttpGetHttpHeaderResult']:
+        """
+        Custom headers to set in the request. HTTP allows repeated headers.
+        """
         return pulumi.get(self, "http_headers")
 
     @property
     @pulumi.getter
     def path(self) -> str:
+        """
+        Path to access on the HTTP server. If set, it should not be empty string.
+        """
         return pulumi.get(self, "path")
 
     @property
     @pulumi.getter
     def port(self) -> int:
+        """
+        Port number to access on the container. Number must be in the range 1 to 65535.
+        If not specified, defaults to the same value as container.ports[0].containerPort.
+        """
         return pulumi.get(self, "port")
 
 
@@ -3998,6 +4651,7 @@ class GetServiceTemplateSpecContainerStartupProbeHttpGetHttpHeaderResult(dict):
                  value: str):
         """
         :param str name: The name of the Cloud Run Service.
+        :param str value: The header field value.
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "value", value)
@@ -4013,6 +4667,9 @@ class GetServiceTemplateSpecContainerStartupProbeHttpGetHttpHeaderResult(dict):
     @property
     @pulumi.getter
     def value(self) -> str:
+        """
+        The header field value.
+        """
         return pulumi.get(self, "value")
 
 
@@ -4020,11 +4677,19 @@ class GetServiceTemplateSpecContainerStartupProbeHttpGetHttpHeaderResult(dict):
 class GetServiceTemplateSpecContainerStartupProbeTcpSocketResult(dict):
     def __init__(__self__, *,
                  port: int):
+        """
+        :param int port: Port number to access on the container. Number must be in the range 1 to 65535.
+               If not specified, defaults to the same value as container.ports[0].containerPort.
+        """
         pulumi.set(__self__, "port", port)
 
     @property
     @pulumi.getter
     def port(self) -> int:
+        """
+        Port number to access on the container. Number must be in the range 1 to 65535.
+        If not specified, defaults to the same value as container.ports[0].containerPort.
+        """
         return pulumi.get(self, "port")
 
 
@@ -4034,6 +4699,8 @@ class GetServiceTemplateSpecContainerVolumeMountResult(dict):
                  mount_path: str,
                  name: str):
         """
+        :param str mount_path: Path within the container at which the volume should be mounted.  Must
+               not contain ':'.
         :param str name: The name of the Cloud Run Service.
         """
         pulumi.set(__self__, "mount_path", mount_path)
@@ -4042,6 +4709,10 @@ class GetServiceTemplateSpecContainerVolumeMountResult(dict):
     @property
     @pulumi.getter(name="mountPath")
     def mount_path(self) -> str:
+        """
+        Path within the container at which the volume should be mounted.  Must
+        not contain ':'.
+        """
         return pulumi.get(self, "mount_path")
 
     @property
@@ -4056,19 +4727,37 @@ class GetServiceTemplateSpecContainerVolumeMountResult(dict):
 @pulumi.output_type
 class GetServiceTemplateSpecVolumeResult(dict):
     def __init__(__self__, *,
+                 csis: Sequence['outputs.GetServiceTemplateSpecVolumeCsiResult'],
                  empty_dirs: Sequence['outputs.GetServiceTemplateSpecVolumeEmptyDirResult'],
                  name: str,
                  secrets: Sequence['outputs.GetServiceTemplateSpecVolumeSecretResult']):
         """
+        :param Sequence['GetServiceTemplateSpecVolumeCsiArgs'] csis: A filesystem specified by the Container Storage Interface (CSI).
+        :param Sequence['GetServiceTemplateSpecVolumeEmptyDirArgs'] empty_dirs: Ephemeral storage which can be backed by real disks (HD, SSD), network storage or memory (i.e. tmpfs). For now only in memory (tmpfs) is supported. It is ephemeral in the sense that when the sandbox is taken down, the data is destroyed with it (it does not persist across sandbox runs).
         :param str name: The name of the Cloud Run Service.
+        :param Sequence['GetServiceTemplateSpecVolumeSecretArgs'] secrets: The secret's value will be presented as the content of a file whose
+               name is defined in the item path. If no items are defined, the name of
+               the file is the secret_name.
         """
+        pulumi.set(__self__, "csis", csis)
         pulumi.set(__self__, "empty_dirs", empty_dirs)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "secrets", secrets)
 
+    @property
+    @pulumi.getter
+    def csis(self) -> Sequence['outputs.GetServiceTemplateSpecVolumeCsiResult']:
+        """
+        A filesystem specified by the Container Storage Interface (CSI).
+        """
+        return pulumi.get(self, "csis")
+
     @property
     @pulumi.getter(name="emptyDirs")
     def empty_dirs(self) -> Sequence['outputs.GetServiceTemplateSpecVolumeEmptyDirResult']:
+        """
+        Ephemeral storage which can be backed by real disks (HD, SSD), network storage or memory (i.e. tmpfs). For now only in memory (tmpfs) is supported. It is ephemeral in the sense that when the sandbox is taken down, the data is destroyed with it (it does not persist across sandbox runs).
+        """
         return pulumi.get(self, "empty_dirs")
 
     @property
@@ -4082,25 +4771,90 @@ class GetServiceTemplateSpecVolumeResult(dict):
     @property
     @pulumi.getter
     def secrets(self) -> Sequence['outputs.GetServiceTemplateSpecVolumeSecretResult']:
+        """
+        The secret's value will be presented as the content of a file whose
+        name is defined in the item path. If no items are defined, the name of
+        the file is the secret_name.
+        """
         return pulumi.get(self, "secrets")
 
 
+@pulumi.output_type
+class GetServiceTemplateSpecVolumeCsiResult(dict):
+    def __init__(__self__, *,
+                 driver: str,
+                 read_only: bool,
+                 volume_attributes: Mapping[str, str]):
+        """
+        :param str driver: Unique name representing the type of file system to be created. Cloud Run supports the following values:
+                 * gcsfuse.run.googleapis.com: Mount a Google Cloud Storage bucket using GCSFuse. This driver requires the
+                   run.googleapis.com/execution-environment annotation to be set to "gen2" and
+                   run.googleapis.com/launch-stage set to "BETA" or "ALPHA".
+        :param bool read_only: If true, all mounts created from this volume will be read-only.
+        :param Mapping[str, str] volume_attributes: Driver-specific attributes. The following options are supported for available drivers:
+                 * gcsfuse.run.googleapis.com
+                   * bucketName: The name of the Cloud Storage Bucket that backs this volume. The Cloud Run Service identity must have access to this bucket.
+        """
+        pulumi.set(__self__, "driver", driver)
+        pulumi.set(__self__, "read_only", read_only)
+        pulumi.set(__self__, "volume_attributes", volume_attributes)
+
+    @property
+    @pulumi.getter
+    def driver(self) -> str:
+        """
+        Unique name representing the type of file system to be created. Cloud Run supports the following values:
+          * gcsfuse.run.googleapis.com: Mount a Google Cloud Storage bucket using GCSFuse. This driver requires the
+            run.googleapis.com/execution-environment annotation to be set to "gen2" and
+            run.googleapis.com/launch-stage set to "BETA" or "ALPHA".
+        """
+        return pulumi.get(self, "driver")
+
+    @property
+    @pulumi.getter(name="readOnly")
+    def read_only(self) -> bool:
+        """
+        If true, all mounts created from this volume will be read-only.
+        """
+        return pulumi.get(self, "read_only")
+
+    @property
+    @pulumi.getter(name="volumeAttributes")
+    def volume_attributes(self) -> Mapping[str, str]:
+        """
+        Driver-specific attributes. The following options are supported for available drivers:
+          * gcsfuse.run.googleapis.com
+            * bucketName: The name of the Cloud Storage Bucket that backs this volume. The Cloud Run Service identity must have access to this bucket.
+        """
+        return pulumi.get(self, "volume_attributes")
+
+
 @pulumi.output_type
 class GetServiceTemplateSpecVolumeEmptyDirResult(dict):
     def __init__(__self__, *,
                  medium: str,
                  size_limit: str):
+        """
+        :param str medium: The medium on which the data is stored. The default is "" which means to use the node's default medium. Must be an empty string (default) or Memory.
+        :param 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.
+        """
         pulumi.set(__self__, "medium", medium)
         pulumi.set(__self__, "size_limit", size_limit)
 
     @property
     @pulumi.getter
     def medium(self) -> str:
+        """
+        The medium on which the data is stored. The default is "" which means to use the node's default medium. Must be an empty string (default) or Memory.
+        """
         return pulumi.get(self, "medium")
 
     @property
     @pulumi.getter(name="sizeLimit")
     def size_limit(self) -> 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")
 
 
@@ -4110,6 +4864,26 @@ class GetServiceTemplateSpecVolumeSecretResult(dict):
                  default_mode: int,
                  items: Sequence['outputs.GetServiceTemplateSpecVolumeSecretItemResult'],
                  secret_name: str):
+        """
+        :param int default_mode: Mode bits to use on created files by default. Must be a value between 0000
+               and 0777. Defaults to 0644. Directories within the path are not affected by
+               this setting. This might be in conflict with other options that affect the
+               file mode, like fsGroup, and the result can be other mode bits set.
+        :param Sequence['GetServiceTemplateSpecVolumeSecretItemArgs'] items: If unspecified, the volume will expose a file whose name is the
+               secret_name.
+               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 key and a path.
+        :param str secret_name: The name of the secret in Cloud Secret Manager. By default, the secret
+               is assumed to be in the same project.
+               If the secret is in another project, you must define an alias.
+               An alias definition has the form:
+               {alias}:projects/{project-id|project-number}/secrets/{secret-name}.
+               If multiple alias definitions are needed, they must be separated by
+               commas.
+               The alias definitions must be set on the run.googleapis.com/secrets
+               annotation.
+        """
         pulumi.set(__self__, "default_mode", default_mode)
         pulumi.set(__self__, "items", items)
         pulumi.set(__self__, "secret_name", secret_name)
@@ -4117,16 +4891,40 @@ class GetServiceTemplateSpecVolumeSecretResult(dict):
     @property
     @pulumi.getter(name="defaultMode")
     def default_mode(self) -> int:
+        """
+        Mode bits to use on created files by default. Must be a value between 0000
+        and 0777. Defaults to 0644. Directories within the path are not affected by
+        this setting. This might be in conflict with other options that affect the
+        file mode, like fsGroup, and the result can be other mode bits set.
+        """
         return pulumi.get(self, "default_mode")
 
     @property
     @pulumi.getter
     def items(self) -> Sequence['outputs.GetServiceTemplateSpecVolumeSecretItemResult']:
+        """
+        If unspecified, the volume will expose a file whose name is the
+        secret_name.
+        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 key and a path.
+        """
         return pulumi.get(self, "items")
 
     @property
     @pulumi.getter(name="secretName")
     def secret_name(self) -> str:
+        """
+        The name of the secret in Cloud Secret Manager. By default, the secret
+        is assumed to be in the same project.
+        If the secret is in another project, you must define an alias.
+        An alias definition has the form:
+        {alias}:projects/{project-id|project-number}/secrets/{secret-name}.
+        If multiple alias definitions are needed, they must be separated by
+        commas.
+        The alias definitions must be set on the run.googleapis.com/secrets
+        annotation.
+        """
         return pulumi.get(self, "secret_name")
 
 
@@ -4136,6 +4934,18 @@ class GetServiceTemplateSpecVolumeSecretItemResult(dict):
                  key: str,
                  mode: int,
                  path: str):
+        """
+        :param str key: The Cloud Secret Manager secret version.
+               Can be 'latest' for the latest value or an integer for a specific version.
+        :param int mode: Mode bits to use on this file, must be a value between 0000 and 0777. If
+               not specified, the volume defaultMode will be used. This might be in
+               conflict with other options that affect the file mode, like fsGroup, and
+               the result can be other mode bits set.
+        :param str path: The relative path of the file to map the key to.
+               May not be an absolute path.
+               May not contain the path element '..'.
+               May not start with the string '..'.
+        """
         pulumi.set(__self__, "key", key)
         pulumi.set(__self__, "mode", mode)
         pulumi.set(__self__, "path", path)
@@ -4143,16 +4953,32 @@ class GetServiceTemplateSpecVolumeSecretItemResult(dict):
     @property
     @pulumi.getter
     def key(self) -> str:
+        """
+        The Cloud Secret Manager secret version.
+        Can be 'latest' for the latest value or an integer for a specific version.
+        """
         return pulumi.get(self, "key")
 
     @property
     @pulumi.getter
     def mode(self) -> int:
+        """
+        Mode bits to use on this file, must be a value between 0000 and 0777. If
+        not specified, the volume defaultMode will be used. This might be in
+        conflict with other options that affect the file mode, like fsGroup, and
+        the result can be other mode bits set.
+        """
         return pulumi.get(self, "mode")
 
     @property
     @pulumi.getter
     def path(self) -> str:
+        """
+        The relative path of the file to map the key to.
+        May not be an absolute path.
+        May not contain the path element '..'.
+        May not start with the string '..'.
+        """
         return pulumi.get(self, "path")
 
 
@@ -4164,6 +4990,18 @@ class GetServiceTrafficResult(dict):
                  revision_name: str,
                  tag: str,
                  url: str):
+        """
+        :param bool latest_revision: LatestRevision may be optionally provided to indicate that the latest ready
+               Revision of the Configuration should be used for this traffic target. When
+               provided LatestRevision must be true if RevisionName is empty; it must be
+               false when RevisionName is non-empty.
+        :param int percent: Percent specifies percent of the traffic to this Revision or Configuration.
+        :param str revision_name: RevisionName of a specific revision to which to send this portion of traffic.
+        :param str tag: Tag is optionally used to expose a dedicated url for referencing this target exclusively.
+        :param str url: URL displays the URL for accessing tagged traffic targets. URL is displayed in status,
+               and is disallowed on spec. URL must contain a scheme (e.g. http://) and a hostname,
+               but may not contain anything else (e.g. basic auth, url path, etc.)
+        """
         pulumi.set(__self__, "latest_revision", latest_revision)
         pulumi.set(__self__, "percent", percent)
         pulumi.set(__self__, "revision_name", revision_name)
@@ -4173,26 +5011,46 @@ class GetServiceTrafficResult(dict):
     @property
     @pulumi.getter(name="latestRevision")
     def latest_revision(self) -> bool:
+        """
+        LatestRevision may be optionally provided to indicate that the latest ready
+        Revision of the Configuration should be used for this traffic target. When
+        provided LatestRevision must be true if RevisionName is empty; it must be
+        false when RevisionName is non-empty.
+        """
         return pulumi.get(self, "latest_revision")
 
     @property
     @pulumi.getter
     def percent(self) -> int:
+        """
+        Percent specifies percent of the traffic to this Revision or Configuration.
+        """
         return pulumi.get(self, "percent")
 
     @property
     @pulumi.getter(name="revisionName")
     def revision_name(self) -> str:
+        """
+        RevisionName of a specific revision to which to send this portion of traffic.
+        """
         return pulumi.get(self, "revision_name")
 
     @property
     @pulumi.getter
     def tag(self) -> str:
+        """
+        Tag is optionally used to expose a dedicated url for referencing this target exclusively.
+        """
         return pulumi.get(self, "tag")
 
     @property
     @pulumi.getter
     def url(self) -> str:
+        """
+        URL displays the URL for accessing tagged traffic targets. URL is displayed in status,
+        and is disallowed on spec. URL must contain a scheme (e.g. http://) and a hostname,
+        but may not contain anything else (e.g. basic auth, url path, etc.)
+        """
         return pulumi.get(self, "url")