> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nebius.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Create

> Creates a Devlab.



## OpenAPI

````yaml https://api.nebius.cloud/openapi.json post /ai/v1/devlabs
openapi: 3.0.3
info:
  title: Nebius API
  version: version not set
servers:
  - url: https://api.nebius.cloud
security:
  - bearerAuth: []
tags:
  - name: nebius.ai.v1.DevlabService
  - name: nebius.ai.v1.EndpointService
  - name: nebius.ai.v1.JobService
  - name: nebius.applications.v1alpha1.K8sReleaseService
  - name: nebius.applications.v1alpha1.VmAppTemplateService
  - name: nebius.audit.v2.AuditEventExportService
  - name: nebius.audit.v2.AuditEventService
  - name: nebius.billing.v1.CalculatorService
  - name: nebius.billing.v1alpha1.CalculatorService
  - name: nebius.billing.v1alpha1.OneTimeExportService
  - name: nebius.capacity.v1.CapacityAllowanceService
  - name: nebius.capacity.v1.CapacityBlockGroupService
  - name: nebius.capacity.v1.CapacityIntervalService
  - name: nebius.capacity.v1.ResourceAdviceService
  - name: nebius.compute.v1.DiskService
  - name: nebius.compute.v1.DiskSnapshotService
  - name: nebius.compute.v1.FilesystemService
  - name: nebius.compute.v1.GpuClusterService
  - name: nebius.compute.v1.ImageService
  - name: nebius.compute.v1.InstanceService
  - name: nebius.compute.v1.MaintenanceService
  - name: nebius.compute.v1.NVLInstanceGroupService
  - name: nebius.compute.v1.NodeService
  - name: nebius.compute.v1.PlatformService
  - name: nebius.dns.v1.RecordService
  - name: nebius.dns.v1.ZoneService
  - name: nebius.iam.v1.AccessKeyService
  - name: nebius.iam.v1.AccessPermitService
  - name: nebius.iam.v1.AuthPublicKeyService
  - name: nebius.iam.v1.FederatedCredentialsService
  - name: nebius.iam.v1.FederationCertificateService
  - name: nebius.iam.v1.FederationService
  - name: nebius.iam.v1.GroupMembershipService
  - name: nebius.iam.v1.GroupService
  - name: nebius.iam.v1.InvitationService
  - name: nebius.iam.v1.ProfileService
  - name: nebius.iam.v1.ProjectService
  - name: nebius.iam.v1.ServiceAccountService
  - name: nebius.iam.v1.SessionManagementService
  - name: nebius.iam.v1.StaticKeyService
  - name: nebius.iam.v1.TenantService
  - name: nebius.iam.v1.TenantUserAccountService
  - name: nebius.iam.v1.TenantUserAccountWithAttributesService
  - name: nebius.iam.v2.AccessKeyService
  - name: nebius.iam.v2.ProjectService
  - name: nebius.iam.v2.TenantService
  - name: nebius.kms.v1.AsymmetricCryptoService
  - name: nebius.kms.v1.AsymmetricKeyService
  - name: nebius.kms.v1.SymmetricCryptoService
  - name: nebius.kms.v1.SymmetricKeyService
  - name: nebius.logging.agentmanager.v1.VersionService
  - name: nebius.logging.v1.LogExportService
  - name: nebius.maintenance.v1alpha1.MaintenanceService
  - name: nebius.mk8s.v1.ClusterService
  - name: nebius.mk8s.v1.NodeGroupService
  - name: nebius.mk8s.v1alpha1.ClusterService
  - name: nebius.mk8s.v1alpha1.NodeGroupService
  - name: nebius.monitoring.v1.RecordingRuleService
  - name: nebius.msp.mlflow.v1alpha1.ClusterService
  - name: nebius.msp.postgresql.v1alpha1.BackupService
  - name: nebius.msp.postgresql.v1alpha1.ClusterService
  - name: nebius.mysterybox.v1.PayloadService
  - name: nebius.mysterybox.v1.SecretService
  - name: nebius.mysterybox.v1.SecretVersionService
  - name: nebius.quotas.v1.QuotaAllowanceService
  - name: nebius.registry.v1.ArtifactService
  - name: nebius.registry.v1.RegistryService
  - name: nebius.storage.v1.BucketService
  - name: nebius.storage.v1.InventoryService
  - name: nebius.storage.v1.TransferService
  - name: nebius.storage.v1alpha1.TransferService
  - name: nebius.tunnel.v1.TunnelService
  - name: nebius.vpc.v1.AllocationService
  - name: nebius.vpc.v1.NetworkService
  - name: nebius.vpc.v1.PoolService
  - name: nebius.vpc.v1.RouteService
  - name: nebius.vpc.v1.RouteTableService
  - name: nebius.vpc.v1.SecurityGroupService
  - name: nebius.vpc.v1.SecurityRuleService
  - name: nebius.vpc.v1.SubnetService
  - name: nebius.vpc.v1.TargetGroupService
  - name: nebius.vpc.v1alpha1.AllocationService
  - name: nebius.vpc.v1alpha1.NetworkService
  - name: nebius.vpc.v1alpha1.PoolService
  - name: nebius.vpc.v1alpha1.ScopeService
  - name: nebius.vpc.v1alpha1.SubnetService
paths:
  /ai/v1/devlabs:
    post:
      tags:
        - nebius.ai.v1.DevlabService
      summary: Create
      description: Creates a Devlab.
      operationId: DevlabService_Create
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/nebius.ai.v1.CreateDevlabRequest'
        description: A request to create a Devlab.
        required: true
        x-originalParamName: body
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/nebius.common.v1.Operation'
          description: A successful response.
components:
  schemas:
    nebius.ai.v1.CreateDevlabRequest:
      description: A request to create a Devlab.
      properties:
        dryRun:
          description: Validates the request without creating the Devlab.
          type: boolean
        metadata:
          allOf:
            - $ref: '#/components/schemas/nebius.common.v1.ResourceMetadata'
          description: The metadata for the new Devlab.
        spec:
          allOf:
            - $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec'
          description: The configuration for the new Devlab.
      required:
        - metadata
        - spec
      type: object
    nebius.common.v1.Operation:
      properties:
        createdAt:
          description: Creation timestamp.
          format: date-time
          type: string
        createdBy:
          description: ID of the user or service account who initiated the operation.
          type: string
        description:
          description: Human-readable description of the operation. 0-256 characters long.
          type: string
        finishedAt:
          description: The time when the operation has finished.
          format: date-time
          type: string
        id:
          description: ID of the operation.
          type: string
        progressData:
          allOf:
            - $ref: '#/components/schemas/google.protobuf.Any'
          description: >-
            Extra information about this operation's progress. MAY be absent
            while the operation is running, MUST be absent after the operation
            has

            completed.


            Type of message that's stored inside [progress_data] is
            service-dependent.
        progressTracker:
          allOf:
            - $ref: '#/components/schemas/nebius.common.v1.ProgressTracker'
          description: >-
            Information about this operation's progress, if this operation
            tracks its progress.

            If the operation tracks its progress, `progress_tracker` MUST be
            present both while

            the operation is running and after it has been completed.
        request:
          allOf:
            - $ref: '#/components/schemas/google.protobuf.Any'
          description: The request that generated this operation.
        requestHeaders:
          additionalProperties:
            $ref: '#/components/schemas/nebius.common.v1.Operation.RequestHeader'
          description: >-
            The request headers that are essential for the request that
            generated the operation.

            For instance, `x-resetmask`. Without these headers the request might
            have been processed

            differently if repeated.

            All the header names *must* be converted to lower case.

            Validator is based on:

            https://httpwg.org/specs/rfc9110.html#considerations.for.new.field.names
          type: object
        resourceId:
          description: >-
            ID of the resource that this operation creates, updates, deletes or
            otherwise changes.


            If the operation affects multiple resources or does not affect any
            API resources at all

            (e.g. a routine maintenance operation visible to the user), the
            [resource_id] must be empty.
          type: string
        status:
          allOf:
            - $ref: '#/components/schemas/google.rpc.Status'
          description: >-
            The status of this operation. Set when this operation is completed.

            See
            https://github.com/grpc/grpc/blob/master/src/proto/grpc/status/status.proto.


            [status.code] is
            https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto:

            - If [status.code] == OK, the operation has completed successfully.

            - If [status.code] != OK, the operation has failed or has been
            cancelled.
              - [status.message] will contain a user-readable and actionable error message.
              - [status.details] will contain additional diagnostic information in the form of [ServiceError] from nebius/common/v1/error.proto
            - [status.code] must belong to an Operation-compatible subset of
            GRPC codes:
              OK, CANCELLED, PERMISSION_DENIED, RESOURCE_EXHAUSTED, FAILED_PRECONDITION, ABORTED, INTERNAL
      type: object
    nebius.common.v1.ResourceMetadata:
      description: Common resource metadata.
      properties:
        createdAt:
          description: Timestamp indicating when the resource was created.
          format: date-time
          readOnly: true
          type: string
        id:
          description: Identifier for the resource, unique for its resource type.
          type: string
        labels:
          additionalProperties:
            type: string
          description: Labels associated with the resource.
          type: object
        name:
          description: Human readable name for the resource.
          type: string
        parentId:
          description: Identifier of the parent resource to which the resource belongs.
          type: string
        resourceVersion:
          description: >-
            Version of the resource for safe concurrent modifications and
            consistent reads.

            Positive and monotonically increases on each resource spec change
            (but *not* on each change of the

            resource's container(s) or status).

            Service allows zero value or current.
          format: int64
          type: string
        updatedAt:
          description: Timestamp indicating when the resource was last updated.
          format: date-time
          readOnly: true
          type: string
      required:
        - parentId
      type: object
    nebius.ai.v1.DevlabSpec:
      description: DevlabSpec defines an interactive workload that will be run.
      properties:
        args:
          description: The arguments to pass to the entrypoint command.
          type: string
        authTokenMysteryboxSecret:
          allOf:
            - $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.MysteryBoxSecretRef'
          description: >-
            The MysteryBox secret that contains the authentication token under
            the `AUTH_TOKEN` payload key.

            This field enables an authentication proxy for the Devlab's HTTP
            ports.

            The proxy rejects requests without an `Authorization: Bearer
            <token>` header that contains the matching token.

            If absent, Serverless does not add this bearer-token check.
        containerCommand:
          description: The entrypoint command for the Devlab's container.
          type: string
        disk:
          allOf:
            - $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.DiskSpec'
          description: Disk spec for the main disk of the Devlab runtime VM.
        environmentVariables:
          description: Specifies the environment variables for the Devlab's container.
          items:
            $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.EnvironmentVariable'
          type: array
        image:
          description: |-
            The Docker image to use for the Devlab's container.

            Required unless `template` is set: the template declares the image.
          type: string
        injectedFiles:
          description: >-
            Small config files injected into the container before the user
            process

            starts. Intended for configs, not datasets. Read methods return
            target

            paths. File content is returned only by Get with view SECRET.
          items:
            $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.FileInjection'
          type: array
        platform:
          description: Compute platform that the Devlab will be run on.
          type: string
        ports:
          description: Specifies the ports that the Devlab exposes.
          items:
            $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.Port'
          type: array
        preset:
          description: Compute preset that the Devlab will be run on.
          type: string
        primaryRoute:
          allOf:
            - $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.PrimaryRoute'
          description: |-
            Primary web route exposed through the managed HTTPS endpoint.

            Required unless `template` is set: the template declares the primary
            web UI port.
        publicIp:
          description: Whether to assign a public IP to the Devlab runtime VM.
          type: boolean
        registryCredentials:
          allOf:
            - $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.RegistryCredentials'
          description: Registry credentials for private Docker registry.
        shmSizeBytes:
          description: Shared memory size in bytes for the Devlab's container.
          format: int64
          type: string
        sshAuthorizedKeys:
          description: Public keys to be authorized for SSH access to the Devlab.
          items:
            type: string
          type: array
        subnetId:
          description: Subnet ID where the Devlab will be deployed.
          type: string
        template:
          allOf:
            - $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.Template'
          description: >-
            Template that defines the Devlab's container.


            When set, the template declares the container shape: image,
            entrypoint

            command, arguments, working directory, ports, optional shared memory
            size,

            the primary web route, and the default workspace path. The spec must
            leave

            image, container command, arguments, working directory, and primary
            route

            empty. Environment variables and ports extend the template-declared
            ones,

            `workspace.container_path` may override the template default, and

            `shm_size_bytes` may be set only when the template leaves it unset.


            The template is consumed at creation time: read methods return the

            rendered container shape instead of the template reference.
        volumes:
          description: Extra volumes to be mounted into the Devlab container.
          items:
            $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.VolumeMount'
          type: array
        workingDir:
          description: The working directory for the Devlab's container.
          type: string
        workspace:
          allOf:
            - $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.Workspace'
          description: Primary workspace storage for user state.
      required:
        - platform
        - preset
        - disk
        - subnetId
        - workspace
      type: object
    google.protobuf.Any:
      additionalProperties: {}
      description: >-
        `Any` contains an arbitrary serialized protocol buffer message along
        with a

        URL that describes the type of the serialized message.


        Protobuf library provides support to pack/unpack Any values in the form

        of utility functions or additional generated methods of the Any type.


        Example 1: Pack and unpack a message in C++.

            Foo foo = ...;
            Any any;
            any.PackFrom(foo);
            ...
            if (any.UnpackTo(&foo)) {
              ...
            }

        Example 2: Pack and unpack a message in Java.

            Foo foo = ...;
            Any any = Any.pack(foo);
            ...
            if (any.is(Foo.class)) {
              foo = any.unpack(Foo.class);
            }
            // or ...
            if (any.isSameTypeAs(Foo.getDefaultInstance())) {
              foo = any.unpack(Foo.getDefaultInstance());
            }

         Example 3: Pack and unpack a message in Python.

            foo = Foo(...)
            any = Any()
            any.Pack(foo)
            ...
            if any.Is(Foo.DESCRIPTOR):
              any.Unpack(foo)
              ...

         Example 4: Pack and unpack a message in Go

             foo := &pb.Foo{...}
             any, err := anypb.New(foo)
             if err != nil {
               ...
             }
             ...
             foo := &pb.Foo{}
             if err := any.UnmarshalTo(foo); err != nil {
               ...
             }

        The pack methods provided by protobuf library will by default use

        'type.googleapis.com/full.type.name' as the type URL and the unpack

        methods only use the fully qualified type name after the last '/'

        in the type URL, for example "foo.bar.com/x/y.z" will yield type

        name "y.z".


        JSON

        ====

        The JSON representation of an `Any` value uses the regular

        representation of the deserialized, embedded message, with an

        additional field `@type` which contains the type URL. Example:

            package google.profile;
            message Person {
              string first_name = 1;
              string last_name = 2;
            }

            {
              "@type": "type.googleapis.com/google.profile.Person",
              "firstName": <string>,
              "lastName": <string>
            }

        If the embedded message type is well-known and has a custom JSON

        representation, that representation will be embedded adding a field

        `value` which holds the custom JSON in addition to the `@type`

        field. Example (for message [google.protobuf.Duration][]):

            {
              "@type": "type.googleapis.com/google.protobuf.Duration",
              "value": "1.212s"
            }
      properties:
        '@type':
          description: >-
            A URL/resource name that uniquely identifies the type of the
            serialized

            protocol buffer message. This string must contain at least

            one "/" character. The last segment of the URL's path must represent

            the fully qualified name of the type (as in

            `path/google.protobuf.Duration`). The name should be in a canonical
            form

            (e.g., leading "." is not accepted).


            In practice, teams usually precompile into the binary all types that
            they

            expect it to use in the context of Any. However, for URLs which use
            the

            scheme `http`, `https`, or no scheme, one can optionally set up a
            type

            server that maps type URLs to message definitions as follows:


            * If no scheme is provided, `https` is assumed.

            * An HTTP GET on the URL must yield a [google.protobuf.Type][]
              value in binary format, or produce an error.
            * Applications are allowed to cache lookup results based on the
              URL, or have them precompiled into a binary to avoid any
              lookup. Therefore, binary compatibility needs to be preserved
              on changes to types. (Use versioned type names to manage
              breaking changes.)

            Note: this functionality is not currently available in the official

            protobuf release, and it is not used for type URLs beginning with

            type.googleapis.com. As of May 2023, there are no widely used type
            server

            implementations and no plans to implement one.


            Schemes other than `http`, `https` (or the empty scheme) might be

            used with implementation specific semantics.
          type: string
      type: object
    nebius.common.v1.ProgressTracker:
      description: >-
        Information for tracking the progress of a task (e.g., an API operation
        or background maintenance action).

        This serves as a UI contract and may be directly reflected in CLI,
        Console, and other tools.
      properties:
        description:
          description: >-
            Human-readable description of the currently executing task, e.g.,
            "Downloading dat-groot-llm.tar.xz".

            Relates to the overall task, not individual steps.

            SHOULD match the Operation's `description` field when this
            ProgressTracker tracks an API Operation's progress.

            MAY provide more detailed overall information.


            MUST be suitable for display to public users.

            Even if the task is internal, this description may be shown to end
            users in overall task step descriptions.


            For individual step descriptions, use `Step.description`.
          type: string
        estimatedFinishedAt:
          description: |-
            Estimated completion timestamp for the task.
            MUST be absent if the task is completed (i.e., finished_at is set).
            MAY be absent if the estimate is unknown.
            MAY be updated as the progress estimate changes.
          format: date-time
          type: string
        finishedAt:
          description: >-
            Completion timestamp of the task.

            MUST be absent for running tasks; MUST be present for completed
            tasks.

            MUST match the operation's finished_at timestamp when tracking an
            API Operation's progress.
          format: date-time
          type: string
        startedAt:
          description: >-
            Timestamp when the overall task started.

            MUST match the operation's created_at timestamp when tracking an API
            Operation's progress.
          format: date-time
          type: string
        steps:
          description: >-
            Detailed information about the task steps that are currently running
            or have been finished.

            - For a completed task, the step list MUST either be empty or
            contain finished steps only.

            - For a running task, the step list MAY be empty if the task
            consists of a single step or no detailed information is available.
              A non-empty step list MUST include all currently running steps and MAY include some or all finished steps.
            - Service SHOULD provide both running and finished steps if the task
            has around 10-20 steps, and provide only running steps otherwise.
              Service MUST consistently choose either the "running steps only" or the "running + finished steps" behavior.
            - The UI, CLI etc. MAY choose not to display all steps provided by
            the service.
          items:
            $ref: '#/components/schemas/nebius.common.v1.ProgressTracker.Step'
          type: array
        workDone:
          allOf:
            - $ref: '#/components/schemas/nebius.common.v1.ProgressTracker.WorkDone'
          description: |-
            Overall work progress details.
            MAY be absent if unknown.
      type: object
    nebius.common.v1.Operation.RequestHeader:
      description: >-
        Request header is a container for all the values of a particular header
        of a request because there is no such thing as

        `map<string, repeated string>`
      properties:
        values:
          description: The values of a particular header from a request
          items:
            type: string
          type: array
      type: object
    google.rpc.Status:
      description: >-
        The `Status` type defines a logical error model that is suitable for

        different programming environments, including REST APIs and RPC APIs. It
        is

        used by [gRPC](https://github.com/grpc). Each `Status` message contains

        three pieces of data: error code, error message, and error details.


        You can find out more about this error model and how to work with it in
        the

        [API Design Guide](https://cloud.google.com/apis/design/errors).
      properties:
        code:
          description: |-
            The status code, which should be an enum value of
            [google.rpc.Code][google.rpc.Code].
          format: int32
          type: integer
        details:
          description: >-
            A list of messages that carry the error details.  There is a common
            set of

            message types for APIs to use.
          items:
            $ref: '#/components/schemas/google.protobuf.Any'
          type: array
        message:
          description: >-
            A developer-facing error message, which should be in English. Any

            user-facing error message should be localized and sent in the

            [google.rpc.Status.details][google.rpc.Status.details] field, or
            localized

            by the client.
          type: string
      type: object
    nebius.ai.v1.DevlabSpec.MysteryBoxSecretRef:
      description: Reference to a MysteryBox secret.
      properties:
        secretId:
          description: MysteryBox secret ID.
          type: string
        versionId:
          description: MysteryBox secret version ID.
          type: string
      type: object
    nebius.ai.v1.DevlabSpec.DiskSpec:
      properties:
        sizeBytes:
          description: Disk size in bytes.
          format: int64
          type: string
        type:
          allOf:
            - $ref: '#/components/schemas/nebius.compute.v1.DiskSpec.DiskType'
          description: Disk type.
      required:
        - type
      type: object
    nebius.ai.v1.DevlabSpec.EnvironmentVariable:
      description: >-
        EnvironmentVariable defines an environment variable for the Devlab's
        container.
      properties:
        mysteryboxSecret:
          allOf:
            - $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.MysteryBoxSecretRef'
          description: >-
            Secret storing the environment variable value.

            The value is read from the payload entry whose key matches the
            variable

            name, or the first entry when no such key exists.
        name:
          description: The name of the environment variable.
          type: string
        value:
          description: |-
            Environment variable value.
            The unmasked value is returned only by Get with view SECRET.
          type: string
      required:
        - name
      type: object
    nebius.ai.v1.DevlabSpec.FileInjection:
      description: FileInjection materializes a small file inside the container at launch.
      properties:
        containerPath:
          description: |-
            Absolute path inside the container where the content is written.

            Must be a clean absolute path: root, trailing slashes, empty path
            segments, "." and ".." are not allowed.
          type: string
        content:
          description: |-
            File content. On create, must contain between 1 byte and 64 KiB
            (one mystery box secret payload).
            Returned only by Get with view SECRET.
          format: byte
          type: string
      required:
        - containerPath
      type: object
    nebius.ai.v1.DevlabSpec.Port:
      properties:
        containerPort:
          description: Container port.
          format: int32
          type: integer
        hostPort:
          description: |-
            Host port.

            Set to 0 to use the same value as container_port.
          format: int32
          type: integer
        protocol:
          allOf:
            - $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.Port.Protocol'
          description: Port's protocol.
      required:
        - protocol
      type: object
    nebius.ai.v1.DevlabSpec.PrimaryRoute:
      properties:
        containerPort:
          description: Container port that serves the primary web UI.
          format: int32
          type: integer
      type: object
    nebius.ai.v1.DevlabSpec.RegistryCredentials:
      properties:
        mysteryboxSecretVersion:
          description: |-
            Secret version storing the registry credentials.
            Must have keys "REGISTRY_USERNAME" and "REGISTRY_PASSWORD".
          type: string
      type: object
    nebius.ai.v1.DevlabSpec.Template:
      description: Reference to a VM app template the Devlab's container is rendered from.
      properties:
        id:
          description: VM app template ID.
          type: string
        inputFieldValues:
          additionalProperties: {}
          description: >-
            The values for the template's input fields, keyed by each
            TemplateInputField.id.

            VmAppTemplateService.Get and List return these field definitions in
            VmAppTemplate.status.input_fields.

            Each value must match its field's type:

            - STRING: string_value. The value must satisfy the template's
            pattern, options, or unit format.

            - INTEGER: number_value with an integer value within the template's
            bounds.

            - BOOLEAN: bool_value.

            - MYSTERYBOX_SECRET_VERSION: string_value with the secret version
            ID.

            null_value and absent entries both omit the input. Required inputs
            cannot be omitted.

            Optional inputs use the defaults from the template's input
            definition.

            Explicit false, 0, and empty strings are values, not omitted inputs.
            The template's validation still applies.

            Object and list values are not supported. Unknown field IDs have no
            effect.

            Read methods do not return this map.
          type: object
      required:
        - id
      type: object
    nebius.ai.v1.DevlabSpec.VolumeMount:
      description: VolumeMount represents an extra volume mount for the Devlab container.
      properties:
        containerPath:
          description: |-
            Path inside the Devlab container where the volume is mounted.

            Must be a clean absolute path: root, trailing slashes, empty path
            segments, "." and ".." are not allowed.
          type: string
        mode:
          allOf:
            - $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.VolumeMount.Mode'
          description: Mount mode.
        s3Config:
          $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.VolumeMount.S3Config'
        source:
          description: >-
            Source of the volume mount.


            Can be a name or an ID of Nebius Storage bucket or filesystem,

            or an S3 URI (e.g. "s3://bucket-name") when using external S3
            storage.
          type: string
        sourcePath:
          description: |-
            Path inside the source volume.

            Optional.
          type: string
      required:
        - source
        - containerPath
        - mode
      type: object
    nebius.ai.v1.DevlabSpec.Workspace:
      properties:
        containerPath:
          description: >-
            Path inside the Devlab container where the workspace is mounted.


            Must be a clean absolute path: root, trailing slashes, empty path

            segments, "." and ".." are not allowed.


            Required unless the Devlab is created from a template: the template

            declares the default workspace path, and a non-empty value overrides
            it.
          type: string
      type: object
    nebius.common.v1.ProgressTracker.Step:
      description: |-
        Represents a basic step in the task.
        Fields are binary-compatible with ProgressTracker for easier processing.
      properties:
        description:
          description: >-
            Human-readable description of the step, e.g., "Connecting to
            localhost:8080".

            MUST be suitable for display to public users.

            Private descriptions must be filtered server-side based on the use
            case.
          type: string
        finishedAt:
          description: >-
            Timestamp when the step finished.

            MUST be absent for running steps; MUST be present for completed
            steps.
          format: date-time
          type: string
        startedAt:
          description: Timestamp when the step started.
          format: date-time
          type: string
        workDone:
          allOf:
            - $ref: '#/components/schemas/nebius.common.v1.ProgressTracker.WorkDone'
          description: |-
            Details on the work to be done for this step and progress made.
            MAY be absent if unknown.
      type: object
    nebius.common.v1.ProgressTracker.WorkDone:
      description: >-
        Information about the work done by the task or its step, expressed in
        ticks (abstract work units).

        Each tick may represent a real measurement (e.g., VMs created, KiB
        uploaded), number of substeps or a percentage of work completed.
      properties:
        doneTickCount:
          description: >-
            Number of ticks completed so far. MUST be between 0 and
            total_tick_count, inclusive.

            MUST equal total_tick_count if the task or step is finished.
          format: int64
          type: string
        totalTickCount:
          description: >-
            Total number of ticks (work units) to be completed. MUST be greater
            than 0.
          format: int64
          type: string
      type: object
    nebius.compute.v1.DiskSpec.DiskType:
      default: UNSPECIFIED
      description: >-
        the list of available types will be clarified later, it is not final
        version
      enum:
        - UNSPECIFIED
        - NETWORK_SSD
        - NETWORK_HDD
        - NETWORK_SSD_NON_REPLICATED
        - NETWORK_SSD_IO_M3
      type: string
    nebius.ai.v1.DevlabSpec.Port.Protocol:
      default: PROTOCOL_UNSPECIFIED
      description: |-
        Represents protocol of the Devlab's port which will be exposed.

         - PROTOCOL_UNSPECIFIED: No protocol selected. Specify HTTP, TCP, or UDP.
         - HTTP: HTTP protocol.
         - TCP: TCP protocol.
         - UDP: UDP protocol.
      enum:
        - PROTOCOL_UNSPECIFIED
        - HTTP
        - TCP
        - UDP
      type: string
    nebius.ai.v1.DevlabSpec.VolumeMount.Mode:
      default: MODE_UNSPECIFIED
      description: |-
        Mode that will be used to mount the volume.

         - MODE_UNSPECIFIED: No mount mode selected. Specify READ_WRITE or READ_ONLY.
         - READ_WRITE: Read-write mode.
         - READ_ONLY: Read-only mode.
      enum:
        - MODE_UNSPECIFIED
        - READ_WRITE
        - READ_ONLY
      type: string
    nebius.ai.v1.DevlabSpec.VolumeMount.S3Config:
      description: |-
        Config for accessing an external S3-compatible storage.

        The bucket name is specified in the `source` field as an S3 URI.
      properties:
        endpoint:
          description: S3-compatible endpoint URL (e.g. "https://s3.amazonaws.com").
          type: string
        mysteryboxSecret:
          allOf:
            - $ref: '#/components/schemas/nebius.ai.v1.DevlabSpec.MysteryBoxSecretRef'
          description: Reference to a MysteryBox secret containing S3 credentials.
        region:
          description: S3 region.
          type: string
      required:
        - endpoint
        - region
        - mysteryboxSecret
      type: object
  securitySchemes:
    bearerAuth:
      description: The Authorization header expects a Bearer token.
      scheme: bearer
      type: http

````