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

# Update a cluster machine

> Updates a machine in a cluster.



## OpenAPI

````yaml /openapi.json patch /v1/projects/{projectId}/cluster-machines/{id}
openapi: 3.0.3
info:
  description: >-
    The CUDO Compute API is organized around
    [REST](http://en.wikipedia.org/wiki/Representational_State_Transfer). Our
    API uses predictable resource-oriented URLs, accepts and returns
    [JSON](http://www.json.org/)-encoded requests and responses, and uses
    standard HTTP response codes, authentication, and verbs where possible.
  title: CUDO Compute service
  version: 1.0.0
servers:
  - url: https://rest.compute.cudo.org/
security:
  - bearerAuth: []
tags:
  - description: API keys allow you to authenticate requests with the CUDO Compute API.
    name: API keys
  - description: >
      Billing accounts hold all billing related information such as credit
      balance, payment methods & transaction history. You can use the same
      billing account for multiple projects.


      Related guide: [Billing](https://www.cudocompute.com/docs/billing)
    name: Billing
  - description: >
      Clusters are high-performance computing environments that can be used to
      run large-scale parallel and distributed applications.


      Related guide: [Clusters](https://www.cudocompute.com/docs/clusters)
    name: Clusters
  - description: >
      Storage disks are virtual disks that operate just like physical disks. You
      can attach & detach created storage disks to and from virtual machines in
      the same data center.


      Related guide: [Disks](https://www.cudocompute.com/docs/disks)
    name: Disks
  - description: |
      Images are boot disk templates used to create virtual machines.

      Related guide: [Images](https://www.cudocompute.com/docs/images)
    name: Images
  - description: >
      Bare-metal machines are dedicated physical servers for high-performance
      computing, offering full control and isolation from other users.


      Related guide: [Bare metal](https://www.cudocompute.com/docs/bare-metal)
    name: Machines
  - description: >
      Private networks allow you to securely connect your virtual machines
      together.


      Related guide: [Networks](https://www.cudocompute.com/docs/networks)
    name: Networks
  - description: >
      Store large amounts of unstructured data, including audio, video and user
      uploaded files.


      Related guide: [Object
      storage](https://www.cudocompute.com/docs/object-storage)
    name: Object storage
  - description: >
      Projects are containers for cloud resources, such as virtual machines &
      clusters.
    name: Projects
  - description: Operations for searching available compute resources.
    name: Resources
  - description: >
      SSH keys are access credentials that are automatically added to bare-metal
      and virtual machines you create.
    name: SSH keys
  - description: Operations related to user accounts and identity verification.
    name: Users
  - description: >
      A virtual machine (VM) is a software emulation of a physical computer.


      Related guide: [Virtual
      machines](https://www.cudocompute.com/docs/virtual-machines)
    name: Virtual machines
  - description: >
      Volumes are high-performance Network File Systems that allow cluster
      machines to share training data and model checkpoints.


      Related guide: [Volumes](https://www.cudocompute.com/docs/volumes)
    name: Volumes
paths:
  /v1/projects/{projectId}/cluster-machines/{id}:
    patch:
      tags:
        - Clusters
      summary: Update a cluster machine
      description: Updates a machine in a cluster.
      operationId: UpdateClusterMachine
      parameters:
        - in: path
          name: projectId
          required: true
          schema:
            type: string
        - in: path
          name: id
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              properties:
                architecture:
                  readOnly: true
                  type: string
                cpuCores:
                  format: int32
                  readOnly: true
                  type: integer
                cpuModel:
                  readOnly: true
                  type: string
                cpuSpeedMhz:
                  format: int32
                  readOnly: true
                  type: integer
                createBy:
                  readOnly: true
                  type: string
                createTime:
                  format: date-time
                  readOnly: true
                  type: string
                dataCenterId:
                  readOnly: true
                  type: string
                diskSizeGib:
                  format: int32
                  readOnly: true
                  type: integer
                disks:
                  format: int32
                  readOnly: true
                  type: integer
                externalIpAddress:
                  readOnly: true
                  type: string
                gpuModelId:
                  readOnly: true
                  type: string
                gpus:
                  format: int32
                  readOnly: true
                  type: integer
                internalIpAddress:
                  readOnly: true
                  type: string
                machineTypeId:
                  readOnly: true
                  type: string
                memoryGib:
                  format: int32
                  readOnly: true
                  type: integer
                powerState:
                  $ref: '#/components/schemas/MachinePowerState'
                priceHr:
                  $ref: '#/components/schemas/Decimal'
                state:
                  $ref: '#/components/schemas/ClusterMachine.State'
                volumeIds:
                  items:
                    type: string
                  type: array
              title: Update cluster machine params
              type: object
        description: Update cluster machine params
        required: true
        x-originalParamName: clusterMachine
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ClusterMachine'
          description: A successful response.
        default:
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Status'
          description: An unexpected error response.
components:
  schemas:
    MachinePowerState:
      default: MACHINE_POWER_STATE_UNSPECIFIED
      enum:
        - MACHINE_POWER_STATE_UNSPECIFIED
        - 'ON'
        - 'OFF'
        - POWERING_ON
        - POWERING_OFF
        - REBOOTING
      type: string
    Decimal:
      description: >-
        A representation of a decimal value, such as 2.5. Clients may convert
        values

        into language-native decimal formats, such as Java's [BigDecimal][] or

        Python's [decimal.Decimal][].


        [BigDecimal]:

        https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/math/BigDecimal.html

        [decimal.Decimal]: https://docs.python.org/3/library/decimal.html
      properties:
        value:
          description: >-
            The decimal value, as a string.


            The string representation consists of an optional sign, `+`
            (`U+002B`)

            or `-` (`U+002D`), followed by a sequence of zero or more decimal
            digits

            ("the integer"), optionally followed by a fraction, optionally
            followed

            by an exponent.


            The fraction consists of a decimal point followed by zero or more
            decimal

            digits. The string must contain at least one digit in either the
            integer

            or the fraction. The number formed by the sign, the integer and the

            fraction is referred to as the significand.


            The exponent consists of the character `e` (`U+0065`) or `E`
            (`U+0045`)

            followed by one or more decimal digits.


            Services **should** normalize decimal values before storing them by:

              - Removing an explicitly-provided `+` sign (`+2.5` -> `2.5`).
              - Replacing a zero-length integer value with `0` (`.5` -> `0.5`).
              - Coercing the exponent character to lower-case (`2.5E8` -> `2.5e8`).
              - Removing an explicitly-provided zero exponent (`2.5e0` -> `2.5`).

            Services **may** perform additional normalization based on its own
            needs

            and the internal decimal implementation selected, such as shifting
            the

            decimal point and exponent value together (example: `2.5e-1` <->
            `0.25`).

            Additionally, services **may** preserve trailing zeroes in the
            fraction

            to indicate increased precision, but are not required to do so.


            Note that only the `.` character is supported to divide the integer

            and the fraction; `,` **should not** be supported regardless of
            locale.

            Additionally, thousand separators **should not** be supported. If a

            service does support them, values **must** be normalized.


            The ENBF grammar is:

                DecimalString =
                  [Sign] Significand [Exponent];

                Sign = '+' | '-';

                Significand =
                  Digits ['.'] [Digits] | [Digits] '.' Digits;

                Exponent = ('e' | 'E') [Sign] Digits;

                Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };

            Services **should** clearly document the range of supported values,
            the

            maximum supported precision (total number of digits), and, if
            applicable,

            the scale (number of digits after the decimal point), as well as how
            it

            behaves when receiving out-of-bounds values.


            Services **may** choose to accept values passed as input even when
            the

            value has a higher precision or scale than the service supports, and

            **should** round the value to fit the supported scale.
            Alternatively, the

            service **may** error with `400 Bad Request` (`INVALID_ARGUMENT` in
            gRPC)

            if precision would be lost.


            Services **should** error with `400 Bad Request` (`INVALID_ARGUMENT`
            in

            gRPC) if the service receives a value outside of the supported
            range.
          type: string
      type: object
    ClusterMachine.State:
      default: STATE_UNSPECIFIED
      enum:
        - STATE_UNSPECIFIED
        - CREATING
        - ACTIVE
        - DELETING
        - FAILED
      type: string
    ClusterMachine:
      properties:
        architecture:
          readOnly: true
          type: string
        cpuCores:
          format: int32
          readOnly: true
          type: integer
        cpuModel:
          readOnly: true
          type: string
        cpuSpeedMhz:
          format: int32
          readOnly: true
          type: integer
        createBy:
          readOnly: true
          type: string
        createTime:
          format: date-time
          readOnly: true
          type: string
        dataCenterId:
          readOnly: true
          type: string
        diskSizeGib:
          format: int32
          readOnly: true
          type: integer
        disks:
          format: int32
          readOnly: true
          type: integer
        externalIpAddress:
          readOnly: true
          type: string
        gpuModelId:
          readOnly: true
          type: string
        gpus:
          format: int32
          readOnly: true
          type: integer
        id:
          readOnly: true
          type: string
        internalIpAddress:
          readOnly: true
          type: string
        machineTypeId:
          readOnly: true
          type: string
        memoryGib:
          format: int32
          readOnly: true
          type: integer
        powerState:
          $ref: '#/components/schemas/MachinePowerState'
        priceHr:
          $ref: '#/components/schemas/Decimal'
        projectId:
          readOnly: true
          type: string
        state:
          $ref: '#/components/schemas/ClusterMachine.State'
        volumeIds:
          items:
            type: string
          type: array
      type: object
    Status:
      properties:
        code:
          format: int32
          type: integer
        details:
          items:
            $ref: '#/components/schemas/Any'
          type: array
        message:
          type: string
      type: object
    Any:
      additionalProperties: {}
      properties:
        '@type':
          type: string
      type: object
  securitySchemes:
    bearerAuth:
      description: >-
        API key authentication. API keys should be passed using the format
        `Bearer API_KEY`.
      in: header
      name: Authorization
      type: apiKey

````