First-run path

From choosing a node to completing your first build

This getting-started guide breaks ordering, connecting, migrating, and acceptance testing into checkable actions. Verify configuration and access boundaries first, then deploy your code and build tools to avoid writing sensitive data before the environment is confirmed.

01 Confirm your use case and configuration
02 Verify delivery details
03 Migrate and run a build
04 Accept the environment and secure it
Before you begin

Document six inputs before choosing a machine

Region, memory, and rental term directly affect your migration approach. Create a concise run sheet first—it is more reliable than filling in requirements after placing an order.

Workflow and region

State whether your primary workload is Xcode builds, a self-hosted runner, local model inference, or media processing. Then choose the node closest to your team or dependent services: Singapore, Tokyo, Seoul, or Hong Kong.

Verification result One clear answer for the use case and target region

Model and rental term

For short-term adaptation and light builds, start by evaluating BookaMac M4. For high-memory concurrency, model inference, and demanding media workloads, consider BookaMac M4 Pro. Choose a daily, weekly, monthly, or quarterly term.

Verification result Chip, memory, storage, and billing cycle are recorded

Connection clients and SSH public keys

Prepare working SSH and VNC clients. Generate a dedicated SSH key pair locally and submit only the public key. Keep the private key on a controlled device; never send it by email or through a support ticket.

Verification result The local public key is readable and private-key permissions are restricted
Choose and order

Choose between two configurations based on resource demand—not vague labels

Both plans provide a dedicated physical Mac mini, not a virtual machine. Before creating an order, verify the model, node, rental term, and additional storage. The console returns current availability and final order details in real time.

  • Confirm that all charges are settled in US dollars (USD).
  • Confirm that the region matches your team's network path and dependency locations.
  • Confirm that the rental term covers setup, task execution, and data export.
  • If you need extra storage or Thunderbolt 5 daisy-chaining, verify it separately in the order.
Lightweight and short-term tasks

BookaMac M4

$21.5/day
Chip
M4
Memory
16GB
Storage
256GB SSD
Choose BookaMac M4
Receive and verify

Check every delivery detail before connecting

Delivery does not mean you can immediately write data. Verify the configuration and access boundaries first, then pull private repositories or import signing materials.

DELIVERY CHECK

Node delivery verification checklist

Awaiting user confirmation
A

Node region

Confirm that the region selected in the order matches the region shown on the delivery page. Do not determine node location from connection speed alone.

B

Device configuration

Check the chip, memory, and storage capacity in System Information, comparing each item with the order confirmation.

C

Connection details

Verify the SSH address, port, username, and source of the host fingerprint. Save the verification result on first connection.

D

Initial access instructions

Confirm the scope, replacement steps, and entry point for temporary credentials. Do not forward complete credentials in shared channels.

Migration path

Proceed through three stages: data, toolchain, and CI

Define the inputs, actions, and verification result for every step. If the previous step has not passed, do not move more repositories, credentials, or tasks onto the node.

  1. 01 Data stage

    Sync only the repositories and resources required for the task

    First pull a repository that can build independently, then verify its branch, commit hash, submodules, and large-file resources. Rebuild dependency caches as needed; do not copy full-machine caches from unknown sources.

    Input
    Repository URL, target commit, resource inventory
    Action
    Pull, verify the hash, check file permissions
    Pass criteria
    Code and required resources are complete, with no unrelated data added
  2. 02 Toolchain stage

    Reproduce Xcode, dependency, and command versions

    Verify the current developer directory, install the command-line tools explicitly required by the project, and restore dependencies from lockfiles. Do not upgrade every tool globally first and then try to explain build differences.

    Input
    Xcode baseline, lockfiles, build scripts
    Action
    Select the toolchain, restore dependencies, run a clean build
    Pass criteria
    Versions match the baseline and the minimum target builds successfully
  3. 03 CI stage

    Register a runner, then run a verification job

    Assign clear labels to the node, isolate the working directory, limit concurrency, and first run a verification pipeline without release actions. Logs must not print keys, tokens, or complete signing materials.

    Input
    Runner registration details, labels, verification job
    Action
    Register, isolate the directory, run the test pipeline
    Pass criteria
    The job is repeatable, with a clear exit code and artifact path
First build

Use a few short commands to verify connectivity, the toolchain, and the release environment

The documentation examples on the right use placeholder addresses. In practice, follow the connection address, username, project workspace, and build target shown on the delivery page.

  • Verify the host fingerprint before the first SSH connection; do not skip unexpected warnings.
  • Read the current developer directory first, then decide whether to switch Xcode.
  • Keep the complete log and exit code from the first build; do not save only the last few lines.
  • The fastlane environment check verifies only that the configuration is readable; it does not trigger a release.
View connection and build documentation
first-build.session
$ ssh build@203.0.113.24
The authenticity of host is confirmed.
Connected to dedicated Mac node

$ xcode-select -p
/Applications/Xcode.app/Contents/Developer

$ xcodebuild \
  -workspace Sample.xcworkspace \
  -scheme Sample \
  -configuration Debug \
  build
** BUILD SUCCEEDED **

$ bundle exec fastlane env
System Locale: zh_CN
Xcode Path: /Applications/Xcode.app
Environment check completed
GUI access

Use remote desktop only for steps that require a graphical interface

Use SSH for daily automation. When you need Xcode, a simulator, or graphical tools, connect with a VNC client.

01 / Client

Configure the connection using the delivery parameters

Use a trusted VNC client and enter the address, port, and credentials provided on the delivery page. Do not export connection settings to a shared sync directory or let the client permanently save shared credentials.

02 / Display

Start with stable settings, then improve image quality

Start your first connection with moderate resolution and color quality. If interaction feels slow, lower image quality first and check your local network. Do not confuse build duration with display-refresh latency.

03 / Clipboard

Copy only necessary, non-sensitive text

Clipboard sync is suitable for short commands and ordinary text; never use it for private keys, complete access tokens, or unsanitized credentials. For sensitive configuration, use a controlled file workflow and verify permissions.

04 / Exit

End the session and lock the screen when idle

When graphical work is complete, exit the relevant tools, lock the macOS interface, and disconnect the VNC session. Long-running tasks should be managed by scripts or a runner, not by an open desktop window.

First-task acceptance

Use repeatable results to confirm that the node is ready

Being able to sign in only proves connectivity. Proper acceptance should cover code, dependencies, builds, logs, and networking, leaving a baseline you can reuse next time.

If any item fails, first record the command, exit code, timestamp, and relevant logs, then narrow the variables. Do not change Xcode, dependency versions, and network settings simultaneously, or the true cause will be difficult to identify.

PASS 01

Code checkout

The target branch and commit hash are correct, and submodules and large-file resources are complete.

PASS 02

Dependency installation

The lockfile is applied, installation is repeatable, and key dependencies were not upgraded unexpectedly.

PASS 03

Build artifacts

The specified target builds successfully, and the artifact location, size, and creation method are traceable.

PASS 04

Log retention

The complete log is archived, sensitive fields are redacted, and the exit code and job ID are clear.

PASS 05

Network access

The repositories and dependency endpoints required by the project are reachable, with no unrelated access exposed.

Post-delivery security checklist

Complete your security wrap-up before daily use

Complete security setup immediately after first acceptance, and review it again before team handoffs, runner changes, and the end of the rental term.

Replace temporary credentials

After completing the initial verification, replace temporary passwords or access credentials and confirm that the old credentials no longer work.

Enable key-based login

Use a dedicated SSH public key, verify authorized_keys, and restrict local private-key file permissions.

Limit shared accounts

Give each member a traceable access method instead of allowing long-term shared use of one administrator identity.

Delete unused files

Remove test archives, temporary downloads, expired caches, and unused credential copies, then review remaining capacity.

Record environment changes

Record Xcode switches, dependency upgrades, runner labels, and network changes so future troubleshooting has an audit trail.

Prepare an exit plan

Define where build artifacts, repository changes, and required logs will be exported; do not postpone data cleanup until after the rental term ends.

Ready to begin

Choose your configuration, then complete the first run using the checklist

Manage orders, renewals, and hosts in the console. Payments support only USDT-TRC20 and Visa / Mastercard / Amex (via Stripe); all charges are in US dollars (USD). Actual available gateways are determined by the backend response.