pulumi-gcp 8.40.0a1754721948__py3-none-any.whl → 8.40.0a1754951145__py3-none-any.whl

pulumi_gcp/vertex/outputs.py

@@ -32,6 +32,35 @@ __all__ = [
     'AiEndpointPredictRequestResponseLoggingConfig',
     'AiEndpointPredictRequestResponseLoggingConfigBigqueryDestination',
     'AiEndpointPrivateServiceConnectConfig',
+    'AiEndpointWithModelGardenDeploymentDeployConfig',
+    'AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResources',
+    'AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesAutoscalingMetricSpec',
+    'AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpec',
+    'AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpecReservationAffinity',
+    'AiEndpointWithModelGardenDeploymentEndpointConfig',
+    'AiEndpointWithModelGardenDeploymentModelConfig',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpec',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecEnv',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecGrpcPort',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbe',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeExec',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeGrpc',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGet',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGetHttpHeader',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeTcpSocket',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbe',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeExec',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeGrpc',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGet',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGetHttpHeader',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeTcpSocket',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecPort',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbe',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeExec',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeGrpc',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGet',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGetHttpHeader',
+    'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeTcpSocket',
     'AiFeatureGroupBigQuery',
     'AiFeatureGroupBigQueryBigQuerySource',
     'AiFeatureGroupIamBindingCondition',
@@ -764,7 +793,7 @@ class AiEndpointDeployedModelDedicatedResourceMachineSpec(dict):
         :param _builtins.str accelerator_type: (Output)
                The type of accelerator(s) that may be attached to the machine as per accelerator_count. See possible values [here](https://cloud.google.com/vertex-ai/docs/reference/rest/v1/MachineSpec#AcceleratorType).
         :param _builtins.str machine_type: (Output)
-               The type of the machine. See the [list of machine types supported for prediction](https://cloud.google.com/vertex-ai/docs/predictions/configure-compute#machine-types) See the [list of machine types supported for custom training](https://cloud.google.com/vertex-ai/docs/training/configure-compute#machine-types). For DeployedModel this field is optional, and the default value is `n1-standard-2`. For BatchPredictionJob or as part of WorkerPoolSpec this field is required. TODO(rsurowka): Try to better unify the required vs optional.
+               The type of the machine. See the [list of machine types supported for prediction](https://cloud.google.com/vertex-ai/docs/predictions/configure-compute#machine-types) See the [list of machine types supported for custom training](https://cloud.google.com/vertex-ai/docs/training/configure-compute#machine-types). For DeployedModel this field is optional, and the default value is `n1-standard-2`. For BatchPredictionJob or as part of WorkerPoolSpec this field is required. TODO: Try to better unify the required vs optional.
         """
         if accelerator_count is not None:
             pulumi.set(__self__, "accelerator_count", accelerator_count)
@@ -796,7 +825,7 @@ class AiEndpointDeployedModelDedicatedResourceMachineSpec(dict):
     def machine_type(self) -> Optional[_builtins.str]:
         """
         (Output)
-        The type of the machine. See the [list of machine types supported for prediction](https://cloud.google.com/vertex-ai/docs/predictions/configure-compute#machine-types) See the [list of machine types supported for custom training](https://cloud.google.com/vertex-ai/docs/training/configure-compute#machine-types). For DeployedModel this field is optional, and the default value is `n1-standard-2`. For BatchPredictionJob or as part of WorkerPoolSpec this field is required. TODO(rsurowka): Try to better unify the required vs optional.
+        The type of the machine. See the [list of machine types supported for prediction](https://cloud.google.com/vertex-ai/docs/predictions/configure-compute#machine-types) See the [list of machine types supported for custom training](https://cloud.google.com/vertex-ai/docs/training/configure-compute#machine-types). For DeployedModel this field is optional, and the default value is `n1-standard-2`. For BatchPredictionJob or as part of WorkerPoolSpec this field is required. TODO: Try to better unify the required vs optional.
         """
         return pulumi.get(self, "machine_type")
 
@@ -1139,6 +1168,2584 @@ class AiEndpointPrivateServiceConnectConfig(dict):
         return pulumi.get(self, "project_allowlists")
 
 
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentDeployConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dedicatedResources":
+            suggest = "dedicated_resources"
+        elif key == "fastTryoutEnabled":
+            suggest = "fast_tryout_enabled"
+        elif key == "systemLabels":
+            suggest = "system_labels"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentDeployConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentDeployConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentDeployConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dedicated_resources: Optional['outputs.AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResources'] = None,
+                 fast_tryout_enabled: Optional[_builtins.bool] = None,
+                 system_labels: Optional[Mapping[str, _builtins.str]] = None):
+        """
+        :param 'AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesArgs' dedicated_resources: A description of resources that are dedicated to a DeployedModel or
+               DeployedIndex, and that need a higher degree of manual configuration.
+               Structure is documented below.
+        :param _builtins.bool fast_tryout_enabled: If true, enable the QMT fast tryout feature for this model if possible.
+        :param Mapping[str, _builtins.str] system_labels: System labels for Model Garden deployments.
+               These labels are managed by Google and for tracking purposes only.
+        """
+        if dedicated_resources is not None:
+            pulumi.set(__self__, "dedicated_resources", dedicated_resources)
+        if fast_tryout_enabled is not None:
+            pulumi.set(__self__, "fast_tryout_enabled", fast_tryout_enabled)
+        if system_labels is not None:
+            pulumi.set(__self__, "system_labels", system_labels)
+
+    @_builtins.property
+    @pulumi.getter(name="dedicatedResources")
+    def dedicated_resources(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResources']:
+        """
+        A description of resources that are dedicated to a DeployedModel or
+        DeployedIndex, and that need a higher degree of manual configuration.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "dedicated_resources")
+
+    @_builtins.property
+    @pulumi.getter(name="fastTryoutEnabled")
+    def fast_tryout_enabled(self) -> Optional[_builtins.bool]:
+        """
+        If true, enable the QMT fast tryout feature for this model if possible.
+        """
+        return pulumi.get(self, "fast_tryout_enabled")
+
+    @_builtins.property
+    @pulumi.getter(name="systemLabels")
+    def system_labels(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        System labels for Model Garden deployments.
+        These labels are managed by Google and for tracking purposes only.
+        """
+        return pulumi.get(self, "system_labels")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResources(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "machineSpec":
+            suggest = "machine_spec"
+        elif key == "minReplicaCount":
+            suggest = "min_replica_count"
+        elif key == "autoscalingMetricSpecs":
+            suggest = "autoscaling_metric_specs"
+        elif key == "maxReplicaCount":
+            suggest = "max_replica_count"
+        elif key == "requiredReplicaCount":
+            suggest = "required_replica_count"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResources. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResources.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResources.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 machine_spec: 'outputs.AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpec',
+                 min_replica_count: _builtins.int,
+                 autoscaling_metric_specs: Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesAutoscalingMetricSpec']] = None,
+                 max_replica_count: Optional[_builtins.int] = None,
+                 required_replica_count: Optional[_builtins.int] = None,
+                 spot: Optional[_builtins.bool] = None):
+        """
+        :param 'AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpecArgs' machine_spec: Specification of a single machine.
+               Structure is documented below.
+        :param _builtins.int min_replica_count: The minimum number of machine replicas that will be always deployed on.
+               This value must be greater than or equal to 1.
+               If traffic increases, it may dynamically be deployed onto more replicas,
+               and as traffic decreases, some of these extra replicas may be freed.
+        :param Sequence['AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesAutoscalingMetricSpecArgs'] autoscaling_metric_specs: The metric specifications that overrides a resource
+               utilization metric (CPU utilization, accelerator's duty cycle, and so on)
+               target value (default to 60 if not set). At most one entry is allowed per
+               metric.
+               If machine_spec.accelerator_count is
+               above 0, the autoscaling will be based on both CPU utilization and
+               accelerator's duty cycle metrics and scale up when either metrics exceeds
+               its target value while scale down if both metrics are under their target
+               value. The default target value is 60 for both metrics.
+               If machine_spec.accelerator_count is
+               0, the autoscaling will be based on CPU utilization metric only with
+               default target value 60 if not explicitly set.
+               For example, in the case of Online Prediction, if you want to override
+               target CPU utilization to 80, you should set
+               autoscaling_metric_specs.metric_name
+               to `aiplatform.googleapis.com/prediction/online/cpu/utilization` and
+               autoscaling_metric_specs.target to `80`.
+               Structure is documented below.
+        :param _builtins.int max_replica_count: The maximum number of replicas that may be deployed on when the traffic
+               against it increases. If the requested value is too large, the deployment
+               will error, but if deployment succeeds then the ability to scale to that
+               many replicas is guaranteed (barring service outages). If traffic increases
+               beyond what its replicas at maximum may handle, a portion of the traffic
+               will be dropped. If this value is not provided, will use
+               min_replica_count as the default value.
+               The value of this field impacts the charge against Vertex CPU and GPU
+               quotas. Specifically, you will be charged for (max_replica_count *
+               number of cores in the selected machine type) and (max_replica_count *
+               number of GPUs per replica in the selected machine type).
+        :param _builtins.int required_replica_count: Number of required available replicas for the deployment to succeed.
+               This field is only needed when partial deployment/mutation is
+               desired. If set, the deploy/mutate operation will succeed once
+               available_replica_count reaches required_replica_count, and the rest of
+               the replicas will be retried. If not set, the default
+               required_replica_count will be min_replica_count.
+        :param _builtins.bool spot: If true, schedule the deployment workload on [spot
+               VMs](https://cloud.google.com/kubernetes-engine/docs/concepts/spot-vms).
+        """
+        pulumi.set(__self__, "machine_spec", machine_spec)
+        pulumi.set(__self__, "min_replica_count", min_replica_count)
+        if autoscaling_metric_specs is not None:
+            pulumi.set(__self__, "autoscaling_metric_specs", autoscaling_metric_specs)
+        if max_replica_count is not None:
+            pulumi.set(__self__, "max_replica_count", max_replica_count)
+        if required_replica_count is not None:
+            pulumi.set(__self__, "required_replica_count", required_replica_count)
+        if spot is not None:
+            pulumi.set(__self__, "spot", spot)
+
+    @_builtins.property
+    @pulumi.getter(name="machineSpec")
+    def machine_spec(self) -> 'outputs.AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpec':
+        """
+        Specification of a single machine.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "machine_spec")
+
+    @_builtins.property
+    @pulumi.getter(name="minReplicaCount")
+    def min_replica_count(self) -> _builtins.int:
+        """
+        The minimum number of machine replicas that will be always deployed on.
+        This value must be greater than or equal to 1.
+        If traffic increases, it may dynamically be deployed onto more replicas,
+        and as traffic decreases, some of these extra replicas may be freed.
+        """
+        return pulumi.get(self, "min_replica_count")
+
+    @_builtins.property
+    @pulumi.getter(name="autoscalingMetricSpecs")
+    def autoscaling_metric_specs(self) -> Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesAutoscalingMetricSpec']]:
+        """
+        The metric specifications that overrides a resource
+        utilization metric (CPU utilization, accelerator's duty cycle, and so on)
+        target value (default to 60 if not set). At most one entry is allowed per
+        metric.
+        If machine_spec.accelerator_count is
+        above 0, the autoscaling will be based on both CPU utilization and
+        accelerator's duty cycle metrics and scale up when either metrics exceeds
+        its target value while scale down if both metrics are under their target
+        value. The default target value is 60 for both metrics.
+        If machine_spec.accelerator_count is
+        0, the autoscaling will be based on CPU utilization metric only with
+        default target value 60 if not explicitly set.
+        For example, in the case of Online Prediction, if you want to override
+        target CPU utilization to 80, you should set
+        autoscaling_metric_specs.metric_name
+        to `aiplatform.googleapis.com/prediction/online/cpu/utilization` and
+        autoscaling_metric_specs.target to `80`.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "autoscaling_metric_specs")
+
+    @_builtins.property
+    @pulumi.getter(name="maxReplicaCount")
+    def max_replica_count(self) -> Optional[_builtins.int]:
+        """
+        The maximum number of replicas that may be deployed on when the traffic
+        against it increases. If the requested value is too large, the deployment
+        will error, but if deployment succeeds then the ability to scale to that
+        many replicas is guaranteed (barring service outages). If traffic increases
+        beyond what its replicas at maximum may handle, a portion of the traffic
+        will be dropped. If this value is not provided, will use
+        min_replica_count as the default value.
+        The value of this field impacts the charge against Vertex CPU and GPU
+        quotas. Specifically, you will be charged for (max_replica_count *
+        number of cores in the selected machine type) and (max_replica_count *
+        number of GPUs per replica in the selected machine type).
+        """
+        return pulumi.get(self, "max_replica_count")
+
+    @_builtins.property
+    @pulumi.getter(name="requiredReplicaCount")
+    def required_replica_count(self) -> Optional[_builtins.int]:
+        """
+        Number of required available replicas for the deployment to succeed.
+        This field is only needed when partial deployment/mutation is
+        desired. If set, the deploy/mutate operation will succeed once
+        available_replica_count reaches required_replica_count, and the rest of
+        the replicas will be retried. If not set, the default
+        required_replica_count will be min_replica_count.
+        """
+        return pulumi.get(self, "required_replica_count")
+
+    @_builtins.property
+    @pulumi.getter
+    def spot(self) -> Optional[_builtins.bool]:
+        """
+        If true, schedule the deployment workload on [spot
+        VMs](https://cloud.google.com/kubernetes-engine/docs/concepts/spot-vms).
+        """
+        return pulumi.get(self, "spot")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesAutoscalingMetricSpec(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "metricName":
+            suggest = "metric_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesAutoscalingMetricSpec. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesAutoscalingMetricSpec.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesAutoscalingMetricSpec.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 metric_name: _builtins.str,
+                 target: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str metric_name: The resource metric name.
+               Supported metrics:
+               * For Online Prediction:
+               * `aiplatform.googleapis.com/prediction/online/accelerator/duty_cycle`
+               * `aiplatform.googleapis.com/prediction/online/cpu/utilization`
+        :param _builtins.int target: The target resource utilization in percentage (1% - 100%) for the given
+               metric; once the real usage deviates from the target by a certain
+               percentage, the machine replicas change. The default value is 60
+               (representing 60%) if not provided.
+        """
+        pulumi.set(__self__, "metric_name", metric_name)
+        if target is not None:
+            pulumi.set(__self__, "target", target)
+
+    @_builtins.property
+    @pulumi.getter(name="metricName")
+    def metric_name(self) -> _builtins.str:
+        """
+        The resource metric name.
+        Supported metrics:
+        * For Online Prediction:
+        * `aiplatform.googleapis.com/prediction/online/accelerator/duty_cycle`
+        * `aiplatform.googleapis.com/prediction/online/cpu/utilization`
+        """
+        return pulumi.get(self, "metric_name")
+
+    @_builtins.property
+    @pulumi.getter
+    def target(self) -> Optional[_builtins.int]:
+        """
+        The target resource utilization in percentage (1% - 100%) for the given
+        metric; once the real usage deviates from the target by a certain
+        percentage, the machine replicas change. The default value is 60
+        (representing 60%) if not provided.
+        """
+        return pulumi.get(self, "target")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpec(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "acceleratorCount":
+            suggest = "accelerator_count"
+        elif key == "acceleratorType":
+            suggest = "accelerator_type"
+        elif key == "machineType":
+            suggest = "machine_type"
+        elif key == "multihostGpuNodeCount":
+            suggest = "multihost_gpu_node_count"
+        elif key == "reservationAffinity":
+            suggest = "reservation_affinity"
+        elif key == "tpuTopology":
+            suggest = "tpu_topology"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpec. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpec.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpec.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 accelerator_count: Optional[_builtins.int] = None,
+                 accelerator_type: Optional[_builtins.str] = None,
+                 machine_type: Optional[_builtins.str] = None,
+                 multihost_gpu_node_count: Optional[_builtins.int] = None,
+                 reservation_affinity: Optional['outputs.AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpecReservationAffinity'] = None,
+                 tpu_topology: Optional[_builtins.str] = None):
+        """
+        :param _builtins.int accelerator_count: The number of accelerators to attach to the machine.
+        :param _builtins.str accelerator_type: Possible values:
+               ACCELERATOR_TYPE_UNSPECIFIED
+               NVIDIA_TESLA_K80
+               NVIDIA_TESLA_P100
+               NVIDIA_TESLA_V100
+               NVIDIA_TESLA_P4
+               NVIDIA_TESLA_T4
+               NVIDIA_TESLA_A100
+               NVIDIA_A100_80GB
+               NVIDIA_L4
+               NVIDIA_H100_80GB
+               NVIDIA_H100_MEGA_80GB
+               NVIDIA_H200_141GB
+               NVIDIA_B200
+               TPU_V2
+               TPU_V3
+               TPU_V4_POD
+               TPU_V5_LITEPOD
+        :param _builtins.str machine_type: The type of the machine.
+               See the [list of machine types supported for
+               prediction](https://cloud.google.com/vertex-ai/docs/predictions/configure-compute#machine-types)
+               See the [list of machine types supported for custom
+               training](https://cloud.google.com/vertex-ai/docs/training/configure-compute#machine-types).
+               For DeployedModel this field is optional, and the default
+               value is `n1-standard-2`. For BatchPredictionJob or as part of
+               WorkerPoolSpec this field is required.
+        :param _builtins.int multihost_gpu_node_count: The number of nodes per replica for multihost GPU deployments.
+        :param 'AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpecReservationAffinityArgs' reservation_affinity: A ReservationAffinity can be used to configure a Vertex AI resource (e.g., a
+               DeployedModel) to draw its Compute Engine resources from a Shared
+               Reservation, or exclusively from on-demand capacity.
+               Structure is documented below.
+        :param _builtins.str tpu_topology: The topology of the TPUs. Corresponds to the TPU topologies available from
+               GKE. (Example: tpu_topology: "2x2x1").
+        """
+        if accelerator_count is not None:
+            pulumi.set(__self__, "accelerator_count", accelerator_count)
+        if accelerator_type is not None:
+            pulumi.set(__self__, "accelerator_type", accelerator_type)
+        if machine_type is not None:
+            pulumi.set(__self__, "machine_type", machine_type)
+        if multihost_gpu_node_count is not None:
+            pulumi.set(__self__, "multihost_gpu_node_count", multihost_gpu_node_count)
+        if reservation_affinity is not None:
+            pulumi.set(__self__, "reservation_affinity", reservation_affinity)
+        if tpu_topology is not None:
+            pulumi.set(__self__, "tpu_topology", tpu_topology)
+
+    @_builtins.property
+    @pulumi.getter(name="acceleratorCount")
+    def accelerator_count(self) -> Optional[_builtins.int]:
+        """
+        The number of accelerators to attach to the machine.
+        """
+        return pulumi.get(self, "accelerator_count")
+
+    @_builtins.property
+    @pulumi.getter(name="acceleratorType")
+    def accelerator_type(self) -> Optional[_builtins.str]:
+        """
+        Possible values:
+        ACCELERATOR_TYPE_UNSPECIFIED
+        NVIDIA_TESLA_K80
+        NVIDIA_TESLA_P100
+        NVIDIA_TESLA_V100
+        NVIDIA_TESLA_P4
+        NVIDIA_TESLA_T4
+        NVIDIA_TESLA_A100
+        NVIDIA_A100_80GB
+        NVIDIA_L4
+        NVIDIA_H100_80GB
+        NVIDIA_H100_MEGA_80GB
+        NVIDIA_H200_141GB
+        NVIDIA_B200
+        TPU_V2
+        TPU_V3
+        TPU_V4_POD
+        TPU_V5_LITEPOD
+        """
+        return pulumi.get(self, "accelerator_type")
+
+    @_builtins.property
+    @pulumi.getter(name="machineType")
+    def machine_type(self) -> Optional[_builtins.str]:
+        """
+        The type of the machine.
+        See the [list of machine types supported for
+        prediction](https://cloud.google.com/vertex-ai/docs/predictions/configure-compute#machine-types)
+        See the [list of machine types supported for custom
+        training](https://cloud.google.com/vertex-ai/docs/training/configure-compute#machine-types).
+        For DeployedModel this field is optional, and the default
+        value is `n1-standard-2`. For BatchPredictionJob or as part of
+        WorkerPoolSpec this field is required.
+        """
+        return pulumi.get(self, "machine_type")
+
+    @_builtins.property
+    @pulumi.getter(name="multihostGpuNodeCount")
+    def multihost_gpu_node_count(self) -> Optional[_builtins.int]:
+        """
+        The number of nodes per replica for multihost GPU deployments.
+        """
+        return pulumi.get(self, "multihost_gpu_node_count")
+
+    @_builtins.property
+    @pulumi.getter(name="reservationAffinity")
+    def reservation_affinity(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpecReservationAffinity']:
+        """
+        A ReservationAffinity can be used to configure a Vertex AI resource (e.g., a
+        DeployedModel) to draw its Compute Engine resources from a Shared
+        Reservation, or exclusively from on-demand capacity.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "reservation_affinity")
+
+    @_builtins.property
+    @pulumi.getter(name="tpuTopology")
+    def tpu_topology(self) -> Optional[_builtins.str]:
+        """
+        The topology of the TPUs. Corresponds to the TPU topologies available from
+        GKE. (Example: tpu_topology: "2x2x1").
+        """
+        return pulumi.get(self, "tpu_topology")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpecReservationAffinity(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "reservationAffinityType":
+            suggest = "reservation_affinity_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpecReservationAffinity. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpecReservationAffinity.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentDeployConfigDedicatedResourcesMachineSpecReservationAffinity.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 reservation_affinity_type: _builtins.str,
+                 key: Optional[_builtins.str] = None,
+                 values: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param _builtins.str reservation_affinity_type: Specifies the reservation affinity type.
+               Possible values:
+               TYPE_UNSPECIFIED
+               NO_RESERVATION
+               ANY_RESERVATION
+               SPECIFIC_RESERVATION
+        :param _builtins.str key: Corresponds to the label key of a reservation resource. To target a
+               SPECIFIC_RESERVATION by name, use `compute.googleapis.com/reservation-name`
+               as the key and specify the name of your reservation as its value.
+        :param Sequence[_builtins.str] values: Corresponds to the label values of a reservation resource. This must be the
+               full resource name of the reservation or reservation block.
+        """
+        pulumi.set(__self__, "reservation_affinity_type", reservation_affinity_type)
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if values is not None:
+            pulumi.set(__self__, "values", values)
+
+    @_builtins.property
+    @pulumi.getter(name="reservationAffinityType")
+    def reservation_affinity_type(self) -> _builtins.str:
+        """
+        Specifies the reservation affinity type.
+        Possible values:
+        TYPE_UNSPECIFIED
+        NO_RESERVATION
+        ANY_RESERVATION
+        SPECIFIC_RESERVATION
+        """
+        return pulumi.get(self, "reservation_affinity_type")
+
+    @_builtins.property
+    @pulumi.getter
+    def key(self) -> Optional[_builtins.str]:
+        """
+        Corresponds to the label key of a reservation resource. To target a
+        SPECIFIC_RESERVATION by name, use `compute.googleapis.com/reservation-name`
+        as the key and specify the name of your reservation as its value.
+        """
+        return pulumi.get(self, "key")
+
+    @_builtins.property
+    @pulumi.getter
+    def values(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        Corresponds to the label values of a reservation resource. This must be the
+        full resource name of the reservation or reservation block.
+        """
+        return pulumi.get(self, "values")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentEndpointConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dedicatedEndpointEnabled":
+            suggest = "dedicated_endpoint_enabled"
+        elif key == "endpointDisplayName":
+            suggest = "endpoint_display_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentEndpointConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentEndpointConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentEndpointConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dedicated_endpoint_enabled: Optional[_builtins.bool] = None,
+                 endpoint_display_name: Optional[_builtins.str] = None):
+        """
+        :param _builtins.bool dedicated_endpoint_enabled: If true, the endpoint will be exposed through a dedicated
+               DNS [Endpoint.dedicated_endpoint_dns]. Your request to the dedicated DNS
+               will be isolated from other users' traffic and will have better
+               performance and reliability. Note: Once you enabled dedicated endpoint,
+               you won't be able to send request to the shared DNS
+               {region}-aiplatform.googleapis.com. The limitations will be removed soon.
+        :param _builtins.str endpoint_display_name: The user-specified display name of the endpoint. If not set, a
+               default name will be used.
+        """
+        if dedicated_endpoint_enabled is not None:
+            pulumi.set(__self__, "dedicated_endpoint_enabled", dedicated_endpoint_enabled)
+        if endpoint_display_name is not None:
+            pulumi.set(__self__, "endpoint_display_name", endpoint_display_name)
+
+    @_builtins.property
+    @pulumi.getter(name="dedicatedEndpointEnabled")
+    def dedicated_endpoint_enabled(self) -> Optional[_builtins.bool]:
+        """
+        If true, the endpoint will be exposed through a dedicated
+        DNS [Endpoint.dedicated_endpoint_dns]. Your request to the dedicated DNS
+        will be isolated from other users' traffic and will have better
+        performance and reliability. Note: Once you enabled dedicated endpoint,
+        you won't be able to send request to the shared DNS
+        {region}-aiplatform.googleapis.com. The limitations will be removed soon.
+        """
+        return pulumi.get(self, "dedicated_endpoint_enabled")
+
+    @_builtins.property
+    @pulumi.getter(name="endpointDisplayName")
+    def endpoint_display_name(self) -> Optional[_builtins.str]:
+        """
+        The user-specified display name of the endpoint. If not set, a
+        default name will be used.
+        """
+        return pulumi.get(self, "endpoint_display_name")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "acceptEula":
+            suggest = "accept_eula"
+        elif key == "containerSpec":
+            suggest = "container_spec"
+        elif key == "huggingFaceAccessToken":
+            suggest = "hugging_face_access_token"
+        elif key == "huggingFaceCacheEnabled":
+            suggest = "hugging_face_cache_enabled"
+        elif key == "modelDisplayName":
+            suggest = "model_display_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentModelConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 accept_eula: Optional[_builtins.bool] = None,
+                 container_spec: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpec'] = None,
+                 hugging_face_access_token: Optional[_builtins.str] = None,
+                 hugging_face_cache_enabled: Optional[_builtins.bool] = None,
+                 model_display_name: Optional[_builtins.str] = None):
+        """
+        :param _builtins.bool accept_eula: Whether the user accepts the End User License Agreement (EULA)
+               for the model.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecArgs' container_spec: Specification of a container for serving predictions. Some fields in this
+               message correspond to fields in the [Kubernetes Container v1 core
+               specification](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#container-v1-core).
+               Structure is documented below.
+        :param _builtins.str hugging_face_access_token: The Hugging Face read access token used to access the model
+               artifacts of gated models.
+        :param _builtins.bool hugging_face_cache_enabled: If true, the model will deploy with a cached version instead of directly
+               downloading the model artifacts from Hugging Face. This is suitable for
+               VPC-SC users with limited internet access.
+        :param _builtins.str model_display_name: The user-specified display name of the uploaded model. If not
+               set, a default name will be used.
+        """
+        if accept_eula is not None:
+            pulumi.set(__self__, "accept_eula", accept_eula)
+        if container_spec is not None:
+            pulumi.set(__self__, "container_spec", container_spec)
+        if hugging_face_access_token is not None:
+            pulumi.set(__self__, "hugging_face_access_token", hugging_face_access_token)
+        if hugging_face_cache_enabled is not None:
+            pulumi.set(__self__, "hugging_face_cache_enabled", hugging_face_cache_enabled)
+        if model_display_name is not None:
+            pulumi.set(__self__, "model_display_name", model_display_name)
+
+    @_builtins.property
+    @pulumi.getter(name="acceptEula")
+    def accept_eula(self) -> Optional[_builtins.bool]:
+        """
+        Whether the user accepts the End User License Agreement (EULA)
+        for the model.
+        """
+        return pulumi.get(self, "accept_eula")
+
+    @_builtins.property
+    @pulumi.getter(name="containerSpec")
+    def container_spec(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpec']:
+        """
+        Specification of a container for serving predictions. Some fields in this
+        message correspond to fields in the [Kubernetes Container v1 core
+        specification](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#container-v1-core).
+        Structure is documented below.
+        """
+        return pulumi.get(self, "container_spec")
+
+    @_builtins.property
+    @pulumi.getter(name="huggingFaceAccessToken")
+    def hugging_face_access_token(self) -> Optional[_builtins.str]:
+        """
+        The Hugging Face read access token used to access the model
+        artifacts of gated models.
+        """
+        return pulumi.get(self, "hugging_face_access_token")
+
+    @_builtins.property
+    @pulumi.getter(name="huggingFaceCacheEnabled")
+    def hugging_face_cache_enabled(self) -> Optional[_builtins.bool]:
+        """
+        If true, the model will deploy with a cached version instead of directly
+        downloading the model artifacts from Hugging Face. This is suitable for
+        VPC-SC users with limited internet access.
+        """
+        return pulumi.get(self, "hugging_face_cache_enabled")
+
+    @_builtins.property
+    @pulumi.getter(name="modelDisplayName")
+    def model_display_name(self) -> Optional[_builtins.str]:
+        """
+        The user-specified display name of the uploaded model. If not
+        set, a default name will be used.
+        """
+        return pulumi.get(self, "model_display_name")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpec(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "imageUri":
+            suggest = "image_uri"
+        elif key == "deploymentTimeout":
+            suggest = "deployment_timeout"
+        elif key == "grpcPorts":
+            suggest = "grpc_ports"
+        elif key == "healthProbe":
+            suggest = "health_probe"
+        elif key == "healthRoute":
+            suggest = "health_route"
+        elif key == "livenessProbe":
+            suggest = "liveness_probe"
+        elif key == "predictRoute":
+            suggest = "predict_route"
+        elif key == "sharedMemorySizeMb":
+            suggest = "shared_memory_size_mb"
+        elif key == "startupProbe":
+            suggest = "startup_probe"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentModelConfigContainerSpec. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpec.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpec.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 image_uri: _builtins.str,
+                 args: Optional[Sequence[_builtins.str]] = None,
+                 commands: Optional[Sequence[_builtins.str]] = None,
+                 deployment_timeout: Optional[_builtins.str] = None,
+                 envs: Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecEnv']] = None,
+                 grpc_ports: Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecGrpcPort']] = None,
+                 health_probe: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbe'] = None,
+                 health_route: Optional[_builtins.str] = None,
+                 liveness_probe: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbe'] = None,
+                 ports: Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecPort']] = None,
+                 predict_route: Optional[_builtins.str] = None,
+                 shared_memory_size_mb: Optional[_builtins.str] = None,
+                 startup_probe: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbe'] = None):
+        """
+        :param _builtins.str image_uri: URI of the Docker image to be used as the custom container for serving
+               predictions. This URI must identify an image in Artifact Registry or
+               Container Registry. Learn more about the [container publishing
+               requirements](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#publishing),
+               including permissions requirements for the Vertex AI Service Agent.
+               The container image is ingested upon ModelService.UploadModel, stored
+               internally, and this original path is afterwards not used.
+               To learn about the requirements for the Docker image itself, see
+               [Custom container
+               requirements](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#).
+               You can use the URI to one of Vertex AI's [pre-built container images for
+               prediction](https://cloud.google.com/vertex-ai/docs/predictions/pre-built-containers)
+               in this field.
+        :param Sequence[_builtins.str] args: Specifies arguments for the command that runs when the container starts.
+               This overrides the container's
+               [`CMD`](https://docs.docker.com/engine/reference/builder/#cmd). Specify
+               this field as an array of executable and arguments, similar to a Docker
+               `CMD`'s "default parameters" form.
+               If you don't specify this field but do specify the
+               command field, then the command from the
+               `command` field runs without any additional arguments. See the
+               [Kubernetes documentation about how the
+               `command` and `args` fields interact with a container's `ENTRYPOINT` and
+               `CMD`](https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#notes).
+               If you don't specify this field and don't specify the `command` field,
+               then the container's
+               [`ENTRYPOINT`](https://docs.docker.com/engine/reference/builder/#cmd) and
+               `CMD` determine what runs based on their default behavior. See the Docker
+               documentation about [how `CMD` and `ENTRYPOINT`
+               interact](https://docs.docker.com/engine/reference/builder/#understand-how-cmd-and-entrypoint-interact).
+               In this field, you can reference [environment variables
+               set by Vertex
+               AI](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables)
+               and environment variables set in the env field.
+               You cannot reference environment variables set in the Docker image. In
+               order for environment variables to be expanded, reference them by using the
+               following syntax:$(VARIABLE_NAME)
+               Note that this differs from Bash variable expansion, which does not use
+               parentheses. If a variable cannot be resolved, the reference in the input
+               string is used unchanged. To avoid variable expansion, you can escape this
+               syntax with `$$`; for example:$$(VARIABLE_NAME)
+               This field corresponds to the `args` field of the Kubernetes Containers
+               [v1 core
+               API](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#container-v1-core).
+        :param Sequence[_builtins.str] commands: Specifies the command that runs when the container starts. This overrides
+               the container's
+               [ENTRYPOINT](https://docs.docker.com/engine/reference/builder/#entrypoint).
+               Specify this field as an array of executable and arguments, similar to a
+               Docker `ENTRYPOINT`'s "exec" form, not its "shell" form.
+               If you do not specify this field, then the container's `ENTRYPOINT` runs,
+               in conjunction with the args field or the
+               container's [`CMD`](https://docs.docker.com/engine/reference/builder/#cmd),
+               if either exists. If this field is not specified and the container does not
+               have an `ENTRYPOINT`, then refer to the Docker documentation about [how
+               `CMD` and `ENTRYPOINT`
+               interact](https://docs.docker.com/engine/reference/builder/#understand-how-cmd-and-entrypoint-interact).
+               If you specify this field, then you can also specify the `args` field to
+               provide additional arguments for this command. However, if you specify this
+               field, then the container's `CMD` is ignored. See the
+               [Kubernetes documentation about how the
+               `command` and `args` fields interact with a container's `ENTRYPOINT` and
+               `CMD`](https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#notes).
+               In this field, you can reference [environment variables set by Vertex
+               AI](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables)
+               and environment variables set in the env field.
+               You cannot reference environment variables set in the Docker image. In
+               order for environment variables to be expanded, reference them by using the
+               following syntax:$(VARIABLE_NAME)
+               Note that this differs from Bash variable expansion, which does not use
+               parentheses. If a variable cannot be resolved, the reference in the input
+               string is used unchanged. To avoid variable expansion, you can escape this
+               syntax with `$$`; for example:$$(VARIABLE_NAME)
+               This field corresponds to the `command` field of the Kubernetes Containers
+               [v1 core
+               API](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#container-v1-core).
+        :param _builtins.str deployment_timeout: Deployment timeout.
+               Limit for deployment timeout is 2 hours.
+        :param Sequence['AiEndpointWithModelGardenDeploymentModelConfigContainerSpecEnvArgs'] envs: List of environment variables to set in the container. After the container
+               starts running, code running in the container can read these environment
+               variables.
+               Additionally, the command and
+               args fields can reference these variables. Later
+               entries in this list can also reference earlier entries. For example, the
+               following example sets the variable `VAR_2` to have the value `foo bar`:
+               ```json
+               [
+               {
+               "name": "VAR_1",
+               "value": "foo"
+               },
+               {
+               "name": "VAR_2",
+               "value": "$(VAR_1) bar"
+               }
+               ]
+               ```
+               If you switch the order of the variables in the example, then the expansion
+               does not occur.
+               This field corresponds to the `env` field of the Kubernetes Containers
+               [v1 core
+               API](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#container-v1-core).
+               Structure is documented below.
+        :param Sequence['AiEndpointWithModelGardenDeploymentModelConfigContainerSpecGrpcPortArgs'] grpc_ports: List of ports to expose from the container. Vertex AI sends gRPC
+               prediction requests that it receives to the first port on this list. Vertex
+               AI also sends liveness and health checks to this port.
+               If you do not specify this field, gRPC requests to the container will be
+               disabled.
+               Vertex AI does not use ports other than the first one listed. This field
+               corresponds to the `ports` field of the Kubernetes Containers v1 core API.
+               Structure is documented below.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeArgs' health_probe: Probe describes a health check to be performed against a container to
+               determine whether it is alive or ready to receive traffic.
+               Structure is documented below.
+        :param _builtins.str health_route: HTTP path on the container to send health checks to. Vertex AI
+               intermittently sends GET requests to this path on the container's IP
+               address and port to check that the container is healthy. Read more about
+               [health
+               checks](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#health).
+               For example, if you set this field to `/bar`, then Vertex AI
+               intermittently sends a GET request to the `/bar` path on the port of your
+               container specified by the first value of this `ModelContainerSpec`'s
+               ports field.
+               If you don't specify this field, it defaults to the following value when
+               you deploy this Model to an Endpoint:/v1/endpoints/ENDPOINT/deployedModels/DEPLOYED_MODEL:predict
+               The placeholders in this value are replaced as follows:
+               * ENDPOINT: The last segment (following `endpoints/`)of the
+               Endpoint.name][] field of the Endpoint where this Model has been
+               deployed. (Vertex AI makes this value available to your container code
+               as the [`AIP_ENDPOINT_ID` environment
+               variable](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables).)
+               * DEPLOYED_MODEL: DeployedModel.id of the `DeployedModel`.
+               (Vertex AI makes this value available to your container code as the
+               [`AIP_DEPLOYED_MODEL_ID` environment
+               variable](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables).)
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeArgs' liveness_probe: Probe describes a health check to be performed against a container to
+               determine whether it is alive or ready to receive traffic.
+               Structure is documented below.
+        :param Sequence['AiEndpointWithModelGardenDeploymentModelConfigContainerSpecPortArgs'] ports: List of ports to expose from the container. Vertex AI sends any
+               prediction requests that it receives to the first port on this list. Vertex
+               AI also sends
+               [liveness and health
+               checks](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#liveness)
+               to this port.
+               If you do not specify this field, it defaults to following value:
+               ```json
+               [
+               {
+               "containerPort": 8080
+               }
+               ]
+               ```
+               Vertex AI does not use ports other than the first one listed. This field
+               corresponds to the `ports` field of the Kubernetes Containers
+               [v1 core
+               API](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#container-v1-core).
+               Structure is documented below.
+        :param _builtins.str predict_route: HTTP path on the container to send prediction requests to. Vertex AI
+               forwards requests sent using
+               projects.locations.endpoints.predict to this
+               path on the container's IP address and port. Vertex AI then returns the
+               container's response in the API response.
+               For example, if you set this field to `/foo`, then when Vertex AI
+               receives a prediction request, it forwards the request body in a POST
+               request to the `/foo` path on the port of your container specified by the
+               first value of this `ModelContainerSpec`'s
+               ports field.
+               If you don't specify this field, it defaults to the following value when
+               you deploy this Model to an Endpoint:/v1/endpoints/ENDPOINT/deployedModels/DEPLOYED_MODEL:predict
+               The placeholders in this value are replaced as follows:
+               * ENDPOINT: The last segment (following `endpoints/`)of the
+               Endpoint.name][] field of the Endpoint where this Model has been
+               deployed. (Vertex AI makes this value available to your container code
+               as the [`AIP_ENDPOINT_ID` environment
+               variable](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables).)
+               * DEPLOYED_MODEL: DeployedModel.id of the `DeployedModel`.
+               (Vertex AI makes this value available to your container code
+               as the [`AIP_DEPLOYED_MODEL_ID` environment
+               variable](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables).)
+        :param _builtins.str shared_memory_size_mb: The amount of the VM memory to reserve as the shared memory for the model
+               in megabytes.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeArgs' startup_probe: Probe describes a health check to be performed against a container to
+               determine whether it is alive or ready to receive traffic.
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "image_uri", image_uri)
+        if args is not None:
+            pulumi.set(__self__, "args", args)
+        if commands is not None:
+            pulumi.set(__self__, "commands", commands)
+        if deployment_timeout is not None:
+            pulumi.set(__self__, "deployment_timeout", deployment_timeout)
+        if envs is not None:
+            pulumi.set(__self__, "envs", envs)
+        if grpc_ports is not None:
+            pulumi.set(__self__, "grpc_ports", grpc_ports)
+        if health_probe is not None:
+            pulumi.set(__self__, "health_probe", health_probe)
+        if health_route is not None:
+            pulumi.set(__self__, "health_route", health_route)
+        if liveness_probe is not None:
+            pulumi.set(__self__, "liveness_probe", liveness_probe)
+        if ports is not None:
+            pulumi.set(__self__, "ports", ports)
+        if predict_route is not None:
+            pulumi.set(__self__, "predict_route", predict_route)
+        if shared_memory_size_mb is not None:
+            pulumi.set(__self__, "shared_memory_size_mb", shared_memory_size_mb)
+        if startup_probe is not None:
+            pulumi.set(__self__, "startup_probe", startup_probe)
+
+    @_builtins.property
+    @pulumi.getter(name="imageUri")
+    def image_uri(self) -> _builtins.str:
+        """
+        URI of the Docker image to be used as the custom container for serving
+        predictions. This URI must identify an image in Artifact Registry or
+        Container Registry. Learn more about the [container publishing
+        requirements](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#publishing),
+        including permissions requirements for the Vertex AI Service Agent.
+        The container image is ingested upon ModelService.UploadModel, stored
+        internally, and this original path is afterwards not used.
+        To learn about the requirements for the Docker image itself, see
+        [Custom container
+        requirements](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#).
+        You can use the URI to one of Vertex AI's [pre-built container images for
+        prediction](https://cloud.google.com/vertex-ai/docs/predictions/pre-built-containers)
+        in this field.
+        """
+        return pulumi.get(self, "image_uri")
+
+    @_builtins.property
+    @pulumi.getter
+    def args(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        Specifies arguments for the command that runs when the container starts.
+        This overrides the container's
+        [`CMD`](https://docs.docker.com/engine/reference/builder/#cmd). Specify
+        this field as an array of executable and arguments, similar to a Docker
+        `CMD`'s "default parameters" form.
+        If you don't specify this field but do specify the
+        command field, then the command from the
+        `command` field runs without any additional arguments. See the
+        [Kubernetes documentation about how the
+        `command` and `args` fields interact with a container's `ENTRYPOINT` and
+        `CMD`](https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#notes).
+        If you don't specify this field and don't specify the `command` field,
+        then the container's
+        [`ENTRYPOINT`](https://docs.docker.com/engine/reference/builder/#cmd) and
+        `CMD` determine what runs based on their default behavior. See the Docker
+        documentation about [how `CMD` and `ENTRYPOINT`
+        interact](https://docs.docker.com/engine/reference/builder/#understand-how-cmd-and-entrypoint-interact).
+        In this field, you can reference [environment variables
+        set by Vertex
+        AI](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables)
+        and environment variables set in the env field.
+        You cannot reference environment variables set in the Docker image. In
+        order for environment variables to be expanded, reference them by using the
+        following syntax:$(VARIABLE_NAME)
+        Note that this differs from Bash variable expansion, which does not use
+        parentheses. If a variable cannot be resolved, the reference in the input
+        string is used unchanged. To avoid variable expansion, you can escape this
+        syntax with `$$`; for example:$$(VARIABLE_NAME)
+        This field corresponds to the `args` field of the Kubernetes Containers
+        [v1 core
+        API](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#container-v1-core).
+        """
+        return pulumi.get(self, "args")
+
+    @_builtins.property
+    @pulumi.getter
+    def commands(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        Specifies the command that runs when the container starts. This overrides
+        the container's
+        [ENTRYPOINT](https://docs.docker.com/engine/reference/builder/#entrypoint).
+        Specify this field as an array of executable and arguments, similar to a
+        Docker `ENTRYPOINT`'s "exec" form, not its "shell" form.
+        If you do not specify this field, then the container's `ENTRYPOINT` runs,
+        in conjunction with the args field or the
+        container's [`CMD`](https://docs.docker.com/engine/reference/builder/#cmd),
+        if either exists. If this field is not specified and the container does not
+        have an `ENTRYPOINT`, then refer to the Docker documentation about [how
+        `CMD` and `ENTRYPOINT`
+        interact](https://docs.docker.com/engine/reference/builder/#understand-how-cmd-and-entrypoint-interact).
+        If you specify this field, then you can also specify the `args` field to
+        provide additional arguments for this command. However, if you specify this
+        field, then the container's `CMD` is ignored. See the
+        [Kubernetes documentation about how the
+        `command` and `args` fields interact with a container's `ENTRYPOINT` and
+        `CMD`](https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#notes).
+        In this field, you can reference [environment variables set by Vertex
+        AI](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables)
+        and environment variables set in the env field.
+        You cannot reference environment variables set in the Docker image. In
+        order for environment variables to be expanded, reference them by using the
+        following syntax:$(VARIABLE_NAME)
+        Note that this differs from Bash variable expansion, which does not use
+        parentheses. If a variable cannot be resolved, the reference in the input
+        string is used unchanged. To avoid variable expansion, you can escape this
+        syntax with `$$`; for example:$$(VARIABLE_NAME)
+        This field corresponds to the `command` field of the Kubernetes Containers
+        [v1 core
+        API](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#container-v1-core).
+        """
+        return pulumi.get(self, "commands")
+
+    @_builtins.property
+    @pulumi.getter(name="deploymentTimeout")
+    def deployment_timeout(self) -> Optional[_builtins.str]:
+        """
+        Deployment timeout.
+        Limit for deployment timeout is 2 hours.
+        """
+        return pulumi.get(self, "deployment_timeout")
+
+    @_builtins.property
+    @pulumi.getter
+    def envs(self) -> Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecEnv']]:
+        """
+        List of environment variables to set in the container. After the container
+        starts running, code running in the container can read these environment
+        variables.
+        Additionally, the command and
+        args fields can reference these variables. Later
+        entries in this list can also reference earlier entries. For example, the
+        following example sets the variable `VAR_2` to have the value `foo bar`:
+        ```json
+        [
+        {
+        "name": "VAR_1",
+        "value": "foo"
+        },
+        {
+        "name": "VAR_2",
+        "value": "$(VAR_1) bar"
+        }
+        ]
+        ```
+        If you switch the order of the variables in the example, then the expansion
+        does not occur.
+        This field corresponds to the `env` field of the Kubernetes Containers
+        [v1 core
+        API](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#container-v1-core).
+        Structure is documented below.
+        """
+        return pulumi.get(self, "envs")
+
+    @_builtins.property
+    @pulumi.getter(name="grpcPorts")
+    def grpc_ports(self) -> Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecGrpcPort']]:
+        """
+        List of ports to expose from the container. Vertex AI sends gRPC
+        prediction requests that it receives to the first port on this list. Vertex
+        AI also sends liveness and health checks to this port.
+        If you do not specify this field, gRPC requests to the container will be
+        disabled.
+        Vertex AI does not use ports other than the first one listed. This field
+        corresponds to the `ports` field of the Kubernetes Containers v1 core API.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "grpc_ports")
+
+    @_builtins.property
+    @pulumi.getter(name="healthProbe")
+    def health_probe(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbe']:
+        """
+        Probe describes a health check to be performed against a container to
+        determine whether it is alive or ready to receive traffic.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "health_probe")
+
+    @_builtins.property
+    @pulumi.getter(name="healthRoute")
+    def health_route(self) -> Optional[_builtins.str]:
+        """
+        HTTP path on the container to send health checks to. Vertex AI
+        intermittently sends GET requests to this path on the container's IP
+        address and port to check that the container is healthy. Read more about
+        [health
+        checks](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#health).
+        For example, if you set this field to `/bar`, then Vertex AI
+        intermittently sends a GET request to the `/bar` path on the port of your
+        container specified by the first value of this `ModelContainerSpec`'s
+        ports field.
+        If you don't specify this field, it defaults to the following value when
+        you deploy this Model to an Endpoint:/v1/endpoints/ENDPOINT/deployedModels/DEPLOYED_MODEL:predict
+        The placeholders in this value are replaced as follows:
+        * ENDPOINT: The last segment (following `endpoints/`)of the
+        Endpoint.name][] field of the Endpoint where this Model has been
+        deployed. (Vertex AI makes this value available to your container code
+        as the [`AIP_ENDPOINT_ID` environment
+        variable](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables).)
+        * DEPLOYED_MODEL: DeployedModel.id of the `DeployedModel`.
+        (Vertex AI makes this value available to your container code as the
+        [`AIP_DEPLOYED_MODEL_ID` environment
+        variable](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables).)
+        """
+        return pulumi.get(self, "health_route")
+
+    @_builtins.property
+    @pulumi.getter(name="livenessProbe")
+    def liveness_probe(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbe']:
+        """
+        Probe describes a health check to be performed against a container to
+        determine whether it is alive or ready to receive traffic.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "liveness_probe")
+
+    @_builtins.property
+    @pulumi.getter
+    def ports(self) -> Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecPort']]:
+        """
+        List of ports to expose from the container. Vertex AI sends any
+        prediction requests that it receives to the first port on this list. Vertex
+        AI also sends
+        [liveness and health
+        checks](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#liveness)
+        to this port.
+        If you do not specify this field, it defaults to following value:
+        ```json
+        [
+        {
+        "containerPort": 8080
+        }
+        ]
+        ```
+        Vertex AI does not use ports other than the first one listed. This field
+        corresponds to the `ports` field of the Kubernetes Containers
+        [v1 core
+        API](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#container-v1-core).
+        Structure is documented below.
+        """
+        return pulumi.get(self, "ports")
+
+    @_builtins.property
+    @pulumi.getter(name="predictRoute")
+    def predict_route(self) -> Optional[_builtins.str]:
+        """
+        HTTP path on the container to send prediction requests to. Vertex AI
+        forwards requests sent using
+        projects.locations.endpoints.predict to this
+        path on the container's IP address and port. Vertex AI then returns the
+        container's response in the API response.
+        For example, if you set this field to `/foo`, then when Vertex AI
+        receives a prediction request, it forwards the request body in a POST
+        request to the `/foo` path on the port of your container specified by the
+        first value of this `ModelContainerSpec`'s
+        ports field.
+        If you don't specify this field, it defaults to the following value when
+        you deploy this Model to an Endpoint:/v1/endpoints/ENDPOINT/deployedModels/DEPLOYED_MODEL:predict
+        The placeholders in this value are replaced as follows:
+        * ENDPOINT: The last segment (following `endpoints/`)of the
+        Endpoint.name][] field of the Endpoint where this Model has been
+        deployed. (Vertex AI makes this value available to your container code
+        as the [`AIP_ENDPOINT_ID` environment
+        variable](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables).)
+        * DEPLOYED_MODEL: DeployedModel.id of the `DeployedModel`.
+        (Vertex AI makes this value available to your container code
+        as the [`AIP_DEPLOYED_MODEL_ID` environment
+        variable](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables).)
+        """
+        return pulumi.get(self, "predict_route")
+
+    @_builtins.property
+    @pulumi.getter(name="sharedMemorySizeMb")
+    def shared_memory_size_mb(self) -> Optional[_builtins.str]:
+        """
+        The amount of the VM memory to reserve as the shared memory for the model
+        in megabytes.
+        """
+        return pulumi.get(self, "shared_memory_size_mb")
+
+    @_builtins.property
+    @pulumi.getter(name="startupProbe")
+    def startup_probe(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbe']:
+        """
+        Probe describes a health check to be performed against a container to
+        determine whether it is alive or ready to receive traffic.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "startup_probe")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecEnv(dict):
+    def __init__(__self__, *,
+                 name: _builtins.str,
+                 value: _builtins.str):
+        """
+        :param _builtins.str name: Name of the environment variable. Must be a valid C identifier.
+        :param _builtins.str value: Variables that reference a $(VAR_NAME) are expanded
+               using the previous defined environment variables in the container and
+               any service environment variables. If a variable cannot be resolved,
+               the reference in the input string will be unchanged. The $(VAR_NAME)
+               syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped
+               references will never be expanded, regardless of whether the variable
+               exists or not.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> _builtins.str:
+        """
+        Name of the environment variable. Must be a valid C identifier.
+        """
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> _builtins.str:
+        """
+        Variables that reference a $(VAR_NAME) are expanded
+        using the previous defined environment variables in the container and
+        any service environment variables. If a variable cannot be resolved,
+        the reference in the input string will be unchanged. The $(VAR_NAME)
+        syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped
+        references will never be expanded, regardless of whether the variable
+        exists or not.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecGrpcPort(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "containerPort":
+            suggest = "container_port"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentModelConfigContainerSpecGrpcPort. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecGrpcPort.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecGrpcPort.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 container_port: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int container_port: The number of the port to expose on the pod's IP address.
+               Must be a valid port number, between 1 and 65535 inclusive.
+        """
+        if container_port is not None:
+            pulumi.set(__self__, "container_port", container_port)
+
+    @_builtins.property
+    @pulumi.getter(name="containerPort")
+    def container_port(self) -> Optional[_builtins.int]:
+        """
+        The number of the port to expose on the pod's IP address.
+        Must be a valid port number, between 1 and 65535 inclusive.
+        """
+        return pulumi.get(self, "container_port")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbe(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "exec":
+            suggest = "exec_"
+        elif key == "failureThreshold":
+            suggest = "failure_threshold"
+        elif key == "httpGet":
+            suggest = "http_get"
+        elif key == "initialDelaySeconds":
+            suggest = "initial_delay_seconds"
+        elif key == "periodSeconds":
+            suggest = "period_seconds"
+        elif key == "successThreshold":
+            suggest = "success_threshold"
+        elif key == "tcpSocket":
+            suggest = "tcp_socket"
+        elif key == "timeoutSeconds":
+            suggest = "timeout_seconds"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbe. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbe.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbe.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 exec_: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeExec'] = None,
+                 failure_threshold: Optional[_builtins.int] = None,
+                 grpc: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeGrpc'] = None,
+                 http_get: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGet'] = None,
+                 initial_delay_seconds: Optional[_builtins.int] = None,
+                 period_seconds: Optional[_builtins.int] = None,
+                 success_threshold: Optional[_builtins.int] = None,
+                 tcp_socket: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeTcpSocket'] = None,
+                 timeout_seconds: Optional[_builtins.int] = None):
+        """
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeExecArgs' exec_: ExecAction specifies a command to execute.
+               Structure is documented below.
+        :param _builtins.int failure_threshold: Number of consecutive failures before the probe is considered failed.
+               Defaults to 3. Minimum value is 1.
+               Maps to Kubernetes probe argument 'failureThreshold'.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeGrpcArgs' grpc: GrpcAction checks the health of a container using a gRPC service.
+               Structure is documented below.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGetArgs' http_get: HttpGetAction describes an action based on HTTP Get requests.
+               Structure is documented below.
+        :param _builtins.int initial_delay_seconds: Number of seconds to wait before starting the probe. Defaults to 0.
+               Minimum value is 0.
+               Maps to Kubernetes probe argument 'initialDelaySeconds'.
+        :param _builtins.int period_seconds: How often (in seconds) to perform the probe. Default to 10 seconds.
+               Minimum value is 1. Must be less than timeout_seconds.
+               Maps to Kubernetes probe argument 'periodSeconds'.
+        :param _builtins.int success_threshold: Number of consecutive successes before the probe is considered successful.
+               Defaults to 1. Minimum value is 1.
+               Maps to Kubernetes probe argument 'successThreshold'.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeTcpSocketArgs' tcp_socket: TcpSocketAction probes the health of a container by opening a TCP socket
+               connection.
+               Structure is documented below.
+        :param _builtins.int timeout_seconds: Number of seconds after which the probe times out. Defaults to 1 second.
+               Minimum value is 1. Must be greater or equal to period_seconds.
+               Maps to Kubernetes probe argument 'timeoutSeconds'.
+        """
+        if exec_ is not None:
+            pulumi.set(__self__, "exec_", exec_)
+        if failure_threshold is not None:
+            pulumi.set(__self__, "failure_threshold", failure_threshold)
+        if grpc is not None:
+            pulumi.set(__self__, "grpc", grpc)
+        if http_get is not None:
+            pulumi.set(__self__, "http_get", http_get)
+        if initial_delay_seconds is not None:
+            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
+        if period_seconds is not None:
+            pulumi.set(__self__, "period_seconds", period_seconds)
+        if success_threshold is not None:
+            pulumi.set(__self__, "success_threshold", success_threshold)
+        if tcp_socket is not None:
+            pulumi.set(__self__, "tcp_socket", tcp_socket)
+        if timeout_seconds is not None:
+            pulumi.set(__self__, "timeout_seconds", timeout_seconds)
+
+    @_builtins.property
+    @pulumi.getter(name="exec")
+    def exec_(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeExec']:
+        """
+        ExecAction specifies a command to execute.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "exec_")
+
+    @_builtins.property
+    @pulumi.getter(name="failureThreshold")
+    def failure_threshold(self) -> Optional[_builtins.int]:
+        """
+        Number of consecutive failures before the probe is considered failed.
+        Defaults to 3. Minimum value is 1.
+        Maps to Kubernetes probe argument 'failureThreshold'.
+        """
+        return pulumi.get(self, "failure_threshold")
+
+    @_builtins.property
+    @pulumi.getter
+    def grpc(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeGrpc']:
+        """
+        GrpcAction checks the health of a container using a gRPC service.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "grpc")
+
+    @_builtins.property
+    @pulumi.getter(name="httpGet")
+    def http_get(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGet']:
+        """
+        HttpGetAction describes an action based on HTTP Get requests.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "http_get")
+
+    @_builtins.property
+    @pulumi.getter(name="initialDelaySeconds")
+    def initial_delay_seconds(self) -> Optional[_builtins.int]:
+        """
+        Number of seconds to wait before starting the probe. Defaults to 0.
+        Minimum value is 0.
+        Maps to Kubernetes probe argument 'initialDelaySeconds'.
+        """
+        return pulumi.get(self, "initial_delay_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="periodSeconds")
+    def period_seconds(self) -> Optional[_builtins.int]:
+        """
+        How often (in seconds) to perform the probe. Default to 10 seconds.
+        Minimum value is 1. Must be less than timeout_seconds.
+        Maps to Kubernetes probe argument 'periodSeconds'.
+        """
+        return pulumi.get(self, "period_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="successThreshold")
+    def success_threshold(self) -> Optional[_builtins.int]:
+        """
+        Number of consecutive successes before the probe is considered successful.
+        Defaults to 1. Minimum value is 1.
+        Maps to Kubernetes probe argument 'successThreshold'.
+        """
+        return pulumi.get(self, "success_threshold")
+
+    @_builtins.property
+    @pulumi.getter(name="tcpSocket")
+    def tcp_socket(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeTcpSocket']:
+        """
+        TcpSocketAction probes the health of a container by opening a TCP socket
+        connection.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "tcp_socket")
+
+    @_builtins.property
+    @pulumi.getter(name="timeoutSeconds")
+    def timeout_seconds(self) -> Optional[_builtins.int]:
+        """
+        Number of seconds after which the probe times out. Defaults to 1 second.
+        Minimum value is 1. Must be greater or equal to period_seconds.
+        Maps to Kubernetes probe argument 'timeoutSeconds'.
+        """
+        return pulumi.get(self, "timeout_seconds")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeExec(dict):
+    def __init__(__self__, *,
+                 commands: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param Sequence[_builtins.str] commands: Command is the command line to execute inside the container, the working
+               directory for the command is root ('/') in the container's filesystem.
+               The command is simply exec'd, it is not run inside a shell, so
+               traditional shell instructions ('|', etc) won't work. To use a shell, you
+               need to explicitly call out to that shell. Exit status of 0 is treated as
+               live/healthy and non-zero is unhealthy.
+        """
+        if commands is not None:
+            pulumi.set(__self__, "commands", commands)
+
+    @_builtins.property
+    @pulumi.getter
+    def commands(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        Command is the command line to execute inside the container, the working
+        directory for the command is root ('/') in the container's filesystem.
+        The command is simply exec'd, it is not run inside a shell, so
+        traditional shell instructions ('|', etc) won't work. To use a shell, you
+        need to explicitly call out to that shell. Exit status of 0 is treated as
+        live/healthy and non-zero is unhealthy.
+        """
+        return pulumi.get(self, "commands")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeGrpc(dict):
+    def __init__(__self__, *,
+                 port: Optional[_builtins.int] = None,
+                 service: Optional[_builtins.str] = None):
+        """
+        :param _builtins.int port: Port number of the gRPC service. Number must be in the range 1 to 65535.
+        :param _builtins.str service: Service is the name of the service to place in the gRPC
+               HealthCheckRequest. See
+               https://github.com/grpc/grpc/blob/master/doc/health-checking.md.
+               If this is not specified, the default behavior is defined by gRPC.
+        """
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if service is not None:
+            pulumi.set(__self__, "service", service)
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
+        """
+        Port number of the gRPC service. Number must be in the range 1 to 65535.
+        """
+        return pulumi.get(self, "port")
+
+    @_builtins.property
+    @pulumi.getter
+    def service(self) -> Optional[_builtins.str]:
+        """
+        Service is the name of the service to place in the gRPC
+        HealthCheckRequest. See
+        https://github.com/grpc/grpc/blob/master/doc/health-checking.md.
+        If this is not specified, the default behavior is defined by gRPC.
+        """
+        return pulumi.get(self, "service")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGet(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "httpHeaders":
+            suggest = "http_headers"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGet. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGet.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGet.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 host: Optional[_builtins.str] = None,
+                 http_headers: Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGetHttpHeader']] = None,
+                 path: Optional[_builtins.str] = None,
+                 port: Optional[_builtins.int] = None,
+                 scheme: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str host: Host name to connect to, defaults to the model serving container's IP.
+               You probably want to set "Host" in httpHeaders instead.
+        :param Sequence['AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGetHttpHeaderArgs'] http_headers: Custom headers to set in the request. HTTP allows repeated headers.
+               Structure is documented below.
+        :param _builtins.str path: Path to access on the HTTP server.
+        :param _builtins.int port: Number of the port to access on the container.
+               Number must be in the range 1 to 65535.
+        :param _builtins.str scheme: Scheme to use for connecting to the host.
+               Defaults to HTTP. Acceptable values are "HTTP" or "HTTPS".
+        """
+        if host is not None:
+            pulumi.set(__self__, "host", host)
+        if http_headers is not None:
+            pulumi.set(__self__, "http_headers", http_headers)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if scheme is not None:
+            pulumi.set(__self__, "scheme", scheme)
+
+    @_builtins.property
+    @pulumi.getter
+    def host(self) -> Optional[_builtins.str]:
+        """
+        Host name to connect to, defaults to the model serving container's IP.
+        You probably want to set "Host" in httpHeaders instead.
+        """
+        return pulumi.get(self, "host")
+
+    @_builtins.property
+    @pulumi.getter(name="httpHeaders")
+    def http_headers(self) -> Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGetHttpHeader']]:
+        """
+        Custom headers to set in the request. HTTP allows repeated headers.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "http_headers")
+
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> Optional[_builtins.str]:
+        """
+        Path to access on the HTTP server.
+        """
+        return pulumi.get(self, "path")
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
+        """
+        Number of the port to access on the container.
+        Number must be in the range 1 to 65535.
+        """
+        return pulumi.get(self, "port")
+
+    @_builtins.property
+    @pulumi.getter
+    def scheme(self) -> Optional[_builtins.str]:
+        """
+        Scheme to use for connecting to the host.
+        Defaults to HTTP. Acceptable values are "HTTP" or "HTTPS".
+        """
+        return pulumi.get(self, "scheme")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeHttpGetHttpHeader(dict):
+    def __init__(__self__, *,
+                 name: Optional[_builtins.str] = None,
+                 value: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str name: The header field name.
+               This will be canonicalized upon output, so case-variant names will be
+               understood as the same header.
+        :param _builtins.str value: The header field value
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[_builtins.str]:
+        """
+        The header field name.
+        This will be canonicalized upon output, so case-variant names will be
+        understood as the same header.
+        """
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[_builtins.str]:
+        """
+        The header field value
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecHealthProbeTcpSocket(dict):
+    def __init__(__self__, *,
+                 host: Optional[_builtins.str] = None,
+                 port: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str host: Optional: Host name to connect to, defaults to the model serving
+               container's IP.
+        :param _builtins.int port: Number of the port to access on the container.
+               Number must be in the range 1 to 65535.
+        """
+        if host is not None:
+            pulumi.set(__self__, "host", host)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+
+    @_builtins.property
+    @pulumi.getter
+    def host(self) -> Optional[_builtins.str]:
+        """
+        Optional: Host name to connect to, defaults to the model serving
+        container's IP.
+        """
+        return pulumi.get(self, "host")
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
+        """
+        Number of the port to access on the container.
+        Number must be in the range 1 to 65535.
+        """
+        return pulumi.get(self, "port")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbe(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "exec":
+            suggest = "exec_"
+        elif key == "failureThreshold":
+            suggest = "failure_threshold"
+        elif key == "httpGet":
+            suggest = "http_get"
+        elif key == "initialDelaySeconds":
+            suggest = "initial_delay_seconds"
+        elif key == "periodSeconds":
+            suggest = "period_seconds"
+        elif key == "successThreshold":
+            suggest = "success_threshold"
+        elif key == "tcpSocket":
+            suggest = "tcp_socket"
+        elif key == "timeoutSeconds":
+            suggest = "timeout_seconds"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbe. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbe.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbe.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 exec_: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeExec'] = None,
+                 failure_threshold: Optional[_builtins.int] = None,
+                 grpc: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeGrpc'] = None,
+                 http_get: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGet'] = None,
+                 initial_delay_seconds: Optional[_builtins.int] = None,
+                 period_seconds: Optional[_builtins.int] = None,
+                 success_threshold: Optional[_builtins.int] = None,
+                 tcp_socket: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeTcpSocket'] = None,
+                 timeout_seconds: Optional[_builtins.int] = None):
+        """
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeExecArgs' exec_: ExecAction specifies a command to execute.
+               Structure is documented below.
+        :param _builtins.int failure_threshold: Number of consecutive failures before the probe is considered failed.
+               Defaults to 3. Minimum value is 1.
+               Maps to Kubernetes probe argument 'failureThreshold'.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeGrpcArgs' grpc: GrpcAction checks the health of a container using a gRPC service.
+               Structure is documented below.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGetArgs' http_get: HttpGetAction describes an action based on HTTP Get requests.
+               Structure is documented below.
+        :param _builtins.int initial_delay_seconds: Number of seconds to wait before starting the probe. Defaults to 0.
+               Minimum value is 0.
+               Maps to Kubernetes probe argument 'initialDelaySeconds'.
+        :param _builtins.int period_seconds: How often (in seconds) to perform the probe. Default to 10 seconds.
+               Minimum value is 1. Must be less than timeout_seconds.
+               Maps to Kubernetes probe argument 'periodSeconds'.
+        :param _builtins.int success_threshold: Number of consecutive successes before the probe is considered successful.
+               Defaults to 1. Minimum value is 1.
+               Maps to Kubernetes probe argument 'successThreshold'.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeTcpSocketArgs' tcp_socket: TcpSocketAction probes the health of a container by opening a TCP socket
+               connection.
+               Structure is documented below.
+        :param _builtins.int timeout_seconds: Number of seconds after which the probe times out. Defaults to 1 second.
+               Minimum value is 1. Must be greater or equal to period_seconds.
+               Maps to Kubernetes probe argument 'timeoutSeconds'.
+        """
+        if exec_ is not None:
+            pulumi.set(__self__, "exec_", exec_)
+        if failure_threshold is not None:
+            pulumi.set(__self__, "failure_threshold", failure_threshold)
+        if grpc is not None:
+            pulumi.set(__self__, "grpc", grpc)
+        if http_get is not None:
+            pulumi.set(__self__, "http_get", http_get)
+        if initial_delay_seconds is not None:
+            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
+        if period_seconds is not None:
+            pulumi.set(__self__, "period_seconds", period_seconds)
+        if success_threshold is not None:
+            pulumi.set(__self__, "success_threshold", success_threshold)
+        if tcp_socket is not None:
+            pulumi.set(__self__, "tcp_socket", tcp_socket)
+        if timeout_seconds is not None:
+            pulumi.set(__self__, "timeout_seconds", timeout_seconds)
+
+    @_builtins.property
+    @pulumi.getter(name="exec")
+    def exec_(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeExec']:
+        """
+        ExecAction specifies a command to execute.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "exec_")
+
+    @_builtins.property
+    @pulumi.getter(name="failureThreshold")
+    def failure_threshold(self) -> Optional[_builtins.int]:
+        """
+        Number of consecutive failures before the probe is considered failed.
+        Defaults to 3. Minimum value is 1.
+        Maps to Kubernetes probe argument 'failureThreshold'.
+        """
+        return pulumi.get(self, "failure_threshold")
+
+    @_builtins.property
+    @pulumi.getter
+    def grpc(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeGrpc']:
+        """
+        GrpcAction checks the health of a container using a gRPC service.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "grpc")
+
+    @_builtins.property
+    @pulumi.getter(name="httpGet")
+    def http_get(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGet']:
+        """
+        HttpGetAction describes an action based on HTTP Get requests.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "http_get")
+
+    @_builtins.property
+    @pulumi.getter(name="initialDelaySeconds")
+    def initial_delay_seconds(self) -> Optional[_builtins.int]:
+        """
+        Number of seconds to wait before starting the probe. Defaults to 0.
+        Minimum value is 0.
+        Maps to Kubernetes probe argument 'initialDelaySeconds'.
+        """
+        return pulumi.get(self, "initial_delay_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="periodSeconds")
+    def period_seconds(self) -> Optional[_builtins.int]:
+        """
+        How often (in seconds) to perform the probe. Default to 10 seconds.
+        Minimum value is 1. Must be less than timeout_seconds.
+        Maps to Kubernetes probe argument 'periodSeconds'.
+        """
+        return pulumi.get(self, "period_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="successThreshold")
+    def success_threshold(self) -> Optional[_builtins.int]:
+        """
+        Number of consecutive successes before the probe is considered successful.
+        Defaults to 1. Minimum value is 1.
+        Maps to Kubernetes probe argument 'successThreshold'.
+        """
+        return pulumi.get(self, "success_threshold")
+
+    @_builtins.property
+    @pulumi.getter(name="tcpSocket")
+    def tcp_socket(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeTcpSocket']:
+        """
+        TcpSocketAction probes the health of a container by opening a TCP socket
+        connection.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "tcp_socket")
+
+    @_builtins.property
+    @pulumi.getter(name="timeoutSeconds")
+    def timeout_seconds(self) -> Optional[_builtins.int]:
+        """
+        Number of seconds after which the probe times out. Defaults to 1 second.
+        Minimum value is 1. Must be greater or equal to period_seconds.
+        Maps to Kubernetes probe argument 'timeoutSeconds'.
+        """
+        return pulumi.get(self, "timeout_seconds")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeExec(dict):
+    def __init__(__self__, *,
+                 commands: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param Sequence[_builtins.str] commands: Command is the command line to execute inside the container, the working
+               directory for the command is root ('/') in the container's filesystem.
+               The command is simply exec'd, it is not run inside a shell, so
+               traditional shell instructions ('|', etc) won't work. To use a shell, you
+               need to explicitly call out to that shell. Exit status of 0 is treated as
+               live/healthy and non-zero is unhealthy.
+        """
+        if commands is not None:
+            pulumi.set(__self__, "commands", commands)
+
+    @_builtins.property
+    @pulumi.getter
+    def commands(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        Command is the command line to execute inside the container, the working
+        directory for the command is root ('/') in the container's filesystem.
+        The command is simply exec'd, it is not run inside a shell, so
+        traditional shell instructions ('|', etc) won't work. To use a shell, you
+        need to explicitly call out to that shell. Exit status of 0 is treated as
+        live/healthy and non-zero is unhealthy.
+        """
+        return pulumi.get(self, "commands")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeGrpc(dict):
+    def __init__(__self__, *,
+                 port: Optional[_builtins.int] = None,
+                 service: Optional[_builtins.str] = None):
+        """
+        :param _builtins.int port: Port number of the gRPC service. Number must be in the range 1 to 65535.
+        :param _builtins.str service: Service is the name of the service to place in the gRPC
+               HealthCheckRequest. See
+               https://github.com/grpc/grpc/blob/master/doc/health-checking.md.
+               If this is not specified, the default behavior is defined by gRPC.
+        """
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if service is not None:
+            pulumi.set(__self__, "service", service)
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
+        """
+        Port number of the gRPC service. Number must be in the range 1 to 65535.
+        """
+        return pulumi.get(self, "port")
+
+    @_builtins.property
+    @pulumi.getter
+    def service(self) -> Optional[_builtins.str]:
+        """
+        Service is the name of the service to place in the gRPC
+        HealthCheckRequest. See
+        https://github.com/grpc/grpc/blob/master/doc/health-checking.md.
+        If this is not specified, the default behavior is defined by gRPC.
+        """
+        return pulumi.get(self, "service")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGet(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "httpHeaders":
+            suggest = "http_headers"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGet. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGet.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGet.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 host: Optional[_builtins.str] = None,
+                 http_headers: Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGetHttpHeader']] = None,
+                 path: Optional[_builtins.str] = None,
+                 port: Optional[_builtins.int] = None,
+                 scheme: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str host: Host name to connect to, defaults to the model serving container's IP.
+               You probably want to set "Host" in httpHeaders instead.
+        :param Sequence['AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGetHttpHeaderArgs'] http_headers: Custom headers to set in the request. HTTP allows repeated headers.
+               Structure is documented below.
+        :param _builtins.str path: Path to access on the HTTP server.
+        :param _builtins.int port: Number of the port to access on the container.
+               Number must be in the range 1 to 65535.
+        :param _builtins.str scheme: Scheme to use for connecting to the host.
+               Defaults to HTTP. Acceptable values are "HTTP" or "HTTPS".
+        """
+        if host is not None:
+            pulumi.set(__self__, "host", host)
+        if http_headers is not None:
+            pulumi.set(__self__, "http_headers", http_headers)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if scheme is not None:
+            pulumi.set(__self__, "scheme", scheme)
+
+    @_builtins.property
+    @pulumi.getter
+    def host(self) -> Optional[_builtins.str]:
+        """
+        Host name to connect to, defaults to the model serving container's IP.
+        You probably want to set "Host" in httpHeaders instead.
+        """
+        return pulumi.get(self, "host")
+
+    @_builtins.property
+    @pulumi.getter(name="httpHeaders")
+    def http_headers(self) -> Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGetHttpHeader']]:
+        """
+        Custom headers to set in the request. HTTP allows repeated headers.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "http_headers")
+
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> Optional[_builtins.str]:
+        """
+        Path to access on the HTTP server.
+        """
+        return pulumi.get(self, "path")
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
+        """
+        Number of the port to access on the container.
+        Number must be in the range 1 to 65535.
+        """
+        return pulumi.get(self, "port")
+
+    @_builtins.property
+    @pulumi.getter
+    def scheme(self) -> Optional[_builtins.str]:
+        """
+        Scheme to use for connecting to the host.
+        Defaults to HTTP. Acceptable values are "HTTP" or "HTTPS".
+        """
+        return pulumi.get(self, "scheme")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeHttpGetHttpHeader(dict):
+    def __init__(__self__, *,
+                 name: Optional[_builtins.str] = None,
+                 value: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str name: The header field name.
+               This will be canonicalized upon output, so case-variant names will be
+               understood as the same header.
+        :param _builtins.str value: The header field value
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[_builtins.str]:
+        """
+        The header field name.
+        This will be canonicalized upon output, so case-variant names will be
+        understood as the same header.
+        """
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[_builtins.str]:
+        """
+        The header field value
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecLivenessProbeTcpSocket(dict):
+    def __init__(__self__, *,
+                 host: Optional[_builtins.str] = None,
+                 port: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str host: Optional: Host name to connect to, defaults to the model serving
+               container's IP.
+        :param _builtins.int port: Number of the port to access on the container.
+               Number must be in the range 1 to 65535.
+        """
+        if host is not None:
+            pulumi.set(__self__, "host", host)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+
+    @_builtins.property
+    @pulumi.getter
+    def host(self) -> Optional[_builtins.str]:
+        """
+        Optional: Host name to connect to, defaults to the model serving
+        container's IP.
+        """
+        return pulumi.get(self, "host")
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
+        """
+        Number of the port to access on the container.
+        Number must be in the range 1 to 65535.
+        """
+        return pulumi.get(self, "port")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecPort(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "containerPort":
+            suggest = "container_port"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentModelConfigContainerSpecPort. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecPort.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecPort.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 container_port: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int container_port: The number of the port to expose on the pod's IP address.
+               Must be a valid port number, between 1 and 65535 inclusive.
+        """
+        if container_port is not None:
+            pulumi.set(__self__, "container_port", container_port)
+
+    @_builtins.property
+    @pulumi.getter(name="containerPort")
+    def container_port(self) -> Optional[_builtins.int]:
+        """
+        The number of the port to expose on the pod's IP address.
+        Must be a valid port number, between 1 and 65535 inclusive.
+        """
+        return pulumi.get(self, "container_port")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbe(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "exec":
+            suggest = "exec_"
+        elif key == "failureThreshold":
+            suggest = "failure_threshold"
+        elif key == "httpGet":
+            suggest = "http_get"
+        elif key == "initialDelaySeconds":
+            suggest = "initial_delay_seconds"
+        elif key == "periodSeconds":
+            suggest = "period_seconds"
+        elif key == "successThreshold":
+            suggest = "success_threshold"
+        elif key == "tcpSocket":
+            suggest = "tcp_socket"
+        elif key == "timeoutSeconds":
+            suggest = "timeout_seconds"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbe. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbe.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbe.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 exec_: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeExec'] = None,
+                 failure_threshold: Optional[_builtins.int] = None,
+                 grpc: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeGrpc'] = None,
+                 http_get: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGet'] = None,
+                 initial_delay_seconds: Optional[_builtins.int] = None,
+                 period_seconds: Optional[_builtins.int] = None,
+                 success_threshold: Optional[_builtins.int] = None,
+                 tcp_socket: Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeTcpSocket'] = None,
+                 timeout_seconds: Optional[_builtins.int] = None):
+        """
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeExecArgs' exec_: ExecAction specifies a command to execute.
+               Structure is documented below.
+        :param _builtins.int failure_threshold: Number of consecutive failures before the probe is considered failed.
+               Defaults to 3. Minimum value is 1.
+               Maps to Kubernetes probe argument 'failureThreshold'.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeGrpcArgs' grpc: GrpcAction checks the health of a container using a gRPC service.
+               Structure is documented below.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGetArgs' http_get: HttpGetAction describes an action based on HTTP Get requests.
+               Structure is documented below.
+        :param _builtins.int initial_delay_seconds: Number of seconds to wait before starting the probe. Defaults to 0.
+               Minimum value is 0.
+               Maps to Kubernetes probe argument 'initialDelaySeconds'.
+        :param _builtins.int period_seconds: How often (in seconds) to perform the probe. Default to 10 seconds.
+               Minimum value is 1. Must be less than timeout_seconds.
+               Maps to Kubernetes probe argument 'periodSeconds'.
+        :param _builtins.int success_threshold: Number of consecutive successes before the probe is considered successful.
+               Defaults to 1. Minimum value is 1.
+               Maps to Kubernetes probe argument 'successThreshold'.
+        :param 'AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeTcpSocketArgs' tcp_socket: TcpSocketAction probes the health of a container by opening a TCP socket
+               connection.
+               Structure is documented below.
+        :param _builtins.int timeout_seconds: Number of seconds after which the probe times out. Defaults to 1 second.
+               Minimum value is 1. Must be greater or equal to period_seconds.
+               Maps to Kubernetes probe argument 'timeoutSeconds'.
+        """
+        if exec_ is not None:
+            pulumi.set(__self__, "exec_", exec_)
+        if failure_threshold is not None:
+            pulumi.set(__self__, "failure_threshold", failure_threshold)
+        if grpc is not None:
+            pulumi.set(__self__, "grpc", grpc)
+        if http_get is not None:
+            pulumi.set(__self__, "http_get", http_get)
+        if initial_delay_seconds is not None:
+            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
+        if period_seconds is not None:
+            pulumi.set(__self__, "period_seconds", period_seconds)
+        if success_threshold is not None:
+            pulumi.set(__self__, "success_threshold", success_threshold)
+        if tcp_socket is not None:
+            pulumi.set(__self__, "tcp_socket", tcp_socket)
+        if timeout_seconds is not None:
+            pulumi.set(__self__, "timeout_seconds", timeout_seconds)
+
+    @_builtins.property
+    @pulumi.getter(name="exec")
+    def exec_(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeExec']:
+        """
+        ExecAction specifies a command to execute.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "exec_")
+
+    @_builtins.property
+    @pulumi.getter(name="failureThreshold")
+    def failure_threshold(self) -> Optional[_builtins.int]:
+        """
+        Number of consecutive failures before the probe is considered failed.
+        Defaults to 3. Minimum value is 1.
+        Maps to Kubernetes probe argument 'failureThreshold'.
+        """
+        return pulumi.get(self, "failure_threshold")
+
+    @_builtins.property
+    @pulumi.getter
+    def grpc(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeGrpc']:
+        """
+        GrpcAction checks the health of a container using a gRPC service.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "grpc")
+
+    @_builtins.property
+    @pulumi.getter(name="httpGet")
+    def http_get(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGet']:
+        """
+        HttpGetAction describes an action based on HTTP Get requests.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "http_get")
+
+    @_builtins.property
+    @pulumi.getter(name="initialDelaySeconds")
+    def initial_delay_seconds(self) -> Optional[_builtins.int]:
+        """
+        Number of seconds to wait before starting the probe. Defaults to 0.
+        Minimum value is 0.
+        Maps to Kubernetes probe argument 'initialDelaySeconds'.
+        """
+        return pulumi.get(self, "initial_delay_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="periodSeconds")
+    def period_seconds(self) -> Optional[_builtins.int]:
+        """
+        How often (in seconds) to perform the probe. Default to 10 seconds.
+        Minimum value is 1. Must be less than timeout_seconds.
+        Maps to Kubernetes probe argument 'periodSeconds'.
+        """
+        return pulumi.get(self, "period_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="successThreshold")
+    def success_threshold(self) -> Optional[_builtins.int]:
+        """
+        Number of consecutive successes before the probe is considered successful.
+        Defaults to 1. Minimum value is 1.
+        Maps to Kubernetes probe argument 'successThreshold'.
+        """
+        return pulumi.get(self, "success_threshold")
+
+    @_builtins.property
+    @pulumi.getter(name="tcpSocket")
+    def tcp_socket(self) -> Optional['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeTcpSocket']:
+        """
+        TcpSocketAction probes the health of a container by opening a TCP socket
+        connection.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "tcp_socket")
+
+    @_builtins.property
+    @pulumi.getter(name="timeoutSeconds")
+    def timeout_seconds(self) -> Optional[_builtins.int]:
+        """
+        Number of seconds after which the probe times out. Defaults to 1 second.
+        Minimum value is 1. Must be greater or equal to period_seconds.
+        Maps to Kubernetes probe argument 'timeoutSeconds'.
+        """
+        return pulumi.get(self, "timeout_seconds")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeExec(dict):
+    def __init__(__self__, *,
+                 commands: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param Sequence[_builtins.str] commands: Command is the command line to execute inside the container, the working
+               directory for the command is root ('/') in the container's filesystem.
+               The command is simply exec'd, it is not run inside a shell, so
+               traditional shell instructions ('|', etc) won't work. To use a shell, you
+               need to explicitly call out to that shell. Exit status of 0 is treated as
+               live/healthy and non-zero is unhealthy.
+        """
+        if commands is not None:
+            pulumi.set(__self__, "commands", commands)
+
+    @_builtins.property
+    @pulumi.getter
+    def commands(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        Command is the command line to execute inside the container, the working
+        directory for the command is root ('/') in the container's filesystem.
+        The command is simply exec'd, it is not run inside a shell, so
+        traditional shell instructions ('|', etc) won't work. To use a shell, you
+        need to explicitly call out to that shell. Exit status of 0 is treated as
+        live/healthy and non-zero is unhealthy.
+        """
+        return pulumi.get(self, "commands")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeGrpc(dict):
+    def __init__(__self__, *,
+                 port: Optional[_builtins.int] = None,
+                 service: Optional[_builtins.str] = None):
+        """
+        :param _builtins.int port: Port number of the gRPC service. Number must be in the range 1 to 65535.
+        :param _builtins.str service: Service is the name of the service to place in the gRPC
+               HealthCheckRequest. See
+               https://github.com/grpc/grpc/blob/master/doc/health-checking.md.
+               If this is not specified, the default behavior is defined by gRPC.
+        """
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if service is not None:
+            pulumi.set(__self__, "service", service)
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
+        """
+        Port number of the gRPC service. Number must be in the range 1 to 65535.
+        """
+        return pulumi.get(self, "port")
+
+    @_builtins.property
+    @pulumi.getter
+    def service(self) -> Optional[_builtins.str]:
+        """
+        Service is the name of the service to place in the gRPC
+        HealthCheckRequest. See
+        https://github.com/grpc/grpc/blob/master/doc/health-checking.md.
+        If this is not specified, the default behavior is defined by gRPC.
+        """
+        return pulumi.get(self, "service")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGet(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "httpHeaders":
+            suggest = "http_headers"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGet. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGet.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGet.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 host: Optional[_builtins.str] = None,
+                 http_headers: Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGetHttpHeader']] = None,
+                 path: Optional[_builtins.str] = None,
+                 port: Optional[_builtins.int] = None,
+                 scheme: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str host: Host name to connect to, defaults to the model serving container's IP.
+               You probably want to set "Host" in httpHeaders instead.
+        :param Sequence['AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGetHttpHeaderArgs'] http_headers: Custom headers to set in the request. HTTP allows repeated headers.
+               Structure is documented below.
+        :param _builtins.str path: Path to access on the HTTP server.
+        :param _builtins.int port: Number of the port to access on the container.
+               Number must be in the range 1 to 65535.
+        :param _builtins.str scheme: Scheme to use for connecting to the host.
+               Defaults to HTTP. Acceptable values are "HTTP" or "HTTPS".
+        """
+        if host is not None:
+            pulumi.set(__self__, "host", host)
+        if http_headers is not None:
+            pulumi.set(__self__, "http_headers", http_headers)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if scheme is not None:
+            pulumi.set(__self__, "scheme", scheme)
+
+    @_builtins.property
+    @pulumi.getter
+    def host(self) -> Optional[_builtins.str]:
+        """
+        Host name to connect to, defaults to the model serving container's IP.
+        You probably want to set "Host" in httpHeaders instead.
+        """
+        return pulumi.get(self, "host")
+
+    @_builtins.property
+    @pulumi.getter(name="httpHeaders")
+    def http_headers(self) -> Optional[Sequence['outputs.AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGetHttpHeader']]:
+        """
+        Custom headers to set in the request. HTTP allows repeated headers.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "http_headers")
+
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> Optional[_builtins.str]:
+        """
+        Path to access on the HTTP server.
+        """
+        return pulumi.get(self, "path")
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
+        """
+        Number of the port to access on the container.
+        Number must be in the range 1 to 65535.
+        """
+        return pulumi.get(self, "port")
+
+    @_builtins.property
+    @pulumi.getter
+    def scheme(self) -> Optional[_builtins.str]:
+        """
+        Scheme to use for connecting to the host.
+        Defaults to HTTP. Acceptable values are "HTTP" or "HTTPS".
+        """
+        return pulumi.get(self, "scheme")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeHttpGetHttpHeader(dict):
+    def __init__(__self__, *,
+                 name: Optional[_builtins.str] = None,
+                 value: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str name: The header field name.
+               This will be canonicalized upon output, so case-variant names will be
+               understood as the same header.
+        :param _builtins.str value: The header field value
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[_builtins.str]:
+        """
+        The header field name.
+        This will be canonicalized upon output, so case-variant names will be
+        understood as the same header.
+        """
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[_builtins.str]:
+        """
+        The header field value
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class AiEndpointWithModelGardenDeploymentModelConfigContainerSpecStartupProbeTcpSocket(dict):
+    def __init__(__self__, *,
+                 host: Optional[_builtins.str] = None,
+                 port: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str host: Optional: Host name to connect to, defaults to the model serving
+               container's IP.
+        :param _builtins.int port: Number of the port to access on the container.
+               Number must be in the range 1 to 65535.
+        """
+        if host is not None:
+            pulumi.set(__self__, "host", host)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+
+    @_builtins.property
+    @pulumi.getter
+    def host(self) -> Optional[_builtins.str]:
+        """
+        Optional: Host name to connect to, defaults to the model serving
+        container's IP.
+        """
+        return pulumi.get(self, "host")
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.int]:
+        """
+        Number of the port to access on the container.
+        Number must be in the range 1 to 65535.
+        """
+        return pulumi.get(self, "port")
+
+
 @pulumi.output_type
 class AiFeatureGroupBigQuery(dict):
     @staticmethod