---
title: "Bring your first server"
description: "Add a server with one command, see it in a pool."
url: https://frazer.ai/docs/quickstarts/first-server
index: https://frazer.ai/docs/llms.txt
tokens: 2062
---

> For agents: this page is indexed at https://frazer.ai/docs/llms.txt, and every page at https://frazer.ai/llms.txt. Copy commands from this file exactly.

# Bring your first server

At the end of this guide, a Linux server you already run is part of Frazer: one command from your laptop has installed the agent, checked the server’s code and accepted it, Frazer has inspected it, and it is **Available** in a pool of your organization’s host project. Nothing on the server is wiped, and you keep its operating system.

You need:

-   A Frazer organization. Every organization has a host project named after it, `acme-infra` for Acme, where servers, sites and pools live.
-   The Servers admin role (`roles/servers.admin`) on the host project.
-   A Linux server you can reach with `ssh` as root, or as a user with `sudo`, running Ubuntu 22.04 or 24.04, Debian 12 or 13, or Rocky Linux or RHEL 9 or 10, with at least an x86-64-v2 CPU with 8 cores, 32 GB of memory (16 GB for a trial) and a 240 GB SSD to boot from.
-   Outbound access from the server on TCP 443 and UDP 51820 (or 443 only), NTP and DNS. No inbound port is opened for Frazer, and an HTTP(S) proxy works.

> **Note:** A server added this way keeps your operating system, so it becomes a **dedicated node**: a whole server for one cluster. To run VMs on a server (clusters of the `small` and `production` classes, devboxes, serverless), Frazer manages its OS: boot the Frazer image or connect a provider account instead. Both are in [Servers and pools](https://frazer.ai/docs/servers).

## Add the server

1.  **Install the CLI and sign in** on your laptop.
    
    ```sh
    curl -fsSL https://get.frazer.ai | sh
    frazer login
    ```
    
    `frazer login` opens your browser. On a machine without one, run `frazer login --no-browser` and enter the code it prints at `https://console.frazer.ai/device`.
    
2.  **Check that SSH works.** `ssh root@203.0.113.10` should log you in. The CLI runs your own `ssh` client, so your keys, agent, `~/.ssh/config` aliases and jump hosts work as they do now, and the server’s host key is checked against your `known_hosts`.
    
3.  **Pick the site and the pool.** A site is where the server sits: one failure domain, such as an office, a rack or a provider data center. This guide uses the site `sf-office` and its pool `sf-office-default`; create them in the console under **Infrastructure › Sites** if they do not exist yet.
    
4.  **Add the server.**
    
    ```sh
    frazer servers add root@203.0.113.10 --site sf-office --pool sf-office-default
    ```
    
    The CLI creates a **join token** for this run only: single use, short-lived and bound to the site and pool. A join token can only make a server appear as pending; it grants nothing else, and your own Frazer credentials never leave your laptop. Over SSH, the CLI runs the signed install script, which checks the signatures of itself and the agent before it installs anything. The agent runs its preflight checks, generates the server’s machine key on the server (sealed in the TPM when there is one) and prints a fingerprint and a 6-character code. The CLI reads the code over the same SSH session, so it knows the pending server is the machine you reached, and accepts it as you:
    
    ```text title="Output"
    ✓ SSH          root@203.0.113.10 · Ubuntu 24.04 · host key known
    ✓ Join token   sf-office · sf-office-default · single use · for this run only
    ✓ Agent        installed from get.frazer.ai/node · signature verified
    ✓ Preflight    kernel · cgroups v2 · clock · swap · disk · 443
    ✓ Machine key  generated on the server · TPM-sealed
    → Fingerprint  TPM EK 9f3a…c41e
    ✓ Code H4K-7NP read over SSH · accepted by lena@acme.example · audit entry
      inspecting … available
    ```
    
    Accepting gives the server a 24-hour certificate, renewed while it stays healthy. With it, Frazer can send typed operations only: inventory, health, join a cluster, reboot in your maintenance window. There is no shell, and a wipe or reinstall always needs your approval. The accept is recorded in the audit log with the fingerprint and the token used.
    
    From the moment you accept, the server is metered per physical core, by the hour; hyperthreads never count. See [pricing](https://frazer.ai/pricing#lines).
    
5.  **Watch it become available.** The command waits while the server is **Inspecting**, which runs six checks: certificate, inventory, disk health, operating system, network test and available. Burn-in is optional for a server you bring. When the checks pass, the server is **Available**: healthy and schedulable.
    
6.  **See it in the pool.** Open **Infrastructure › Pools** and select `sf-office-default`: the server is listed with its state, site and agent. From your laptop:
    
    ```sh
    frazer servers server-pools list --project acme-infra
    ```
    
    On the server, `sudo frazer-nodelet status` shows the agent’s own view. The agent sends a heartbeat every 30 seconds and listens on no network port except localhost.
    

## Other ways to run it

-   **On the server itself.** Install the CLI on the server, sign in with `frazer login --no-browser`, then run `sudo frazer servers add --site sf-office --pool sf-office-default` with no destination.
    
-   **Someone else accepts.** Add `--no-accept`, or run the command without the Servers admin role: the server waits as **Pending** in the console’s **Waiting for servers** panel, with its code, its fingerprint, the hardware it detected and the preflight results. An admin compares the code with the one the command printed, then chooses **Accept**. **Reject** deletes the record and blocks the fingerprint.
    
-   **Automation and cloud-init.** Create a join token in **Infrastructure › Servers › Add server › Run install command** or with `frazer servers join-tokens create`, and run the line it gives in the server’s cloud-init or your configuration management:
    
    ```sh
    curl -fsSL https://get.frazer.ai/node | sudo sh -s -- --token <join-token> --site sf-office
    ```
    
    The token expires in 24 hours by default (30 days at most), has a use limit and can be revoked. The server waits as pending until a person, or a pool rule, accepts it.
    

## If the server does not appear

Run `sudo frazer-nodelet diagnose` on the server. The usual causes:

-   **SSH fails.** The CLI stops before it changes anything and prints `ssh`’s own error. Check that `ssh root@203.0.113.10` works on its own.
-   **Outbound 443 is blocked.** Set `HTTPS_PROXY` on the server and run `frazer servers add` again.
-   **The clock is more than 5 minutes off.** Fix time sync, then run the command again.
-   **The token was used or has expired** (install command). Create a new one and run the line with it; `frazer servers add` makes a fresh token on every run.
-   **The server joined Frazer before.** The console offers to re-attach it to its existing record instead of creating a second one.

## Take the server back

Detach the server in the console, or run this on the server; it works even when Frazer is unreachable:

```sh
sudo frazer-nodelet detach
```

Frazer’s components and credentials are removed, and you choose whether to keep the disks, reset state or crypto-erase them. Billing stops, and the record stays for the audit log.

## Next steps

[Create a Kubernetes cluster](https://frazer.ai/docs/quickstarts/kubernetes-cluster) Plan and apply a cluster on servers in a pool.

[Servers and pools](https://frazer.ai/docs/servers) Sites, pools, sharing with projects, and every way to add a server.

[How it works](https://frazer.ai/how-it-works) The agent, Frazer Link, and what Frazer may do on a server.

[Servers on frazer.ai](https://frazer.ai/servers) The product page, with pools and controls.

## Pages in Get started

- [Docs home](https://frazer.ai/docs.md)
- [Bring your first server](https://frazer.ai/docs/quickstarts/first-server.md) (this page)
- [Create a Kubernetes cluster](https://frazer.ai/docs/quickstarts/kubernetes-cluster.md)
- [Deploy serverless with Postgres](https://frazer.ai/docs/quickstarts/serverless-postgres.md)
- [Deploy an open model](https://frazer.ai/docs/quickstarts/open-model.md)
- [Give your team devboxes](https://frazer.ai/docs/quickstarts/devboxes.md)
- [Connect your environment repo](https://frazer.ai/docs/quickstarts/environment-repo.md)
