pulumi-gcp 7.10.0a1708496697__py3-none-any.whl → 7.11.0__py3-none-any.whl

pulumi_gcp/clouddeploy/outputs.py

@@ -16,6 +16,10 @@ __all__ = [
     'AutomationRulePromoteReleaseRule',
     'AutomationSelector',
     'AutomationSelectorTarget',
+    'CustomTargetTypeCustomActions',
+    'CustomTargetTypeCustomActionsIncludeSkaffoldModule',
+    'CustomTargetTypeCustomActionsIncludeSkaffoldModuleGit',
+    'CustomTargetTypeCustomActionsIncludeSkaffoldModuleGoogleCloudStorage',
     'DeliveryPipelineCondition',
     'DeliveryPipelineConditionPipelineReadyCondition',
     'DeliveryPipelineConditionTargetsPresentCondition',
@@ -290,6 +294,207 @@ class AutomationSelectorTarget(dict):
         return pulumi.get(self, "labels")
 
 
+@pulumi.output_type
+class CustomTargetTypeCustomActions(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "deployAction":
+            suggest = "deploy_action"
+        elif key == "includeSkaffoldModules":
+            suggest = "include_skaffold_modules"
+        elif key == "renderAction":
+            suggest = "render_action"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CustomTargetTypeCustomActions. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CustomTargetTypeCustomActions.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CustomTargetTypeCustomActions.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 deploy_action: str,
+                 include_skaffold_modules: Optional[Sequence['outputs.CustomTargetTypeCustomActionsIncludeSkaffoldModule']] = None,
+                 render_action: Optional[str] = None):
+        """
+        :param str deploy_action: The Skaffold custom action responsible for deploy operations.
+        :param Sequence['CustomTargetTypeCustomActionsIncludeSkaffoldModuleArgs'] include_skaffold_modules: List of Skaffold modules Cloud Deploy will include in the Skaffold Config as required before performing diagnose.
+               Structure is documented below.
+        :param str render_action: The Skaffold custom action responsible for render operations. If not provided then Cloud Deploy will perform the render operations via `skaffold render`.
+        """
+        pulumi.set(__self__, "deploy_action", deploy_action)
+        if include_skaffold_modules is not None:
+            pulumi.set(__self__, "include_skaffold_modules", include_skaffold_modules)
+        if render_action is not None:
+            pulumi.set(__self__, "render_action", render_action)
+
+    @property
+    @pulumi.getter(name="deployAction")
+    def deploy_action(self) -> str:
+        """
+        The Skaffold custom action responsible for deploy operations.
+        """
+        return pulumi.get(self, "deploy_action")
+
+    @property
+    @pulumi.getter(name="includeSkaffoldModules")
+    def include_skaffold_modules(self) -> Optional[Sequence['outputs.CustomTargetTypeCustomActionsIncludeSkaffoldModule']]:
+        """
+        List of Skaffold modules Cloud Deploy will include in the Skaffold Config as required before performing diagnose.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "include_skaffold_modules")
+
+    @property
+    @pulumi.getter(name="renderAction")
+    def render_action(self) -> Optional[str]:
+        """
+        The Skaffold custom action responsible for render operations. If not provided then Cloud Deploy will perform the render operations via `skaffold render`.
+        """
+        return pulumi.get(self, "render_action")
+
+
+@pulumi.output_type
+class CustomTargetTypeCustomActionsIncludeSkaffoldModule(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "googleCloudStorage":
+            suggest = "google_cloud_storage"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CustomTargetTypeCustomActionsIncludeSkaffoldModule. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CustomTargetTypeCustomActionsIncludeSkaffoldModule.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CustomTargetTypeCustomActionsIncludeSkaffoldModule.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 configs: Optional[Sequence[str]] = None,
+                 git: Optional['outputs.CustomTargetTypeCustomActionsIncludeSkaffoldModuleGit'] = None,
+                 google_cloud_storage: Optional['outputs.CustomTargetTypeCustomActionsIncludeSkaffoldModuleGoogleCloudStorage'] = None):
+        """
+        :param Sequence[str] configs: The Skaffold Config modules to use from the specified source.
+        :param 'CustomTargetTypeCustomActionsIncludeSkaffoldModuleGitArgs' git: Remote git repository containing the Skaffold Config modules.
+               Structure is documented below.
+        :param 'CustomTargetTypeCustomActionsIncludeSkaffoldModuleGoogleCloudStorageArgs' google_cloud_storage: Cloud Storage bucket containing Skaffold Config modules.
+               Structure is documented below.
+        """
+        if configs is not None:
+            pulumi.set(__self__, "configs", configs)
+        if git is not None:
+            pulumi.set(__self__, "git", git)
+        if google_cloud_storage is not None:
+            pulumi.set(__self__, "google_cloud_storage", google_cloud_storage)
+
+    @property
+    @pulumi.getter
+    def configs(self) -> Optional[Sequence[str]]:
+        """
+        The Skaffold Config modules to use from the specified source.
+        """
+        return pulumi.get(self, "configs")
+
+    @property
+    @pulumi.getter
+    def git(self) -> Optional['outputs.CustomTargetTypeCustomActionsIncludeSkaffoldModuleGit']:
+        """
+        Remote git repository containing the Skaffold Config modules.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "git")
+
+    @property
+    @pulumi.getter(name="googleCloudStorage")
+    def google_cloud_storage(self) -> Optional['outputs.CustomTargetTypeCustomActionsIncludeSkaffoldModuleGoogleCloudStorage']:
+        """
+        Cloud Storage bucket containing Skaffold Config modules.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "google_cloud_storage")
+
+
+@pulumi.output_type
+class CustomTargetTypeCustomActionsIncludeSkaffoldModuleGit(dict):
+    def __init__(__self__, *,
+                 repo: str,
+                 path: Optional[str] = None,
+                 ref: Optional[str] = None):
+        """
+        :param str repo: Git repository the package should be cloned from.
+        :param str path: Relative path from the repository root to the Skaffold file.
+        :param str ref: Git ref the package should be cloned from.
+        """
+        pulumi.set(__self__, "repo", repo)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if ref is not None:
+            pulumi.set(__self__, "ref", ref)
+
+    @property
+    @pulumi.getter
+    def repo(self) -> str:
+        """
+        Git repository the package should be cloned from.
+        """
+        return pulumi.get(self, "repo")
+
+    @property
+    @pulumi.getter
+    def path(self) -> Optional[str]:
+        """
+        Relative path from the repository root to the Skaffold file.
+        """
+        return pulumi.get(self, "path")
+
+    @property
+    @pulumi.getter
+    def ref(self) -> Optional[str]:
+        """
+        Git ref the package should be cloned from.
+        """
+        return pulumi.get(self, "ref")
+
+
+@pulumi.output_type
+class CustomTargetTypeCustomActionsIncludeSkaffoldModuleGoogleCloudStorage(dict):
+    def __init__(__self__, *,
+                 source: str,
+                 path: Optional[str] = None):
+        """
+        :param str source: Cloud Storage source paths to copy recursively. For example, providing `gs://my-bucket/dir/configs/*` will result in Skaffold copying all files within the `dir/configs` directory in the bucket `my-bucket`.
+        :param str path: Relative path from the source to the Skaffold file.
+        """
+        pulumi.set(__self__, "source", source)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+
+    @property
+    @pulumi.getter
+    def source(self) -> str:
+        """
+        Cloud Storage source paths to copy recursively. For example, providing `gs://my-bucket/dir/configs/*` will result in Skaffold copying all files within the `dir/configs` directory in the bucket `my-bucket`.
+        """
+        return pulumi.get(self, "source")
+
+    @property
+    @pulumi.getter
+    def path(self) -> Optional[str]:
+        """
+        Relative path from the source to the Skaffold file.
+        """
+        return pulumi.get(self, "path")
+
+
 @pulumi.output_type
 class DeliveryPipelineCondition(dict):
     @staticmethod
@@ -1119,6 +1324,12 @@ class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigCloudRun(dic
         suggest = None
         if key == "automaticTrafficControl":
             suggest = "automatic_traffic_control"
+        elif key == "canaryRevisionTags":
+            suggest = "canary_revision_tags"
+        elif key == "priorRevisionTags":
+            suggest = "prior_revision_tags"
+        elif key == "stableRevisionTags":
+            suggest = "stable_revision_tags"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigCloudRun. Access the value via the '{suggest}' property getter instead.")
@@ -1132,12 +1343,24 @@ class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigCloudRun(dic
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 automatic_traffic_control: Optional[bool] = None):
+                 automatic_traffic_control: Optional[bool] = None,
+                 canary_revision_tags: Optional[Sequence[str]] = None,
+                 prior_revision_tags: Optional[Sequence[str]] = None,
+                 stable_revision_tags: Optional[Sequence[str]] = None):
         """
         :param bool automatic_traffic_control: Whether Cloud Deploy should update the traffic stanza in a Cloud Run Service on the user's behalf to facilitate traffic splitting. This is required to be true for CanaryDeployments, but optional for CustomCanaryDeployments.
+        :param Sequence[str] canary_revision_tags: Optional. A list of tags that are added to the canary revision while the canary phase is in progress.
+        :param Sequence[str] prior_revision_tags: Optional. A list of tags that are added to the prior revision while the canary phase is in progress.
+        :param Sequence[str] stable_revision_tags: Optional. A list of tags that are added to the final stable revision when the stable phase is applied.
         """
         if automatic_traffic_control is not None:
             pulumi.set(__self__, "automatic_traffic_control", automatic_traffic_control)
+        if canary_revision_tags is not None:
+            pulumi.set(__self__, "canary_revision_tags", canary_revision_tags)
+        if prior_revision_tags is not None:
+            pulumi.set(__self__, "prior_revision_tags", prior_revision_tags)
+        if stable_revision_tags is not None:
+            pulumi.set(__self__, "stable_revision_tags", stable_revision_tags)
 
     @property
     @pulumi.getter(name="automaticTrafficControl")
@@ -1147,6 +1370,30 @@ class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigCloudRun(dic
         """
         return pulumi.get(self, "automatic_traffic_control")
 
+    @property
+    @pulumi.getter(name="canaryRevisionTags")
+    def canary_revision_tags(self) -> Optional[Sequence[str]]:
+        """
+        Optional. A list of tags that are added to the canary revision while the canary phase is in progress.
+        """
+        return pulumi.get(self, "canary_revision_tags")
+
+    @property
+    @pulumi.getter(name="priorRevisionTags")
+    def prior_revision_tags(self) -> Optional[Sequence[str]]:
+        """
+        Optional. A list of tags that are added to the prior revision while the canary phase is in progress.
+        """
+        return pulumi.get(self, "prior_revision_tags")
+
+    @property
+    @pulumi.getter(name="stableRevisionTags")
+    def stable_revision_tags(self) -> Optional[Sequence[str]]:
+        """
+        Optional. A list of tags that are added to the final stable revision when the stable phase is applied.
+        """
+        return pulumi.get(self, "stable_revision_tags")
+
 
 @pulumi.output_type
 class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetes(dict):
@@ -1207,6 +1454,8 @@ class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesGa
             suggest = "http_route"
         elif key == "routeUpdateWaitTime":
             suggest = "route_update_wait_time"
+        elif key == "stableCutbackDuration":
+            suggest = "stable_cutback_duration"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesGatewayServiceMesh. Access the value via the '{suggest}' property getter instead.")
@@ -1223,18 +1472,22 @@ class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesGa
                  deployment: str,
                  http_route: str,
                  service: str,
-                 route_update_wait_time: Optional[str] = None):
+                 route_update_wait_time: Optional[str] = None,
+                 stable_cutback_duration: Optional[str] = None):
         """
         :param str deployment: Required. Name of the Kubernetes Deployment whose traffic is managed by the specified HTTPRoute and Service.
         :param str http_route: Required. Name of the Gateway API HTTPRoute.
         :param str service: Required. Name of the Kubernetes Service.
         :param str route_update_wait_time: Optional. The time to wait for route updates to propagate. The maximum configurable time is 3 hours, in seconds format. If unspecified, there is no wait time.
+        :param str stable_cutback_duration: Optional. The amount of time to migrate traffic back from the canary Service to the original Service during the stable phase deployment. If specified, must be between 15s and 3600s. If unspecified, there is no cutback time.
         """
         pulumi.set(__self__, "deployment", deployment)
         pulumi.set(__self__, "http_route", http_route)
         pulumi.set(__self__, "service", service)
         if route_update_wait_time is not None:
             pulumi.set(__self__, "route_update_wait_time", route_update_wait_time)
+        if stable_cutback_duration is not None:
+            pulumi.set(__self__, "stable_cutback_duration", stable_cutback_duration)
 
     @property
     @pulumi.getter
@@ -1268,6 +1521,14 @@ class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesGa
         """
         return pulumi.get(self, "route_update_wait_time")
 
+    @property
+    @pulumi.getter(name="stableCutbackDuration")
+    def stable_cutback_duration(self) -> Optional[str]:
+        """
+        Optional. The amount of time to migrate traffic back from the canary Service to the original Service during the stable phase deployment. If specified, must be between 15s and 3600s. If unspecified, there is no cutback time.
+        """
+        return pulumi.get(self, "stable_cutback_duration")
+
 
 @pulumi.output_type
 class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesServiceNetworking(dict):

pulumi_gcp/cloudfunctions/function.py

@@ -550,6 +550,7 @@ class _FunctionState:
                  status: Optional[pulumi.Input[str]] = None,
                  timeout: Optional[pulumi.Input[int]] = None,
                  trigger_http: Optional[pulumi.Input[bool]] = None,
+                 version_id: Optional[pulumi.Input[str]] = None,
                  vpc_connector: Optional[pulumi.Input[str]] = None,
                  vpc_connector_egress_settings: Optional[pulumi.Input[str]] = None):
         """
@@ -593,6 +594,8 @@ class _FunctionState:
         :param pulumi.Input[str] status: Describes the current stage of a deployment.
         :param pulumi.Input[int] timeout: Timeout (in seconds) for the function. Default value is 60 seconds. Cannot be more than 540 seconds.
         :param pulumi.Input[bool] trigger_http: Boolean variable. Any HTTP request (of a supported type) to the endpoint will trigger function execution. Supported HTTP request types are: POST, PUT, GET, DELETE, and OPTIONS. Endpoint is returned as `https_trigger_url`. Cannot be used with `event_trigger`.
+        :param pulumi.Input[str] version_id: The version identifier of the Cloud Function. Each deployment attempt results in a new version of a function being
+               created.
         :param pulumi.Input[str] vpc_connector: The VPC Network Connector that this cloud function can connect to. It should be set up as fully-qualified URI. The format of this field is `projects/*/locations/*/connectors/*`.
         :param pulumi.Input[str] vpc_connector_egress_settings: The egress settings for the connector, controlling what traffic is diverted through it. Allowed values are `ALL_TRAFFIC` and `PRIVATE_RANGES_ONLY`. Defaults to `PRIVATE_RANGES_ONLY`. If unset, this field preserves the previously set value.
         """
@@ -658,6 +661,8 @@ class _FunctionState:
             pulumi.set(__self__, "timeout", timeout)
         if trigger_http is not None:
             pulumi.set(__self__, "trigger_http", trigger_http)
+        if version_id is not None:
+            pulumi.set(__self__, "version_id", version_id)
         if vpc_connector is not None:
             pulumi.set(__self__, "vpc_connector", vpc_connector)
         if vpc_connector_egress_settings is not None:
@@ -1043,6 +1048,19 @@ class _FunctionState:
     def trigger_http(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "trigger_http", value)
 
+    @property
+    @pulumi.getter(name="versionId")
+    def version_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The version identifier of the Cloud Function. Each deployment attempt results in a new version of a function being
+        created.
+        """
+        return pulumi.get(self, "version_id")
+
+    @version_id.setter
+    def version_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "version_id", value)
+
     @property
     @pulumi.getter(name="vpcConnector")
     def vpc_connector(self) -> Optional[pulumi.Input[str]]:
@@ -1426,6 +1444,7 @@ class Function(pulumi.CustomResource):
             __props__.__dict__["effective_labels"] = None
             __props__.__dict__["pulumi_labels"] = None
             __props__.__dict__["status"] = None
+            __props__.__dict__["version_id"] = None
         secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["effectiveLabels", "pulumiLabels"])
         opts = pulumi.ResourceOptions.merge(opts, secret_opts)
         super(Function, __self__).__init__(
@@ -1469,6 +1488,7 @@ class Function(pulumi.CustomResource):
             status: Optional[pulumi.Input[str]] = None,
             timeout: Optional[pulumi.Input[int]] = None,
             trigger_http: Optional[pulumi.Input[bool]] = None,
+            version_id: Optional[pulumi.Input[str]] = None,
             vpc_connector: Optional[pulumi.Input[str]] = None,
             vpc_connector_egress_settings: Optional[pulumi.Input[str]] = None) -> 'Function':
         """
@@ -1517,6 +1537,8 @@ class Function(pulumi.CustomResource):
         :param pulumi.Input[str] status: Describes the current stage of a deployment.
         :param pulumi.Input[int] timeout: Timeout (in seconds) for the function. Default value is 60 seconds. Cannot be more than 540 seconds.
         :param pulumi.Input[bool] trigger_http: Boolean variable. Any HTTP request (of a supported type) to the endpoint will trigger function execution. Supported HTTP request types are: POST, PUT, GET, DELETE, and OPTIONS. Endpoint is returned as `https_trigger_url`. Cannot be used with `event_trigger`.
+        :param pulumi.Input[str] version_id: The version identifier of the Cloud Function. Each deployment attempt results in a new version of a function being
+               created.
         :param pulumi.Input[str] vpc_connector: The VPC Network Connector that this cloud function can connect to. It should be set up as fully-qualified URI. The format of this field is `projects/*/locations/*/connectors/*`.
         :param pulumi.Input[str] vpc_connector_egress_settings: The egress settings for the connector, controlling what traffic is diverted through it. Allowed values are `ALL_TRAFFIC` and `PRIVATE_RANGES_ONLY`. Defaults to `PRIVATE_RANGES_ONLY`. If unset, this field preserves the previously set value.
         """
@@ -1555,6 +1577,7 @@ class Function(pulumi.CustomResource):
         __props__.__dict__["status"] = status
         __props__.__dict__["timeout"] = timeout
         __props__.__dict__["trigger_http"] = trigger_http
+        __props__.__dict__["version_id"] = version_id
         __props__.__dict__["vpc_connector"] = vpc_connector
         __props__.__dict__["vpc_connector_egress_settings"] = vpc_connector_egress_settings
         return Function(resource_name, opts=opts, __props__=__props__)
@@ -1815,6 +1838,15 @@ class Function(pulumi.CustomResource):
         """
         return pulumi.get(self, "trigger_http")
 
+    @property
+    @pulumi.getter(name="versionId")
+    def version_id(self) -> pulumi.Output[str]:
+        """
+        The version identifier of the Cloud Function. Each deployment attempt results in a new version of a function being
+        created.
+        """
+        return pulumi.get(self, "version_id")
+
     @property
     @pulumi.getter(name="vpcConnector")
     def vpc_connector(self) -> pulumi.Output[Optional[str]]:

pulumi_gcp/cloudfunctions/get_function.py

@@ -22,7 +22,7 @@ class GetFunctionResult:
     """
     A collection of values returned by getFunction.
     """
-    def __init__(__self__, available_memory_mb=None, build_environment_variables=None, build_worker_pool=None, description=None, docker_registry=None, docker_repository=None, effective_labels=None, entry_point=None, environment_variables=None, event_triggers=None, https_trigger_security_level=None, https_trigger_url=None, id=None, ingress_settings=None, kms_key_name=None, labels=None, max_instances=None, min_instances=None, name=None, project=None, pulumi_labels=None, region=None, runtime=None, secret_environment_variables=None, secret_volumes=None, service_account_email=None, source_archive_bucket=None, source_archive_object=None, source_repositories=None, status=None, timeout=None, trigger_http=None, vpc_connector=None, vpc_connector_egress_settings=None):
+    def __init__(__self__, available_memory_mb=None, build_environment_variables=None, build_worker_pool=None, description=None, docker_registry=None, docker_repository=None, effective_labels=None, entry_point=None, environment_variables=None, event_triggers=None, https_trigger_security_level=None, https_trigger_url=None, id=None, ingress_settings=None, kms_key_name=None, labels=None, max_instances=None, min_instances=None, name=None, project=None, pulumi_labels=None, region=None, runtime=None, secret_environment_variables=None, secret_volumes=None, service_account_email=None, source_archive_bucket=None, source_archive_object=None, source_repositories=None, status=None, timeout=None, trigger_http=None, version_id=None, vpc_connector=None, vpc_connector_egress_settings=None):
         if available_memory_mb and not isinstance(available_memory_mb, int):
             raise TypeError("Expected argument 'available_memory_mb' to be a int")
         pulumi.set(__self__, "available_memory_mb", available_memory_mb)
@@ -119,6 +119,9 @@ class GetFunctionResult:
         if trigger_http and not isinstance(trigger_http, bool):
             raise TypeError("Expected argument 'trigger_http' to be a bool")
         pulumi.set(__self__, "trigger_http", trigger_http)
+        if version_id and not isinstance(version_id, str):
+            raise TypeError("Expected argument 'version_id' to be a str")
+        pulumi.set(__self__, "version_id", version_id)
         if vpc_connector and not isinstance(vpc_connector, str):
             raise TypeError("Expected argument 'vpc_connector' to be a str")
         pulumi.set(__self__, "vpc_connector", vpc_connector)
@@ -337,6 +340,11 @@ class GetFunctionResult:
         """
         return pulumi.get(self, "trigger_http")
 
+    @property
+    @pulumi.getter(name="versionId")
+    def version_id(self) -> str:
+        return pulumi.get(self, "version_id")
+
     @property
     @pulumi.getter(name="vpcConnector")
     def vpc_connector(self) -> str:
@@ -392,6 +400,7 @@ class AwaitableGetFunctionResult(GetFunctionResult):
             status=self.status,
             timeout=self.timeout,
             trigger_http=self.trigger_http,
+            version_id=self.version_id,
             vpc_connector=self.vpc_connector,
             vpc_connector_egress_settings=self.vpc_connector_egress_settings)
 
@@ -463,6 +472,7 @@ def get_function(name: Optional[str] = None,
         status=pulumi.get(__ret__, 'status'),
         timeout=pulumi.get(__ret__, 'timeout'),
         trigger_http=pulumi.get(__ret__, 'trigger_http'),
+        version_id=pulumi.get(__ret__, 'version_id'),
         vpc_connector=pulumi.get(__ret__, 'vpc_connector'),
         vpc_connector_egress_settings=pulumi.get(__ret__, 'vpc_connector_egress_settings'))
 

pulumi_gcp/cloudrunv2/service.py

@@ -1182,6 +1182,15 @@ class Service(pulumi.CustomResource):
                     gcp.cloudrunv2.ServiceTemplateContainerArgs(
                         name="hello-2",
                         image="us-docker.pkg.dev/cloudrun/container/hello",
+                        envs=[gcp.cloudrunv2.ServiceTemplateContainerEnvArgs(
+                            name="PORT",
+                            value="8081",
+                        )],
+                        startup_probe=gcp.cloudrunv2.ServiceTemplateContainerStartupProbeArgs(
+                            http_get=gcp.cloudrunv2.ServiceTemplateContainerStartupProbeHttpGetArgs(
+                                port=8081,
+                            ),
+                        ),
                     ),
                 ],
                 volumes=[gcp.cloudrunv2.ServiceTemplateVolumeArgs(
@@ -1608,6 +1617,15 @@ class Service(pulumi.CustomResource):
                     gcp.cloudrunv2.ServiceTemplateContainerArgs(
                         name="hello-2",
                         image="us-docker.pkg.dev/cloudrun/container/hello",
+                        envs=[gcp.cloudrunv2.ServiceTemplateContainerEnvArgs(
+                            name="PORT",
+                            value="8081",
+                        )],
+                        startup_probe=gcp.cloudrunv2.ServiceTemplateContainerStartupProbeArgs(
+                            http_get=gcp.cloudrunv2.ServiceTemplateContainerStartupProbeHttpGetArgs(
+                                port=8081,
+                            ),
+                        ),
                     ),
                 ],
                 volumes=[gcp.cloudrunv2.ServiceTemplateVolumeArgs(

pulumi_gcp/compute/_inputs.py

@@ -5966,18 +5966,18 @@ class InstanceBootDiskInitializeParamsArgs:
                field is only applicable for persistent disks.
         :param pulumi.Input[int] provisioned_iops: Indicates how many IOPS to provision for the disk.
                This sets the number of I/O operations per second that the disk can handle.
-               Values must be between 10,000 and 120,000. For more details,see the
-               [Extreme persistent disk documentation](https://cloud.google.com/compute/docs/disks/extreme-persistent-disk).
+               For more details,see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
                Note: Updating currently is only supported for hyperdisk skus via disk update
                api/gcloud without the need to delete and recreate the disk, hyperdisk allows
                for an update of IOPS every 4 hours. To update your hyperdisk more frequently,
                you'll need to manually delete and recreate it.
         :param pulumi.Input[int] provisioned_throughput: Indicates how much throughput to provision for the disk.
                This sets the number of throughput mb per second that the disk can handle.
-               Values must be between 1 and 7,124. Note: Updating currently is only supported
-               for hyperdisk skus via disk update api/gcloud without the need to delete and
-               recreate the disk, hyperdisk allows for an update of throughput every 4 hours.
-               To update your hyperdisk more frequently, you'll need to manually delete and recreate it.
+               For more details,see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
+               Note: Updating currently is only supported for hyperdisk skus via disk update
+               api/gcloud without the need to delete and recreate the disk, hyperdisk allows
+               for an update of throughput every 4 hours. To update your hyperdisk more
+               frequently, you'll need to manually delete and recreate it.
         :param pulumi.Input[Mapping[str, Any]] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         :param pulumi.Input[int] size: The size of the image in gigabytes. If not specified, it
                will inherit the size of its base image.
@@ -6052,8 +6052,7 @@ class InstanceBootDiskInitializeParamsArgs:
         """
         Indicates how many IOPS to provision for the disk.
         This sets the number of I/O operations per second that the disk can handle.
-        Values must be between 10,000 and 120,000. For more details,see the
-        [Extreme persistent disk documentation](https://cloud.google.com/compute/docs/disks/extreme-persistent-disk).
+        For more details,see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
         Note: Updating currently is only supported for hyperdisk skus via disk update
         api/gcloud without the need to delete and recreate the disk, hyperdisk allows
         for an update of IOPS every 4 hours. To update your hyperdisk more frequently,
@@ -6071,10 +6070,11 @@ class InstanceBootDiskInitializeParamsArgs:
         """
         Indicates how much throughput to provision for the disk.
         This sets the number of throughput mb per second that the disk can handle.
-        Values must be between 1 and 7,124. Note: Updating currently is only supported
-        for hyperdisk skus via disk update api/gcloud without the need to delete and
-        recreate the disk, hyperdisk allows for an update of throughput every 4 hours.
-        To update your hyperdisk more frequently, you'll need to manually delete and recreate it.
+        For more details,see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
+        Note: Updating currently is only supported for hyperdisk skus via disk update
+        api/gcloud without the need to delete and recreate the disk, hyperdisk allows
+        for an update of throughput every 4 hours. To update your hyperdisk more
+        frequently, you'll need to manually delete and recreate it.
         """
         return pulumi.get(self, "provisioned_throughput")
 
@@ -6466,8 +6466,8 @@ class InstanceFromMachineImageBootDiskInitializeParamsArgs:
         :param pulumi.Input[bool] enable_confidential_compute: A flag to enable confidential compute mode on boot disk
         :param pulumi.Input[str] image: The image from which this disk was initialised.
         :param pulumi.Input[Mapping[str, Any]] labels: A set of key/value label pairs assigned to the disk.
-        :param pulumi.Input[int] provisioned_iops: Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle. Values must be between 10,000 and 120,000.
-        :param pulumi.Input[int] provisioned_throughput: Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle. Values must be between 1 and 7,124.
+        :param pulumi.Input[int] provisioned_iops: Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle.
+        :param pulumi.Input[int] provisioned_throughput: Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle.
         :param pulumi.Input[Mapping[str, Any]] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         :param pulumi.Input[int] size: The size of the image in gigabytes.
         :param pulumi.Input[str] type: The Google Compute Engine disk type. Such as pd-standard, pd-ssd or pd-balanced.
@@ -6529,7 +6529,7 @@ class InstanceFromMachineImageBootDiskInitializeParamsArgs:
     @pulumi.getter(name="provisionedIops")
     def provisioned_iops(self) -> Optional[pulumi.Input[int]]:
         """
-        Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle. Values must be between 10,000 and 120,000.
+        Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle.
         """
         return pulumi.get(self, "provisioned_iops")
 
@@ -6541,7 +6541,7 @@ class InstanceFromMachineImageBootDiskInitializeParamsArgs:
     @pulumi.getter(name="provisionedThroughput")
     def provisioned_throughput(self) -> Optional[pulumi.Input[int]]:
         """
-        Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle. Values must be between 1 and 7,124.
+        Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle.
         """
         return pulumi.get(self, "provisioned_throughput")
 
@@ -8017,8 +8017,8 @@ class InstanceFromTemplateBootDiskInitializeParamsArgs:
         :param pulumi.Input[bool] enable_confidential_compute: A flag to enable confidential compute mode on boot disk
         :param pulumi.Input[str] image: The image from which this disk was initialised.
         :param pulumi.Input[Mapping[str, Any]] labels: A set of key/value label pairs assigned to the disk.
-        :param pulumi.Input[int] provisioned_iops: Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle. Values must be between 10,000 and 120,000.
-        :param pulumi.Input[int] provisioned_throughput: Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle. Values must be between 1 and 7,124.
+        :param pulumi.Input[int] provisioned_iops: Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle.
+        :param pulumi.Input[int] provisioned_throughput: Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle.
         :param pulumi.Input[Mapping[str, Any]] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         :param pulumi.Input[int] size: The size of the image in gigabytes.
         :param pulumi.Input[str] type: The Google Compute Engine disk type. Such as pd-standard, pd-ssd or pd-balanced.
@@ -8080,7 +8080,7 @@ class InstanceFromTemplateBootDiskInitializeParamsArgs:
     @pulumi.getter(name="provisionedIops")
     def provisioned_iops(self) -> Optional[pulumi.Input[int]]:
         """
-        Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle. Values must be between 10,000 and 120,000.
+        Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle.
         """
         return pulumi.get(self, "provisioned_iops")
 
@@ -8092,7 +8092,7 @@ class InstanceFromTemplateBootDiskInitializeParamsArgs:
     @pulumi.getter(name="provisionedThroughput")
     def provisioned_throughput(self) -> Optional[pulumi.Input[int]]:
         """
-        Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle. Values must be between 1 and 7,124.
+        Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle.
         """
         return pulumi.get(self, "provisioned_throughput")