From Node Delivery to Build Baseline

Connect Your Cloud Mac to Your Development and CI Workflow

Choose your region, model, and billing term first, then harden credentials, verify SSH, initialize the desktop, and run your first Xcode build. Keep an auditable status record at every step.

Node type
Dedicated Apple Silicon physical node
Available regions
SG · JP · KR · HK
Goal
First build and CI test job pass
ORB / NODE COMMISSIONING RUNBOOK 01
Choose Harden Connect Build Add to CI
Target node Apple Silicon / Dedicated physical node
Region
To be selected
SSH key
To be added
Xcode baseline
Pending verification
Runner
Pending registration
Delivery gate Run production jobs only after every check passes
Use the address, credentials, and live availability returned by the console 365 DAYS
Before You Start

Prepare These Six Inputs

Choosing a node is about more than the chip. Region, access method, toolchain versions, and team ownership all shape the first hour after provisioning.

01

Target region

Choose between Singapore, Japan (Tokyo), South Korea (Seoul), and Hong Kong based on proximity to key developers or artifact storage. Consider repository and dependency-source network paths—not just where you are located.

SG · JP · KR · HK
02

Node model

Start with Orb M4 16 for lightweight builds; consider Orb M4 24 for larger dependency graphs and parallel jobs; choose Orb M4 Pro for memory-intensive builds or local AI experiments.

3 configurations
03

Billing term

Choose daily or weekly billing for short validation runs, or monthly or quarterly billing for stable pipelines. Record your internal acceptance date before renewing, so production releases never depend on an unattended temporary order.

Daily · Weekly · Monthly · Quarterly
04

SSH public key

Prepare an Ed25519 public key dedicated to this node. Keep the private key only on authorized devices or in a controlled key system. Never reuse a personal everyday key as a shared team credential.

Ed25519 recommended
05

Team access list

Assign a node owner, CI administrator, and incident contact. Each person should use a separate key, with join, change, and revocation records—never one credential for the whole team.

One credential per person
06

macOS toolchain

Pin macOS, Xcode, Command Line Tools, Ruby, Node, CocoaPods, and dependency-manager versions in advance. Record the requirements in the repository and verify each one during node initialization.

Reproducible versions required
Order and Delivery

Choose Your Node in Three Steps

The console shows available regions for each model. Regular catalog combinations can be ordered; actual availability is determined by the console in real time.

  1. 01

    Choose One of Three Models

    Orb M4 16 includes M4, 16GB RAM, and 256GB storage; Orb M4 24 includes M4, 24GB RAM, and 512GB storage; Orb M4 Pro includes M4 Pro, 64GB RAM, and 2TB storage.

  2. 02

    Choose a Region and Billing Term

    Choose Singapore, Japan (Tokyo), South Korea (Seoul), or Hong Kong; terms are daily, weekly, monthly, or quarterly. Record the region code and renewal date in your internal asset register.

  3. 03

    Review the Order and Await Delivery

    Confirm the model, region, term, and add-ons before placing the order. The console provides the node address, initial access details, and service status; do not forward them through unauthorized channels.

Node Credentials and Security

Harden Access Before Installing the Development Environment

Initial access details are only for establishing the first controlled connection. Do not import production repositories or signing materials until key verification, access changes, and recovery records are complete.

FIRST ACCESS RECORD After First Login

Turn Temporary Access into an Auditable Entry Point

  • Review Delivery Details Confirm that the node ID, address, port, and region match the order, then record the result in the team asset register.
  • Add a Dedicated SSH Public Key Assign separate keys to administrators, developers, and automation runners. Never share one private key between human and CI access.
  • Adjust Access Settings After confirming key-based login works, narrow the scope of temporary credentials. Keep a verified recovery path after every change.
  • Save Recovery Information Record the node ID, authorized members, key fingerprints, recovery owner, and last verification time. Store recovery materials separately from the node itself.
Credential Boundaries

Separate Human and Automation Access

Use developer keys for interactive troubleshooting and runner keys only for pipeline-required permissions. Revoke a departing member’s public key instead of replacing a credential shared by everyone.

Traceable Individual Fingerprints
Recovery Verification

Confirm the Rollback Path Before Making Changes

Before changing network, SSH, or desktop-session settings, keep the current working session open and have a second owner review the recovery information in the console.

View Connection Troubleshooting Steps
First SSH Connection

Verify the Fingerprint, Then Check System Status

Never skip host-fingerprint verification. Get the address and port from the console, then compare the trusted fingerprint with the team-approved delivery record.

Node Access Record Pending
# Set variables only after obtaining the console address
export NODE_HOST="NODE_ADDRESS"
export NODE_PORT="22"

# Correct permissions for the dedicated private key
chmod 600 ~/.ssh/orbvps_node

# Read and display the host fingerprint, then compare it with the delivery record
ssh-keyscan -p "$NODE_PORT" "$NODE_HOST" \
  | ssh-keygen -lf -

# Initiate the first connection
ssh -p "$NODE_PORT" \
  -i ~/.ssh/orbvps_node \
  nodeadmin@"$NODE_HOST"

# Confirm hardware, system, and disk status after login
$ uname -m
arm64
$ sw_vers
$ sysctl -n machdep.cpu.brand_string
$ df -h /
$ uptime
SSH ACCEPTANCE 4 CHECKS
  1. Fingerprint matches The scan result must match the trusted delivery record. If it does not, stop connecting and verify through a console support ticket.
  2. Key permissions are correct SSH refuses to load a private key with overly broad permissions. Set it so only the current user can read and write it.
  3. Architecture is arm64 After login, confirm the processor architecture and chip information before deploying the toolchain.
  4. Disk and uptime are readable Record root-volume capacity, system version, and uptime as the starting point for future build troubleshooting.
Desktop Initialization

Make the VNC Session a Repeatable Work Environment

Use the desktop to configure display settings, system preferences, and Xcode’s first-run interactions. Connection credentials are not published; view the address and access details after provisioning.

DESKTOP BASELINE Desktop Acceptance Checklist

After completing each setting, disconnect and reconnect once to confirm it remains effective in a new session.

01

Display and Resolution

Choose a resolution suited to your network and screen. If text is too small or latency is noticeable, lower the resolution first, then assess the network path.

02

System Language and Time Zone

Standardize the system language, regional format, and time zone across the team so build logs, date output, and automation scripts remain consistent.

03

Lock Screen Policy

Confirm that locking the screen will not interrupt tasks that must keep running, while still restricting unauthorized access. Validate interactive sessions and CI jobs separately.

04

Reconnect After Disconnecting

Intentionally disconnect a desktop session, reconnect, and confirm that the desktop state, resolution, and running processes are as expected.

Migration Path

Move from a Local Mac to a Stable Cloud Build Node

Migrate in three stages: move verifiable data, pin the toolchain, then connect CI. Do not copy repositories, dependencies, and automation settings all at once without checks.

LOCAL
01

Migrate Data and Repositories

Move only the required repositories, dependency lockfiles, build scripts, and test data. Exclude temporary caches, old artifacts, and orphaned files; then verify repository status and key-file hashes.

  • Confirm the default branch and remote URL
  • Check submodules and large-file dependencies
  • Sanitize test data
TOOLCHAIN
02

Install and Pin the Toolchain

Install Xcode, Command Line Tools, and dependency managers as required by the repository. Save the actual version output in the baseline record; never substitute “latest” for a specific version.

  • Record Xcode and SDK versions
  • Restore dependencies from the lockfiles
  • Pin shell and runtime paths
CLOUD MAC
03

Connect CI and Verify Rollback

After registering the self-hosted runner, run a controlled test job first. Confirm that failure logs, cache cleanup, and recovery steps work before gradually enabling production branches.

  • Use dedicated labels to limit job scope
  • Verify cache hits and cleanup
  • Rehearse runner shutdown and rollback

Migration acceptance standard:The same commit must build on both the local and cloud Macs with the recorded toolchain, produce matching key test results, and be redeployable from the documentation.

First Build

Create an Auditable Success Baseline

The first build is not about the shortest runtime. It proves that the toolchain, dependencies, permissions, and output paths are reproducible.

  1. 01

    Check the Xcode Path and Version

    Confirm that the selected developer directory, Xcode version, and available SDK match the project requirements.

  2. 02

    Accept the License and Install Dependencies

    After accepting the Xcode license, install Ruby, Node, CocoaPods, and other project dependencies strictly from the lockfiles.

  3. 03

    Run a Controlled Build

    Explicitly set the workspace, scheme, and configuration, and save the complete standard output to a separate log file.

  4. 04

    Save the Baseline Record

    Record the commit ID, toolchain versions, start and end times, exit code, and artifact location for comparison with future changes.

First Build Baseline Command Examples
$ xcode-select -p
/Applications/Xcode.app/Contents/Developer

$ xcodebuild -version
Xcode <PROJECT_VERSION>

$ sudo xcodebuild -license accept
$ bundle install
$ bundle exec pod install

$ mkdir -p build-logs
$ set -o pipefail
$ xcodebuild \
  -workspace App.xcworkspace \
  -scheme App \
  -configuration Release \
  clean build \
  | tee build-logs/first-success.log

** BUILD SUCCEEDED **
CI Integration

Let the Runner Accept Only the Jobs It Should Run

After adding the self-hosted runner, use dedicated labels and a test branch to limit its scope, then gradually enable production builds.

RUNNER PROFILE

Runner Identity

Name
orb-m4-ci-01
Labels
macos · arm64 · xcode
Working directory
/Users/runner/work
Concurrency policy
Start validation with one job
ACCESS POLICY

Permissions and Keys

  • Use a Dedicated Runner User Do not let automation jobs use an administrator’s interactive account over the long term.
  • Split Keys by Purpose Grant separate minimum required permissions for repository reads, artifact writes, and deployment operations.
  • Keep Sensitive Values out of the Repository Inject them through controlled CI variables and verify that logs never echo complete values.
CACHE CONTROL

Caching and Recovery

  • Version the Cache Key Include the lockfile digest, architecture, and toolchain version in the cache key.
  • Support Clean Rebuilds Every pipeline should complete a full build once the cache has been cleared.
  • Limit Working-Directory Growth Check the space used by DerivedData, archives, and temporary artifacts regularly.
CONTROLLED TEST JOB

Run a Predictable Test Job First

The job should only report the environment, restore dependencies, run unit tests, and perform one build without publishing. Confirm correct label routing, complete logs, cleanable caches, and stoppability on failure before enabling production branches.

Expected exit code
0 / Success
Must be retained
Logs, commit ID, artifact hash
Failure handling
Stop production jobs and return to the baseline checks
Pre-Launch Review

Run Production Builds Only After All Six States Are Clear

Add the results below to the team runbook. The node can run year-round, but builds still require clear data, monitoring, and response ownership.

Backups

Keep copies of repositories, build configuration, key-recovery information, and required artifacts outside the node, and complete one recovery test.

Recovery verified

Monitoring

At minimum, record free disk space, build exit codes, job wait time, and runner online status, with thresholds for anomalies.

Metrics have an owner

Incident Contacts

Both the primary and backup contacts can access node records, build logs, and console support tickets, with the handoff path documented.

Primary and backup contacts assigned

Renewal Date

Record the order term and internal confirmation date; do not rely on one person’s memory. Assess active job windows before changing the configuration.

Term recorded

Access Revocation

List user and runner keys with their permissions so each can be revoked independently without affecting other members.

One record per item

Incident Contact Path

Keep the node ID, incident time, reproduction steps, and sanitized logs ready to submit; authorized members must be able to file a console support ticket.

Materials ready to submit
Ready to Deploy

Start with a Verifiable Cloud Mac

Choose a model, region, and term, then complete secure access, the first build, and CI acceptance using this guide after provisioning.