---
order: 3
summary: Join two networks and publish one service, end to end, in about fifteen minutes.
title: Quickstart
path: quickstart
status: published
---

# Quickstart

This walks through the smallest useful deployment: two connectors, one
published service, one policy. Fifteen minutes if your egress is already open.

> **The endpoint names below are provisional.** `api.proxility.scailabs.ai`
> and `*.edge.proxility.scailabs.ai` do not resolve yet — the control plane is
> not generally available (see the status table on
> [Proxility](/docs/proxility)). Nobody should spend an afternoon debugging
> DNS for a service that has not launched. Correct these names here the moment
> the real ones exist.

## Before you start

- A Proxility tenant and a realm. If you have neither, ask your administrator
  or see [Tenants and realms](/docs/proxility/concepts/tenancy).
- Two networks, each with a Linux host that has **outbound** access to
  `*.edge.proxility.scailabs.ai` on UDP/443 (TCP/443 is the fallback).
- The `proxility` CLI on your workstation.

```bash
curl -fsSL https://downloads.scailabs.ai/proxility/install.sh | sh
proxility login            # opens a browser, authenticates via ScaiKey
proxility realm use acme/prod
```

## 1. Install the connector in the first network

On the host inside your data centre:

```bash
# Create the enrolment token on your workstation, not on the host
proxility connector create dc1 --description "Amsterdam DC, rack 4"
# → enrolment token: ptk_... (valid 60 minutes, single use)
```

Then on the host:

```bash
curl -fsSL https://downloads.scailabs.ai/proxility/install.sh | sh
proxility-connector enrol --token ptk_...
systemctl status proxility-connector
```

The connector generates its own keypair during enrolment. **The private key
never leaves the host** — the token only proves the host is allowed to ask for
a certificate. Check in:

```bash
proxility connector list
# NAME  IDENTITY                     EDGE        STATE
# dc1   prox://acme/prod/dc1         nlwest-std  connected
```

## 2. Install the connector in the second network

Same two steps, different name:

```bash
proxility connector create aws-prod --description "AWS eu-west-1, prod account"
# on the cloud host:
proxility-connector enrol --token ptk_...
```

## 3. Publish a service

Services are published by the connector that can reach them locally:

```bash
proxility service create payments \
  --connector dc1 \
  --target 10.20.4.17:8443 \
  --protocol tcp
```

That service is now named `payments.prod.acme.prox`. It is not yet reachable
by anyone.

## 4. Allow one thing

Default deny means nothing happens until you say so:

```bash
proxility policy allow \
  --from prox://acme/prod/aws-prod \
  --to payments.prod.acme \
  --ports 8443 \
  --description "prod API reaches the payments gateway"
```

## 5. Use it

From the cloud host:

```bash
curl -v https://payments.prod.acme.prox:8443/health
```

Name resolution happens inside the connector's split-horizon resolver; see
[Services and DNS](/docs/proxility/using/services-and-dns). The TLS session
your client negotiates is **your own**, end to end to the target — Proxility's
encryption is underneath it and does not terminate yours.

## 6. Watch the decision

```bash
proxility log tail --follow
# allow  prox://acme/prod/aws-prod → payments.prod.acme:8443  rule=prod-api-to-payments  12ms
```

A denied attempt looks like this, and names the absence of a rule rather than
failing silently:

```
deny   prox://acme/prod/dev-laptop → payments.prod.acme:8443  reason=no_matching_rule
```

## What to read next

- [Policy](/docs/proxility/concepts/policy) — how rules are written and
  evaluated, and why they are checked twice
- [Connect a network](/docs/proxility/using/connect-a-network) — production
  deployment: redundant connectors, sizing, upgrades
- [Cryptography](/docs/proxility/concepts/cryptography) — what actually
  protects the session
