Package com.google.cloud.aiplatform.v1

Class ModelContainerSpec.Builder

java.lang.Object
com.google.protobuf.AbstractMessageLite.Builder
com.google.protobuf.AbstractMessage.Builder<BuilderT>
com.google.protobuf.GeneratedMessage.Builder<ModelContainerSpec.Builder>
com.google.cloud.aiplatform.v1.ModelContainerSpec.Builder
All Implemented Interfaces:
ModelContainerSpecOrBuilder, com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, Cloneable
Enclosing class:
ModelContainerSpec
public static final class ModelContainerSpec.Builder extends com.google.protobuf.GeneratedMessage.Builder<ModelContainerSpec.Builder> implements ModelContainerSpecOrBuilder
 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).
Protobuf type google.cloud.aiplatform.v1.ModelContainerSpec

  • Method Details

    • getDescriptor

      public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()

    • internalGetFieldAccessorTable

      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable()
      Specified by:
      internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessage.Builder<ModelContainerSpec.Builder>

    • clear

      public ModelContainerSpec.Builder clear()
      Specified by:
      clear in interface com.google.protobuf.Message.Builder
      Specified by:
      clear in interface com.google.protobuf.MessageLite.Builder
      Overrides:
      clear in class com.google.protobuf.GeneratedMessage.Builder<ModelContainerSpec.Builder>

    • getDescriptorForType

      public com.google.protobuf.Descriptors.Descriptor getDescriptorForType()
      Specified by:
      getDescriptorForType in interface com.google.protobuf.Message.Builder
      Specified by:
      getDescriptorForType in interface com.google.protobuf.MessageOrBuilder
      Overrides:
      getDescriptorForType in class com.google.protobuf.GeneratedMessage.Builder<ModelContainerSpec.Builder>

    • getDefaultInstanceForType

      public ModelContainerSpec getDefaultInstanceForType()
      Specified by:
      getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder
      Specified by:
      getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder

    • build

      public ModelContainerSpec build()
      Specified by:
      build in interface com.google.protobuf.Message.Builder
      Specified by:
      build in interface com.google.protobuf.MessageLite.Builder

    • buildPartial

      public ModelContainerSpec buildPartial()
      Specified by:
      buildPartial in interface com.google.protobuf.Message.Builder
      Specified by:
      buildPartial in interface com.google.protobuf.MessageLite.Builder

    • mergeFrom

      public ModelContainerSpec.Builder mergeFrom(com.google.protobuf.Message other)
      Specified by:
      mergeFrom in interface com.google.protobuf.Message.Builder
      Overrides:
      mergeFrom in class com.google.protobuf.AbstractMessage.Builder<ModelContainerSpec.Builder>

    • mergeFrom

      public ModelContainerSpec.Builder mergeFrom(ModelContainerSpec other)

    • isInitialized

      public final boolean isInitialized()
      Specified by:
      isInitialized in interface com.google.protobuf.MessageLiteOrBuilder
      Overrides:
      isInitialized in class com.google.protobuf.GeneratedMessage.Builder<ModelContainerSpec.Builder>

    • mergeFrom

      public ModelContainerSpec.Builder mergeFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws IOException
      Specified by:
      mergeFrom in interface com.google.protobuf.Message.Builder
      Specified by:
      mergeFrom in interface com.google.protobuf.MessageLite.Builder
      Overrides:
      mergeFrom in class com.google.protobuf.AbstractMessage.Builder<ModelContainerSpec.Builder>
      Throws:
      IOException

    • getImageUri

      public String getImageUri()
       Required. Immutable. 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][google.cloud.aiplatform.v1.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.
      string image_uri = 1 [(.google.api.field_behavior) = REQUIRED, (.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getImageUri in interface ModelContainerSpecOrBuilder
      Returns:
      The imageUri.

    • getImageUriBytes

      public com.google.protobuf.ByteString getImageUriBytes()
       Required. Immutable. 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][google.cloud.aiplatform.v1.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.
      string image_uri = 1 [(.google.api.field_behavior) = REQUIRED, (.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getImageUriBytes in interface ModelContainerSpecOrBuilder
      Returns:
      The bytes for imageUri.

    • setImageUri

      public ModelContainerSpec.Builder setImageUri(String value)
       Required. Immutable. 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][google.cloud.aiplatform.v1.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.
      string image_uri = 1 [(.google.api.field_behavior) = REQUIRED, (.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The imageUri to set.
      Returns:
      This builder for chaining.

    • clearImageUri

      public ModelContainerSpec.Builder clearImageUri()
       Required. Immutable. 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][google.cloud.aiplatform.v1.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.
      string image_uri = 1 [(.google.api.field_behavior) = REQUIRED, (.google.api.field_behavior) = IMMUTABLE];
      Returns:
      This builder for chaining.

    • setImageUriBytes

      public ModelContainerSpec.Builder setImageUriBytes(com.google.protobuf.ByteString value)
       Required. Immutable. 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][google.cloud.aiplatform.v1.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.
      string image_uri = 1 [(.google.api.field_behavior) = REQUIRED, (.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The bytes for imageUri to set.
      Returns:
      This builder for chaining.

    • getCommandList

      public com.google.protobuf.ProtocolStringList getCommandList()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string command = 2 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getCommandList in interface ModelContainerSpecOrBuilder
      Returns:
      A list containing the command.

    • getCommandCount

      public int getCommandCount()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string command = 2 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getCommandCount in interface ModelContainerSpecOrBuilder
      Returns:
      The count of command.

    • getCommand

      public String getCommand(int index)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string command = 2 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getCommand in interface ModelContainerSpecOrBuilder
      Parameters:
      index - The index of the element to return.
      Returns:
      The command at the given index.

    • getCommandBytes

      public com.google.protobuf.ByteString getCommandBytes(int index)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string command = 2 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getCommandBytes in interface ModelContainerSpecOrBuilder
      Parameters:
      index - The index of the value to return.
      Returns:
      The bytes of the command at the given index.

    • setCommand

      public ModelContainerSpec.Builder setCommand(int index, String value)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string command = 2 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      index - The index to set the value at.
      value - The command to set.
      Returns:
      This builder for chaining.

    • addCommand

      public ModelContainerSpec.Builder addCommand(String value)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string command = 2 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The command to add.
      Returns:
      This builder for chaining.

    • addAllCommand

      public ModelContainerSpec.Builder addAllCommand(Iterable<String> values)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string command = 2 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      values - The command to add.
      Returns:
      This builder for chaining.

    • clearCommand

      public ModelContainerSpec.Builder clearCommand()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string command = 2 [(.google.api.field_behavior) = IMMUTABLE];
      Returns:
      This builder for chaining.

    • addCommandBytes

      public ModelContainerSpec.Builder addCommandBytes(com.google.protobuf.ByteString value)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string command = 2 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The bytes of the command to add.
      Returns:
      This builder for chaining.

    • getArgsList

      public com.google.protobuf.ProtocolStringList getArgsList()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string args = 3 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getArgsList in interface ModelContainerSpecOrBuilder
      Returns:
      A list containing the args.

    • getArgsCount

      public int getArgsCount()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string args = 3 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getArgsCount in interface ModelContainerSpecOrBuilder
      Returns:
      The count of args.

    • getArgs

      public String getArgs(int index)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string args = 3 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getArgs in interface ModelContainerSpecOrBuilder
      Parameters:
      index - The index of the element to return.
      Returns:
      The args at the given index.

    • getArgsBytes

      public com.google.protobuf.ByteString getArgsBytes(int index)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string args = 3 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getArgsBytes in interface ModelContainerSpecOrBuilder
      Parameters:
      index - The index of the value to return.
      Returns:
      The bytes of the args at the given index.

    • setArgs

      public ModelContainerSpec.Builder setArgs(int index, String value)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string args = 3 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      index - The index to set the value at.
      value - The args to set.
      Returns:
      This builder for chaining.

    • addArgs

      public ModelContainerSpec.Builder addArgs(String value)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string args = 3 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The args to add.
      Returns:
      This builder for chaining.

    • addAllArgs

      public ModelContainerSpec.Builder addAllArgs(Iterable<String> values)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string args = 3 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      values - The args to add.
      Returns:
      This builder for chaining.

    • clearArgs

      public ModelContainerSpec.Builder clearArgs()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string args = 3 [(.google.api.field_behavior) = IMMUTABLE];
      Returns:
      This builder for chaining.

    • addArgsBytes

      public ModelContainerSpec.Builder addArgsBytes(com.google.protobuf.ByteString value)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.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][google.cloud.aiplatform.v1.ModelContainerSpec.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: <code>$(<var>VARIABLE_NAME</var>)</code> 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: <code>$$(<var>VARIABLE_NAME</var>)</code> 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).
      repeated string args = 3 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The bytes of the args to add.
      Returns:
      This builder for chaining.

    • getEnvList

      public List<EnvVar> getEnvList()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getEnvList in interface ModelContainerSpecOrBuilder

    • getEnvCount

      public int getEnvCount()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getEnvCount in interface ModelContainerSpecOrBuilder

    • getEnv

      public EnvVar getEnv(int index)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getEnv in interface ModelContainerSpecOrBuilder

    • setEnv

      public ModelContainerSpec.Builder setEnv(int index, EnvVar value)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • setEnv

      public ModelContainerSpec.Builder setEnv(int index, EnvVar.Builder builderForValue)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • addEnv

      public ModelContainerSpec.Builder addEnv(EnvVar value)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • addEnv

      public ModelContainerSpec.Builder addEnv(int index, EnvVar value)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • addEnv

      public ModelContainerSpec.Builder addEnv(EnvVar.Builder builderForValue)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • addEnv

      public ModelContainerSpec.Builder addEnv(int index, EnvVar.Builder builderForValue)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • addAllEnv

      public ModelContainerSpec.Builder addAllEnv(Iterable<? extends EnvVar> values)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • clearEnv

      public ModelContainerSpec.Builder clearEnv()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • removeEnv

      public ModelContainerSpec.Builder removeEnv(int index)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • getEnvBuilder

      public EnvVar.Builder getEnvBuilder(int index)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • getEnvOrBuilder

      public EnvVarOrBuilder getEnvOrBuilder(int index)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getEnvOrBuilder in interface ModelContainerSpecOrBuilder

    • getEnvOrBuilderList

      public List<? extends EnvVarOrBuilder> getEnvOrBuilderList()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getEnvOrBuilderList in interface ModelContainerSpecOrBuilder

    • addEnvBuilder

      public EnvVar.Builder addEnvBuilder()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • addEnvBuilder

      public EnvVar.Builder addEnvBuilder(int index)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • getEnvBuilderList

      public List<EnvVar.Builder> getEnvBuilderList()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.command] and
 [args][google.cloud.aiplatform.v1.ModelContainerSpec.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).
      repeated .google.cloud.aiplatform.v1.EnvVar env = 4 [(.google.api.field_behavior) = IMMUTABLE];

    • getPortsList

      public List<Port> getPortsList()
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getPortsList in interface ModelContainerSpecOrBuilder

    • getPortsCount

      public int getPortsCount()
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getPortsCount in interface ModelContainerSpecOrBuilder

    • getPorts

      public Port getPorts(int index)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getPorts in interface ModelContainerSpecOrBuilder

    • setPorts

      public ModelContainerSpec.Builder setPorts(int index, Port value)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • setPorts

      public ModelContainerSpec.Builder setPorts(int index, Port.Builder builderForValue)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • addPorts

      public ModelContainerSpec.Builder addPorts(Port value)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • addPorts

      public ModelContainerSpec.Builder addPorts(int index, Port value)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • addPorts

      public ModelContainerSpec.Builder addPorts(Port.Builder builderForValue)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • addPorts

      public ModelContainerSpec.Builder addPorts(int index, Port.Builder builderForValue)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • addAllPorts

      public ModelContainerSpec.Builder addAllPorts(Iterable<? extends Port> values)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • clearPorts

      public ModelContainerSpec.Builder clearPorts()
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • removePorts

      public ModelContainerSpec.Builder removePorts(int index)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • getPortsBuilder

      public Port.Builder getPortsBuilder(int index)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • getPortsOrBuilder

      public PortOrBuilder getPortsOrBuilder(int index)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getPortsOrBuilder in interface ModelContainerSpecOrBuilder

    • getPortsOrBuilderList

      public List<? extends PortOrBuilder> getPortsOrBuilderList()
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getPortsOrBuilderList in interface ModelContainerSpecOrBuilder

    • addPortsBuilder

      public Port.Builder addPortsBuilder()
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • addPortsBuilder

      public Port.Builder addPortsBuilder(int index)
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • getPortsBuilderList

      public List<Port.Builder> getPortsBuilderList()
       Immutable. 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).
      repeated .google.cloud.aiplatform.v1.Port ports = 5 [(.google.api.field_behavior) = IMMUTABLE];

    • getPredictRoute

      public String getPredictRoute()
       Immutable. HTTP path on the container to send prediction requests to.
 Vertex AI forwards requests sent using
 [projects.locations.endpoints.predict][google.cloud.aiplatform.v1.PredictionService.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][google.cloud.aiplatform.v1.ModelContainerSpec.ports] field.

 If you don't specify this field, it defaults to the following value when
 you [deploy this Model to an
 Endpoint][google.cloud.aiplatform.v1.EndpointService.DeployModel]:
 <code>/v1/endpoints/<var>ENDPOINT</var>/deployedModels/<var>DEPLOYED_MODEL</var>:predict</code>
 The placeholders in this value are replaced as follows:

 * <var>ENDPOINT</var>: 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).)

 * <var>DEPLOYED_MODEL</var>:
 [DeployedModel.id][google.cloud.aiplatform.v1.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).)
      string predict_route = 6 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getPredictRoute in interface ModelContainerSpecOrBuilder
      Returns:
      The predictRoute.

    • getPredictRouteBytes

      public com.google.protobuf.ByteString getPredictRouteBytes()
       Immutable. HTTP path on the container to send prediction requests to.
 Vertex AI forwards requests sent using
 [projects.locations.endpoints.predict][google.cloud.aiplatform.v1.PredictionService.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][google.cloud.aiplatform.v1.ModelContainerSpec.ports] field.

 If you don't specify this field, it defaults to the following value when
 you [deploy this Model to an
 Endpoint][google.cloud.aiplatform.v1.EndpointService.DeployModel]:
 <code>/v1/endpoints/<var>ENDPOINT</var>/deployedModels/<var>DEPLOYED_MODEL</var>:predict</code>
 The placeholders in this value are replaced as follows:

 * <var>ENDPOINT</var>: 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).)

 * <var>DEPLOYED_MODEL</var>:
 [DeployedModel.id][google.cloud.aiplatform.v1.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).)
      string predict_route = 6 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getPredictRouteBytes in interface ModelContainerSpecOrBuilder
      Returns:
      The bytes for predictRoute.

    • setPredictRoute

      public ModelContainerSpec.Builder setPredictRoute(String value)
       Immutable. HTTP path on the container to send prediction requests to.
 Vertex AI forwards requests sent using
 [projects.locations.endpoints.predict][google.cloud.aiplatform.v1.PredictionService.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][google.cloud.aiplatform.v1.ModelContainerSpec.ports] field.

 If you don't specify this field, it defaults to the following value when
 you [deploy this Model to an
 Endpoint][google.cloud.aiplatform.v1.EndpointService.DeployModel]:
 <code>/v1/endpoints/<var>ENDPOINT</var>/deployedModels/<var>DEPLOYED_MODEL</var>:predict</code>
 The placeholders in this value are replaced as follows:

 * <var>ENDPOINT</var>: 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).)

 * <var>DEPLOYED_MODEL</var>:
 [DeployedModel.id][google.cloud.aiplatform.v1.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).)
      string predict_route = 6 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The predictRoute to set.
      Returns:
      This builder for chaining.

    • clearPredictRoute

      public ModelContainerSpec.Builder clearPredictRoute()
       Immutable. HTTP path on the container to send prediction requests to.
 Vertex AI forwards requests sent using
 [projects.locations.endpoints.predict][google.cloud.aiplatform.v1.PredictionService.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][google.cloud.aiplatform.v1.ModelContainerSpec.ports] field.

 If you don't specify this field, it defaults to the following value when
 you [deploy this Model to an
 Endpoint][google.cloud.aiplatform.v1.EndpointService.DeployModel]:
 <code>/v1/endpoints/<var>ENDPOINT</var>/deployedModels/<var>DEPLOYED_MODEL</var>:predict</code>
 The placeholders in this value are replaced as follows:

 * <var>ENDPOINT</var>: 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).)

 * <var>DEPLOYED_MODEL</var>:
 [DeployedModel.id][google.cloud.aiplatform.v1.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).)
      string predict_route = 6 [(.google.api.field_behavior) = IMMUTABLE];
      Returns:
      This builder for chaining.

    • setPredictRouteBytes

      public ModelContainerSpec.Builder setPredictRouteBytes(com.google.protobuf.ByteString value)
       Immutable. HTTP path on the container to send prediction requests to.
 Vertex AI forwards requests sent using
 [projects.locations.endpoints.predict][google.cloud.aiplatform.v1.PredictionService.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][google.cloud.aiplatform.v1.ModelContainerSpec.ports] field.

 If you don't specify this field, it defaults to the following value when
 you [deploy this Model to an
 Endpoint][google.cloud.aiplatform.v1.EndpointService.DeployModel]:
 <code>/v1/endpoints/<var>ENDPOINT</var>/deployedModels/<var>DEPLOYED_MODEL</var>:predict</code>
 The placeholders in this value are replaced as follows:

 * <var>ENDPOINT</var>: 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).)

 * <var>DEPLOYED_MODEL</var>:
 [DeployedModel.id][google.cloud.aiplatform.v1.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).)
      string predict_route = 6 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The bytes for predictRoute to set.
      Returns:
      This builder for chaining.

    • getHealthRoute

      public String getHealthRoute()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.ports] field.

 If you don't specify this field, it defaults to the following value when
 you [deploy this Model to an
 Endpoint][google.cloud.aiplatform.v1.EndpointService.DeployModel]:
 <code>/v1/endpoints/<var>ENDPOINT</var>/deployedModels/<var>DEPLOYED_MODEL</var>:predict</code>
 The placeholders in this value are replaced as follows:

 * <var>ENDPOINT</var>: 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).)

 * <var>DEPLOYED_MODEL</var>:
 [DeployedModel.id][google.cloud.aiplatform.v1.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).)
      string health_route = 7 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getHealthRoute in interface ModelContainerSpecOrBuilder
      Returns:
      The healthRoute.

    • getHealthRouteBytes

      public com.google.protobuf.ByteString getHealthRouteBytes()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.ports] field.

 If you don't specify this field, it defaults to the following value when
 you [deploy this Model to an
 Endpoint][google.cloud.aiplatform.v1.EndpointService.DeployModel]:
 <code>/v1/endpoints/<var>ENDPOINT</var>/deployedModels/<var>DEPLOYED_MODEL</var>:predict</code>
 The placeholders in this value are replaced as follows:

 * <var>ENDPOINT</var>: 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).)

 * <var>DEPLOYED_MODEL</var>:
 [DeployedModel.id][google.cloud.aiplatform.v1.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).)
      string health_route = 7 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getHealthRouteBytes in interface ModelContainerSpecOrBuilder
      Returns:
      The bytes for healthRoute.

    • setHealthRoute

      public ModelContainerSpec.Builder setHealthRoute(String value)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.ports] field.

 If you don't specify this field, it defaults to the following value when
 you [deploy this Model to an
 Endpoint][google.cloud.aiplatform.v1.EndpointService.DeployModel]:
 <code>/v1/endpoints/<var>ENDPOINT</var>/deployedModels/<var>DEPLOYED_MODEL</var>:predict</code>
 The placeholders in this value are replaced as follows:

 * <var>ENDPOINT</var>: 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).)

 * <var>DEPLOYED_MODEL</var>:
 [DeployedModel.id][google.cloud.aiplatform.v1.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).)
      string health_route = 7 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The healthRoute to set.
      Returns:
      This builder for chaining.

    • clearHealthRoute

      public ModelContainerSpec.Builder clearHealthRoute()
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.ports] field.

 If you don't specify this field, it defaults to the following value when
 you [deploy this Model to an
 Endpoint][google.cloud.aiplatform.v1.EndpointService.DeployModel]:
 <code>/v1/endpoints/<var>ENDPOINT</var>/deployedModels/<var>DEPLOYED_MODEL</var>:predict</code>
 The placeholders in this value are replaced as follows:

 * <var>ENDPOINT</var>: 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).)

 * <var>DEPLOYED_MODEL</var>:
 [DeployedModel.id][google.cloud.aiplatform.v1.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).)
      string health_route = 7 [(.google.api.field_behavior) = IMMUTABLE];
      Returns:
      This builder for chaining.

    • setHealthRouteBytes

      public ModelContainerSpec.Builder setHealthRouteBytes(com.google.protobuf.ByteString value)
       Immutable. 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][google.cloud.aiplatform.v1.ModelContainerSpec.ports] field.

 If you don't specify this field, it defaults to the following value when
 you [deploy this Model to an
 Endpoint][google.cloud.aiplatform.v1.EndpointService.DeployModel]:
 <code>/v1/endpoints/<var>ENDPOINT</var>/deployedModels/<var>DEPLOYED_MODEL</var>:predict</code>
 The placeholders in this value are replaced as follows:

 * <var>ENDPOINT</var>: 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).)

 * <var>DEPLOYED_MODEL</var>:
 [DeployedModel.id][google.cloud.aiplatform.v1.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).)
      string health_route = 7 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The bytes for healthRoute to set.
      Returns:
      This builder for chaining.

    • getInvokeRoutePrefix

      public String getInvokeRoutePrefix()
       Immutable. Invoke route prefix for the custom container. "/*" is the only
 supported value right now. By setting this field, any non-root route on
 this model will be accessible with invoke http call eg: "/invoke/foo/bar",
 however the [PredictionService.Invoke] RPC is not supported yet.

 Only one of `predict_route` or `invoke_route_prefix` can be set, and we
 default to using `predict_route` if this field is not set. If this field
 is set, the Model can only be deployed to dedicated endpoint.
      string invoke_route_prefix = 15 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getInvokeRoutePrefix in interface ModelContainerSpecOrBuilder
      Returns:
      The invokeRoutePrefix.

    • getInvokeRoutePrefixBytes

      public com.google.protobuf.ByteString getInvokeRoutePrefixBytes()
       Immutable. Invoke route prefix for the custom container. "/*" is the only
 supported value right now. By setting this field, any non-root route on
 this model will be accessible with invoke http call eg: "/invoke/foo/bar",
 however the [PredictionService.Invoke] RPC is not supported yet.

 Only one of `predict_route` or `invoke_route_prefix` can be set, and we
 default to using `predict_route` if this field is not set. If this field
 is set, the Model can only be deployed to dedicated endpoint.
      string invoke_route_prefix = 15 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getInvokeRoutePrefixBytes in interface ModelContainerSpecOrBuilder
      Returns:
      The bytes for invokeRoutePrefix.

    • setInvokeRoutePrefix

      public ModelContainerSpec.Builder setInvokeRoutePrefix(String value)
       Immutable. Invoke route prefix for the custom container. "/*" is the only
 supported value right now. By setting this field, any non-root route on
 this model will be accessible with invoke http call eg: "/invoke/foo/bar",
 however the [PredictionService.Invoke] RPC is not supported yet.

 Only one of `predict_route` or `invoke_route_prefix` can be set, and we
 default to using `predict_route` if this field is not set. If this field
 is set, the Model can only be deployed to dedicated endpoint.
      string invoke_route_prefix = 15 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The invokeRoutePrefix to set.
      Returns:
      This builder for chaining.

    • clearInvokeRoutePrefix

      public ModelContainerSpec.Builder clearInvokeRoutePrefix()
       Immutable. Invoke route prefix for the custom container. "/*" is the only
 supported value right now. By setting this field, any non-root route on
 this model will be accessible with invoke http call eg: "/invoke/foo/bar",
 however the [PredictionService.Invoke] RPC is not supported yet.

 Only one of `predict_route` or `invoke_route_prefix` can be set, and we
 default to using `predict_route` if this field is not set. If this field
 is set, the Model can only be deployed to dedicated endpoint.
      string invoke_route_prefix = 15 [(.google.api.field_behavior) = IMMUTABLE];
      Returns:
      This builder for chaining.

    • setInvokeRoutePrefixBytes

      public ModelContainerSpec.Builder setInvokeRoutePrefixBytes(com.google.protobuf.ByteString value)
       Immutable. Invoke route prefix for the custom container. "/*" is the only
 supported value right now. By setting this field, any non-root route on
 this model will be accessible with invoke http call eg: "/invoke/foo/bar",
 however the [PredictionService.Invoke] RPC is not supported yet.

 Only one of `predict_route` or `invoke_route_prefix` can be set, and we
 default to using `predict_route` if this field is not set. If this field
 is set, the Model can only be deployed to dedicated endpoint.
      string invoke_route_prefix = 15 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The bytes for invokeRoutePrefix to set.
      Returns:
      This builder for chaining.

    • getGrpcPortsList

      public List<Port> getGrpcPortsList()
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getGrpcPortsList in interface ModelContainerSpecOrBuilder

    • getGrpcPortsCount

      public int getGrpcPortsCount()
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getGrpcPortsCount in interface ModelContainerSpecOrBuilder

    • getGrpcPorts

      public Port getGrpcPorts(int index)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getGrpcPorts in interface ModelContainerSpecOrBuilder

    • setGrpcPorts

      public ModelContainerSpec.Builder setGrpcPorts(int index, Port value)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • setGrpcPorts

      public ModelContainerSpec.Builder setGrpcPorts(int index, Port.Builder builderForValue)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • addGrpcPorts

      public ModelContainerSpec.Builder addGrpcPorts(Port value)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • addGrpcPorts

      public ModelContainerSpec.Builder addGrpcPorts(int index, Port value)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • addGrpcPorts

      public ModelContainerSpec.Builder addGrpcPorts(Port.Builder builderForValue)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • addGrpcPorts

      public ModelContainerSpec.Builder addGrpcPorts(int index, Port.Builder builderForValue)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • addAllGrpcPorts

      public ModelContainerSpec.Builder addAllGrpcPorts(Iterable<? extends Port> values)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • clearGrpcPorts

      public ModelContainerSpec.Builder clearGrpcPorts()
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • removeGrpcPorts

      public ModelContainerSpec.Builder removeGrpcPorts(int index)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • getGrpcPortsBuilder

      public Port.Builder getGrpcPortsBuilder(int index)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • getGrpcPortsOrBuilder

      public PortOrBuilder getGrpcPortsOrBuilder(int index)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getGrpcPortsOrBuilder in interface ModelContainerSpecOrBuilder

    • getGrpcPortsOrBuilderList

      public List<? extends PortOrBuilder> getGrpcPortsOrBuilderList()
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getGrpcPortsOrBuilderList in interface ModelContainerSpecOrBuilder

    • addGrpcPortsBuilder

      public Port.Builder addGrpcPortsBuilder()
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • addGrpcPortsBuilder

      public Port.Builder addGrpcPortsBuilder(int index)
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • getGrpcPortsBuilderList

      public List<Port.Builder> getGrpcPortsBuilderList()
       Immutable. 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.
      repeated .google.cloud.aiplatform.v1.Port grpc_ports = 9 [(.google.api.field_behavior) = IMMUTABLE];

    • hasDeploymentTimeout

      public boolean hasDeploymentTimeout()
       Immutable. Deployment timeout.
 Limit for deployment timeout is 2 hours.
      .google.protobuf.Duration deployment_timeout = 10 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      hasDeploymentTimeout in interface ModelContainerSpecOrBuilder
      Returns:
      Whether the deploymentTimeout field is set.

    • getDeploymentTimeout

      public com.google.protobuf.Duration getDeploymentTimeout()
       Immutable. Deployment timeout.
 Limit for deployment timeout is 2 hours.
      .google.protobuf.Duration deployment_timeout = 10 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getDeploymentTimeout in interface ModelContainerSpecOrBuilder
      Returns:
      The deploymentTimeout.

    • setDeploymentTimeout

      public ModelContainerSpec.Builder setDeploymentTimeout(com.google.protobuf.Duration value)
       Immutable. Deployment timeout.
 Limit for deployment timeout is 2 hours.
      .google.protobuf.Duration deployment_timeout = 10 [(.google.api.field_behavior) = IMMUTABLE];

    • setDeploymentTimeout

      public ModelContainerSpec.Builder setDeploymentTimeout(com.google.protobuf.Duration.Builder builderForValue)
       Immutable. Deployment timeout.
 Limit for deployment timeout is 2 hours.
      .google.protobuf.Duration deployment_timeout = 10 [(.google.api.field_behavior) = IMMUTABLE];

    • mergeDeploymentTimeout

      public ModelContainerSpec.Builder mergeDeploymentTimeout(com.google.protobuf.Duration value)
       Immutable. Deployment timeout.
 Limit for deployment timeout is 2 hours.
      .google.protobuf.Duration deployment_timeout = 10 [(.google.api.field_behavior) = IMMUTABLE];

    • clearDeploymentTimeout

      public ModelContainerSpec.Builder clearDeploymentTimeout()
       Immutable. Deployment timeout.
 Limit for deployment timeout is 2 hours.
      .google.protobuf.Duration deployment_timeout = 10 [(.google.api.field_behavior) = IMMUTABLE];

    • getDeploymentTimeoutBuilder

      public com.google.protobuf.Duration.Builder getDeploymentTimeoutBuilder()
       Immutable. Deployment timeout.
 Limit for deployment timeout is 2 hours.
      .google.protobuf.Duration deployment_timeout = 10 [(.google.api.field_behavior) = IMMUTABLE];

    • getDeploymentTimeoutOrBuilder

      public com.google.protobuf.DurationOrBuilder getDeploymentTimeoutOrBuilder()
       Immutable. Deployment timeout.
 Limit for deployment timeout is 2 hours.
      .google.protobuf.Duration deployment_timeout = 10 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getDeploymentTimeoutOrBuilder in interface ModelContainerSpecOrBuilder

    • getSharedMemorySizeMb

      public long getSharedMemorySizeMb()
       Immutable. The amount of the VM memory to reserve as the shared memory for
 the model in megabytes.
      int64 shared_memory_size_mb = 11 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getSharedMemorySizeMb in interface ModelContainerSpecOrBuilder
      Returns:
      The sharedMemorySizeMb.

    • setSharedMemorySizeMb

      public ModelContainerSpec.Builder setSharedMemorySizeMb(long value)
       Immutable. The amount of the VM memory to reserve as the shared memory for
 the model in megabytes.
      int64 shared_memory_size_mb = 11 [(.google.api.field_behavior) = IMMUTABLE];
      Parameters:
      value - The sharedMemorySizeMb to set.
      Returns:
      This builder for chaining.

    • clearSharedMemorySizeMb

      public ModelContainerSpec.Builder clearSharedMemorySizeMb()
       Immutable. The amount of the VM memory to reserve as the shared memory for
 the model in megabytes.
      int64 shared_memory_size_mb = 11 [(.google.api.field_behavior) = IMMUTABLE];
      Returns:
      This builder for chaining.

    • hasStartupProbe

      public boolean hasStartupProbe()
       Immutable. Specification for Kubernetes startup probe.
      .google.cloud.aiplatform.v1.Probe startup_probe = 12 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      hasStartupProbe in interface ModelContainerSpecOrBuilder
      Returns:
      Whether the startupProbe field is set.

    • getStartupProbe

      public Probe getStartupProbe()
       Immutable. Specification for Kubernetes startup probe.
      .google.cloud.aiplatform.v1.Probe startup_probe = 12 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getStartupProbe in interface ModelContainerSpecOrBuilder
      Returns:
      The startupProbe.

    • setStartupProbe

      public ModelContainerSpec.Builder setStartupProbe(Probe value)
       Immutable. Specification for Kubernetes startup probe.
      .google.cloud.aiplatform.v1.Probe startup_probe = 12 [(.google.api.field_behavior) = IMMUTABLE];

    • setStartupProbe

      public ModelContainerSpec.Builder setStartupProbe(Probe.Builder builderForValue)
       Immutable. Specification for Kubernetes startup probe.
      .google.cloud.aiplatform.v1.Probe startup_probe = 12 [(.google.api.field_behavior) = IMMUTABLE];

    • mergeStartupProbe

      public ModelContainerSpec.Builder mergeStartupProbe(Probe value)
       Immutable. Specification for Kubernetes startup probe.
      .google.cloud.aiplatform.v1.Probe startup_probe = 12 [(.google.api.field_behavior) = IMMUTABLE];

    • clearStartupProbe

      public ModelContainerSpec.Builder clearStartupProbe()
       Immutable. Specification for Kubernetes startup probe.
      .google.cloud.aiplatform.v1.Probe startup_probe = 12 [(.google.api.field_behavior) = IMMUTABLE];

    • getStartupProbeBuilder

      public Probe.Builder getStartupProbeBuilder()
       Immutable. Specification for Kubernetes startup probe.
      .google.cloud.aiplatform.v1.Probe startup_probe = 12 [(.google.api.field_behavior) = IMMUTABLE];

    • getStartupProbeOrBuilder

      public ProbeOrBuilder getStartupProbeOrBuilder()
       Immutable. Specification for Kubernetes startup probe.
      .google.cloud.aiplatform.v1.Probe startup_probe = 12 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getStartupProbeOrBuilder in interface ModelContainerSpecOrBuilder

    • hasHealthProbe

      public boolean hasHealthProbe()
       Immutable. Specification for Kubernetes readiness probe.
      .google.cloud.aiplatform.v1.Probe health_probe = 13 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      hasHealthProbe in interface ModelContainerSpecOrBuilder
      Returns:
      Whether the healthProbe field is set.

    • getHealthProbe

      public Probe getHealthProbe()
       Immutable. Specification for Kubernetes readiness probe.
      .google.cloud.aiplatform.v1.Probe health_probe = 13 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getHealthProbe in interface ModelContainerSpecOrBuilder
      Returns:
      The healthProbe.

    • setHealthProbe

      public ModelContainerSpec.Builder setHealthProbe(Probe value)
       Immutable. Specification for Kubernetes readiness probe.
      .google.cloud.aiplatform.v1.Probe health_probe = 13 [(.google.api.field_behavior) = IMMUTABLE];

    • setHealthProbe

      public ModelContainerSpec.Builder setHealthProbe(Probe.Builder builderForValue)
       Immutable. Specification for Kubernetes readiness probe.
      .google.cloud.aiplatform.v1.Probe health_probe = 13 [(.google.api.field_behavior) = IMMUTABLE];

    • mergeHealthProbe

      public ModelContainerSpec.Builder mergeHealthProbe(Probe value)
       Immutable. Specification for Kubernetes readiness probe.
      .google.cloud.aiplatform.v1.Probe health_probe = 13 [(.google.api.field_behavior) = IMMUTABLE];

    • clearHealthProbe

      public ModelContainerSpec.Builder clearHealthProbe()
       Immutable. Specification for Kubernetes readiness probe.
      .google.cloud.aiplatform.v1.Probe health_probe = 13 [(.google.api.field_behavior) = IMMUTABLE];

    • getHealthProbeBuilder

      public Probe.Builder getHealthProbeBuilder()
       Immutable. Specification for Kubernetes readiness probe.
      .google.cloud.aiplatform.v1.Probe health_probe = 13 [(.google.api.field_behavior) = IMMUTABLE];

    • getHealthProbeOrBuilder

      public ProbeOrBuilder getHealthProbeOrBuilder()
       Immutable. Specification for Kubernetes readiness probe.
      .google.cloud.aiplatform.v1.Probe health_probe = 13 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getHealthProbeOrBuilder in interface ModelContainerSpecOrBuilder

    • hasLivenessProbe

      public boolean hasLivenessProbe()
       Immutable. Specification for Kubernetes liveness probe.
      .google.cloud.aiplatform.v1.Probe liveness_probe = 14 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      hasLivenessProbe in interface ModelContainerSpecOrBuilder
      Returns:
      Whether the livenessProbe field is set.

    • getLivenessProbe

      public Probe getLivenessProbe()
       Immutable. Specification for Kubernetes liveness probe.
      .google.cloud.aiplatform.v1.Probe liveness_probe = 14 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getLivenessProbe in interface ModelContainerSpecOrBuilder
      Returns:
      The livenessProbe.

    • setLivenessProbe

      public ModelContainerSpec.Builder setLivenessProbe(Probe value)
       Immutable. Specification for Kubernetes liveness probe.
      .google.cloud.aiplatform.v1.Probe liveness_probe = 14 [(.google.api.field_behavior) = IMMUTABLE];

    • setLivenessProbe

      public ModelContainerSpec.Builder setLivenessProbe(Probe.Builder builderForValue)
       Immutable. Specification for Kubernetes liveness probe.
      .google.cloud.aiplatform.v1.Probe liveness_probe = 14 [(.google.api.field_behavior) = IMMUTABLE];

    • mergeLivenessProbe

      public ModelContainerSpec.Builder mergeLivenessProbe(Probe value)
       Immutable. Specification for Kubernetes liveness probe.
      .google.cloud.aiplatform.v1.Probe liveness_probe = 14 [(.google.api.field_behavior) = IMMUTABLE];

    • clearLivenessProbe

      public ModelContainerSpec.Builder clearLivenessProbe()
       Immutable. Specification for Kubernetes liveness probe.
      .google.cloud.aiplatform.v1.Probe liveness_probe = 14 [(.google.api.field_behavior) = IMMUTABLE];

    • getLivenessProbeBuilder

      public Probe.Builder getLivenessProbeBuilder()
       Immutable. Specification for Kubernetes liveness probe.
      .google.cloud.aiplatform.v1.Probe liveness_probe = 14 [(.google.api.field_behavior) = IMMUTABLE];

    • getLivenessProbeOrBuilder

      public ProbeOrBuilder getLivenessProbeOrBuilder()
       Immutable. Specification for Kubernetes liveness probe.
      .google.cloud.aiplatform.v1.Probe liveness_probe = 14 [(.google.api.field_behavior) = IMMUTABLE];
      Specified by:
      getLivenessProbeOrBuilder in interface ModelContainerSpecOrBuilder