> For the complete documentation index, see [llms.txt](https://service.block-pro.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://service.block-pro.net/mainnet/celestia/validator-node/fibre.md).

# Fibre

Set up Mainnet Fibre with private mTLS signing, storage and host registration.

**Mainnet Beta · Chain ID `celestia` · celestia-app / Fibre v11.0.0**

Install **Fibre v11.0.0** alongside the Mainnet consensus multiplexer before activation. Existing Fibre deployments can use their saved home, signer connection, health settings, storage and host registration. [Validator Upgrade](https://service.block-pro.net/mainnet/celestia/validator-node/upgrade.md) · [Official release](https://github.com/celestiaorg/celestia-app/releases/tag/v11.0.0)

Use a **separate Fibre server** in the same datacenter or region as the validator. Keep object storage nearby too: a distant bucket can delay endorsements. This guide uses two Linux hosts connected by a trusted private network.

## Requirements

| Item                  | Requirement                                                                                                                                                              |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| CPU                   | Pass the [official CPU benchmark](https://github.com/celestiaorg/celestia-app/blob/main/tools/cpu_requirements/README.md)                                                |
| RAM                   | At least 32 GB, with headroom for the configured connection limits                                                                                                       |
| Disk and bandwidth    | Size for your stake with the [official calculator](https://docs.google.com/spreadsheets/d/1P3k-KQrZxbRjRwIxWkJBNwgAFlFMJUdT7OupA_WoKa0/edit?gid=971673838#gid=971673838) |
| OS in this guide      | Ubuntu 24.04, Linux x86-64                                                                                                                                               |
| Validator             | Synchronized, bonded, active app version 10 or later                                                                                                                     |
| External KMS, if used | SignRawBytes support and median signing latency at or below 10 ms                                                                                                        |

Use the calculator's Mainnet tab and your current stake. Launch sizing and a possible higher-throughput scenario are different; a forecast is not an activated requirement. Add capacity for downloads, persistent local metadata and OS overhead.

Default receive buffers can consume approximately `16 × 13 × 132 MiB ≈ 27 GiB`. Raising `max_connections` or `max_concurrent_streams` requires more memory. An upload can occupy all 16 default connection slots; increasing that limit leaves room for downloads but raises the RAM budget.

### Run the CPU benchmark

If Docker is installed, run the official test before placing production workload on this host.

```bash
docker run --rm ghcr.io/celestiaorg/128mb-6s-benchmark:v0.0.1
```

## Connection plan

Replace these **example private addresses** throughout the guide.

| Connection                 | Example           | Access                                     |
| -------------------------- | ----------------- | ------------------------------------------ |
| Validator application gRPC | `10.0.0.10:9090`  | Fibre host only, trusted private network   |
| Validator signing gRPC     | `10.0.0.10:26669` | Fibre host only, mutual TLS                |
| Fibre private IP           | `10.0.0.20`       | Source allowed by validator firewall rules |
| Fibre client listener      | `0.0.0.0:7980`    | Public TCP 7980                            |

Application gRPC is separate from core RPC gRPC. Preserve the bridge's existing core listener, commonly `9098`; Fibre uses the application listener in `app.toml`.

Fibre requests signatures through the validator node, which forwards them to a KMS if configured. Do not copy the consensus private key or operator wallet to Fibre.

## Validator host: readiness

### Check synchronization

Confirm celestia, a current block time and catching\_up=false.

```bash
curl -fsS http://127.0.0.1:26657/status | jq '.result | {chain: .node_info.network, height: .sync_info.latest_block_height, time: .sync_info.latest_block_time, catching_up: .sync_info.catching_up}'
```

### Check active app version

Require 10 or later. An installed v10 multiplexer alone does not prove activation.

```bash
curl -fsS http://127.0.0.1:26657/abci_info | jq -r '.result.response.app_version'
```

### Check the installed release

Use the matching Mainnet release; see the Validator Upgrade guide if needed.

```bash
celestia-appd version
```

### Back up configuration

Run as the validator service user. Use a fresh backup path if this one exists.

```bash
cp -a "$HOME/.celestia-app/config" "$HOME/.celestia-app/config.before-fibre"
```

### Enable application gRPC

Edit the existing section without duplicating it.

```bash
nano "$HOME/.celestia-app/config/app.toml"
```

```toml
[grpc]
enable = true
address = "10.0.0.10:9090"
```

Set enable=true explicitly. Embedded v9 behavior could hide a disabled value; v10 uses the saved setting. Restrict this plaintext listener to the Fibre host over the trusted private network.

## Certificates for private signing

Use a dedicated CA and separate server/client certificates. The server certificate SAN must match the private address Fibre dials. Run the following in a **new directory on a trusted administration machine**, with Bash and OpenSSL.

### Create the private workspace

Use another path if this directory already exists.

```bash
install -d -m 0700 "$HOME/fibre-pki"
```

### Open the workspace

Generate the certificate files here.

```bash
cd "$HOME/fibre-pki"
```

### Restrict new files

Limit access to newly created private keys.

```bash
umask 077
```

### Create the CA

Keep ca.key offline after issuing certificates.

```bash
openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes \
  -keyout ca.key -out ca.crt -days 3650 -subj "/CN=fibre-private-ca"
```

### Create the validator CSR

This TLS key is separate from the consensus signing key.

```bash
openssl req -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes \
  -keyout validator.key -out validator.csr -subj "/CN=validator-privval"
```

### Sign the validator certificate

Replace 10.0.0.10 with the exact dialed address. For a hostname, use DNS:your-private-name instead of IP:10.0.0.10.

```bash
openssl x509 -req -in validator.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -out validator.crt -days 365 \
  -extfile <(printf "subjectAltName=IP:10.0.0.10\nextendedKeyUsage=serverAuth\n")
```

### Create the Fibre CSR

Generate a separate client TLS key.

```bash
openssl req -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes \
  -keyout fibre.key -out fibre.csr -subj "/CN=fibre-client"
```

### Sign the Fibre certificate

Issue a certificate for client authentication.

```bash
openssl x509 -req -in fibre.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -out fibre.crt -days 365 \
  -extfile <(printf "extendedKeyUsage=clientAuth\n")
```

### Verify both certificates

Both must verify successfully.

```bash
openssl verify -CAfile ca.crt validator.crt fibre.crt
```

Transfer `ca.crt`, `validator.crt` and `validator.key` securely to the validator. Transfer `ca.crt`, `fibre.crt` and `fibre.key` securely to Fibre. Keep the CA private key off both production hosts.

## Validator host: configure mTLS

These steps assume the validator's three files were securely placed in `$HOME/fibre-tls-incoming` for the existing service user.

### Create the certificate directory

Run as the validator service user.

```bash
install -d -m 0700 "$HOME/.celestia-app/tls"
```

### Install the node certificates

Copy only the CA certificate and this host's certificate/key.

```bash
install -m 0600 "$HOME/fibre-tls-incoming/ca.crt" "$HOME/fibre-tls-incoming/validator.crt" "$HOME/fibre-tls-incoming/validator.key" "$HOME/.celestia-app/tls/"
```

### Edit signing settings

Update these top-level keys before the first section. Certificate paths are relative to the node home.

```bash
nano "$HOME/.celestia-app/config/config.toml"
```

```toml
priv_validator_grpc_laddr = "10.0.0.10:26669"
priv_validator_grpc_cert_file = "tls/validator.crt"
priv_validator_grpc_key_file = "tls/validator.key"
priv_validator_grpc_client_ca_file = "tls/ca.crt"
priv_validator_grpc_allow_insecure = false
```

All three TLS fields are required together. Restrict TCP 9090 and 26669 to the Fibre host at the host and provider firewalls. Use a trusted private route or VPN: signing mTLS does not encrypt the separate application-gRPC connection.

### Review service overrides

Check that flags do not replace the intended connection settings.

```bash
sudo systemctl cat celestia-appd
```

### Restart the validator

Apply configuration with the existing home and signing identity.

```bash
sudo systemctl restart celestia-appd
```

### Verify recovery

Confirm normal block processing and validator signing before proceeding.

```bash
sudo journalctl -u celestia-appd -n 100 --no-pager -o cat
```

## Fibre host: install

Use the same release as your validator. These commands target Linux x86-64; arm64 needs its matching official asset. Fibre requires glibc 2.34 or newer, while the consensus multiplexer requires glibc 2.38.

### Refresh packages

Load the package index.

```bash
sudo apt update
```

### Install utilities

Install download, configuration and connectivity tools.

```bash
sudo apt install -y ca-certificates curl jq nano openssl netcat-openbsd
```

### Create a download directory

Keep release files separate from service data.

```bash
FIBRE_DOWNLOAD=$(mktemp -d "$HOME/fibre-download.XXXXXX")
```

### Open the directory

Download and verify the archive here.

```bash
cd "$FIBRE_DOWNLOAD"
```

### Download Fibre

Select the Mainnet v11.0.0 archive.

```bash
curl -fL --retry 3 https://github.com/celestiaorg/celestia-app/releases/download/v11.0.0/fibre_Linux_x86_64.tar.gz -o fibre_Linux_x86_64.tar.gz
```

### Download checksums

Use the checksum list from the same release.

```bash
curl -fL --retry 3 https://github.com/celestiaorg/celestia-app/releases/download/v11.0.0/checksums.txt -o checksums.txt
```

### Select the checksum

Save the entry for this archive.

```bash
awk '$2 == "fibre_Linux_x86_64.tar.gz" {print}' checksums.txt > fibre.sha256
```

### Check the entry

Stop unless there is exactly one matching entry.

```bash
test "$(wc -l < fibre.sha256)" -eq 1
```

### Verify the download

Continue only when the result is OK.

```bash
sha256sum --check fibre.sha256
```

### Extract the binary

Extract inside the fresh download directory.

```bash
tar -xzf fibre_Linux_x86_64.tar.gz
```

### Install Fibre

Install the verified executable.

```bash
sudo install -m 0755 fibre /usr/local/bin/fibre
```

### Check the version

Confirm it matches the validator's release.

```bash
fibre version
```

## Fibre host: configure the service

This example uses a dedicated disk mounted at `/mnt/fibre` and a service user named `fibre`. Provision and persist the mount first. Do not format a disk containing node data. For an existing deployment, keep its current account and data home.

### Create the service account

Run once on a fresh host; skip if this account already exists.

```bash
sudo useradd --system --create-home --home-dir /var/lib/fibre --shell /usr/sbin/nologin fibre
```

### Verify the dedicated mount

Stop if this fails. Adapt the path if your mounted disk is elsewhere.

```bash
mountpoint -q /mnt/fibre
```

### Create service directories

Give Fibre access to its own data and TLS directories.

```bash
sudo install -d -o fibre -g fibre -m 0750 /mnt/fibre/data /mnt/fibre/data/config /etc/fibre /etc/fibre/tls
```

### Install client TLS files

Assumes the Fibre files were securely transferred to your login user's fibre-tls-incoming directory.

```bash
sudo install -o fibre -g fibre -m 0600 "$HOME/fibre-tls-incoming/ca.crt" "$HOME/fibre-tls-incoming/fibre.crt" "$HOME/fibre-tls-incoming/fibre.key" /etc/fibre/tls/
```

### Write server configuration

For an existing home, edit its current keys rather than replacing unrelated settings.

```bash
sudo nano /mnt/fibre/data/config/server_config.toml
```

```toml
app_grpc_address = "10.0.0.10:9090"
signer_grpc_address = "10.0.0.10:26669"
signer_grpc_ca_file = "/etc/fibre/tls/ca.crt"
signer_grpc_cert_file = "/etc/fibre/tls/fibre.crt"
signer_grpc_key_file = "/etc/fibre/tls/fibre.key"
server_listen_address = "0.0.0.0:7980"
max_connections = 16
max_concurrent_streams = 13
storage_backend = "local"

[health]
check_interval = "10s"
probe_timeout = "3s"
max_block_age = "2m"
```

The `[health]` values above are defaults. Keep intentional custom values. When reviewing an older configuration, add missing settings manually or use the [official config-sync reference](https://github.com/celestiaorg/celestia-app/blob/v11.0.0/fibre/cmd/README.md#config) on the host containing the file. Update the existing table when adding these settings.

### Create the systemd unit

Use the same data path in the unit. RequiresMountsFor makes the mount a service dependency.

```bash
sudo nano /etc/systemd/system/fibre.service
```

```ini
[Unit]
Description=Celestia Mainnet Fibre
Wants=network-online.target
After=network-online.target
RequiresMountsFor=/mnt/fibre/data

[Service]
User=fibre
Group=fibre
ExecStart=/usr/local/bin/fibre start --home /mnt/fibre/data
Restart=on-failure
RestartSec=5
LimitNOFILE=65535
TimeoutStopSec=120

[Install]
WantedBy=multi-user.target
```

### Test the signing connection

Verify server identity and client authentication from the Fibre host. Use the private IP included in the validator certificate SAN.

```bash
sudo -u fibre openssl s_client -connect 10.0.0.10:26669 \
  -CAfile /etc/fibre/tls/ca.crt -cert /etc/fibre/tls/fibre.crt \
  -key /etc/fibre/tls/fibre.key -verify_ip 10.0.0.10 \
  -verify_return_error -alpn h2 </dev/null
```

For a DNS SAN, replace `-verify_ip` with `-verify_hostname your-private-name`. This handshake checks TLS; startup logs confirm the application connections.

### Reload systemd

Load the new unit.

```bash
sudo systemctl daemon-reload
```

### Start Fibre

Proceed after the validator and mTLS checks succeed.

```bash
sudo systemctl enable --now fibre
```

### Check startup

Confirm chain celestia, validator addresses and the selected storage backend.

```bash
sudo journalctl -u fibre -n 100 --no-pager -o cat
```

Allow public TCP 7980 on the Fibre host. Its client-facing TLS certificate is generated and endorsed automatically; no public web-server certificate is required.

## Register the public address

Run transaction commands on the trusted host containing your operator wallet. Register only after the Fibre service is reachable. Use a public IP or DNS name with a port, without `https://` or a path.

### Check external reachability

Run from outside the Fibre server's network. This tests TCP reachability, not a complete upload.

```bash
nc -vz YOUR_PUBLIC_FIBRE_HOST 7980
```

### Set the transaction gas price

Use a price accepted by your endpoint, including the utia denomination.

```bash
GAS_PRICE="YOUR_GAS_PRICE_IN_UTIA"
```

### Register Fibre

Use your bonded validator's operator account and review the confirmation.

```bash
celestia-appd tx valaddr set-host YOUR_PUBLIC_FIBRE_HOST:7980 \
  --from validator --keyring-backend file --home "$HOME/.celestia-app" \
  --chain-id celestia --node http://127.0.0.1:26657 \
  --gas auto --gas-adjustment 1.5 --gas-prices "$GAS_PRICE"
```

### Read the consensus address

Copy the celestiavalcons address for the registry query.

```bash
celestia-appd comet show-address --home "$HOME/.celestia-app"
```

### Verify registration

Replace YOUR\_VALCONS\_ADDRESS. Require found=true and the intended public host.

```bash
celestia-appd query valaddr provider YOUR_VALCONS_ADDRESS --node http://127.0.0.1:26657
```

Registration survives restarts. Repeat it only after an address change or removal of the registry entry. Monitor endorsements and validator signing; an open port alone does not prove correct operation.

## Health and readiness

Use `grpc_health_probe` from its [official releases](https://github.com/grpc-ecosystem/grpc-health-probe/releases). The following checks run locally **on the Fibre host** against its TLS listener; adjust the port if yours differs.

Check whether Fibre is ready.

```bash
grpc_health_probe -addr=127.0.0.1:7980 -tls -tls-no-verify
```

Check whether the Fibre process answers, even if a dependency is unavailable.

```bash
grpc_health_probe -addr=127.0.0.1:7980 -tls -tls-no-verify -service=fibre-liveness
```

Expect `SERVING` for both after setup and registration. Readiness may remain `NOT_SERVING` until the validator is bonded, the public host is registered, and the next health check succeeds. Liveness alone does not prove readiness.

These commands skip conventional certificate verification only for a local diagnostic: Fibre uses a validator-endorsed certificate. They do not authenticate a remote validator. Keep this check on loopback; use a Fibre-aware client for remote identity verification.

Readiness checks cover the app connection and recent blocks, signer identity, validator membership, host registration and the local metadata store. A failure is reported in the Fibre log; it does not itself disable uploads or downloads.

Read the failed check and its recovery advice.

```bash
sudo journalctl -u fibre -n 100 --no-pager -o cat
```

The gRPC health service shares port `7980`; no separate HTTP health port is required. An unexpected gRPC server exit now ends the process, so keep a supervisor such as systemd with `Restart=on-failure`.

The internal readiness check cannot prove public reachability or a successful upload. Continue checking the public address from outside the network and monitor real upload/endorsement success.

## Optional object storage

Fibre supports S3-compatible shard storage while keeping its metadata database on local persistent disk. Place the bucket in the same region as Fibre and grant bucket-scoped read, write, list and delete access.

**HTTPS remains required.** A configured `object_storage.endpoint` must be an absolute `https://` URL. HTTP fails validation. Startup also checks bucket accessibility using the service credentials and fails if the bucket check fails. Confirm bucket-level permissions as well as object read/write/delete permissions.

### Edit the backend

Edit the existing root-level `storage_backend` key **before any `[table]` headings**, then add or edit one `[object_storage]` table. Do not place `storage_backend` inside `[health]`. Use your actual provider values.

```bash
sudo nano /mnt/fibre/data/config/server_config.toml
```

```toml
storage_backend = "object"

[object_storage]
endpoint = "https://s3.YOUR_REGION.amazonaws.com"
region = "YOUR_REGION"
bucket = "YOUR_BUCKET"
prefix = "fibre"
```

For R2, use the account's S3 API endpoint and `region = "auto"`. Keep credentials out of this TOML file.

### Create a private credentials file

First setup only. For rotation, edit the existing file instead of replacing it with an empty one.

```bash
sudo install -m 0600 /dev/null /etc/fibre/s3.env
```

### Enter credentials

Enter secrets locally; never post them in shared documentation.

```bash
sudo nano /etc/fibre/s3.env
```

```ini
AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY=YOUR_SECRET_ACCESS_KEY
```

Add AWS\_SESSION\_TOKEN for temporary credentials. A suitable instance role may supply credentials instead of a file.

### Add the service environment

Add this systemd override.

```bash
sudo systemctl edit fibre
```

```ini
[Service]
EnvironmentFile=/etc/fibre/s3.env
```

### Reload the unit

Load the environment-file override.

```bash
sudo systemctl daemon-reload
```

### Restart Fibre

Apply storage settings and credentials.

```bash
sudo systemctl restart fibre
```

### Verify object storage

Check the effective backend and canonical bucket/prefix in startup logs.

```bash
sudo journalctl -u fibre -n 100 --no-pager -o cat
```

### Change backend or migrate a bucket

Switching between local and object storage changes where new shards go; existing shards stay in their original location. Keep their data available until pruned. After switching back to local, keep the previous object configuration and credentials while object-backed shards remain.

For a bucket move:

1. Stop Fibre and copy every object to the new bucket, preserving key layout.
2. Verify the copy is complete, then update the endpoint/bucket/prefix and credentials.
3. Start once with `--override-object-namespace` appended to the existing start command. This flag does not copy or verify objects.
4. Remove the flag and restart normally. Retain the original bucket until serving from the new one is verified.

When replacing an old HTTP endpoint with HTTPS, confirm it reaches the same bucket and retained objects. The endpoint is part of the recorded namespace, so an intentional scheme change may require the same reviewed namespace procedure; do not bypass a mismatch without verifying the objects.

Follow the [official migration procedure](https://docs.celestia.org/operate/consensus-validators/fibre/#migrate-to-another-bucket). Do not use the override to hide an unexplained namespace mismatch.

## Same-host signing and troubleshooting

For local plaintext signing, both services must use a loopback **IP literal**, such as `127.0.0.1:26669` or `[::1]:26669`. `localhost` no longer qualifies. Leave the TLS fields empty only for this local mode, and keep application gRPC at `127.0.0.1:9090`. A separate Fibre host with mTLS is the recommended production layout.

| Symptom                          | Check                                                                                  |
| -------------------------------- | -------------------------------------------------------------------------------------- |
| Missing Fibre or valaddr service | Active app version and application-gRPC endpoint                                       |
| Application gRPC refused         | enable=true, private bind address, route and firewall                                  |
| Signing connection fails         | Port, complete mTLS fields, and SAN matching the dialed address                        |
| Unknown configuration field      | Correct the exact field reported by the binary                                         |
| Health reports NOT\_SERVING      | Check the named failure in logs, app sync, signer, bonded status and host registration |
| Object endpoint rejected         | Replace HTTP with a valid HTTPS endpoint and verify namespace continuity               |
| Bucket check fails               | Check TLS, network reachability, bucket name and service credential permissions        |
| Object credential error          | Service environment, credential scope and file permissions                             |
| Object namespace mismatch        | Restore the original namespace or complete a verified migration                        |
| High endorsement latency         | Validator/Fibre/bucket placement, signer latency and memory pressure                   |

Rotate certificates before expiry and restart the validator and Fibre after replacing them. With a remote signer, monitor the validator's `cometbft_privval_signing_latency_*` metrics. Never enable the remote insecure-signing overrides in production.

[v11.0.0 release](https://github.com/celestiaorg/celestia-app/releases/tag/v11.0.0) · [Health reference](https://github.com/celestiaorg/celestia-app/blob/v11.0.0/fibre/cmd/README.md#health) · [Validator Upgrade](https://service.block-pro.net/mainnet/celestia/validator-node/upgrade.md) · [Official Fibre guide](https://docs.celestia.org/operate/consensus-validators/fibre/) · [mTLS reference](https://github.com/celestiaorg/celestia-core/blob/main/docs/guides/privval-grpc-tls.md) · [Fibre server specification](https://github.com/celestiaorg/celestia-app/blob/v11.0.0/specs/src/fibre_server.md)
