A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
---
# SPDX-License-Identifier: AGPL-3.0-or-later
title: Environment variables
description: Every environment variable Fluxer and the Docker Compose bundle use.
sidebar:
label: Environment variables
---
rexctl generates this page and the `.env.example` in the compose bundle of each release. Use the `.env.example` that came with your release. An entry for a setting rexctl manages ends with the `rexctl config set` command that changes it.
## Required
Fill these in before the first start.
### `FLUXER_SETTINGS_LOADED`
Leave it set to `true`. Docker Compose won't start without it.
### `FLUXER_DOMAIN`
The domain Fluxer runs on, such as `chat.example.com`. With rexctl, use `rexctl config set domain`.
## First admin account
### `FLUXER_SETUP_TOKEN`
The token the setup wizard asks for before it creates the first admin account. Use 32 to 256 printable characters, such as the output of `openssl rand -hex 32`. When it's empty, the API generates one on its first start and writes it to its log once. With Docker Compose, `docker compose logs api` shows it. Keep it secret.
## Secrets
Fill these in before the first start, and keep a copy of `.env` somewhere safe. Only `FLUXER_ACTIVITYPUB_SIGNING_KEY_BASE64` may stay empty. rexctl generates these when it installs Fluxer. With Docker Compose, [these commands](/operator/docker-compose/#fill-in-env) fill them in.
### `FLUXER_S3_ACCESS_KEY`
The object store access key. Keep the default for the bundled object store, or set the access key of your own store. The default is `fluxer`. With rexctl, use `rexctl config set storage.access_key`.
### `LIVEKIT_API_KEY`
The LiveKit API key. Docker Compose passes it to the bundled LiveKit as its API key and webhook key, and to Fluxer as `FLUXER_LIVEKIT_API_KEY`. The value is `fluxer`.
### `POSTGRES_PASSWORD`
The Postgres password. Docker Compose passes it to Fluxer as `FLUXER_POSTGRES_PASSWORD` and to the bundled Postgres, which sets it only on its first start with an empty data directory. Set it once before the first start and never change it. Keep it secret.
### `MEILI_MASTER_KEY`
The Meilisearch master key. Docker Compose passes it to the bundled Meilisearch and to Fluxer as `FLUXER_SEARCH_API_KEY`. Set it once before the first start and never change it. Keep it secret.
### `FLUXER_S3_SECRET_KEY`
The object store secret key. For your own object store, set its secret key, and update it when you rotate the key at the store. With Docker Compose, a new value applies the next time it starts the services. Keep it secret. With rexctl, use `rexctl config set storage.secret_key`.
### `LIVEKIT_API_SECRET`
The LiveKit API secret that goes with `LIVEKIT_API_KEY`, at least 32 characters. Docker Compose passes it to the bundled LiveKit and to Fluxer as `FLUXER_LIVEKIT_API_SECRET`. With Docker Compose, a new value applies the next time it starts the services. Keep it secret.
### `FLUXER_SUDO_MODE_SECRET`
The key Fluxer signs sudo mode tokens with and derives a few other internal signing keys from. Changing it ends every active sudo mode session, voids codes already emailed and makes every remembered device count as new. Keep it secret.
### `FLUXER_CONNECTION_INITIATION_SECRET`
The key that signs connection initiation tokens, data export links and admin download links. Changing it breaks tokens not yet verified and download links already sent. Keep it secret.
### `FLUXER_PROFILE_PSEUDONYM_SECRET`
The key Fluxer uses to derive the placeholder name and tag that others see while an account's profile is hidden. The api, worker and users services must have the same value. Changing it gives every hidden profile a new placeholder. Keep it secret.
### `FLUXER_GATEWAY_RPC_AUTH_TOKEN`
The token the api, worker, gateway and push services use to authenticate internal calls to each other. Every service must have the same value. Keep it secret.
### `FLUXER_ERLANG_COOKIE`
The shared secret for Erlang distribution in the gateway. Anyone who can connect to the distribution port with this value can run code in the gateway. Keep the value secret and the port private.
### `FLUXER_MEDIA_PROXY_SECRET_KEY`
The key that signs the `/external/` URLs for third-party media, such as link preview images and GIF results. The API also uses it to call the media proxy's internal endpoints. It doesn't sign uploaded attachments, which use `FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64`. The api, worker, media-proxy, gifs and unfurl services must have the same value, so change it on all of them and restart them together. Changing it doesn't affect anything stored, but proxy URLs that were already handed out stop working, such as link preview images in clients that are already open, until they reload. Keep it secret.
### `FLUXER_ADMIN_SECRET_KEY_BASE`
The key the admin panel signs its sessions, CSRF tokens and OAuth state with. Changing it signs everyone out of the admin panel. Keep it secret.
### `FLUXER_ADMIN_OAUTH_CLIENT_SECRET`
The OAuth2 client secret the admin panel uses to sign in through the API. The api and admin services must have the same value. Keep it secret.
### `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SECRET_BASE64`
The key that signs upload relay tokens, as standard base64 that decodes to at least 32 bytes. The api, worker and media-proxy services must have the same value. Keep it secret.
### `FLUXER_ACTIVITYPUB_SIGNING_KEY_BASE64`
The RSA private key the unfurl service signs ActivityPub requests with when it builds link previews for fediverse posts. Use base64 DER in PKCS#8 or PKCS#1 form. When it's empty, the unfurl service makes those requests unsigned. Keep it secret.
### `FLUXER_VAPID_PUBLIC_KEY`
The public half of the VAPID key pair for browser push notifications, as unpadded base64url of the 65-byte uncompressed P-256 point. The value is 87 characters long. Set the pair once before the first start and never change it.
### `FLUXER_VAPID_PRIVATE_KEY`
The private half of the VAPID key pair for browser push notifications, as unpadded base64url of the 32-byte P-256 private key. The value is 43 characters long. It must match `FLUXER_VAPID_PUBLIC_KEY`. Set the pair once before the first start and never change it. Keep it secret.
## Compose files
The optional compose files change how Fluxer runs. To use one, list it after `docker-compose.yml` in `COMPOSE_FILE`, such as `COMPOSE_FILE=docker-compose.yml:docker-compose.proxy.yml`.
- `docker-compose.proxy.yml` for your own reverse proxy
- `tunnel.compose.yml` for a tunnel
- `external-object-store.compose.yml` for your own object store
- `ipv6.compose.yml` for IPv6 on Fluxer's network
- `external-voice.compose.yml` for voice servers of your own without the bundled LiveKit
### `COMPOSE_FILE`
The compose files Docker Compose uses, with `docker-compose.yml` first. Separate them with colons, or with semicolons on Windows. rexctl takeover uses the value in your shell first and then the one in `.env`. Leave it commented out to use `docker-compose.yml` and, if there is one, `docker-compose.override.yml`. An empty value stops Docker Compose from finding any file.
### `COMPOSE_PATH_SEPARATOR`
The separator between the files in `COMPOSE_FILE`. When it's empty, Docker Compose and rexctl use a colon, or a semicolon on Windows.
### `COMPOSE_PROJECT_NAME`
The Docker Compose project name, which Docker Compose puts in front of every container and volume name. When it's empty, Docker Compose uses `fluxer` from `docker-compose.yml`. rexctl eject writes the project name rexctl ran the instance under. Keep that value, or Docker Compose starts new containers with new, empty volumes. rexctl takeover uses the value in your shell first and then the one in `.env`.
## Public address
Fluxer works out every address from `FLUXER_DOMAIN`. Set these only when a part of Fluxer runs on another address.
### `FLUXER_PUBLIC_SCHEME`
The scheme browsers use to open the instance. Use `https` or `http`. Fluxer builds public addresses from it and `FLUXER_DOMAIN` when `FLUXER_PUBLIC_ORIGIN` is empty. With `http`, also set `FLUXER_PUBLIC_PORT`, usually to `80`. Without rexctl, the edge also uses it for its default site address. The default is `https`. rexctl sets this from your domain and edge settings unless you set it. With rexctl, use `rexctl config set FLUXER_PUBLIC_SCHEME`.
### `FLUXER_PUBLIC_ORIGIN`
The origin browsers use to open the instance, as a scheme, host and optional port with no path or trailing slash, such as `https://chat.example.com:8443`. When it's set, the default public addresses of the api, worker and other services come from it. Keep `FLUXER_DOMAIN` set to the same host. The edge site address, the passkey relying party ID, the default sender and VAPID contact addresses and the gateway still use `FLUXER_DOMAIN`. rexctl sets this from your domain and edge settings unless you set it. With rexctl, use `rexctl config set FLUXER_PUBLIC_ORIGIN`.
### `FLUXER_APP_ORIGIN_ALIASES`
More web app origins, separated by commas, for an instance that serves the web app on more than one hostname. Each must be an http or https origin. The API allows each one through CORS and accepts it for sign-in handoff. For passkeys on these origins, list them and the web app origin in `FLUXER_PASSKEY_ADDITIONAL_ALLOWED_ORIGINS`. With rexctl, use `rexctl config set FLUXER_APP_ORIGIN_ALIASES`.
### `FLUXER_API_ENDPOINT`
The public base URL of the API. When it's empty, Fluxer uses the public origin followed by `/api`. With rexctl, use `rexctl config set FLUXER_API_ENDPOINT`.
### `FLUXER_API_CLIENT_ENDPOINT`
The API base URL Fluxer hands to clients. When it's empty, Fluxer uses the public origin followed by `/api`. With rexctl, use `rexctl config set FLUXER_API_CLIENT_ENDPOINT`.
### `FLUXER_API_DISCOVERY_PUBLIC_ENDPOINT`
The public API base URL Fluxer lists in instance discovery as `api_public`. The ActivityPub actor and its key ID use the same address, so its host must serve `/.well-known/webfinger`, and changing it on an instance with a signing key gives remote servers a new actor. When it's empty, Fluxer uses `FLUXER_API_ENDPOINT`. Webhooks, signed links and Bluesky sign-in always use `FLUXER_API_ENDPOINT`. With rexctl, use `rexctl config set FLUXER_API_DISCOVERY_PUBLIC_ENDPOINT`.
### `FLUXER_APP_ENDPOINT`
The address of the web app, which Fluxer allows through CORS and uses in links. When it's empty, Fluxer uses the public origin. With rexctl, use `rexctl config set FLUXER_APP_ENDPOINT`.
### `FLUXER_GATEWAY_ENDPOINT`
The public WebSocket URL of the gateway, starting with `ws` or `wss`. When it's empty, Fluxer uses `wss` on the public host followed by `/gateway`, or `ws` when the public scheme is `http`. With rexctl, use `rexctl config set FLUXER_GATEWAY_ENDPOINT`.
### `FLUXER_MEDIA_ENDPOINT`
The public address of the media proxy. When it's empty, Fluxer uses the public origin followed by `/media`. With rexctl, use `rexctl config set FLUXER_MEDIA_ENDPOINT`.
### `FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT`
The public media proxy address that the gifs, unfurl and media-proxy services use when they build media links. When it's empty, they use `FLUXER_MEDIA_ENDPOINT`, or the public origin followed by `/media`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_PUBLIC_ENDPOINT`.
### `FLUXER_STATIC_CDN_ENDPOINT`
The origin Fluxer serves static assets such as the favicon and app icons from. When it's empty, the api and worker services derive it from `FLUXER_STATIC_CDN_DOMAIN` or the public origin, and the admin and gateway services use the public origin. The app-proxy service uses it only when it's set, and serves its own copies of the web app files otherwise. With rexctl, use `rexctl config set FLUXER_STATIC_CDN_ENDPOINT`.
### `FLUXER_ADMIN_ENDPOINT`
The public address of the admin panel. When it's empty, Fluxer uses the public origin followed by `FLUXER_ADMIN_BASE_PATH`. The admin sign-in redirect is this address followed by `/oauth2_callback`, the single sign-on redirect is this address followed by `/sso/callback`, and the admin panel uses secure cookies when the address starts with `https`. With rexctl, use `rexctl config set FLUXER_ADMIN_ENDPOINT`.
### `FLUXER_MARKETING_ENDPOINT`
The address of the marketing site, which Fluxer allows through CORS and uses in some links. When it's empty, Fluxer uses the public origin. With rexctl, use `rexctl config set FLUXER_MARKETING_ENDPOINT`.
### `FLUXER_INVITE_ENDPOINT`
The base URL of invite links. When it's empty, Fluxer uses `FLUXER_INVITE_DOMAIN` or the public host, followed by `/invite`. With rexctl, use `rexctl config set FLUXER_INVITE_ENDPOINT`.
### `FLUXER_GIFT_ENDPOINT`
The base URL of gift links. When it's empty, Fluxer uses `FLUXER_GIFT_DOMAIN` or the public host, followed by `/gift`. With rexctl, use `rexctl config set FLUXER_GIFT_ENDPOINT`.
### `FLUXER_STATIC_CDN_DOMAIN`
A separate hostname for static assets, with no scheme, port or path. When it's set, the default static address of the api and worker services is `https://` followed by this host. With rexctl, use `rexctl config set FLUXER_STATIC_CDN_DOMAIN`.
### `FLUXER_INVITE_DOMAIN`
A separate hostname for invite links, with no scheme, port or path. When it's set, the default invite address uses this host. With rexctl, use `rexctl config set FLUXER_INVITE_DOMAIN`.
### `FLUXER_GIFT_DOMAIN`
A separate hostname for gift links, with no scheme, port or path. When it's set, the default gift address uses this host. With rexctl, use `rexctl config set FLUXER_GIFT_DOMAIN`.
## Edge and HTTPS
By default Fluxer listens on ports 80 and 443 and gets its own HTTPS certificate for your domain.
### `FLUXER_PUBLIC_PORT`
The port people use in Fluxer's address, when it differs from the one Fluxer listens on. The default is `443`. rexctl sets this from your domain and edge settings unless you set it. With rexctl, use `rexctl config set edge.public_port`.
### `FLUXER_HTTP_PORT`
The port Fluxer listens on for HTTP. `docker-compose.proxy.yml` and `tunnel.compose.yml` ignore it and use `FLUXER_EDGE_BIND`. The default is `80`. With rexctl, use `rexctl config set edge.http_port`.
### `FLUXER_HTTPS_PORT`
The port Fluxer listens on for HTTPS. If people connect to this port directly, set `FLUXER_PUBLIC_PORT` to the same port. `docker-compose.proxy.yml` and `tunnel.compose.yml` ignore it and use `FLUXER_EDGE_BIND`. The default is `443`. With rexctl, use `rexctl config set edge.https_port`.
### `FLUXER_EDGE_BIND`
The address your reverse proxy or tunnel connects to. The default is `127.0.0.1:8080` with `docker-compose.proxy.yml`, or `127.0.0.1:80` with `tunnel.compose.yml`. With rexctl, use `rexctl config set edge.bind`.
### `FLUXER_EDGE_LISTEN_ADDRESS`
The IP address on this machine that Fluxer listens on for HTTP and HTTPS, or empty for every address. Write an IPv6 address without brackets. `docker-compose.proxy.yml` and `tunnel.compose.yml` ignore it and use `FLUXER_EDGE_BIND`. With rexctl, use `rexctl config set edge.listen_address`.
### `FLUXER_ADMIN_BASE_PATH`
The path the admin panel is served under, with a leading slash and no trailing slash, such as `/panel`. The edge serves the admin panel under this path, the admin service builds its links with it, and the default `FLUXER_ADMIN_ENDPOINT` follows it. The default is `/admin`. With rexctl, use `rexctl config set FLUXER_ADMIN_BASE_PATH`.
### `FLUXER_EDGE_SITE_ADDRESS`
The site address the edge serves in its Caddyfile, including the scheme. When it's empty, Docker Compose uses `FLUXER_CADDY_SITE_ADDRESS`, or `FLUXER_PUBLIC_SCHEME` followed by `://` and `FLUXER_DOMAIN`. `docker-compose.proxy.yml` and `tunnel.compose.yml` set their own value. rexctl sets this from your domain and edge settings unless you set it. With rexctl, use `rexctl config set FLUXER_EDGE_SITE_ADDRESS`.
### `FLUXER_CADDY_SITE_ADDRESS`
The old name for `FLUXER_EDGE_SITE_ADDRESS`. Docker Compose uses it only without rexctl and when `FLUXER_EDGE_SITE_ADDRESS` is empty. rexctl takeover and rexctl upgrade move it to `FLUXER_EDGE_SITE_ADDRESS`.
### `FLUXER_EDGE_TRUSTED_PROXIES`
Proxies whose client address headers Fluxer trusts, separated by spaces. The default is `127.0.0.1/32`, or `private_ranges` with `docker-compose.proxy.yml` or `tunnel.compose.yml`. With rexctl, use `rexctl config set edge.trusted_proxies`.
### `FLUXER_EDGE_ENCODE`
The response compression the edge offers, written as the arguments of the Caddy encode directive, such as `gzip` alone. The default is `zstd gzip`. With rexctl, use `rexctl config set FLUXER_EDGE_ENCODE`.
### `FLUXER_EDGE_PROTOCOLS`
The HTTP versions the edge serves, as the arguments of the Caddy protocols option, such as `h1 h2` to turn off HTTP/3. The default is `h1 h2 h3`. On a machine with little memory, rexctl turns off HTTP/3 unless you set it. With rexctl, use `rexctl config set FLUXER_EDGE_PROTOCOLS`.
### `FLUXER_EDGE_GLOBAL_OPTIONS`
Extra Caddy global options on one line, added to the global block of the edge Caddyfile, such as `email [email protected]` for the certificate account. An empty value adds nothing. With rexctl, use `rexctl config set FLUXER_EDGE_GLOBAL_OPTIONS`.
### `FLUXER_EDGE_TLS`
The arguments of a Caddy tls directive for the edge, such as `internal` for a certificate from Caddy's own local CA, or a certificate and key path under `/certs`. When it's empty, the edge adds no tls line and Caddy gets certificates on its own. `docker-compose.proxy.yml` and `tunnel.compose.yml` ignore it. With rexctl, use `rexctl config set FLUXER_EDGE_TLS`.
## Voice and video
Calls connect directly to this machine on `FLUXER_LIVEKIT_TCP_PORT` and `FLUXER_LIVEKIT_UDP_PORT`, even when Fluxer is behind your own proxy. To run without the bundled LiveKit, add `external-voice.compose.yml` to `COMPOSE_FILE` and set `FLUXER_LIVEKIT_BUNDLED` to `false`.
### `FLUXER_LIVEKIT_ENABLED`
Whether voice and video calls are turned on. Use `true` or `false`. The default is `true`. With rexctl, use `rexctl config set FLUXER_LIVEKIT_ENABLED`.
### `FLUXER_LIVEKIT_INTERNAL_URL`
The URL the API uses for the LiveKit control API of the bundled LiveKit, the first server in the default voice region. Servers added in the admin panel use their own address. Fluxer ignores it when `FLUXER_LIVEKIT_BUNDLED` is `false`. The default is `http://livekit:7880`. With rexctl, use `rexctl config set FLUXER_LIVEKIT_INTERNAL_URL`.
### `FLUXER_LIVEKIT_BUNDLED`
Whether Fluxer runs its own LiveKit voice server on this machine. Use `true` or `false`. The bundled LiveKit is the first server in the default voice region. With `false`, Fluxer creates the default region with no server in it, removes the server it made for the bundled LiveKit and keeps calls on the servers you add with `rexctl voice add`, `rexctl voice join` or the admin panel. With Docker Compose, also add `external-voice.compose.yml` to `COMPOSE_FILE`. The default is `true`. With rexctl, use `rexctl config set voice.bundled`.
### `FLUXER_LIVEKIT_DEFAULT_REGION`
The voice region Fluxer creates when no voice regions exist yet, as a JSON object with `id`, `name`, `emoji`, `latitude` and `longitude`. The default is `{"id":"default","name":"Default","emoji":"🌍","latitude":0,"longitude":0}`. With rexctl, use `rexctl config set FLUXER_LIVEKIT_DEFAULT_REGION`.
### `FLUXER_LIVEKIT_URL`
The URL browsers and apps use for voice signalling. When it's empty, Fluxer uses the public origin, or `FLUXER_PUBLIC_SCHEME`, `FLUXER_DOMAIN` and `FLUXER_PUBLIC_PORT`, followed by `/livekit`. Set it only when LiveKit runs on another host. With rexctl, use `rexctl config set FLUXER_LIVEKIT_URL`.
### `FLUXER_VOICE_P2P_STUN_URLS`
STUN URLs for peer-to-peer calls, separated by commas, such as `stun:stun.example.com:3478`. When it's empty, peer-to-peer calls work only between devices with a direct route to each other, such as on one local network. With rexctl, use `rexctl config set FLUXER_VOICE_P2P_STUN_URLS`.
### `FLUXER_VOICE_JOIN_ALLOW_PRIVATE_ENDPOINTS`
Whether the API accepts a voice server joining with an endpoint that resolves to a private address. Use `true` or `false`. Set it to `true` only for tests and private networks. With rexctl, use `rexctl config set FLUXER_VOICE_JOIN_ALLOW_PRIVATE_ENDPOINTS`.
### `FLUXER_VOICE_HEALTH_INTERVAL_MS`
How often each API node checks every active voice server, in milliseconds. A server that fails two checks in a row gets no new calls until a check passes. Set it to `0` to turn the checks off. When it's empty, the API checks every 15 seconds. With rexctl, use `rexctl config set FLUXER_VOICE_HEALTH_INTERVAL_MS`.
### `FLUXER_VOICE_PARTICIPANT_SWEEP_ENABLED`
Whether a worker compares each voice server's call participants with the gateway's call state every minute and disconnects connections the gateway has not known for two minutes. Use `true` or `false`. When it's empty, the check runs. With rexctl, use `rexctl config set FLUXER_VOICE_PARTICIPANT_SWEEP_ENABLED`.
### `FLUXER_VOICE_PARTICIPANT_SWEEP_DRY_RUN`
Whether the voice participant check from `FLUXER_VOICE_PARTICIPANT_SWEEP_ENABLED` only logs the connections it would disconnect. Use `true` or `false`. When it's empty, the check only logs them. With rexctl, use `rexctl config set FLUXER_VOICE_PARTICIPANT_SWEEP_DRY_RUN`.
### `FLUXER_LIVEKIT_TCP_PORT`
The TCP port for voice and video. The default is `7881`. With rexctl, use `rexctl config set voice.tcp_port`.
### `FLUXER_LIVEKIT_UDP_PORT`
The UDP port for voice and video. The default is `7882`. With rexctl, use `rexctl config set voice.udp_port`.
### `FLUXER_LIVEKIT_NODE_IP`
The public IP address voice and video use, when Fluxer can't find it by itself. Set `FLUXER_LIVEKIT_USE_EXTERNAL_IP` to `false` with it. With rexctl, use `rexctl config set voice.public_ip`.
### `FLUXER_LIVEKIT_USE_EXTERNAL_IP`
Whether LiveKit finds its public IP address through STUN. Use `true` or `false`. Set it to `false` when you set `FLUXER_LIVEKIT_NODE_IP`. The default is `true`. With rexctl, use `rexctl config set voice.public_ip`.
### `FLUXER_LIVEKIT_STUN_PRIMARY`
The first STUN host LiveKit asks to find its public IP address, as `host:port`. Point it at another STUN host to avoid contacting Google. The default is `stun.l.google.com:19302`. With rexctl, use `rexctl config set FLUXER_LIVEKIT_STUN_PRIMARY`.
### `FLUXER_LIVEKIT_STUN_SECONDARY`
The second STUN host LiveKit asks to find its public IP address, as `host:port`. The default is `stun1.l.google.com:19302`. With rexctl, use `rexctl config set FLUXER_LIVEKIT_STUN_SECONDARY`.
### `FLUXER_LIVEKIT_TURN_SERVERS`
TURN servers that browsers and apps get when they join a call, as a JSON array of objects with `host`, `port` and `protocol`, and either `username` and `credential` or `secret` with an optional `ttl`, such as `[{"host":"turn.example.com","port":3478,"protocol":"udp","secret":"a-long-random-secret"}]`. Use `udp`, `tcp` or `tls` for `protocol`, and a hostname or an IPv4 address for `host`. With `secret`, LiveKit makes short-lived credentials for each participant in the form coturn checks with `use-auth-secret`, and `ttl`, a whole number from 1, sets how many seconds they last. The bundled voice server and the servers you add with rexctl voice add give these to clients, and rexctl restarts the added servers one at a time when the list changes. A server that joined with rexctl voice join gets the list when it joins and on each rexctl upgrade in its voice folder, unless the instance runs an older release than the rexctl there. Set it when callers can't connect to a voice server directly, such as from networks that allow only port 443. When it's empty, clients get no TURN server. A value the API can't read stops it from starting, and rexctl config set refuses one. The default is `[]`. With rexctl, use `rexctl config set FLUXER_LIVEKIT_TURN_SERVERS`.
## Standalone voice servers
These go in the settings file of a voice server from the voice folder of the compose bundle, such as `fra-server-1.env`, not in Fluxer's `.env`. `rexctl voice add` and `rexctl voice join` write them for you.
### `FLUXER_VOICE_ID`
The ID of the voice server, such as `fra-server-2`. Use lowercase letters, digits and dashes. The container uses `voice-` followed by this ID as its host name on the voice network, and the edge routes `/livekit-` followed by this ID to it.
### `FLUXER_VOICE_API_KEY`
The LiveKit API key of this server. Every voice server of an instance needs its own key, such as `fluxer-` followed by the server ID.
### `FLUXER_VOICE_API_SECRET`
The LiveKit API secret that goes with `FLUXER_VOICE_API_KEY`, at least 32 characters, such as the output of `openssl rand -hex 32`.
### `FLUXER_VOICE_WEBHOOK_URL`
The URL LiveKit sends its webhooks to. On the Fluxer machine it's `http://api:8080/webhooks/livekit`. On another machine it's the public API address followed by `/webhooks/livekit`.
### `FLUXER_VOICE_TCP_PORT`
The TCP port for media on this host. LiveKit listens on the same port inside the container, and each server on a host needs its own.
### `FLUXER_VOICE_UDP_PORT`
The UDP port for media on this host. LiveKit listens on the same port inside the container, and each server on a host needs its own.
### `FLUXER_VOICE_NODE_IP`
The public addresses LiveKit gives to clients. Give an IPv4 address, an IPv6 address, or both with a comma between them, such as `203.0.113.7,2001:db8::7`. Set `FLUXER_VOICE_USE_EXTERNAL_IP` to `false` with it. LiveKit offers an IPv6 address only when the server's Docker network has IPv6.
### `FLUXER_VOICE_ICE_IPS`
The address ranges LiveKit may offer to clients, as a JSON array of ranges such as `["::/0"]`. rexctl sets it to the families in `FLUXER_VOICE_NODE_IP`, and a server with only IPv6 then offers no private IPv4 address of its container. Use `[]` to offer every address.
### `FLUXER_VOICE_USE_EXTERNAL_IP`
Whether LiveKit finds its public IP address through STUN. Use `true` or `false`.
### `FLUXER_VOICE_BIND_IP`
The host address the media ports are published on, for a host with more than one public address. When it's empty, Docker publishes them on every address.
### `FLUXER_VOICE_HTTP_PORT`
The port that `voice-http.compose.yml` publishes LiveKit's HTTP and WebSocket port on, for your own proxy.
### `FLUXER_VOICE_HTTP_BIND`
The host address that `voice-http.compose.yml` publishes `FLUXER_VOICE_HTTP_PORT` on. The default is `127.0.0.1`. Use another address of the host, or `0.0.0.0` for every address, when your proxy runs in another network. Write an IPv6 address in brackets, such as `[2001:db8::5]`. The port has no TLS of its own. Let only your proxy's network connect to it in your firewall.
### `FLUXER_VOICE_NETWORK`
The Docker network the server joins. On a voice machine it's the network of the voice edge. On the Fluxer machine it's the network of the instance, such as `fluxer_fluxer`, and Fluxer's own edge routes to the server.
### `FLUXER_VOICE_MEMORY_LIMIT`
The memory limit for the server's container.
### `FLUXER_VOICE_GOMEMLIMIT`
The soft memory limit of the Go runtime in LiveKit. Keep it at about 85% of `FLUXER_VOICE_MEMORY_LIMIT`.
### `FLUXER_VOICE_STOP_GRACE`
How long Docker waits for the calls on the server to end when it stops or replaces the container, before it stops LiveKit anyway.
## Voice edge
These go in `edge.env` next to `voice-edge.compose.yml` in the voice folder of the compose bundle. `rexctl voice join` writes them for you.
### `FLUXER_VOICE_EDGE_IP`
The public IPv4 address of the voice machine, when an endpoint uses that address and not a hostname. The edge then gives clients that send no server name the certificate for that address, which browsers need.
### `FLUXER_VOICE_NETWORK_IPV6`
Whether the voice network gets IPv6. Use `true` or `false`. rexctl sets it to `true` when it creates the network on a machine with a public IPv6 address. Docker can't add IPv6 to a network that already exists.
### `FLUXER_VOICE_EDGE_EMAIL`
The email address the voice edge gives Let's Encrypt for notices about its certificates. When it's empty, the edge gets certificates without one.
## Object storage
By default Fluxer keeps files in the bundled object store. To use your own S3-compatible store, set its address and buckets, add `external-object-store.compose.yml` to `COMPOSE_FILE` and put its keys in `FLUXER_S3_ACCESS_KEY` and `FLUXER_S3_SECRET_KEY`.
### `FLUXER_S3_ENDPOINT`
The address of the S3-compatible object store. The default is `http://seaweedfs:8333`. With rexctl, use `rexctl config set storage.endpoint`.
### `FLUXER_S3_PUBLIC_ENDPOINT`
The object store address browsers use, when it differs from the one Fluxer uses. When it's empty, the api and worker use `FLUXER_S3_ENDPOINT`, and the web app doesn't let browsers upload to the object store. With rexctl, use `rexctl config set storage.public_endpoint`.
### `FLUXER_S3_REGION`
The object store region. The default is `us-east-1`. With rexctl, use `rexctl config set storage.region`.
### `FLUXER_S3_FORCE_PATH_STYLE`
Whether the object store needs path-style addresses. Use `true` or `false`. The default is `true`. With rexctl, use `rexctl config set storage.path_style`.
### `FLUXER_S3_SESSION_TOKEN`
A temporary S3 session token the media proxy sends with its object store requests. When it's empty, the media proxy sends none. Keep it secret. With rexctl, use `rexctl config set FLUXER_S3_SESSION_TOKEN`.
### `FLUXER_S3_BUCKET_CDN`
The bucket for processed media such as avatars and other served assets. The bundled object store creates it, and an outside store needs it to exist already. The default is `fluxer`. With rexctl, use `rexctl config set FLUXER_S3_BUCKET_CDN`.
### `FLUXER_S3_BUCKET_UPLOADS`
The bucket for raw uploads. The bundled object store creates it, and an outside store needs it to exist already. The default is `fluxer-uploads`. With rexctl, use `rexctl config set FLUXER_S3_BUCKET_UPLOADS`.
### `FLUXER_S3_BUCKET_REPORTS`
The bucket for abuse report evidence. The bundled object store creates it, and an outside store needs it to exist already. The default is `fluxer-reports`. With rexctl, use `rexctl config set FLUXER_S3_BUCKET_REPORTS`.
### `FLUXER_S3_BUCKET_HARVESTS`
The bucket for data export archives. The bundled object store creates it, and an outside store needs it to exist already. The default is `fluxer-harvests`. With rexctl, use `rexctl config set FLUXER_S3_BUCKET_HARVESTS`.
### `FLUXER_S3_READ_ENDPOINT`
A separate http or https address, with no credentials, that the media proxy fetches objects in `FLUXER_S3_READ_BUCKET` from. When it's empty, the media proxy fetches everything through `FLUXER_S3_ENDPOINT`. With rexctl, use `rexctl config set FLUXER_S3_READ_ENDPOINT`.
### `FLUXER_S3_READ_BUCKET`
The bucket the media proxy fetches through `FLUXER_S3_READ_ENDPOINT`. When it's empty, the media proxy uses `FLUXER_S3_BUCKET_CDN`. With rexctl, use `rexctl config set FLUXER_S3_READ_BUCKET`.
### `FLUXER_S3_READ_BUCKET_STYLE`
How the bucket appears in URLs to `FLUXER_S3_READ_ENDPOINT`. Use `path`, `virtual` or `root`. When it's empty, the media proxy uses `path` when `FLUXER_S3_FORCE_PATH_STYLE` is on and `virtual` when it's off. With rexctl, use `rexctl config set FLUXER_S3_READ_BUCKET_STYLE`.
### `FLUXER_S3_READ_SIGNED`
Whether the media proxy signs its requests to `FLUXER_S3_READ_ENDPOINT`. Use `true` or `false`. Use `false` only for a bucket that allows anonymous downloads. The default is `true`. With rexctl, use `rexctl config set FLUXER_S3_READ_SIGNED`.
### `FLUXER_API_PRESIGNED_ATTACHMENT_UPLOADS_ENABLED`
Whether the API hands clients upload URLs that let them upload attachments before they send the message. Use `true` or `false`. The default is `true`. With rexctl, use `rexctl config set FLUXER_API_PRESIGNED_ATTACHMENT_UPLOADS_ENABLED`.
### `FLUXER_API_PRESIGNED_HARVEST_DOWNLOADS_ENABLED`
Whether data export and admin download links are presigned URLs to the object store. Use `true` or `false`. With `false`, the API serves those downloads itself. Turn it on only once browsers can connect to `FLUXER_S3_PUBLIC_ENDPOINT`. The default is `false`. With rexctl, use `rexctl config set FLUXER_API_PRESIGNED_HARVEST_DOWNLOADS_ENABLED`.
### `FLUXER_API_STORAGE_CHANGE_FEED_ENABLED`
Whether the api and worker services publish a record of each object store write and delete they make to a NATS JetStream stream. Uploads written by the media proxy relay or sent directly to the store by clients are not in it. Use `true` or `false`. When it's empty, the feed is off. With rexctl, use `rexctl config set FLUXER_API_STORAGE_CHANGE_FEED_ENABLED`.
### `FLUXER_API_STORAGE_CHANGE_FEED_STREAM`
The JetStream stream the storage change feed publishes to, in letters, digits, underscores or hyphens. When it's empty, Fluxer uses `STORAGE_CHANGES`. With rexctl, use `rexctl config set FLUXER_API_STORAGE_CHANGE_FEED_STREAM`.
### `FLUXER_API_STORAGE_CHANGE_FEED_SKIP_BUCKETS`
Buckets the storage change feed leaves out, separated by commas, or `none` to leave out no bucket. When it's empty, the feed leaves out the uploads bucket. With rexctl, use `rexctl config set FLUXER_API_STORAGE_CHANGE_FEED_SKIP_BUCKETS`.
### `FLUXER_SEAWEEDFS_INIT_ATTEMPTS`
How many rounds, about two seconds apart, the bundled object store's setup job tries to create the buckets and set up access before it gives up. The default is `60`. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_INIT_ATTEMPTS`.
### `FLUXER_SEAWEEDFS_UPLOADS_TTL`
How long the bundled object store keeps files in the uploads bucket before it deletes them, such as `1d` or `12h`. Use `off` to keep them. A new value applies to uploads written after the next start, and files already stored keep their old expiry. The default is `1d`. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_UPLOADS_TTL`.
## Database
Leave these unset to use the bundled Postgres.
### `FLUXER_POSTGRES_HOST`
The hostname or address of the Postgres database. Set it when Postgres runs outside the stack. The default is `postgres`. With rexctl, use `rexctl config set FLUXER_POSTGRES_HOST`.
### `FLUXER_POSTGRES_PORT`
The Postgres port, from 1 to 65535. When it's empty, Fluxer uses `5432`. With rexctl, use `rexctl config set FLUXER_POSTGRES_PORT`.
### `FLUXER_POSTGRES_DATABASE`
The Postgres database name. When it's empty, Fluxer uses `fluxer`. The bundled Postgres creates this database only on its first start with an empty data directory. With rexctl, use `rexctl config set FLUXER_POSTGRES_DATABASE`.
### `FLUXER_POSTGRES_USERNAME`
The Postgres role Fluxer connects as. When it's empty, Fluxer uses `fluxer`. The bundled Postgres creates this role only on its first start with an empty data directory. With rexctl, use `rexctl config set FLUXER_POSTGRES_USERNAME`.
### `FLUXER_POSTGRES_URL`
A full Postgres connection URL, such as `postgres://fluxer:[email protected]:5432/fluxer`. When it's set, Fluxer connects with it and ignores the host, port, database, username and password settings. An `sslmode` in the URL can turn TLS on when `FLUXER_POSTGRES_SSL` isn't `true`. For the api and worker, it also wins over `FLUXER_POSTGRES_SSL`. Keep it secret. With rexctl, use `rexctl config set FLUXER_POSTGRES_URL`.
### `FLUXER_POSTGRES_SSL`
Whether Fluxer connects to Postgres over TLS. Use `true` or `false`. When it isn't `true` and `FLUXER_POSTGRES_URL` has no `sslmode`, the api and worker follow `PGSSLMODE` and the other services connect without TLS. With rexctl, use `rexctl config set FLUXER_POSTGRES_SSL`.
### `FLUXER_POSTGRES_SSL_CA`
A CA certificate in PEM form that Fluxer trusts for the Postgres TLS connection, with `\n` for line breaks. The Rust services use it whenever the connection uses TLS. The api and worker use it only when `FLUXER_POSTGRES_SSL` is `true` and `FLUXER_POSTGRES_URL` has no `sslmode`. With rexctl, use `rexctl config set FLUXER_POSTGRES_SSL_CA`.
### `FLUXER_POSTGRES_PREPARED_STATEMENTS`
Whether Fluxer uses Postgres prepared statements. Use `true` or `false`. When it's empty, Fluxer uses them. Set it to `false` behind a transaction-pooling pooler such as PgBouncer. With rexctl, use `rexctl config set FLUXER_POSTGRES_PREPARED_STATEMENTS`.
### `FLUXER_POSTGRES_KV_TABLE`
The Postgres table for Fluxer's key-value data, a plain identifier of letters, digits and underscores that starts with a letter or an underscore. When it's empty, Fluxer uses `fluxer_kv`. With rexctl, use `rexctl config set FLUXER_POSTGRES_KV_TABLE`.
## Cache, queue and search
Leave these unset to use the bundled Valkey, NATS and Meilisearch.
### `FLUXER_KV_URL`
The Valkey or Redis URL Fluxer uses for its cache, rate limits and other short-lived data. The default is `redis://valkey:6379/0`. With rexctl, use `rexctl config set FLUXER_KV_URL`.
### `FLUXER_KV_MODE`
How Fluxer connects to the key-value store. Use `standalone` for a single Valkey or Redis node or `cluster` for a Redis-compatible cluster. When it's empty, Fluxer uses `standalone`. With rexctl, use `rexctl config set FLUXER_KV_MODE`.
### `FLUXER_NATS_URL`
The core NATS address the api, worker and gateway services use, including for requests to the internal services and the push service. The internal services and JetStream follow it unless `FLUXER_SVC_NATS_URL` or `FLUXER_NATS_JETSTREAM_URL` is set. The default is `nats://nats:4222`. With rexctl, use `rexctl config set FLUXER_NATS_URL`.
### `FLUXER_NATS_JETSTREAM_URL`
The NATS address the api and worker services use for JetStream. When it's empty, they use `FLUXER_NATS_URL`. With rexctl, use `rexctl config set FLUXER_NATS_JETSTREAM_URL`.
### `FLUXER_NATS_AUTH_TOKEN`
The token every service sends when it connects to NATS. When it's empty, services connect without a token. The bundled NATS needs none. Keep it secret. With rexctl, use `rexctl config set FLUXER_NATS_AUTH_TOKEN`.
### `FLUXER_SVC_NATS_URL`
The NATS address the internal services and the push service listen on. When it's empty, they use `FLUXER_NATS_URL`. The api and worker send their requests to these services over `FLUXER_NATS_URL`, and both addresses must lead to the same NATS cluster. With rexctl, use `rexctl config set FLUXER_SVC_NATS_URL`.
### `FLUXER_SVC_MAX_CONCURRENT_REQUESTS`
How many requests each internal service handles at once before it turns new ones away. When it's empty, the messages service uses `192`, the snowflakes service `320` and the others `64`. One value you set applies to all of them. rexctl takeover and rexctl upgrade remove a value under `320`. With rexctl, use `rexctl config set FLUXER_SVC_MAX_CONCURRENT_REQUESTS`.
### `FLUXER_SVC_CACHE_MAX_ENTRIES`
The most entries each internal service process keeps in its cache. When it's empty, the internal services use `100000`. With rexctl, use `rexctl config set FLUXER_SVC_CACHE_MAX_ENTRIES`.
### `FLUXER_SVC_CACHE_TTL_MS`
How long the internal services keep cached entries, in milliseconds. When it's empty, they use `30000`. With rexctl, use `rexctl config set FLUXER_SVC_CACHE_TTL_MS`.
### `FLUXER_GIF_SERVICE_NATS_CLIENT_NAME`
The client name the API gives its NATS connection to the gifs service, which shows in NATS monitoring. When it's empty, the API uses `fluxer-api-gifs`. With rexctl, use `rexctl config set FLUXER_GIF_SERVICE_NATS_CLIENT_NAME`.
### `FLUXER_GIF_SERVICE_TIMEOUT_MS`
How long the API waits for gifs service requests such as searches, in milliseconds. When it's empty, the API uses `12000`. Recording a share uses `FLUXER_GIF_SERVICE_REGISTER_SHARE_TIMEOUT_MS`. With rexctl, use `rexctl config set FLUXER_GIF_SERVICE_TIMEOUT_MS`.
### `FLUXER_GIF_SERVICE_REGISTER_SHARE_TIMEOUT_MS`
How long the API waits for the gifs service to record that someone shared a GIF, in milliseconds. When it's empty, the API uses `3000`. With rexctl, use `rexctl config set FLUXER_GIF_SERVICE_REGISTER_SHARE_TIMEOUT_MS`.
### `FLUXER_USERS_SERVICE_NATS_CLIENT_NAME`
The client name the API gives its NATS connection to the users service, which shows in NATS monitoring. When it's empty, the API uses `fluxer-api-users`. With rexctl, use `rexctl config set FLUXER_USERS_SERVICE_NATS_CLIENT_NAME`.
### `FLUXER_USERS_SERVICE_TIMEOUT_MS`
How long the API waits for the users service, in milliseconds. When it's empty, the API uses `6000`. With rexctl, use `rexctl config set FLUXER_USERS_SERVICE_TIMEOUT_MS`.
### `FLUXER_USERS_SERVICE_INFLIGHT_MAX_ENTRIES`
How many user lookups the API tracks in flight, which lets requests for the same user share one call to the users service. Lookups past this limit go to the service on their own. When it's empty, the API uses `10000`. With rexctl, use `rexctl config set FLUXER_USERS_SERVICE_INFLIGHT_MAX_ENTRIES`.
### `FLUXER_SNOWFLAKE_SERVICE_NATS_CLIENT_NAME`
The client name the API gives its NATS connection to the snowflakes service, which shows in NATS monitoring. When it's empty, the API uses `fluxer-api-snowflakes`. With rexctl, use `rexctl config set FLUXER_SNOWFLAKE_SERVICE_NATS_CLIENT_NAME`.
### `FLUXER_SNOWFLAKE_SERVICE_BATCH_SIZE`
How many IDs the API fetches from the snowflakes service at a time, from 1 to 512. When it's empty, the API uses `128`. With rexctl, use `rexctl config set FLUXER_SNOWFLAKE_SERVICE_BATCH_SIZE`.
### `FLUXER_SNOWFLAKE_SERVICE_LOW_WATERMARK`
The number of unused IDs at which the API fetches a new batch, from 0 to one less than the batch size. When it's empty, the API uses `32`, or one less than the batch size if that's smaller. With rexctl, use `rexctl config set FLUXER_SNOWFLAKE_SERVICE_LOW_WATERMARK`.
### `FLUXER_SNOWFLAKE_SERVICE_MAX_BUFFER_AGE_MS`
How long the API keeps a fetched batch of IDs before it throws the rest away, in milliseconds from 1 to 60000. When it's empty, the API uses `5000`. With rexctl, use `rexctl config set FLUXER_SNOWFLAKE_SERVICE_MAX_BUFFER_AGE_MS`.
### `FLUXER_SNOWFLAKE_SERVICE_REQUEST_TIMEOUT_MS`
How long the API waits for the snowflakes service, in milliseconds from 1 to 60000. When it's empty, the API uses `6000`. With rexctl, use `rexctl config set FLUXER_SNOWFLAKE_SERVICE_REQUEST_TIMEOUT_MS`.
### `FLUXER_SEARCH_ENGINE`
Which search engine Fluxer uses. Use `meilisearch` or `elasticsearch`, or `none` to turn search off. With `elasticsearch`, set `MEILI_MASTER_KEY` to your Elasticsearch API key. Docker Compose passes it to Fluxer as `FLUXER_SEARCH_API_KEY`. The default is `meilisearch`. With rexctl, use `rexctl config set FLUXER_SEARCH_ENGINE`.
### `FLUXER_SEARCH_URL`
The address of the search engine. The default is `http://meilisearch:7700`. With rexctl, use `rexctl config set FLUXER_SEARCH_URL`.
### `FLUXER_SEARCH_USERNAME`
The basic auth username for Elasticsearch. Fluxer uses it only when `FLUXER_SEARCH_API_KEY` is empty. Docker Compose always sets that key from `MEILI_MASTER_KEY`. To use basic auth, set `FLUXER_SEARCH_API_KEY` to an empty value for the api and worker in a compose file of your own. With rexctl, use `rexctl config set FLUXER_SEARCH_USERNAME`.
### `FLUXER_SEARCH_PASSWORD`
The basic auth password for Elasticsearch. Fluxer uses it only when `FLUXER_SEARCH_API_KEY` is empty, the same as `FLUXER_SEARCH_USERNAME`. Keep it secret. With rexctl, use `rexctl config set FLUXER_SEARCH_PASSWORD`.
### `FLUXER_SEARCH_TLS_REJECT_UNAUTHORIZED`
Whether Fluxer checks the Elasticsearch TLS certificate. Use `true` or `false`. When it's empty, Fluxer checks it. Meilisearch connections don't use it. With rexctl, use `rexctl config set FLUXER_SEARCH_TLS_REJECT_UNAUTHORIZED`.
## Outgoing proxy
These settings are for Fluxer's services. rexctl and the Linux and macOS install script take `HTTPS_PROXY`, `HTTP_PROXY` and `NO_PROXY` from the shell you run them from.
### `HTTP_PROXY`
The proxy the Rust services other than the app-proxy use for outgoing HTTP requests. The api, worker and gateway don't use it. Docker Compose also sets `http_proxy` to this value for tools that only look up the lowercase name. With rexctl, use `rexctl config set network.http_proxy`.
### `HTTPS_PROXY`
The proxy the Rust services other than the app-proxy use for outgoing HTTPS requests. The api, worker and gateway don't use it. Docker Compose also sets `https_proxy` to this value for tools that only look up the lowercase name. With rexctl, use `rexctl config set network.https_proxy`.
### `NO_PROXY`
Hosts the Rust services other than the app-proxy connect to without the proxy, separated by commas. Docker Compose also sets `no_proxy` to this value for tools that only look up the lowercase name. With rexctl, use `rexctl config set network.no_proxy`.
### `FLUXER_NODE_EXTRA_CA_CERTS`
The path of a PEM file of CA certificates that the api and worker trust for outgoing TLS on top of Node's built-in ones. Use it when your email server has a certificate from your own CA. The path is inside their containers. With Docker Compose they see the ca folder of your instance at `/etc/fluxer/ca`, and nothing else from the instance folder. A file you set replaces the system bundle. Node's built-in CAs still apply, and the file can have only your own CA. The Rust services don't use it and take their CA certificates from `SSL_CERT_FILE`. The default is `/etc/ssl/certs/ca-certificates.crt`. With rexctl, use `rexctl config set FLUXER_NODE_EXTRA_CA_CERTS`.
## Sign-in
### `FLUXER_SSO_ALLOW_PRIVATE_ADDRESSES`
Whether single sign-on can use a provider on a private or local network address. Use `true` or `false`. When it's empty, Fluxer uses `false`. With rexctl, use `rexctl config set sso.allow_private_addresses`.
### `FLUXER_PASSKEY_RP_ID`
The relying party ID that passkeys are tied to, a domain such as `chat.example.com`. When it's empty, Fluxer uses `FLUXER_DOMAIN`. Changing it makes every passkey registered against the old value stop working. With rexctl, use `rexctl config set FLUXER_PASSKEY_RP_ID`.
### `FLUXER_PASSKEY_RP_NAME`
The title browsers show for Fluxer when someone creates or uses a passkey. When it's empty, browsers show `Fluxer`. With rexctl, use `rexctl config set FLUXER_PASSKEY_RP_NAME`.
### `FLUXER_PASSKEY_ADDITIONAL_ALLOWED_ORIGINS`
Every origin where passkeys work, separated by commas. When it's empty, Docker Compose uses `FLUXER_PUBLIC_ORIGIN`, or `FLUXER_PUBLIC_SCHEME` followed by `://` and `FLUXER_DOMAIN`. A list you set replaces it and must include the web app origin. Set a list when `FLUXER_APP_ENDPOINT` is on another origin. Each entry is an http or https origin or an Android app, written as `android:apk-key-hash:` followed by its signing certificate's SHA-256 hash in unpadded base64url. With rexctl, use `rexctl config set FLUXER_PASSKEY_ADDITIONAL_ALLOWED_ORIGINS`.
### `FLUXER_ADMIN_SSO_ISSUER`
The HTTPS issuer URL of an OpenID Connect provider that staff can also use to sign in to the admin panel. The issuer must not contain credentials, a query or a fragment. Discovery and token endpoints must serve responses directly without redirects. Admin single sign-on is on when `FLUXER_ADMIN_SSO_ISSUER`, `FLUXER_ADMIN_SSO_CLIENT_ID` and `FLUXER_ADMIN_SSO_CLIENT_SECRET` are all set. The admin service won't start when only some of them are set. The api and admin services must have the same issuer and client ID. The provider's ID token must have a `fluxer_id` claim with the ID of the Fluxer account, and access still comes from the admin ACLs of that account. Only trusted provider administrators may set this claim; users must not be able to change it. With rexctl, use `rexctl config set FLUXER_ADMIN_SSO_ISSUER`.
### `FLUXER_ADMIN_SSO_CLIENT_ID`
The client ID of the admin panel at the provider in `FLUXER_ADMIN_SSO_ISSUER`. Register the admin address followed by `/sso/callback` as its redirect URL. With rexctl, use `rexctl config set FLUXER_ADMIN_SSO_CLIENT_ID`.
### `FLUXER_ADMIN_SSO_CLIENT_SECRET`
The client secret that goes with `FLUXER_ADMIN_SSO_CLIENT_ID`. Only the admin service uses it. Keep it secret. With rexctl, use `rexctl config set FLUXER_ADMIN_SSO_CLIENT_SECRET`.
### `FLUXER_ADMIN_SSO_DISPLAY_NAME`
The provider name on the single sign-on button of the admin panel. With `Ferret`, the button says `Sign in with Ferret`. When it's empty, the button says `Sign in with single sign-on`. With rexctl, use `rexctl config set FLUXER_ADMIN_SSO_DISPLAY_NAME`.
### `FLUXER_ADMIN_SSO_ONLY`
Whether staff can sign in to the admin panel only with single sign-on. Use `true` or `false`. With `true`, the login page hides the button for signing in with a Fluxer account, and the admin panel refuses new sign-ins that way. Staff who are already signed in stay signed in. It needs `FLUXER_ADMIN_SSO_ISSUER`, `FLUXER_ADMIN_SSO_CLIENT_ID` and `FLUXER_ADMIN_SSO_CLIENT_SECRET`, and the admin service won't start without them. When it's empty, it's `false`. With rexctl, use `rexctl config set FLUXER_ADMIN_SSO_ONLY`.
## Email
The admin panel can also save the delivery mode, the sender and the SMTP server. A value saved there is used first.
### `FLUXER_EMAIL_ENABLED`
The older way to turn email on. Use `FLUXER_EMAIL_DELIVERY`. With rexctl, use `rexctl config set integrations.email.delivery`.
### `FLUXER_EMAIL_PROVIDER`
The older way to pick the email transport, which takes `smtp` or `none`. Use `FLUXER_EMAIL_DELIVERY`. With rexctl, use `rexctl config set integrations.email.delivery`.
### `FLUXER_EMAIL_DELIVERY`
How Fluxer sends email. Use `smtp` or `off`. When it's empty, `FLUXER_EMAIL_ENABLED` and `FLUXER_EMAIL_PROVIDER` decide, and email is off when those are empty too. With rexctl, use `rexctl config set integrations.email.delivery`.
### `FLUXER_EMAIL_FROM_EMAIL`
The address Fluxer sends email from. When it's empty, Fluxer uses `noreply@` followed by `FLUXER_DOMAIN`. With rexctl, use `rexctl config set integrations.email.from_email`.
### `FLUXER_EMAIL_FROM_NAME`
The sender name on email from Fluxer. When it's empty, Fluxer uses the product name of the instance. With rexctl, use `rexctl config set integrations.email.from_name`.
### `FLUXER_EMAIL_REPLY_TO_EMAIL`
The address replies go to, sent as the Reply-To header on every email, such as `[email protected]`. When it's empty, Fluxer sends no Reply-To header. With rexctl, use `rexctl config set FLUXER_EMAIL_REPLY_TO_EMAIL`.
### `FLUXER_EMAIL_APP_BASE_URL`
The base URL Fluxer uses for links in emails, an http or https URL with no credentials, query or fragment. When it's empty, Fluxer uses `FLUXER_APP_ENDPOINT`. With rexctl, use `rexctl config set FLUXER_EMAIL_APP_BASE_URL`.
### `FLUXER_EMAIL_WEBHOOK_SECRET`
The base64 secret Fluxer uses to check the signature on bounce and complaint webhooks from the Sweego email service. When it's empty, Fluxer turns those webhooks away. Keep it secret. With rexctl, use `rexctl config set FLUXER_EMAIL_WEBHOOK_SECRET`.
### `FLUXER_EMAIL_SMTP_HOST`
The hostname of your SMTP server. With rexctl, use `rexctl config set integrations.email.smtp.host`.
### `FLUXER_EMAIL_SMTP_PORT`
The port of your SMTP server. When it's empty, Fluxer uses `587`. With rexctl, use `rexctl config set integrations.email.smtp.port`.
### `FLUXER_EMAIL_SMTP_USERNAME`
The username Fluxer signs in to your SMTP server with. With rexctl, use `rexctl config set integrations.email.smtp.username`.
### `FLUXER_EMAIL_SMTP_PASSWORD`
The password Fluxer signs in to your SMTP server with. Keep it secret. With rexctl, use `rexctl config set integrations.email.smtp.password`.
### `FLUXER_EMAIL_SMTP_TLS_MODE`
How the SMTP connection is encrypted. Use `implicit` for TLS from the start, usually on port 465, `starttls` to upgrade before signing in, usually on port 587, `opportunistic` to upgrade when the server offers it, or `none`. When it's empty, `FLUXER_EMAIL_SMTP_SECURE` decides. When both are empty, Fluxer uses `implicit` on port 465 and `starttls` on any other port. With rexctl, use `rexctl config set integrations.email.smtp.tls_mode`.
### `FLUXER_EMAIL_SMTP_SECURE`
The older way to set `FLUXER_EMAIL_SMTP_TLS_MODE`, used only while that is empty. Use `true` for `implicit` on port 465 and `starttls` on any other port, or `false` for `opportunistic`. With rexctl, use `rexctl config set integrations.email.smtp.tls_mode`.
### `FLUXER_EMAIL_FALLBACK_DOMAINS`
Recipient domains, separated by commas, whose mail goes through the fallback SMTP provider, such as `gmail.com,googlemail.com`. Only exact domain matches count, and `*` alone sends all mail through the fallback provider. With rexctl, use `rexctl config set FLUXER_EMAIL_FALLBACK_DOMAINS`.
### `FLUXER_EMAIL_FALLBACK_SMTP_HOST`
The hostname of the fallback SMTP provider. With rexctl, use `rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_HOST`.
### `FLUXER_EMAIL_FALLBACK_SMTP_PORT`
The port of the fallback SMTP provider, from 1 to 65535. When it's empty, Fluxer uses `587`. With rexctl, use `rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_PORT`.
### `FLUXER_EMAIL_FALLBACK_SMTP_USERNAME`
The username Fluxer signs in to the fallback SMTP provider with. Fluxer doesn't start when a fallback provider is set without it. With rexctl, use `rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_USERNAME`.
### `FLUXER_EMAIL_FALLBACK_SMTP_PASSWORD`
The password Fluxer signs in to the fallback SMTP provider with. Fluxer doesn't start when a fallback provider is set without it. Keep it secret. With rexctl, use `rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_PASSWORD`.
### `FLUXER_EMAIL_FALLBACK_SMTP_TLS_MODE`
How Fluxer encrypts the connection to the fallback provider. Use `implicit`, `starttls`, `opportunistic` or `none`. When it's empty, Fluxer uses `implicit` on port 465 and `starttls` on any other port. With rexctl, use `rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_TLS_MODE`.
### `FLUXER_EMAIL_FALLBACK_SMTP_HEADERS`
Extra headers added to every message sent through the fallback provider, as a JSON object that maps header names to string values. Core headers such as From, To, Subject and Reply-To can't be set here. With rexctl, use `rexctl config set FLUXER_EMAIL_FALLBACK_SMTP_HEADERS`.
## Push notifications
### `FLUXER_PUSH_APNS_ENABLED`
Whether the push service sends mobile notifications through Apple Push Notification service with your own credentials. Use `true` or `false`. When it's empty, APNs is off. With rexctl, use `rexctl config set FLUXER_PUSH_APNS_ENABLED`.
### `FLUXER_PUSH_APNS_TEAM_ID`
Your Apple developer team ID. With rexctl, use `rexctl config set FLUXER_PUSH_APNS_TEAM_ID`.
### `FLUXER_PUSH_APNS_KEY_ID`
The ID of your APNs signing key, from your Apple developer account. With rexctl, use `rexctl config set FLUXER_PUSH_APNS_KEY_ID`.
### `FLUXER_PUSH_APNS_PRIVATE_KEY`
Your APNs signing key as PEM text. Set this or `FLUXER_PUSH_APNS_PRIVATE_KEY_PATH`, and this one wins when both are set. Keep it secret. With rexctl, use `rexctl config set FLUXER_PUSH_APNS_PRIVATE_KEY`.
### `FLUXER_PUSH_APNS_PRIVATE_KEY_PATH`
The path to your APNs signing key file inside the push container. With rexctl, use `rexctl config set FLUXER_PUSH_APNS_PRIVATE_KEY_PATH`.
### `FLUXER_PUSH_APNS_APPS`
The apps the push service sends to through APNs, as a JSON array of objects. Each object has an `app_id` and a `topic` with the app's bundle ID, and can have an `environment` of `production` or `development`. APNs sends fail for an app that isn't listed or has no topic. A push relay with APNs on doesn't start until this lists at least one app. With rexctl, use `rexctl config set FLUXER_PUSH_APNS_APPS`.
### `FLUXER_PUSH_APNS_DEFAULT_ENVIRONMENT`
The APNs environment the push service uses for a device that registered without one. Use `production` or `development`. When it's empty, it uses `production`. With rexctl, use `rexctl config set FLUXER_PUSH_APNS_DEFAULT_ENVIRONMENT`.
### `FLUXER_PUSH_FCM_ENABLED`
Whether the push service sends mobile notifications through Firebase Cloud Messaging with your own credentials. Use `true` or `false`. When it's empty, FCM is off. With rexctl, use `rexctl config set FLUXER_PUSH_FCM_ENABLED`.
### `FLUXER_PUSH_FCM_PROJECT_ID`
Your Firebase project ID. When it's empty, the push service uses the one in `FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH`. With rexctl, use `rexctl config set FLUXER_PUSH_FCM_PROJECT_ID`.
### `FLUXER_PUSH_FCM_CLIENT_EMAIL`
The client email of your Firebase service account. When it's empty, the push service uses the one in `FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH`. With rexctl, use `rexctl config set FLUXER_PUSH_FCM_CLIENT_EMAIL`.
### `FLUXER_PUSH_FCM_PRIVATE_KEY`
The private key of your Firebase service account as PEM text. When it's empty, the push service uses `FLUXER_PUSH_FCM_PRIVATE_KEY_PATH` or the key in the service account JSON. Keep it secret. With rexctl, use `rexctl config set FLUXER_PUSH_FCM_PRIVATE_KEY`.
### `FLUXER_PUSH_FCM_PRIVATE_KEY_PATH`
The path to your Firebase service account private key inside the push container. The push service uses it when `FLUXER_PUSH_FCM_PRIVATE_KEY` is empty. With rexctl, use `rexctl config set FLUXER_PUSH_FCM_PRIVATE_KEY_PATH`.
### `FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH`
The path to your Firebase service account JSON file inside the push container. The push service loads the project ID, client email and private key from it when those settings are empty. With rexctl, use `rexctl config set FLUXER_PUSH_FCM_SERVICE_ACCOUNT_JSON_PATH`.
### `FLUXER_PUSH_FCM_TOKEN_URI`
The OAuth token URL the push service uses for FCM. When it's empty, it uses `https://oauth2.googleapis.com/token`. Change it only for a proxy or a test double. With rexctl, use `rexctl config set FLUXER_PUSH_FCM_TOKEN_URI`.
### `FLUXER_PUSH_FCM_APPS`
The apps the push service sends to through FCM, as a JSON array of objects that each have an `app_id` and can have a `project_id`. An app with no entry or no `project_id` uses `FLUXER_PUSH_FCM_PROJECT_ID`. A push relay with FCM on doesn't start until this lists at least one app. With rexctl, use `rexctl config set FLUXER_PUSH_FCM_APPS`.
### `FLUXER_VAPID_EMAIL`
The contact email Fluxer sends to browser push services with its VAPID key. When it's empty, Fluxer uses `admin@` followed by `FLUXER_DOMAIN`. Set it if that mailbox doesn't exist. With rexctl, use `rexctl config set FLUXER_VAPID_EMAIL`.
### `FLUXER_PUSH_SERVICE_QUEUE_CAPACITY`
How many notification jobs the push service queues at once, from 1 to 1000000. When it's empty, it uses `10000`. With rexctl, use `rexctl config set FLUXER_PUSH_SERVICE_QUEUE_CAPACITY`.
### `FLUXER_PUSH_SERVICE_SEND_CONCURRENCY`
How many provider requests the push service sends at once across all jobs, from 1 to 65536. When it's empty, it uses `256`. With rexctl, use `rexctl config set FLUXER_PUSH_SERVICE_SEND_CONCURRENCY`.
### `FLUXER_PUSH_SERVICE_APNS_BASE_URL`
A URL that replaces the APNs host in both environments, for a test double only. When it's empty, the push service uses Apple's own hosts. With rexctl, use `rexctl config set FLUXER_PUSH_SERVICE_APNS_BASE_URL`.
### `FLUXER_PUSH_SERVICE_FCM_BASE_URL`
The FCM host the push service sends to. When it's empty, it uses `https://fcm.googleapis.com`. Change it only for a proxy or a test double. With rexctl, use `rexctl config set FLUXER_PUSH_SERVICE_FCM_BASE_URL`.
### `FLUXER_PUSH_SERVICE_MANAGED_RELAY_HOSTS`
Hostnames, separated by commas, of the push relay that Fluxer runs. When it's empty, the push service uses `push.fluxer.com`. It sends to these hosts only once relay consent is accepted. With rexctl, use `rexctl config set FLUXER_PUSH_SERVICE_MANAGED_RELAY_HOSTS`.
### `FLUXER_PUSH_SERVICE_OWN_RELAY_HOSTS`
Hostnames, separated by commas, of a push relay your instance runs itself. The push service sends mobile app notifications addressed to these hosts directly to APNs or FCM with its own credentials. With rexctl, use `rexctl config set FLUXER_PUSH_SERVICE_OWN_RELAY_HOSTS`.
### `FLUXER_PUSH_SERVICE_PRIVATE_HOSTS`
Hostnames, separated by commas, that push endpoints may use even when they resolve to private or loopback addresses, such as a ntfy service on your own network. The push service refuses every other such endpoint. With rexctl, use `rexctl config set FLUXER_PUSH_SERVICE_PRIVATE_HOSTS`.
### `FLUXER_PUSH_SERVICE_RELAY_CONSENT_ACCEPTED`
Whether this push service accepts the push relay privacy notice, which lets it send through the relay Fluxer runs. Use `true`, `1` or `yes` to accept. With `false`, `0`, `no` or an empty value, the push relay setting of the instance decides. With rexctl, use `rexctl config set FLUXER_PUSH_SERVICE_RELAY_CONSENT_ACCEPTED`.
## Media
### `FLUXER_CLAMAV_ENABLED`
Whether Fluxer scans uploads for viruses with ClamAV. Use `true` or `false`. When it's empty, Fluxer uses `false`. No ClamAV container ships with the stack. Point `FLUXER_CLAMAV_HOST` at your own. With rexctl, use `rexctl config set FLUXER_CLAMAV_ENABLED`.
### `FLUXER_CLAMAV_HOST`
The hostname or address of your ClamAV scanner. When it's empty, Fluxer uses `127.0.0.1`. With rexctl, use `rexctl config set FLUXER_CLAMAV_HOST`.
### `FLUXER_CLAMAV_PORT`
The port of your ClamAV scanner. When it's empty, Fluxer uses `3310`. With rexctl, use `rexctl config set FLUXER_CLAMAV_PORT`.
### `FLUXER_CLAMAV_FAIL_OPEN`
Whether uploads go through when a ClamAV scan fails, such as when Fluxer can't connect to the scanner or gets no usable answer. Use `true` or `false`. When it's empty, Fluxer rejects the upload. With rexctl, use `rexctl config set FLUXER_CLAMAV_FAIL_OPEN`.
### `FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64`
Keys that sign attachment URLs, separated by commas. Each is standard base64 that decodes to at least 32 bytes. The first entry signs and every entry verifies. To rotate keys, add the new key last and restart the stack. Then move it first and restart again. Every process can then verify the new key before any process signs with it. Remove the old key 24 hours later. Removing a key ends the data package links it signed. When it's empty, Fluxer returns unsigned attachment URLs. Keep it secret. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64`.
### `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_ENDPOINT`
The upload relay URL the API hands to clients. When it's empty, the API uses the public origin followed by `/media`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_ENDPOINT`.
### `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES`
The largest single request body the relay accepts, which is one object or one part of a multipart upload, in bytes from 1 to 5 GiB. It can't be more than `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_MAX_TOTAL_BYTES`. When it's empty, the relay uses `524288000`, which is 500 MiB. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES`.
### `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_TOKEN_TTL_SECS`
How long an upload relay token stays valid, in seconds. When it's empty, the API uses `900`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_TOKEN_TTL_SECS`.
### `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_KEEP_DIRECT_COUNTRIES`
Two-letter country codes, separated by commas, whose clients upload to the object store directly and skip the relay. It needs the GeoIP database in `FLUXER_GEOIP_DB_PATH`, and browsers can only upload directly when `FLUXER_S3_PUBLIC_ENDPOINT` is set. When it's empty or there's no GeoIP database, every client uses the relay and browsers never see the internal store address. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_KEEP_DIRECT_COUNTRIES`.
### `FLUXER_MEDIA_PROXY_CORS_MODE`
Whether the media proxy checks the Origin of media requests. Use `off`, `report` or `enforce`. When it's empty, it's off. With `report`, the media proxy logs requests it would refuse, and with `enforce` it refuses them. A request with no Origin header is always served. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_CORS_MODE`.
### `FLUXER_MEDIA_PROXY_CORS_ALLOWED_ORIGINS`
The web origins, separated by commas, that may load media through CORS when `FLUXER_MEDIA_PROXY_CORS_MODE` is `report` or `enforce`. When it's empty, the media proxy uses the public origin. The desktop app is always allowed. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_CORS_ALLOWED_ORIGINS`.
### `FLUXER_MEDIA_PROXY_ATTACHMENT_SIGNATURE_MODE`
Whether attachment downloads need a signed link. Use `off`, `report` or `enforce`. When it's empty, it's off. With `report`, the media proxy logs downloads it would refuse, and with `enforce` it refuses them. Both need `FLUXER_MEDIA_PROXY_ATTACHMENT_URL_SECRETS_BASE64`, and rexctl makes a key the first time you turn it on if that's empty. With rexctl, use `rexctl config set media.signed_attachments`.
### `FLUXER_MEDIA_PROXY_READ_ONLY`
Whether the media proxy refuses to write to storage. Use `true` or `false`. When it's empty, it writes as usual. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_READ_ONLY`.
### `FLUXER_MEDIA_PROXY_NSFW_THRESHOLD`
The NSFW classifier score, from 0.0 to 1.0, that the media proxy uses as its cutoff. When it's empty, it uses `0.85`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_NSFW_THRESHOLD`.
### `FLUXER_NSFW_SERVICE_ENDPOINT`
The URL of an outside NSFW classifier the media proxy calls. No such service ships with the stack. When it's empty, the media proxy calls none. With rexctl, use `rexctl config set FLUXER_NSFW_SERVICE_ENDPOINT`.
### `FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS`
How many image transforms the media proxy runs at once, from 1 to 128. When it's empty, it uses the number of CPU cores, kept between 2 and 8. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS`.
### `FLUXER_MEDIA_PROXY_WORKER_QUEUE_CAPACITY`
How many transforms may wait in the media proxy's queue, from 1 to 8192. When it's empty, it uses eight times `FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_WORKER_QUEUE_CAPACITY`.
### `FLUXER_MEDIA_PROXY_MAX_ENCODE_DURATION_MS`
The longest animation the media proxy encodes, in milliseconds from 100 to 600000. When it's empty, it uses `30000`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_MAX_ENCODE_DURATION_MS`.
### `FLUXER_MEDIA_PROXY_MAX_ENCODE_FRAMES`
The most frames the media proxy encodes in one animation, from 1 to 100000. When it's empty, it uses `20000`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_MAX_ENCODE_FRAMES`.
### `FLUXER_MEDIA_PROXY_TRANSFORM_TIMEOUT_MS`
How long one media transform may take, in milliseconds from 1000 to 120000. When it's empty, the media proxy uses `15000`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_TRANSFORM_TIMEOUT_MS`.
### `FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_BYTES`
How much memory the media proxy's transform cache may use, in bytes from 0 to 4 GiB. When it's empty, it uses `268435456`, which is 256 MiB. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_BYTES`.
### `FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_MAX_ENTRY_BYTES`
The largest transform result the media proxy caches, in bytes from 0 to 512 MiB. When it's empty, it uses `67108864`, which is 64 MiB. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_MAX_ENTRY_BYTES`.
### `FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_TTL_MS`
How long the media proxy keeps a transform result in its cache, in milliseconds from 0 to 3600000. When it's empty, it uses `120000`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_TRANSFORM_CACHE_TTL_MS`.
### `FLUXER_MEDIA_PROXY_SOCKET_IO_TIMEOUT_MS`
How long the media proxy waits on socket input and output, in milliseconds from 0 to 300000. When it's empty, it uses `30000`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_SOCKET_IO_TIMEOUT_MS`.
### `FLUXER_MEDIA_PROXY_SHUTDOWN_GRACE_MS`
How long the media proxy waits for open requests and transforms to finish when it stops, in milliseconds from 0 to 300000. When it's empty, it uses `30000`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_SHUTDOWN_GRACE_MS`.
### `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_S3_TIMEOUT_MS`
How long the relay waits for an upload's write to the object store, in milliseconds from 1000 to 3600000. When it's empty, it uses `900000`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_S3_TIMEOUT_MS`.
### `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_BYTES`
The largest upload the relay keeps in memory so it can retry the object store write, in bytes from 0 to 256 MiB. Larger uploads stream to the store without a retry. When it's empty, the relay uses `33554432`, which is 32 MiB. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_BYTES`.
### `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_TOTAL_BYTES`
How much memory all buffered relay uploads may use together, in bytes from 0 to 8 GiB. An upload that would go past it streams without a retry. When it's empty, the relay uses `536870912`, which is 512 MiB. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_BUFFERED_RETRY_TOTAL_BYTES`.
### `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_DIR`
The directory where the relay spools upload bodies and the media proxy keeps copies of large audio and video files it inspects. It must be writable. When it's empty, the media proxy uses the system temporary directory. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_DIR`.
### `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_CHUNK_BYTES`
The chunk size the relay uses when it writes upload bodies to its spool on disk, in bytes from 64 KiB to 64 MiB. When it's empty, it uses `1048576`, which is 1 MiB. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_CHUNK_BYTES`.
### `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_MAX_TOTAL_BYTES`
The most disk space the spool may use at once, in bytes from 0 to 256 GiB, shared by relay uploads and copies of large audio and video files. It must be at least `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES`. The default is `2147483648`, which is 2 GiB. rexctl raises this to `FLUXER_MEDIA_PROXY_UPLOAD_RELAY_MAX_BODY_BYTES` if you set that higher. When disk.profile is small, rexctl sets this to 536870912, which is 512 MiB, unless you set it. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_UPLOAD_RELAY_SPOOL_MAX_TOTAL_BYTES`.
### `FLUXER_CACHE_PURGE_ADAPTER`
How Fluxer purges cached copies of deleted or replaced media from your CDN or caching proxy. Use `none`, `http` or `controller`. When it's empty, Fluxer uses `none` and sends no purges. With rexctl, use `rexctl config set FLUXER_CACHE_PURGE_ADAPTER`.
### `FLUXER_CACHE_PURGE_HTTP_ENDPOINT`
The URL the worker posts purge requests to when `FLUXER_CACHE_PURGE_ADAPTER` is `http`, as an absolute http or https URL without credentials. Your endpoint then purges the listed media URL prefixes from every cache in front of the media. With rexctl, use `rexctl config set FLUXER_CACHE_PURGE_HTTP_ENDPOINT`.
### `FLUXER_CACHE_PURGE_HTTP_TOKEN`
The bearer token Fluxer sends in the Authorization header of each purge request to `FLUXER_CACHE_PURGE_HTTP_ENDPOINT`, in visible ASCII characters with no spaces. Keep it secret. With rexctl, use `rexctl config set FLUXER_CACHE_PURGE_HTTP_TOKEN`.
### `FLUXER_CACHE_PURGE_HTTP_TIMEOUT_MS`
How long each purge request to `FLUXER_CACHE_PURGE_HTTP_ENDPOINT` may take, in milliseconds from 1000 to 10000. When it's empty, Fluxer uses `10000`. With rexctl, use `rexctl config set FLUXER_CACHE_PURGE_HTTP_TIMEOUT_MS`.
### `FLUXER_CACHE_PURGE_CONTROLLER_ENDPOINT`
The purge URL of the Controller edge site that serves your media, as an absolute https URL without credentials. Fluxer uses it when `FLUXER_CACHE_PURGE_ADAPTER` is `controller`. With rexctl, use `rexctl config set FLUXER_CACHE_PURGE_CONTROLLER_ENDPOINT`.
### `FLUXER_CACHE_PURGE_CONTROLLER_TOKEN`
The Controller API key Fluxer sends as a bearer token with each purge request, in visible ASCII characters with no spaces. Keep it secret. With rexctl, use `rexctl config set FLUXER_CACHE_PURGE_CONTROLLER_TOKEN`.
### `FLUXER_CACHE_PURGE_CONTROLLER_TIMEOUT_MS`
How long each Controller purge request may take, in milliseconds from 1000 to 10000. When it's empty, Fluxer uses `10000`. With rexctl, use `rexctl config set FLUXER_CACHE_PURGE_CONTROLLER_TIMEOUT_MS`.
## Gateway
### `FLUXER_GATEWAY_MEDIA_PROXY_ENDPOINT`
The public media URL the gateway uses to build avatar links in push notifications. When it's empty, the gateway uses `FLUXER_MEDIA_ENDPOINT`, or the public origin followed by `/media`. With rexctl, use `rexctl config set FLUXER_GATEWAY_MEDIA_PROXY_ENDPOINT`.
### `FLUXER_GATEWAY_STATIC_CDN_ENDPOINT`
The public static file URL the gateway uses to build default avatar links in push notifications. When it's empty, the gateway uses `FLUXER_STATIC_CDN_ENDPOINT`, or the public origin. With rexctl, use `rexctl config set FLUXER_GATEWAY_STATIC_CDN_ENDPOINT`.
### `FLUXER_GATEWAY_PUSH_ENABLED`
Whether the gateway sends push notifications through the push service. Use `true` or `false`. When it's empty, the gateway uses `true`. With rexctl, use `rexctl config set FLUXER_GATEWAY_PUSH_ENABLED`.
### `FLUXER_GATEWAY_PUSH_ENROLLED_CLEAR_NOTIFICATIONS_ENABLED`
Whether the gateway asks the push service to clear a channel's push notifications once the user has caught up on that channel. Use `true` or `false`. When it's empty, the gateway uses `true`. With rexctl, use `rexctl config set FLUXER_GATEWAY_PUSH_ENROLLED_CLEAR_NOTIFICATIONS_ENABLED`.
### `FLUXER_GATEWAY_PUSH_OUTBOX_REQUEST_TIMEOUT_MS`
How long the gateway waits for the push service to respond to one push request, in milliseconds. When it's empty, the gateway uses `100000`. With rexctl, use `rexctl config set FLUXER_GATEWAY_PUSH_OUTBOX_REQUEST_TIMEOUT_MS`.
### `FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_ENTRIES`
The most push notifications the gateway keeps back for one user while one of their sessions is active, dropping the oldest first. A value of `0` keeps none. When it's empty, the gateway uses `128`. With rexctl, use `rexctl config set FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_ENTRIES`.
### `FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_BYTES`
The most bytes of push notifications the gateway keeps back for one user while one of their sessions is active. A value of `0` turns off this limit. When it's empty, the gateway uses `1048576`, which is 1 MiB. With rexctl, use `rexctl config set FLUXER_GATEWAY_PRESENCE_PUSH_BUFFER_MAX_BYTES`.
### `FLUXER_GATEWAY_HTTP_RPC_MAX_CONCURRENCY`
How many HTTP requests the gateway can have open to the API at once. When it's empty, the gateway uses `512`. With rexctl, use `rexctl config set FLUXER_GATEWAY_HTTP_RPC_MAX_CONCURRENCY`.
### `FLUXER_GATEWAY_NATS_RPC_MAX_HANDLERS`
How many NATS RPC requests the gateway works on at once. When it's empty, the gateway uses `512`. With rexctl, use `rexctl config set FLUXER_GATEWAY_NATS_RPC_MAX_HANDLERS`.
### `FLUXER_GATEWAY_ZSTD_WINDOW_LOG`
The base 2 logarithm of the zstd window the gateway compresses websocket traffic with, from 10 to 21. Values outside that range count as the nearest end. Larger values compress better and use more memory per connection. When it's empty, the gateway uses `17`. With rexctl, use `rexctl config set FLUXER_GATEWAY_ZSTD_WINDOW_LOG`.
### `FLUXER_GATEWAY_IDENTIFY_TOKEN_LIMIT_PER_MINUTE`
The most times one token can identify on one gateway node in a minute. The gateway does not answer identifies over the limit. A value of `0` turns off this limit. When it's empty, the gateway uses `0`. With rexctl, use `rexctl config set FLUXER_GATEWAY_IDENTIFY_TOKEN_LIMIT_PER_MINUTE`.
### `FLUXER_GATEWAY_HTTP_FAILURE_THRESHOLD`
How many failed requests from the gateway to the API in 10 seconds open its circuit breaker, when at least 80 percent of the requests in that time failed. The breaker then stops further requests for a while. When it's empty, the gateway uses `6`. With rexctl, use `rexctl config set FLUXER_GATEWAY_HTTP_FAILURE_THRESHOLD`.
### `FLUXER_GATEWAY_HTTP_RECOVERY_TIMEOUT_MS`
How long the circuit breaker for gateway requests to the API stays open before it tries again, in milliseconds. When it's empty, the gateway uses `15000`. With rexctl, use `rexctl config set FLUXER_GATEWAY_HTTP_RECOVERY_TIMEOUT_MS`.
### `FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_MAX`
The most visitor sessions one community allows, however many members it has. A visitor views a community without joining it. When it's empty, the gateway uses `10000`. With rexctl, use `rexctl config set FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_MAX`.
### `FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_FLOOR`
The fewest visitor sessions one community allows, however few members it has. When it's empty, the gateway uses `500`. With rexctl, use `rexctl config set FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_FLOOR`.
### `FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_MEMBER`
How many visitor sessions a community allows for each of its members, kept between the floor and the maximum. When it's empty, the gateway uses `2`. With rexctl, use `rexctl config set FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_MEMBER`.
### `FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_USER`
How many visitor sessions one account can have in a single community at once. When it's empty, the gateway uses `5`. With rexctl, use `rexctl config set FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_USER`.
### `FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_IP`
How many visitor sessions one IPv4 address or one IPv6 `/64` network can have in a single community at once. When it's empty, the gateway uses `20`. With rexctl, use `rexctl config set FLUXER_GATEWAY_GUILD_VISITOR_SESSIONS_PER_IP`.
## Web app
### `DISCOVERY_REFRESH_INTERVAL_MS`
How often the app-proxy service fetches the discovery document, in milliseconds. The document has the branding saved in the admin panel, such as the product name, icons and custom CSS. Values under 1 second count as 1 second. A failed fetch is retried with a growing delay of up to five minutes. The default is `5000`. With rexctl, use `rexctl config set DISCOVERY_REFRESH_INTERVAL_MS`.
### `FLUXER_APP_PROXY_INDEX_UPSTREAM_URL`
An http or https URL that the app-proxy service fetches the web app's `index.html` from. When it's empty, the app-proxy service serves the `index.html` built into its image. With rexctl, use `rexctl config set FLUXER_APP_PROXY_INDEX_UPSTREAM_URL`.
### `FLUXER_APP_PROXY_SAME_ORIGIN_HOSTS`
Extra hostnames that serve the web app, separated by commas or spaces, with no scheme, port or path. On these hostnames, the web app uses the same hostname for the API and for the gateway and media endpoints that share the API's host. Each one must route `/api`, `/gateway` and `/media` like the main one. With rexctl, use `rexctl config set FLUXER_APP_PROXY_SAME_ORIGIN_HOSTS`.
### `FLUXER_APP_PROXY_MANIFEST_SCOPE_EXTENSIONS`
HTTPS origins with no path, separated by commas or spaces, that the app-proxy service adds to the `scope_extensions` list of the web app manifest. An installed web app keeps them inside its window. Each origin must serve `/.well-known/web-app-origin-association` for this web app. Invalid entries are logged and dropped. With rexctl, use `rexctl config set FLUXER_APP_PROXY_MANIFEST_SCOPE_EXTENSIONS`.
### `FLUXER_CSP_EXTRA_DEFAULT_SRC`
Extra sources the app-proxy service adds to the default-src directive of the web app's Content-Security-Policy, separated by commas or spaces. Set one only when a browser must connect to an origin the built-in policy doesn't cover. With rexctl, use `rexctl config set FLUXER_CSP_EXTRA_DEFAULT_SRC`.
### `FLUXER_CSP_EXTRA_CONNECT_SRC`
Extra sources the app-proxy service adds to the connect-src directive of the web app's Content-Security-Policy, separated by commas or spaces, such as `wss://livekit.example.com`. A ws or wss source also allows the matching http or https source. With rexctl, use `rexctl config set FLUXER_CSP_EXTRA_CONNECT_SRC`.
### `FLUXER_CSP_EXTRA_IMG_SRC`
Extra sources the app-proxy service adds to the img-src directive of the web app's Content-Security-Policy, separated by commas or spaces, such as `https://cdn.example.com`. With rexctl, use `rexctl config set FLUXER_CSP_EXTRA_IMG_SRC`.
### `FLUXER_CSP_EXTRA_MEDIA_SRC`
Extra sources the app-proxy service adds to the media-src directive of the web app's Content-Security-Policy, separated by commas or spaces. With rexctl, use `rexctl config set FLUXER_CSP_EXTRA_MEDIA_SRC`.
### `FLUXER_CSP_EXTRA_FONT_SRC`
Extra sources the app-proxy service adds to the font-src directive of the web app's Content-Security-Policy, separated by commas or spaces. With rexctl, use `rexctl config set FLUXER_CSP_EXTRA_FONT_SRC`.
### `FLUXER_CSP_EXTRA_SCRIPT_SRC`
Extra sources the app-proxy service adds to the script-src directive of the web app's Content-Security-Policy, separated by commas or spaces, such as `https://analytics.example.com`. With rexctl, use `rexctl config set FLUXER_CSP_EXTRA_SCRIPT_SRC`.
### `FLUXER_CSP_EXTRA_STYLE_SRC`
Extra sources the app-proxy service adds to the style-src directive of the web app's Content-Security-Policy, separated by commas or spaces. With rexctl, use `rexctl config set FLUXER_CSP_EXTRA_STYLE_SRC`.
### `FLUXER_CSP_EXTRA_FRAME_SRC`
Extra sources the app-proxy service adds to the frame-src directive of the web app's Content-Security-Policy, separated by commas or spaces. With rexctl, use `rexctl config set FLUXER_CSP_EXTRA_FRAME_SRC`.
### `FLUXER_CSP_EXTRA_WORKER_SRC`
Extra sources the app-proxy service adds to the worker-src directive of the web app's Content-Security-Policy, separated by commas or spaces. With rexctl, use `rexctl config set FLUXER_CSP_EXTRA_WORKER_SRC`.
### `FLUXER_CSP_EXTRA_MANIFEST_SRC`
Extra sources the app-proxy service adds to the manifest-src directive of the web app's Content-Security-Policy, separated by commas or spaces. With rexctl, use `rexctl config set FLUXER_CSP_EXTRA_MANIFEST_SRC`.
### `FLUXER_CSP_REPORT_URI`
One http or https URL that browsers send Content-Security-Policy violation reports to. When it's empty, the policy has no report-uri. With rexctl, use `rexctl config set FLUXER_CSP_REPORT_URI`.
## API and worker
### `FLUXER_API_HEADERS_TIMEOUT_MS`
How long a client may take to send the request line and headers to the API, in milliseconds from 1000 to 3600000. It is capped at `FLUXER_API_REQUEST_TIMEOUT_MS`. When it's empty, the API uses `30000`. With rexctl, use `rexctl config set FLUXER_API_HEADERS_TIMEOUT_MS`.
### `FLUXER_API_REQUEST_TIMEOUT_MS`
How long a client may take over a whole request to the API, in milliseconds from 1000 to 3600000. Raise it for large uploads or slow links. When it's empty, the API uses `120000`. With rexctl, use `rexctl config set FLUXER_API_REQUEST_TIMEOUT_MS`.
### `FLUXER_API_MAX_INFLIGHT_REQUESTS`
How many requests the API handles at once before it responds to new ones with 503 and a Retry-After header, from 1 to 100000. When it's empty, the API uses `512`. With rexctl, use `rexctl config set FLUXER_API_MAX_INFLIGHT_REQUESTS`.
### `FLUXER_API_MAX_CONCURRENT_FORM_UPLOADS`
How many attachment files sent as multipart form data the API streams to the object store at once, from 1 to 10000. Each one can use up to about 25 MiB of memory. A file that waits more than 10 seconds for a turn gets 503 with a Retry-After header. When it's empty, the API uses `16`. With rexctl, use `rexctl config set FLUXER_API_MAX_CONCURRENT_FORM_UPLOADS`.
### `FLUXER_TRUST_CLIENT_IP_HEADER`
Whether Fluxer trusts the client address in the `FLUXER_CLIENT_IP_HEADER_NAME` header. Use `true` or `false`. The api, worker, admin and gateway services and the push relay use it. With `false`, they use the address of the connection, which behind the edge is the edge itself. Outside Docker Compose, the services use `false` when it's empty. The default is `true`. With rexctl, use `rexctl config set FLUXER_TRUST_CLIENT_IP_HEADER`.
### `FLUXER_CLIENT_IP_HEADER_NAME`
The request header that has the client's IP address. When it's empty, the api, worker, admin and gateway services and the push relay use `x-forwarded-for`, the header the edge sets. With rexctl, use `rexctl config set FLUXER_CLIENT_IP_HEADER_NAME`.
### `FLUXER_API_IP_BAN_EXEMPT_IPS`
IP addresses and CIDR ranges, separated by commas, that IP bans never apply to, such as `203.0.113.7,2001:db8::/56`. The API refuses to start when an entry doesn't parse. With rexctl, use `rexctl config set FLUXER_API_IP_BAN_EXEMPT_IPS`.
### `FLUXER_IP_BAN_REFRESH_INTERVAL_MS`
How often the API reloads its IP ban list, in milliseconds. When it's empty, the API uses `300000`. A value of `0` turns the periodic reload off. With rexctl, use `rexctl config set FLUXER_IP_BAN_REFRESH_INTERVAL_MS`.
### `FLUXER_API_DONATION_PROXY_KEY`
An older way to add one trusted caller that may pass the client address for the donation and purchase rate limits. Fluxer's marketing site uses it. It must be at least 32 characters. Your own instance can leave it empty. Keep it secret. With rexctl, use `rexctl config set FLUXER_API_DONATION_PROXY_KEY`.
### `FLUXER_API_TRUSTED_CALLERS`
A JSON array of trusted callers, such as a front end that calls the API for its own visitors. Each entry is an object with a `name`, a `key` of at least 32 characters and `buckets`, a non-empty list of the rate limit buckets the caller may pass a client address for. The caller sends its key in the `X-Fluxer-Internal-Key` header and the client address in the `X-Fluxer-Client-IP` header. Keep it secret. With rexctl, use `rexctl config set FLUXER_API_TRUSTED_CALLERS`.
### `FLUXER_API_WORKER_LANE_CONCURRENCY_OVERRIDES`
How many jobs each worker lane runs at once, as a JSON object that maps each lane to a whole number of at least 1. The lanes are `realtime`, `unfurl`, `lifecycle`, `batch` and `crosspost`. Lanes left out use 10, 20, 8, 12 and 8 in that order, scaled down on machines with fewer than 4 CPU cores. With rexctl, use `rexctl config set FLUXER_API_WORKER_LANE_CONCURRENCY_OVERRIDES`.
## Instance and branding
Fluxer uses the product name, images, theme colour and status page links set here only until the setup wizard finishes or someone saves branding in the admin panel. After that it uses the saved values and ignores these. Make later changes in the admin panel or with `rexctl config set`.
### `FLUXER_APP_PRODUCT_NAME`
The product name the apps show and Fluxer uses in emails and system messages. When it's empty or set to `Fluxer` on a self-hosted instance, Fluxer uses the hostname of the web app. With rexctl, use `rexctl config set app_public.branding.product_name`.
### `FLUXER_APP_ICON_URL`
The URL of the app icon. With rexctl, use `rexctl config set app_public.branding.icon_url`.
### `FLUXER_APP_SYMBOL_URL`
The URL of the symbol mark. With rexctl, use `rexctl config set app_public.branding.symbol_url`.
### `FLUXER_APP_LOGO_URL`
The URL of the logo. With rexctl, use `rexctl config set app_public.branding.logo_url`.
### `FLUXER_APP_WORDMARK_URL`
The URL of the wordmark. With rexctl, use `rexctl config set app_public.branding.wordmark_url`.
### `FLUXER_APP_FAVICON_URL`
The URL of the favicon. With rexctl, use `rexctl config set app_public.branding.favicon_url`.
### `FLUXER_APP_FAVICON_DARK_URL`
The URL of the favicon for browsers in dark mode. With rexctl, use `rexctl config set app_public.branding.favicon_dark_url`.
### `FLUXER_APP_SIGN_IN_BACKDROP_URL`
The URL of the image behind the sign-in screen. With rexctl, use `rexctl config set app_public.branding.sign_in_backdrop_url`.
### `FLUXER_APP_THEME_COLOR`
The brand colour of the web app and the browser theme colour, as a hex value such as `#4641d9`. With rexctl, use `rexctl config set app_public.branding.theme_color`.
### `FLUXER_APP_STATUS_PAGE_URL`
The URL of your public status page. The web app links to it when loading takes a long time. Fluxer checks whether it is an Instatus page. If it is, the web app also reads its current incidents and maintenance automatically. With rexctl, use `rexctl config set app_public.branding.status_page_url`.
### `FLUXER_APP_STATUS_PAGE_INCIDENT_HISTORY_URL`
The URL of the incident history on your status page. The apps don't use it yet. With rexctl, use `rexctl config set app_public.branding.status_page_incident_history_url`.
### `FLUXER_INSTANCE_SETUP_CONFIGURED`
Whether a new instance starts as already set up. Use `true` or `false`. With `true`, the setup wizard is skipped and registration opens without making the first account an admin. Once a setup state is saved, this has no effect. When it's empty, Fluxer uses `false`. With rexctl, use `rexctl config set FLUXER_INSTANCE_SETUP_CONFIGURED`.
### `FLUXER_APP_ATTEST_APP_IDS`
The iOS apps whose age reports the users service accepts through Apple App Attest, separated by commas. Each entry is a team ID, a dot and a bundle ID, such as `ABCDE12345.com.example.app`. When it's empty, App Attest is off and its API endpoints respond that the feature isn't available. The users service doesn't start when an entry isn't in that form. With rexctl, use `rexctl config set FLUXER_APP_ATTEST_APP_IDS`.
### `FLUXER_APP_ATTEST_ALLOW_DEVELOPMENT`
Whether the users service also accepts App Attest keys from development builds of the apps in `FLUXER_APP_ATTEST_APP_IDS`. Use `true` or `false`. When it's empty, it uses `false`, so only App Store, TestFlight and other production builds are accepted. With rexctl, use `rexctl config set FLUXER_APP_ATTEST_ALLOW_DEVELOPMENT`.
### `FLUXER_PLAY_INTEGRITY_PACKAGE_NAMES`
The Android apps whose age reports the users service accepts through the Google Play Integrity API, separated by commas, such as `com.example.app`. When it's empty, Play Integrity is off and its API endpoints respond that the feature isn't available. When it's set, `FLUXER_PLAY_INTEGRITY_CERT_SHA256` and `FLUXER_PLAY_INTEGRITY_SERVICE_ACCOUNT_JSON_PATH` are required, and the users service doesn't start without them. With rexctl, use `rexctl config set FLUXER_PLAY_INTEGRITY_PACKAGE_NAMES`.
### `FLUXER_PLAY_INTEGRITY_CERT_SHA256`
The SHA-256 fingerprints of the app signing certificates that Google Play uses for the apps in `FLUXER_PLAY_INTEGRITY_PACKAGE_NAMES`, separated by commas. Each entry is the hex fingerprint the Play Console shows under app signing, with or without colons, or the same digest as base64url. With rexctl, use `rexctl config set FLUXER_PLAY_INTEGRITY_CERT_SHA256`.
### `FLUXER_PLAY_INTEGRITY_SERVICE_ACCOUNT_JSON_PATH`
The path to a Google Cloud service account JSON key file inside the users container. The users service uses it to ask Google Play to decode integrity tokens. The service account must belong to the Cloud project linked to the apps in the Play Console. With rexctl, use `rexctl config set FLUXER_PLAY_INTEGRITY_SERVICE_ACCOUNT_JSON_PATH`.
### `FLUXER_PLAY_INTEGRITY_DEVICE_INTEGRITY`
The device check an Android device must pass. Use `device` to need `MEETS_DEVICE_INTEGRITY`, or `strong` to need `MEETS_STRONG_INTEGRITY`, which you must turn on in the Play Console first. When it's empty, it uses `device`. With rexctl, use `rexctl config set FLUXER_PLAY_INTEGRITY_DEVICE_INTEGRITY`.
### `FLUXER_ACCOUNT_IDENTITY`
How people sign in on a new instance. Use `username` or `email`. Fluxer uses it only on the first start with no saved sign-in method. When it's empty, Fluxer uses `email` if email delivery is set up and `username` otherwise. When `FLUXER_INSTANCE_SETUP_CONFIGURED` is `true` or any account exists, Fluxer uses email sign-in with random tags and ignores this. Otherwise the setup wizard asks again, and its answer replaces this value. With rexctl, use `rexctl config set FLUXER_ACCOUNT_IDENTITY`.
### `FLUXER_TAG_STYLE`
How usernames are tagged on a new instance that signs in by email. Use `none` for unique usernames with no tag or `random` for a random tag on every account. Username sign-in always uses `none`. Fluxer reads this setting only on the first start. When it's empty, Fluxer uses `none`. When `FLUXER_INSTANCE_SETUP_CONFIGURED` is `true` or any account exists, Fluxer uses random tags and ignores this. Otherwise the setup wizard asks again, and its answer replaces this value. With rexctl, use `rexctl config set FLUXER_TAG_STYLE`.
### `FLUXER_AUTO_JOIN_INVITE_CODE`
One or more invite codes, separated by commas or spaces. A new account that signs up without an invite of its own joins the communities these invites lead to. With rexctl, use `rexctl config set FLUXER_AUTO_JOIN_INVITE_CODE`.
### `FLUXER_DISCOVERY_ENABLED`
Whether community discovery is on. Use `true` or `false`. With `false`, discovery search, joining from discovery and discovery applications are turned off. When it's empty, Fluxer uses `true`. With rexctl, use `rexctl config set FLUXER_DISCOVERY_ENABLED`.
### `FLUXER_DISCOVERY_MIN_MEMBER_COUNT`
How many members a community needs before it can be listed in discovery. When it's empty, Fluxer uses `1`. With rexctl, use `rexctl config set FLUXER_DISCOVERY_MIN_MEMBER_COUNT`.
### `FLUXER_DELETION_GRACE_PERIOD_HOURS`
How many hours a deleted account can still be recovered before Fluxer removes it. When it's empty, Fluxer uses `336`, which is 14 days. With rexctl, use `rexctl config set FLUXER_DELETION_GRACE_PERIOD_HOURS`.
### `FLUXER_REPORT_RETENTION_DAYS`
How many days the daily retention job keeps a resolved report, from 1 to 36500. It then deletes the report, its evidence copies and its search entry. A child safety report is kept for at least 365 days after it's resolved, and a report with an enforcement decision for at least 365 days after the decision. The job never deletes a pending report or a report under a legal hold. When it's empty, the worker uses `365`. With rexctl, use `rexctl config set FLUXER_REPORT_RETENTION_DAYS`.
### `FLUXER_REPORT_RETENTION_DRY_RUN`
Whether the report retention job only counts what it would delete and changes nothing. Use `true` or `false`. When it's empty, the worker uses `false`. With rexctl, use `rexctl config set FLUXER_REPORT_RETENTION_DRY_RUN`.
### `FLUXER_AGE_POLICY_ENABLED`
Whether the apps need an age check before they show mature content to people in the regions in `FLUXER_AGE_POLICY_RESTRICTED_REGIONS`. Use `true` or `false`. When it's empty, the age check is on only when `FLUXER_AGE_POLICY_RESTRICTED_REGIONS` is set. With rexctl, use `rexctl config set FLUXER_AGE_POLICY_ENABLED`.
### `FLUXER_AGE_POLICY_RESTRICTED_REGIONS`
The regions where the apps need an age check before they show mature content, separated by commas. Use a country code such as `GB` or a country and region code such as `US-MS`. When it's empty and `FLUXER_AGE_POLICY_ENABLED` is `true`, Fluxer uses `GB` and `BR`. With rexctl, use `rexctl config set FLUXER_AGE_POLICY_RESTRICTED_REGIONS`.
## Billing
The admin panel can also save whether billing is on, the Stripe keys and the prices. A value saved there is used first, and a saved price list replaces all of `FLUXER_STRIPE_PRICES`.
### `FLUXER_STRIPE_ENABLED`
Whether Fluxer sells subscriptions through Stripe. Use `true` or `false`. When it's empty, Fluxer uses `false`. With rexctl, use `rexctl config set billing.enabled`.
### `FLUXER_STRIPE_SECRET_KEY`
Your Stripe secret API key. Keep it secret. With rexctl, use `rexctl config set billing.stripe_secret_key`.
### `FLUXER_STRIPE_WEBHOOK_SECRET`
The signing secret of your Stripe webhook. Keep it secret. With rexctl, use `rexctl config set billing.stripe_webhook_secret`.
### `FLUXER_STRIPE_PRICES`
Your Stripe price IDs as one JSON object, keyed by plan and currency such as `monthly_usd`. With rexctl, use `rexctl config set billing.prices`.
### `FLUXER_STRIPE_LEGACY_PRICES`
Stripe price IDs you have retired, as a JSON object with the same keys as `FLUXER_STRIPE_PRICES` and a list of IDs for each. Subscriptions on these prices keep renewing. With rexctl, use `rexctl config set billing.legacy_prices`.
### `FLUXER_VISIONARIES_GUILD_ID`
The ID of the community that people who buy Visionary are added to. When it's empty on a self-hosted instance, nobody is added. With rexctl, use `rexctl config set FLUXER_VISIONARIES_GUILD_ID`.
### `FLUXER_VISIONARIES_GUILD_VISIONARY_ROLE_ID`
The ID of the role Fluxer gives Visionary buyers in the community set by `FLUXER_VISIONARIES_GUILD_ID`. Set it whenever `FLUXER_VISIONARIES_GUILD_ID` is set. With rexctl, use `rexctl config set FLUXER_VISIONARIES_GUILD_VISIONARY_ROLE_ID`.
## Integrations
The admin panel can also save the Bluesky settings and keys. A value saved there is used first.
### `FLUXER_BREACHED_PASSWORD_CHECK_ENABLED`
Whether Fluxer rejects passwords found in known data breaches, by sending the first five characters of the password's SHA-1 hash to `api.pwnedpasswords.com`. Use `true` or `false`. When it's empty, this is off on a self-hosted instance. With rexctl, use `rexctl config set FLUXER_BREACHED_PASSWORD_CHECK_ENABLED`.
### `FLUXER_BLOCKLIST_FEEDS_ENABLED`
Whether the worker downloads the URLhaus and PhishTank link lists every six hours and the MalwareBazaar file hashes every twelve hours, and checks posted links and uploads against them. Use `true` or `false`. When it's empty, this is off on a self-hosted instance. With rexctl, use `rexctl config set FLUXER_BLOCKLIST_FEEDS_ENABLED`.
### `FLUXER_GEOIP_DB_PATH`
Where the api and worker load the MaxMind GeoIP database from, as a file path or an `s3://bucket/key` URL. An s3 URL needs a `download_path` query parameter with an absolute path. With rexctl, use `rexctl config set FLUXER_GEOIP_DB_PATH`.
### `FLUXER_KLIPY_API_KEY`
The Klipy API key for GIF search and Klipy link previews. A key saved in the admin panel is used first. GIF search is off when neither is set. Keep it secret. With rexctl, use `rexctl config set integrations.gif.klipy_api_key`.
### `FLUXER_YOUTUBE_API_KEY`
The YouTube Data API key Fluxer uses for YouTube link previews. A key saved in the admin panel is used first. The unfurl service calls the API from your server. The key needs YouTube Data API v3 enabled, a daily quota above 0, and an application restriction of None or IP addresses. A key restricted to websites (HTTP referrers) always fails. When Google rejects the key, the unfurl logs show the reason it gives, such as `quotaExceeded` or `API_KEY_HTTP_REFERRER_BLOCKED`. Keep it secret. With rexctl, use `rexctl config set integrations.youtube.api_key`.
### `FLUXER_API_UNFURL_IGNORED_HOSTS`
Hostnames, separated by commas, that Fluxer never makes link previews for. A link matches only when its host is exactly one of these. With rexctl, use `rexctl config set FLUXER_API_UNFURL_IGNORED_HOSTS`.
### `FLUXER_AUTH_BLUESKY_ENABLED`
Whether people can link a Bluesky account to their profile. Use `true` or `false`. It needs `FLUXER_AUTH_BLUESKY_KEYS`. When it's empty, Fluxer uses `false`. With rexctl, use `rexctl config set integrations.bluesky.enabled`.
### `FLUXER_AUTH_BLUESKY_CLIENT_NAME`
The app name Bluesky shows when someone links their account. When it's empty, Bluesky shows `Fluxer`, even when `FLUXER_APP_PRODUCT_NAME` is set. With rexctl, use `rexctl config set integrations.bluesky.client_name`.
### `FLUXER_AUTH_BLUESKY_CLIENT_URI`
Fluxer doesn't use this value. Bluesky shows the API address as the home page of your instance.
### `FLUXER_AUTH_BLUESKY_LOGO_URI`
The logo URL Bluesky shows for your instance. With rexctl, use `rexctl config set integrations.bluesky.logo_uri`.
### `FLUXER_AUTH_BLUESKY_TOS_URI`
The terms of service URL Bluesky shows for your instance. With rexctl, use `rexctl config set integrations.bluesky.tos_uri`.
### `FLUXER_AUTH_BLUESKY_POLICY_URI`
The privacy policy URL Bluesky shows for your instance. With rexctl, use `rexctl config set integrations.bluesky.policy_uri`.
### `FLUXER_AUTH_BLUESKY_KEYS`
The keys Fluxer signs Bluesky account linking requests with, as a JSON array of objects with a `kid` and a `private_key` or a `private_key_path`, which is an absolute path inside the api and worker containers. Keys saved in the admin panel replace these. Keep it secret. With rexctl, use `rexctl config set integrations.bluesky.keys`.
## Memory and performance
rexctl sets some of these from the machine's memory and CPU on every start. A value you set wins.
### `FLUXER_TOKIO_WORKER_THREADS`
How many worker threads the async runtime uses in the app-proxy, push, admin, snowflakes, users, gifs, messages and unfurl containers, set as their `TOKIO_WORKER_THREADS`. The default is `2`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_TOKIO_WORKER_THREADS`.
### `FLUXER_MALLOC_ARENA_MAX`
How many memory arenas the glibc allocator may create in the push, admin, snowflakes, users, gifs, messages and unfurl containers, set as their `MALLOC_ARENA_MAX`. Lower values use less memory. The default is `2`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_MALLOC_ARENA_MAX`.
### `FLUXER_CADDY_MEMORY_LIMIT`
The memory limit for the edge container, which runs Caddy. The default is `384mb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_CADDY_MEMORY_LIMIT`.
### `FLUXER_POSTGRES_MEMORY_LIMIT`
The memory limit for the postgres container. Keep it at or above `FLUXER_POSTGRES_MEMORY_RESERVATION`. The default is `5gb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_MEMORY_LIMIT`.
### `FLUXER_POSTGRES_MEMORY_RESERVATION`
The memory reservation for the postgres container, the amount Docker tries to keep for it when the machine runs low. Keep it at or below `FLUXER_POSTGRES_MEMORY_LIMIT`. The default is `3gb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_MEMORY_RESERVATION`.
### `FLUXER_POSTGRES_SERVER_MAX_CONNECTIONS`
Postgres `max_connections`, how many connections the database accepts in total. Keep it above the sum of all pool sizes, counting each worker replica. The default is `150`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_SERVER_MAX_CONNECTIONS`.
### `FLUXER_POSTGRES_SHARED_BUFFERS`
Postgres `shared_buffers`, the memory Postgres uses for its own cache. The default is `512MB`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_SHARED_BUFFERS`.
### `FLUXER_POSTGRES_EFFECTIVE_CACHE_SIZE`
Postgres `effective_cache_size`, how much disk cache the query planner assumes there is. It allocates no memory. The default is `2GB`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_EFFECTIVE_CACHE_SIZE`.
### `FLUXER_POSTGRES_WORK_MEM`
Postgres `work_mem`, the memory each sort or hash step in a query can use before it spills to disk. The default is `8MB`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_WORK_MEM`.
### `FLUXER_POSTGRES_MAINTENANCE_WORK_MEM`
Postgres `maintenance_work_mem`, the memory one VACUUM, CREATE INDEX or ALTER TABLE can use. The default is `256MB`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_MAINTENANCE_WORK_MEM`.
### `FLUXER_POSTGRES_AUTOVACUUM_WORK_MEM`
Postgres `autovacuum_work_mem`, the memory each autovacuum worker can use. The default is `128MB`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_AUTOVACUUM_WORK_MEM`.
### `FLUXER_POSTGRES_RANDOM_PAGE_COST`
Postgres `random_page_cost`, how costly the query planner thinks fetching a random disk page is next to a sequential one. Values near 1 suit SSDs. The default is `1.1`. With rexctl, use `rexctl config set FLUXER_POSTGRES_RANDOM_PAGE_COST`.
### `FLUXER_POSTGRES_EFFECTIVE_IO_CONCURRENCY`
Postgres `effective_io_concurrency`, how many disk requests Postgres may have in flight at once. High values suit SSDs. The default is `200`. With rexctl, use `rexctl config set FLUXER_POSTGRES_EFFECTIVE_IO_CONCURRENCY`.
### `FLUXER_POSTGRES_DEFAULT_STATISTICS_TARGET`
Postgres `default_statistics_target`, how much detail the query planner's table statistics have. Higher values give better plans and a slower ANALYZE. The default is `200`. With rexctl, use `rexctl config set FLUXER_POSTGRES_DEFAULT_STATISTICS_TARGET`.
### `FLUXER_POSTGRES_JIT`
Postgres `jit`, whether Postgres compiles parts of queries with JIT. Use `on` or `off`. The default is `off`. With rexctl, use `rexctl config set FLUXER_POSTGRES_JIT`.
### `FLUXER_POSTGRES_MIN_WAL_SIZE`
Postgres `min_wal_size`, the write-ahead log space Postgres keeps for reuse after a checkpoint. The default is `80MB`. With rexctl, use `rexctl config set FLUXER_POSTGRES_MIN_WAL_SIZE`.
### `FLUXER_POSTGRES_MAX_WAL_SIZE`
Postgres `max_wal_size`, how large the write-ahead log may grow before Postgres starts a checkpoint. The default is `2GB`. When disk.profile is small, rexctl sets this to 512MB unless you set it. With rexctl, use `rexctl config set FLUXER_POSTGRES_MAX_WAL_SIZE`.
### `FLUXER_POSTGRES_CHECKPOINT_COMPLETION_TARGET`
Postgres `checkpoint_completion_target`, how much of the time between checkpoints a checkpoint spreads its writes over, as a fraction. The default is `0.9`. With rexctl, use `rexctl config set FLUXER_POSTGRES_CHECKPOINT_COMPLETION_TARGET`.
### `FLUXER_POSTGRES_WAL_BUFFERS`
Postgres `wal_buffers`, the memory for write-ahead log data not yet written to disk. The default is `16MB`. With rexctl, use `rexctl config set FLUXER_POSTGRES_WAL_BUFFERS`.
### `FLUXER_POSTGRES_WAL_COMPRESSION`
Postgres `wal_compression`, how full-page images in the write-ahead log are compressed, such as `lz4`, `pglz` or `off`. The default is `zstd`. With rexctl, use `rexctl config set FLUXER_POSTGRES_WAL_COMPRESSION`.
### `FLUXER_POSTGRES_BGWRITER_DELAY`
Postgres `bgwriter_delay`, how long the background writer sleeps between rounds, such as `200ms`. The default is `50ms`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_BGWRITER_DELAY`.
### `FLUXER_POSTGRES_BGWRITER_LRU_MAXPAGES`
Postgres `bgwriter_lru_maxpages`, the most buffers the background writer writes to disk in one round. The default is `1000`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_BGWRITER_LRU_MAXPAGES`.
### `FLUXER_POSTGRES_AUTOVACUUM_VACUUM_SCALE_FACTOR`
Postgres `autovacuum_vacuum_scale_factor`, the share of a table's rows that must be updated or deleted before autovacuum vacuums it, as a fraction such as `0.1`. The default is `0.05`. With rexctl, use `rexctl config set FLUXER_POSTGRES_AUTOVACUUM_VACUUM_SCALE_FACTOR`.
### `FLUXER_POSTGRES_AUTOVACUUM_ANALYZE_SCALE_FACTOR`
Postgres `autovacuum_analyze_scale_factor`, the share of a table's rows that must change before autovacuum analyses it again, as a fraction such as `0.05`. The default is `0.02`. With rexctl, use `rexctl config set FLUXER_POSTGRES_AUTOVACUUM_ANALYZE_SCALE_FACTOR`.
### `FLUXER_POSTGRES_AUTOVACUUM_VACUUM_COST_LIMIT`
Postgres `autovacuum_vacuum_cost_limit`, how much disk work autovacuum may do before it pauses. Higher values let it finish sooner. The default is `2000`. With rexctl, use `rexctl config set FLUXER_POSTGRES_AUTOVACUUM_VACUUM_COST_LIMIT`.
### `FLUXER_POSTGRES_AUTOVACUUM_MAX_WORKERS`
Postgres `autovacuum_max_workers`, how many autovacuum processes can run at once. The default is `3`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_AUTOVACUUM_MAX_WORKERS`.
### `FLUXER_POSTGRES_MAX_PARALLEL_WORKERS_PER_GATHER`
Postgres `max_parallel_workers_per_gather`, how many parallel workers one step of a query can use. The default is `2`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_MAX_PARALLEL_WORKERS_PER_GATHER`.
### `FLUXER_POSTGRES_MAX_PARALLEL_WORKERS`
Postgres `max_parallel_workers`, how many parallel query workers can run at once across the database. Postgres caps it at `max_worker_processes`, and the stack leaves that at 8. The default is `8`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_MAX_PARALLEL_WORKERS`.
### `FLUXER_POSTGRES_TRACK_IO_TIMING`
Postgres `track_io_timing`, whether Postgres times its disk I/O for its statistics. Use `on` or `off`. The default is `on`. With rexctl, use `rexctl config set FLUXER_POSTGRES_TRACK_IO_TIMING`.
### `FLUXER_POSTGRES_SHARED_PRELOAD_LIBRARIES`
Postgres `shared_preload_libraries`, the extensions Postgres loads at start, separated by commas. Keep `pg_stat_statements` in the list. The api turns it on at start. The default is `pg_stat_statements`. With rexctl, use `rexctl config set FLUXER_POSTGRES_SHARED_PRELOAD_LIBRARIES`.
### `FLUXER_POSTGRES_SHM_SIZE`
The shared memory size of the postgres container, used by parallel queries and parallel maintenance. Keep it well above `FLUXER_POSTGRES_MAINTENANCE_WORK_MEM`. The default is `1gb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_POSTGRES_SHM_SIZE`.
### `FLUXER_VALKEY_MEMORY_LIMIT`
The memory limit for the valkey container. Keep it above `FLUXER_VALKEY_MAXMEMORY`. The default is `256mb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_VALKEY_MEMORY_LIMIT`.
### `FLUXER_VALKEY_MAXMEMORY`
Valkey `maxmemory`, the most memory Valkey may use for stored data. The append-only file buffer and memory fragmentation come on top. Keep it below `FLUXER_VALKEY_MEMORY_LIMIT`. The default is `192mb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_VALKEY_MAXMEMORY`.
### `FLUXER_VALKEY_MAXMEMORY_POLICY`
Valkey `maxmemory-policy`, what Valkey does when its data grows to `FLUXER_VALKEY_MAXMEMORY`. With `noeviction`, writes fail when Valkey is full and no data is dropped. The default is `noeviction`. With rexctl, use `rexctl config set FLUXER_VALKEY_MAXMEMORY_POLICY`.
### `FLUXER_NATS_MEMORY_LIMIT`
The memory limit for the nats container. The default is `256mb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_NATS_MEMORY_LIMIT`.
### `FLUXER_NATS_GOMEMLIMIT`
The soft memory limit of the Go runtime in NATS, set as its `GOMEMLIMIT`. Keep it below `FLUXER_NATS_MEMORY_LIMIT`. The default is `200MiB`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_NATS_GOMEMLIMIT`.
### `FLUXER_NATS_MAX_MEMORY_STORE`
NATS JetStream `max_memory_store`, the most memory JetStream may use for streams kept in memory, such as `128MB`. The default is `64MB`. With rexctl, use `rexctl config set FLUXER_NATS_MAX_MEMORY_STORE`.
### `FLUXER_NATS_MAX_FILE_STORE`
NATS JetStream `max_file_store`, the most disk space JetStream may use for its streams, such as `20GB`. The default is `10GB`. With rexctl, use `rexctl config set FLUXER_NATS_MAX_FILE_STORE`.
### `FLUXER_MEILISEARCH_MEMORY_LIMIT`
The memory limit for the meilisearch container. The default is `1536mb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_MEILISEARCH_MEMORY_LIMIT`.
### `FLUXER_MEILISEARCH_MAX_INDEXING_MEMORY`
The memory Meilisearch aims to stay under while indexing, set as its `MEILI_MAX_INDEXING_MEMORY`, such as `512mb`. Meilisearch can go a little over it. Keep it well below `FLUXER_MEILISEARCH_MEMORY_LIMIT`. The default is `256mb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_MEILISEARCH_MAX_INDEXING_MEMORY`.
### `FLUXER_MEILISEARCH_MAX_INDEXING_THREADS`
The most threads Meilisearch may use for indexing, set as its `MEILI_MAX_INDEXING_THREADS`. The default is `2`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_MEILISEARCH_MAX_INDEXING_THREADS`.
### `FLUXER_SEAWEEDFS_MEMORY_LIMIT`
The memory limit for the seaweedfs container. The default is `2gb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_MEMORY_LIMIT`.
### `FLUXER_SEAWEEDFS_GOMEMLIMIT`
The soft memory limit of the Go runtime in SeaweedFS, set as its `GOMEMLIMIT`. Go can't see the container limit. Keep this at 75 to 85 percent of `FLUXER_SEAWEEDFS_MEMORY_LIMIT` and raise both together. The default is `1536MiB`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_GOMEMLIMIT`.
### `FLUXER_SEAWEEDFS_VOLUME_GROWTH`
How many volumes SeaweedFS creates at once when a bucket has no writable volume left, set as its `WEED_MASTER_VOLUME_GROWTH_COPY_1`. The default is `1`. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_VOLUME_GROWTH`.
### `FLUXER_SEAWEEDFS_VOLUME_SIZE_LIMIT_MB`
The size in MB a volume can grow to before SeaweedFS stops writing to it, set as its `-master.volumeSizeLimitMB`. The default is `1024`. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_VOLUME_SIZE_LIMIT_MB`.
### `FLUXER_SEAWEEDFS_GARBAGE_THRESHOLD`
The share of deleted space in a volume that makes SeaweedFS compact it, as a fraction, set as its `-master.garbageThreshold`. The default is `0.1`. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_GARBAGE_THRESHOLD`.
### `FLUXER_SEAWEEDFS_S3_CONCURRENT_UPLOADS`
How many uploads the bundled object store writes at once, set as its `-s3.concurrentFileUploadLimit`. More uploads wait for a free slot. Each upload in progress uses up to 32 MB of memory in SeaweedFS. Raise `FLUXER_SEAWEEDFS_MEMORY_LIMIT` before you raise this. The default is `5`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_S3_CONCURRENT_UPLOADS`.
### `FLUXER_SEAWEEDFS_VOLUME_MAX`
The most volumes the SeaweedFS volume store may have, set as its `-volume.max`. The default is `10000`. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_VOLUME_MAX`.
### `FLUXER_SEAWEEDFS_INIT_MEMORY_LIMIT`
The memory limit for the seaweedfs-init container, which creates the buckets, sets up the S3 key and the expiry of the uploads bucket, and then exits. The default is `128mb`. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_INIT_MEMORY_LIMIT`.
### `FLUXER_LIVEKIT_MEMORY_LIMIT`
The memory limit for the livekit container. The default is `512mb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_LIVEKIT_MEMORY_LIMIT`.
### `FLUXER_LIVEKIT_GOMEMLIMIT`
The soft memory limit of the Go runtime in LiveKit, set as its `GOMEMLIMIT`. Keep it below `FLUXER_LIVEKIT_MEMORY_LIMIT`. The default is `435MiB`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_LIVEKIT_GOMEMLIMIT`.
### `FLUXER_API_MEMORY_LIMIT`
The memory limit for the api container. The default is `2560mb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_API_MEMORY_LIMIT`.
### `FLUXER_API_MEMORY_RESERVATION`
The memory reservation for the api container, the amount Docker tries to keep for it when the machine runs low. Keep it at or below `FLUXER_API_MEMORY_LIMIT`. The default is `1gb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_API_MEMORY_RESERVATION`.
### `FLUXER_API_NODE_HEAP_MB`
The Node heap limit of the api container, in MB, set as `--max-old-space-size`. When it's empty, Node uses 60 percent of the memory available to the container. A value above `FLUXER_API_MEMORY_LIMIT` lets the heap grow until Docker kills the container for running out of memory. With rexctl, use `rexctl config set FLUXER_API_NODE_HEAP_MB`.
### `FLUXER_API_NODE_OPTIONS`
Extra Node flags for the api container, added to the end of `NODE_OPTIONS`, such as `--dns-result-order=ipv4first`. Set the heap with `FLUXER_API_NODE_HEAP_MB`. While that is empty, a `--max-old-space-size` flag here has no effect. With rexctl, use `rexctl config set FLUXER_API_NODE_OPTIONS`.
### `FLUXER_API_POSTGRES_MAX_CONNECTIONS`
The size of the Postgres connection pool of the api container, from 1 to 1000. The default is `25`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_API_POSTGRES_MAX_CONNECTIONS`.
### `FLUXER_API_EMBEDDED_WORKER`
Whether the api container also runs the background worker jobs inside the api process. Use `true` or `false`. With `true`, rexctl sets `FLUXER_WORKER_REPLICAS` to 0 and gives the api container more memory. Without rexctl, set `FLUXER_WORKER_REPLICAS` to 0 yourself. The default is `false`. With rexctl, use `rexctl config set FLUXER_API_EMBEDDED_WORKER`.
### `FLUXER_WORKER_REPLICAS`
How many worker containers Docker runs. With `FLUXER_API_EMBEDDED_WORKER` set to `true`, rexctl sets it to 0. Without rexctl, set it to 0 yourself. The default is `1`. With rexctl, use `rexctl config set FLUXER_WORKER_REPLICAS`.
### `FLUXER_WORKER_MEMORY_LIMIT`
The memory limit for each worker container. The default is `2560mb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_WORKER_MEMORY_LIMIT`.
### `FLUXER_WORKER_MEMORY_RESERVATION`
The memory reservation for each worker container, the amount Docker tries to keep for it when the machine runs low. Keep it at or below `FLUXER_WORKER_MEMORY_LIMIT`. The default is `1gb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_WORKER_MEMORY_RESERVATION`.
### `FLUXER_WORKER_NODE_HEAP_MB`
The Node heap limit of each worker container, in MB, set as `--max-old-space-size`. When it's empty, Node uses 55 percent of the memory available to the container. A value above `FLUXER_WORKER_MEMORY_LIMIT` lets the heap grow until Docker kills the container for running out of memory. With rexctl, use `rexctl config set FLUXER_WORKER_NODE_HEAP_MB`.
### `FLUXER_WORKER_NODE_OPTIONS`
Extra Node flags for each worker container, added to the end of `NODE_OPTIONS`, such as `--dns-result-order=ipv4first`. Set the heap with `FLUXER_WORKER_NODE_HEAP_MB`. While that is empty, a `--max-old-space-size` flag here has no effect. With rexctl, use `rexctl config set FLUXER_WORKER_NODE_OPTIONS`.
### `FLUXER_WORKER_POSTGRES_MAX_CONNECTIONS`
The size of the Postgres connection pool of each worker container, from 1 to 1000. It has no effect when `FLUXER_API_EMBEDDED_WORKER` is `true`. The default is `25`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_WORKER_POSTGRES_MAX_CONNECTIONS`.
### `FLUXER_WORKER_POSTGRES_SYNCHRONOUS_COMMIT`
Postgres `synchronous_commit` for the database connections of each worker container. Use `on`, `off`, `local`, `remote_write` or `remote_apply`. When it's empty, the worker uses `off`, and a Postgres crash can lose the worker's most recent writes. It has no effect when `FLUXER_API_EMBEDDED_WORKER` is `true`. With rexctl, use `rexctl config set FLUXER_WORKER_POSTGRES_SYNCHRONOUS_COMMIT`.
### `FLUXER_GATEWAY_MEMORY_LIMIT`
The memory limit for the gateway container. The default is `1gb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_GATEWAY_MEMORY_LIMIT`.
### `FLUXER_GATEWAY_MEMORY_RESERVATION`
The memory reservation for the gateway container, the amount Docker tries to keep for it when the machine runs low. Keep it at or below `FLUXER_GATEWAY_MEMORY_LIMIT`. The default is `384mb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_GATEWAY_MEMORY_RESERVATION`.
### `FLUXER_ERLANG_SCHEDULERS`
How many normal schedulers the Erlang VM of the gateway runs, a positive whole number. When it's empty, the gateway uses the container's CPU count kept between `FLUXER_ERLANG_SCHEDULERS_MIN` and `FLUXER_ERLANG_SCHEDULERS_MAX`. With rexctl, use `rexctl config set FLUXER_ERLANG_SCHEDULERS`.
### `FLUXER_ERLANG_SCHEDULERS_MIN`
The lowest scheduler count the gateway picks from the CPU count when `FLUXER_ERLANG_SCHEDULERS` is empty. When it's empty, the gateway uses `2`. With rexctl, use `rexctl config set FLUXER_ERLANG_SCHEDULERS_MIN`.
### `FLUXER_ERLANG_SCHEDULERS_MAX`
The highest scheduler count the gateway picks from the CPU count when `FLUXER_ERLANG_SCHEDULERS` is empty. When it's empty, the gateway uses `16`. With rexctl, use `rexctl config set FLUXER_ERLANG_SCHEDULERS_MAX`.
### `FLUXER_ERLANG_DIRTY_CPU_SCHEDULERS`
How many dirty CPU schedulers the Erlang VM of the gateway runs, a positive whole number. When it's empty, the gateway uses half the normal scheduler count, and at least `1`. With rexctl, use `rexctl config set FLUXER_ERLANG_DIRTY_CPU_SCHEDULERS`.
### `FLUXER_ERLANG_DIRTY_IO_SCHEDULERS`
How many dirty I/O schedulers the Erlang VM of the gateway runs, a positive whole number. When it's empty, the gateway uses the normal scheduler count kept between 2 and 4. With rexctl, use `rexctl config set FLUXER_ERLANG_DIRTY_IO_SCHEDULERS`.
### `FLUXER_MEDIA_PROXY_MEMORY_LIMIT`
The memory limit for the media-proxy container. The default is `1gb`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_MEMORY_LIMIT`.
### `FLUXER_MEDIA_PROXY_TOKIO_WORKER_THREADS`
How many worker threads the async runtime of the media proxy uses, set as its `TOKIO_WORKER_THREADS`. The default is `4`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_TOKIO_WORKER_THREADS`.
### `FLUXER_PUSH_MEMORY_LIMIT`
The memory limit for the push container. The default is `256mb`. With rexctl, use `rexctl config set FLUXER_PUSH_MEMORY_LIMIT`.
### `FLUXER_STATIC_PROXY_MEMORY_LIMIT`
The memory limit for the static-proxy container. The default is `256mb`. With rexctl, use `rexctl config set FLUXER_STATIC_PROXY_MEMORY_LIMIT`.
### `FLUXER_APP_PROXY_MEMORY_LIMIT`
The memory limit for the app-proxy container. The default is `256mb`. With rexctl, use `rexctl config set FLUXER_APP_PROXY_MEMORY_LIMIT`.
### `FLUXER_SNOWFLAKES_MEMORY_LIMIT`
The memory limit for the snowflakes container. The default is `256mb`. With rexctl, use `rexctl config set FLUXER_SNOWFLAKES_MEMORY_LIMIT`.
### `FLUXER_USERS_MEMORY_LIMIT`
The memory limit for the users container. The default is `256mb`. With rexctl, use `rexctl config set FLUXER_USERS_MEMORY_LIMIT`.
### `FLUXER_USERS_POSTGRES_MAX_CONNECTIONS`
The size of the Postgres connection pool of the users container. The default is `20`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_USERS_POSTGRES_MAX_CONNECTIONS`.
### `FLUXER_GIFS_MEMORY_LIMIT`
The memory limit for the gifs container. The default is `256mb`. With rexctl, use `rexctl config set FLUXER_GIFS_MEMORY_LIMIT`.
### `FLUXER_GIFS_SHARD_CACHE_MAX_BYTES`
How many bytes the gifs service may use for its cache, at least `16777216`, which is 16 MiB. Keep it below `FLUXER_GIFS_MEMORY_LIMIT`. The default is `134217728`, which is 128 MiB. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_GIFS_SHARD_CACHE_MAX_BYTES`.
### `FLUXER_MESSAGES_MEMORY_LIMIT`
The memory limit for the messages container. The default is `256mb`. With rexctl, use `rexctl config set FLUXER_MESSAGES_MEMORY_LIMIT`.
### `FLUXER_MESSAGES_POSTGRES_MAX_CONNECTIONS`
The size of the Postgres connection pool of the messages container. The default is `20`. rexctl sizes this. With rexctl, use `rexctl config set FLUXER_MESSAGES_POSTGRES_MAX_CONNECTIONS`.
### `FLUXER_UNFURL_MEMORY_LIMIT`
The memory limit for the unfurl container. The default is `256mb`. With rexctl, use `rexctl config set FLUXER_UNFURL_MEMORY_LIMIT`.
### `FLUXER_ADMIN_MEMORY_LIMIT`
The memory limit for the admin container. The default is `256mb`. With rexctl, use `rexctl config set FLUXER_ADMIN_MEMORY_LIMIT`.
## Bundled services
These change how the bundled Valkey, Meilisearch and SeaweedFS run.
### `FLUXER_VALKEY_APPENDFSYNC`
Valkey `appendfsync`, how often Valkey flushes its append-only file to disk. Use `always`, `everysec` or `no`. With `everysec`, a crash can lose the last second of writes. The default is `everysec`. With rexctl, use `rexctl config set FLUXER_VALKEY_APPENDFSYNC`.
### `FLUXER_VALKEY_SAVE`
Valkey `save`, when Valkey writes RDB snapshots, as pairs of seconds and changes such as `3600 1 300 100`. When it's empty, snapshots are off and Valkey keeps its data in the append-only file alone. With rexctl, use `rexctl config set FLUXER_VALKEY_SAVE`.
### `FLUXER_MEILISEARCH_ENV`
The Meilisearch environment, set as its `MEILI_ENV`. Use `production` or `development`. With `production`, Meilisearch refuses to start without a master key of at least 16 bytes and turns off its search preview. The default is `production`. With rexctl, use `rexctl config set FLUXER_MEILISEARCH_ENV`.
### `FLUXER_MEILISEARCH_NO_ANALYTICS`
Whether Meilisearch stops sending usage data to the Meilisearch team, set as its `MEILI_NO_ANALYTICS`. Use `true` or `false`. The default is `true`. With rexctl, use `rexctl config set FLUXER_MEILISEARCH_NO_ANALYTICS`.
### `FLUXER_SEAWEEDFS_TELEMETRY`
Whether SeaweedFS sends usage data to the SeaweedFS project, set as its `-master.telemetry`. Use `true` or `false`. The default is `false`. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_TELEMETRY`.
## Logs and health checks
### `LOG_LEVEL`
How much the api and worker log. Use `trace`, `debug`, `info`, `warn`, `error` or `fatal`. An empty or unknown value gives `info`. With rexctl, use `rexctl config set LOG_LEVEL`.
### `RUST_LOG`
The log filter of media-proxy, app-proxy, admin, push, snowflakes, users, gifs, messages and unfurl, in tracing EnvFilter format such as `debug` or `off`. An empty or invalid filter gives `info`. With rexctl, use `rexctl config set RUST_LOG`.
### `FLUXER_GATEWAY_LOGGER_LEVEL`
The gateway log level. Use `debug`, `info`, `notice`, `warning`, `error`, `critical`, `alert` or `emergency`. An empty or unknown value gives `info`. `LOGGER_LEVEL` wins over this one. With rexctl, use `rexctl config set FLUXER_GATEWAY_LOGGER_LEVEL`.
### `LOGGER_LEVEL`
The gateway log level, which wins over `FLUXER_GATEWAY_LOGGER_LEVEL` and takes the same levels. An empty or unknown value falls back to `FLUXER_GATEWAY_LOGGER_LEVEL`. With rexctl, use `rexctl config set LOGGER_LEVEL`.
### `FLUXER_MEILISEARCH_LOG_LEVEL`
How much Meilisearch logs, set as its `MEILI_LOG_LEVEL`. Use `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG` or `TRACE`. The default is `WARN`. With rexctl, use `rexctl config set FLUXER_MEILISEARCH_LOG_LEVEL`.
### `FLUXER_LIVEKIT_LOG_LEVEL`
How much LiveKit logs. Use `debug`, `info`, `warn` or `error`. The default is `info`. With rexctl, use `rexctl config set FLUXER_LIVEKIT_LOG_LEVEL`.
### `FLUXER_LOG_MAX_SIZE`
How large the log file of a container grows before Docker rotates it, such as `50m`. The default is `10m`. When disk.profile is small, rexctl sets this to 5m unless you set it. With rexctl, use `rexctl config set FLUXER_LOG_MAX_SIZE`.
### `FLUXER_LOG_MAX_FILE`
How many log files Docker keeps for each container when it rotates logs. The default is `3`. When disk.profile is small, rexctl sets this to 2 unless you set it. With rexctl, use `rexctl config set FLUXER_LOG_MAX_FILE`.
### `FLUXER_RESTART_POLICY`
The Docker restart policy of every long-running service, such as `always`, `on-failure` or `no`. The default is `unless-stopped`. With rexctl, use `rexctl config set FLUXER_RESTART_POLICY`.
### `FLUXER_HEALTHCHECK_INTERVAL`
How often Docker runs the health check of each service, such as `30s`. The media-proxy and app-proxy containers have their own interval settings. The default is `10s`. With rexctl, use `rexctl config set FLUXER_HEALTHCHECK_INTERVAL`.
### `FLUXER_MEDIA_PROXY_HEALTHCHECK_INTERVAL`
How often Docker runs the health check of the media-proxy container. The default is `30s`. With rexctl, use `rexctl config set FLUXER_MEDIA_PROXY_HEALTHCHECK_INTERVAL`.
### `FLUXER_APP_PROXY_HEALTHCHECK_INTERVAL`
How often Docker runs the health check of the app-proxy container. The default is `30s`. With rexctl, use `rexctl config set FLUXER_APP_PROXY_HEALTHCHECK_INTERVAL`.
### `FLUXER_HEALTHCHECK_TIMEOUT`
How long one health check may run before Docker counts it as failed. The default is `5s`. With rexctl, use `rexctl config set FLUXER_HEALTHCHECK_TIMEOUT`.
### `FLUXER_HEALTHCHECK_RETRIES`
How many failed health checks in a row mark the edge, postgres, valkey, nats, meilisearch, livekit, media-proxy, static-proxy and app-proxy containers as unhealthy. The default is `10`. With rexctl, use `rexctl config set FLUXER_HEALTHCHECK_RETRIES`.
### `FLUXER_HEALTHCHECK_START_PERIOD`
How long the edge, postgres, valkey, nats, meilisearch, livekit, media-proxy, static-proxy and app-proxy containers get to start before failed health checks count. The default is `60s`. With rexctl, use `rexctl config set FLUXER_HEALTHCHECK_START_PERIOD`.
### `FLUXER_HEALTHCHECK_START_INTERVAL`
How often Docker runs each health check while a service is still in its start period. The default is `1s`. With rexctl, use `rexctl config set FLUXER_HEALTHCHECK_START_INTERVAL`.
### `FLUXER_APP_HEALTHCHECK_RETRIES`
How many failed health checks in a row mark the api, gateway, push, admin, snowflakes, users, gifs, messages and unfurl containers as unhealthy. The default is `30`. With rexctl, use `rexctl config set FLUXER_APP_HEALTHCHECK_RETRIES`.
### `FLUXER_APP_HEALTHCHECK_START_PERIOD`
How long the api, worker and gateway containers get to start before failed health checks count, such as `120s`. The default is `90s`. With rexctl, use `rexctl config set FLUXER_APP_HEALTHCHECK_START_PERIOD`.
### `FLUXER_SVC_HEALTHCHECK_START_PERIOD`
How long the push, admin, snowflakes, users, gifs, messages and unfurl containers get to start before failed health checks count. The default is `60s`. With rexctl, use `rexctl config set FLUXER_SVC_HEALTHCHECK_START_PERIOD`.
### `FLUXER_SEAWEEDFS_HEALTHCHECK_RETRIES`
How many failed health checks in a row mark the seaweedfs container as unhealthy. The default is `20`. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_HEALTHCHECK_RETRIES`.
### `FLUXER_SEAWEEDFS_HEALTHCHECK_START_PERIOD`
How long the seaweedfs container gets to start before failed health checks count. The default is `60s`. With rexctl, use `rexctl config set FLUXER_SEAWEEDFS_HEALTHCHECK_START_PERIOD`.
### `FLUXER_WORKER_HEALTHCHECK_RETRIES`
How many failed health checks in a row mark a worker container as unhealthy. The check passes while the worker has updated its heartbeat file in the last 30 seconds. The default is `3`. With rexctl, use `rexctl config set FLUXER_WORKER_HEALTHCHECK_RETRIES`.
## Images
Set one to use your own mirror or another version. Fluxer's own images are pinned to the release in `docker-compose.yml`.
### `FLUXER_CADDY_IMAGE`
The image the edge container runs. The default is `caddy:2.11-alpine`. With rexctl, use `rexctl config set images.edge`.
### `FLUXER_POSTGRES_IMAGE`
The image the postgres container runs. The default is `postgres:16-alpine`. With rexctl, use `rexctl config set images.postgres`.
### `FLUXER_VALKEY_IMAGE`
The image the valkey container runs. The default is `valkey/valkey:9.1-alpine`. With rexctl, use `rexctl config set images.valkey`.
### `FLUXER_NATS_IMAGE`
The image the nats container runs. The default is `nats:2.14-alpine`. With rexctl, use `rexctl config set images.nats`.
### `FLUXER_MEILISEARCH_IMAGE`
The image the meilisearch container runs. The default is `getmeili/meilisearch:v1.53`. With rexctl, use `rexctl config set images.meilisearch`.
### `FLUXER_SEAWEEDFS_IMAGE`
The image the seaweedfs and seaweedfs-init containers run. The default is `chrislusf/seaweedfs:4.52`. With rexctl, use `rexctl config set images.seaweedfs`.
### `FLUXER_LIVEKIT_IMAGE`
The image the livekit container runs. The default is `livekit/livekit-server:v1.12.0`. With rexctl, use `rexctl config set images.livekit`.
### `FLUXER_REGISTRY`
The registry of Fluxer's own images in the `docker-compose.yml` of the Fluxer repository. When it's empty, that file uses `ghcr.io/` followed by `FLUXER_REGISTRY_OWNER`. The compose bundle pins every Fluxer image to the release.
### `FLUXER_REGISTRY_OWNER`
The owner of Fluxer's own images on `ghcr.io`, in the `docker-compose.yml` of the Fluxer repository. The compose bundle pins every Fluxer image to the release. The default is `fluxerapp`.
### `FLUXER_IMAGE_TAG`
The tag of Fluxer's own images in the `docker-compose.yml` of the Fluxer repository. The compose bundle pins every Fluxer image to the release. `rexctl upgrade --check` reads it to find the release a Docker Compose install runs, and uses `v1` when it's empty. The default is `v1`.
## Values from files
The api, worker, gateway and Rust services also take a setting from a file. Set `NAME_FILE` to the path of a file that has the value, such as a Docker secret, and leave `NAME` unset. A service with both `NAME` and `NAME_FILE` set refuses to start. `docker-compose.yml` passes only the variables it lists. To use a `NAME_FILE` variable, add it to the service's environment in a compose file of your own and list that file in `COMPOSE_FILE`.
These variables don't take the file form. Set them as plain values.
- `BUILD_VERSION`
- `FLUXER_API_PORT`
- `FLUXER_CLIENT_IP_HEADER_NAME`
- `FLUXER_DISABLE_RATE_LIMITS`
- `FLUXER_ENV`
- `FLUXER_ERLANG_DIRTY_CPU_SCHEDULERS`
- `FLUXER_ERLANG_DIRTY_IO_SCHEDULERS`
- `FLUXER_ERLANG_DIST_PORT`
- `FLUXER_ERLANG_NODE_NAME`
- `FLUXER_ERLANG_NODE_NAME_PREFIX`
- `FLUXER_ERLANG_SCHEDULERS`
- `FLUXER_ERLANG_SCHEDULERS_MAX`
- `FLUXER_ERLANG_SCHEDULERS_MIN`
- `FLUXER_OPERATOR_SOCKET`
- `HOSTNAME`
- `LOG_LEVEL`
- `POD_NAME`
- `RELX_REPLACE_OS_VARS`
The file form doesn't work for the docs site variables either, or for variables that system libraries and runtimes look up, such as `NODE_OPTIONS`, `MALLOC_ARENA_MAX`, `TOKIO_WORKER_THREADS`, `HTTP_PROXY`, `SSL_CERT_FILE` and `VIPS_CONCURRENCY`. The bundled third-party images follow their own rules.
## rexctl
rexctl and its install scripts look these up in the shell you run them from. A value in `.env` has no effect.
### `FLUXER_VOICE_JOIN_TOKEN`
The join token for `rexctl voice join` when the command line doesn't have one. Other accounts on the machine can't see it in the process list.
### `REXCTL_RELEASE_URL`
The URL of the release index that rexctl and its install scripts download releases from. When it's empty, they use `https://fluxer.dev/rexctl/release.json`. Another server must respond to the same queries as that address, including `version` and `format=sh`.
### `REXCTL_IMAGE_SET`
The path of an image set JSON file with a release and its image list, which rexctl uses for its built-in images. Only tests use it.
### `VISUAL`
The editor `rexctl config edit` opens. When it's empty, rexctl uses `EDITOR`.
### `EDITOR`
The editor `rexctl config edit` opens when `VISUAL` is empty. When both are empty, rexctl uses Notepad on Windows and nano or vi elsewhere.
### `NO_COLOR`
Set it to any value to turn off colour in rexctl and its install scripts. A `TERM` of `dumb` turns colour off too.
### `ACCESSIBLE`
Set it to any value to make rexctl ask questions as plain text prompts and print steps as plain lines for screen readers.
### `DOCKER_HOST`
The engine address rexctl tries first, such as `unix:///run/user/1000/podman/podman.sock`. rexctl reads it for install, takeover and restore, and when the engine an instance uses doesn't respond. When it's empty, rexctl uses the current Docker context and then looks for a Docker or Podman socket.
### `DOCKER_CONTEXT`
The Docker context rexctl tries first when `DOCKER_HOST` is empty. rexctl reads it for install, takeover and restore, and when the engine an instance uses doesn't respond. When it's empty, rexctl uses the current context of the Docker CLI.
### `DOCKER_CONFIG`
The directory of the Docker CLI configuration, which has the current Docker context. When it's empty, rexctl uses `.docker` in your home directory.
## Set by the compose stack
`docker-compose.yml` sets these for the services from the settings above or to fixed values. A value in `.env` has no effect.
### `DISCOVERY_UPSTREAM_URL`
Where app-proxy loads the instance discovery document from. Docker Compose sets it to `http://edge:8088/.well-known/fluxer`.
### `FLUXER_ADMIN_PORT`
The port the admin service listens on inside its container. Docker Compose sets it to `8080`.
### `FLUXER_API_PORT`
The port the api service listens on inside its container. Docker Compose sets it to `8080`.
### `FLUXER_API_PUBLIC_ENDPOINT`
The public API address the admin panel allows images from, set from `FLUXER_API_ENDPOINT`.
### `FLUXER_API_WORKER_ENABLE_CRON_SCHEDULER`
Whether the worker runs the scheduled jobs. Docker Compose sets it to `true`.
### `FLUXER_API_WORKER_MODE`
Which job lanes the worker runs. Docker Compose sets it to `all_lanes`.
### `FLUXER_APP_PROXY_PORT`
The port the app-proxy service listens on inside its container. Docker Compose sets it to `8080`.
### `FLUXER_BASE_DOMAIN`
The domain the services build their addresses from, set from `FLUXER_DOMAIN`.
### `FLUXER_DATABASE_BACKEND`
The database the services use. Docker Compose sets it to `postgres`.
### `FLUXER_EDGE_TLS_DIRECTIVE`
The tls line of the edge Caddyfile, set from `FLUXER_EDGE_TLS`.
### `FLUXER_ENV`
The environment the services run in. Docker Compose sets it to `production`.
### `FLUXER_GATEWAY_PORT`
The port the gateway listens on inside its container. Docker Compose sets it to `8080`.
### `FLUXER_INTERNAL_API_ENDPOINT`
The address the services use to call the api service inside the stack. Docker Compose sets it to `http://api:8080`.
### `FLUXER_INTERNAL_MEDIA_PROXY_ENDPOINT`
The address the services use to call the media proxy inside the stack. Docker Compose sets it to `http://media-proxy:8080`.
### `FLUXER_LIVEKIT_API_KEY`
The LiveKit API key the services use, set from `LIVEKIT_API_KEY`.
### `FLUXER_LIVEKIT_API_SECRET`
The LiveKit API secret the services use, set from `LIVEKIT_API_SECRET`.
### `FLUXER_MEDIA_PROXY_ENDPOINT`
The address the unfurl service uses to call the media proxy. The api and worker also read it when `FLUXER_INTERNAL_MEDIA_PROXY_ENDPOINT` is empty. Docker Compose sets it to `http://media-proxy:8080`.
### `FLUXER_MEDIA_PROXY_MODE`
How the media proxy runs. Docker Compose sets it to `upload`.
### `FLUXER_MEDIA_PROXY_PORT`
The port the media proxy listens on inside its container. Docker Compose sets it to `8080`.
### `FLUXER_MEDIA_PROXY_STORAGE_BACKEND`
Where the media proxy keeps files. Docker Compose sets it to `s3`.
### `FLUXER_POSTGRES_MAX_CONNECTIONS`
The size of each service's Postgres connection pool, set from `FLUXER_API_POSTGRES_MAX_CONNECTIONS`, `FLUXER_WORKER_POSTGRES_MAX_CONNECTIONS`, `FLUXER_USERS_POSTGRES_MAX_CONNECTIONS` or `FLUXER_MESSAGES_POSTGRES_MAX_CONNECTIONS`.
### `FLUXER_POSTGRES_PASSWORD`
The Postgres password the services use, set from `POSTGRES_PASSWORD`.
### `FLUXER_S3_ACCESS_KEY_ID`
The object store access key the services use, set from `FLUXER_S3_ACCESS_KEY`.
### `FLUXER_S3_SECRET_ACCESS_KEY`
The object store secret key the services use, set from `FLUXER_S3_SECRET_KEY`.
### `FLUXER_SEARCH_API_KEY`
The search API key the services use, set from `MEILI_MASTER_KEY`.
### `FLUXER_SELF_HOSTED`
Whether the services run as a self-hosted instance. Docker Compose sets it to `true`.
### `FLUXER_SVC_MODE`
How the snowflakes, users, gifs, messages and unfurl services run. Docker Compose sets it to `combined`.
### `FLUXER_SVC_NAME`
The service name the internal services use to pick their default for `FLUXER_SVC_MAX_CONCURRENT_REQUESTS`. Each image always runs its own service. Docker Compose sets it to the name of each service, such as `users`.
### `FLUXER_SVC_SHARD_COUNT`
How many shards each internal service has. Docker Compose sets it to `1`.
### `GOMEMLIMIT`
The soft memory limit of the Go runtime in NATS, LiveKit and SeaweedFS, set from `FLUXER_NATS_GOMEMLIMIT`, `FLUXER_LIVEKIT_GOMEMLIMIT` and `FLUXER_SEAWEEDFS_GOMEMLIMIT`.
### `LIVEKIT_CONFIG`
The LiveKit config in YAML, built from the voice and video settings and `LIVEKIT_API_KEY`.
### `LIVEKIT_KEYS`
The LiveKit API key and secret pair, set from `LIVEKIT_API_KEY` and `LIVEKIT_API_SECRET`.
### `MALLOC_ARENA_MAX`
The glibc memory arena limit of the push, admin, snowflakes, users, gifs, messages and unfurl services, set from `FLUXER_MALLOC_ARENA_MAX`.
### `MEILI_ENV`
The Meilisearch environment, set from `FLUXER_MEILISEARCH_ENV`.
### `MEILI_LOG_LEVEL`
The Meilisearch log level, set from `FLUXER_MEILISEARCH_LOG_LEVEL`.
### `MEILI_MAX_INDEXING_MEMORY`
The memory Meilisearch aims to stay under while indexing, set from `FLUXER_MEILISEARCH_MAX_INDEXING_MEMORY`.
### `MEILI_MAX_INDEXING_THREADS`
The most threads Meilisearch may use for indexing, set from `FLUXER_MEILISEARCH_MAX_INDEXING_THREADS`.
### `MEILI_NO_ANALYTICS`
Whether Meilisearch stops sending usage data, set from `FLUXER_MEILISEARCH_NO_ANALYTICS`.
### `MEILI_UPGRADE_DB`
Whether Meilisearch upgrades its database on start after a version change. Docker Compose sets it to `true`.
### `NODE_EXTRA_CA_CERTS`
The extra CA certificates Node trusts in the api and worker services, set from `FLUXER_NODE_EXTRA_CA_CERTS`.
### `NODE_OPTIONS`
The Node options of the api and worker services, built from `FLUXER_API_NODE_HEAP_MB`, `FLUXER_API_NODE_OPTIONS`, `FLUXER_WORKER_NODE_HEAP_MB` and `FLUXER_WORKER_NODE_OPTIONS`.
### `POSTGRES_DB`
The database the bundled Postgres creates on its first start, set from `FLUXER_POSTGRES_DATABASE`.
### `POSTGRES_USER`
The role the bundled Postgres creates on its first start, set from `FLUXER_POSTGRES_USERNAME`.
### `TOKIO_WORKER_THREADS`
How many async worker threads the Rust services use, set from `FLUXER_TOKIO_WORKER_THREADS` or `FLUXER_MEDIA_PROXY_TOKIO_WORKER_THREADS`.
### `WEED_MASTER_VOLUME_GROWTH_COPY_1`
How many volumes SeaweedFS creates at once, set from `FLUXER_SEAWEEDFS_VOLUME_GROWTH`.
## Not passed by the compose stack
Fluxer's services, their images, some of the libraries they use and the Fluxer Helm chart also use these variables, but `docker-compose.yml` doesn't pass them to any service. A value in `.env` has no effect.
### `ALL_PROXY`
The proxy the Rust services use for HTTP and HTTPS requests when `HTTP_PROXY` or `HTTPS_PROXY` is empty. They also take the lowercase `all_proxy`.
### `BUILD_VERSION`
The build version a service reports. Each image sets its own.
### `FLUXER_ADMIN_HOST`
The address the admin service listens on. When it's empty, it listens on `0.0.0.0`.
### `FLUXER_ADMIN_OAUTH_CLIENT_ID`
The OAuth2 client ID the admin panel signs in with. The stack uses the built-in client ID of the admin service.
### `FLUXER_ADMIN_OAUTH_REDIRECT_URI`
The OAuth2 redirect URL of the admin panel. The admin service works it out from its own address.
### `FLUXER_ADMIN_SSO_REDIRECT_URI`
The single sign-on redirect URL of the admin panel. The admin service works it out from its own address.
### `FLUXER_API_WORKER_LANE`
The job lane a worker runs when `FLUXER_API_WORKER_MODE` is `single_lane`. Each worker container in the stack runs every lane.
### `FLUXER_API_WORKER_METRICS_PORT`
The port the worker serves its metrics on. The stack doesn't collect worker metrics.
### `FLUXER_API_WORKER_TASK`
The one task a worker runs when `FLUXER_API_WORKER_MODE` is `single_task`. Each worker container in the stack runs every lane.
### `FLUXER_APP_PROXY_HOST`
The address the app-proxy service listens on. When it's empty, it listens on `0.0.0.0`.
### `FLUXER_BUILD_VERSION`
The older name for `BUILD_VERSION`, which only the admin and app-proxy services read when `BUILD_VERSION` is empty. Their images set `BUILD_VERSION`.
### `FLUXER_ERLANG_COOKIE_FILE`
A file that has the gateway's Erlang cookie. The stack passes `FLUXER_ERLANG_COOKIE` itself.
### `FLUXER_GATEWAY_API_RPC_ENDPOINT`
The URL the gateway sends API RPC requests to. When it's empty, the gateway uses `FLUXER_INTERNAL_API_ENDPOINT` followed by `/internal/rpc`.
### `FLUXER_GATEWAY_NATS_RPC_ENABLED`
Whether the gateway responds to RPC requests over NATS. The gateway responds to the API only over NATS RPC and must keep it turned on.
### `FLUXER_GIF_SERVICE_SUBJECT`
The NATS subject the API sends gifs service requests to. The gifs service always listens on `svc.gifs`, and any other value breaks GIF search.
### `FLUXER_MEDIA_PROXY_HOST`
The address the media proxy listens on. When it's empty, it listens on `0.0.0.0`.
### `FLUXER_MEDIA_PROXY_STORAGE_ROOT`
The directory the media proxy keeps files in when it stores them on disk. The stack keeps media in the object store.
### `FLUXER_NATS_CORE_URL`
The older name for `FLUXER_NATS_URL`, which only the api and worker read. Docker Compose passes `FLUXER_NATS_URL`.
### `FLUXER_PUSH_SERVICE_HOST`
The address the push service listens on. When it's empty, it listens on `0.0.0.0`.
### `FLUXER_PUSH_SERVICE_PORT`
The port the push service listens on. When it's empty, it uses `8126`, or `8127` for the push relay.
### `FLUXER_S3_BUCKET_STATIC`
The bucket the media proxy serves files from when `FLUXER_MEDIA_PROXY_MODE` is `static`. The stack runs the media proxy in `upload` mode.
### `FLUXER_SNOWFLAKE_SERVICE_SUBJECT`
The NATS subject the API sends snowflakes service requests to. The snowflakes service always listens on `svc.snowflakes`, and any other value breaks ID generation.
### `FLUXER_STATIC_DIR`
The directory the app-proxy service serves static files from. The app-proxy image has its static files built in.
### `FLUXER_SVC_LISTEN_HOST`
The address an internal service listens on. When it's empty, it listens on `0.0.0.0`.
### `FLUXER_SVC_PORT`
The port an internal service listens on. When it's empty, it uses `8090`.
### `FLUXER_SVC_SHARD_ID`
Which shard of an internal service a container runs. When it's empty, the service takes the number at the end of `POD_NAME`, or `0`. The stack runs one shard of each service.
### `FLUXER_USERS_SERVICE_SUBJECT`
The NATS subject the API sends users service requests to. The users service always listens on `svc.users`, and any other value breaks user lookups.
### `FLUXER_VALKEY_PASSWORD`
The password of the Valkey that the Fluxer Helm chart runs, at least 32 letters and digits. The chart builds `FLUXER_KV_URL` from it.
### `G_MESSAGES_DEBUG`
The GLib log domains whose debug messages libvips prints in the media proxy, or `all`. The media-proxy image sets it to an empty value and GLib prints none.
### `HOSTNAME`
The hostname of the container. Docker sets it.
### `KLIPY_API_KEY`
The older name for `FLUXER_KLIPY_API_KEY`, used only by the unfurl service. Docker Compose passes `FLUXER_KLIPY_API_KEY`.
### `LD_PRELOAD`
Libraries the dynamic loader loads before any others. The media-proxy and app-proxy images set it to `libjemalloc.so.2` to use the jemalloc memory allocator.
### `LIVEKIT_WEBHOOK_URL`
The address the bundled LiveKit sends its webhooks to. The Fluxer Helm chart sets it on the LiveKit pod and adds it to the LiveKit config.
### `MALLOC_CONF`
The jemalloc options of the media proxy and app-proxy. Both images set it to `background_thread:true,metadata_thp:auto,dirty_decay_ms:5000,muzzy_decay_ms:5000`.
### `NODE_ENV`
The Node environment that libraries in the api and worker look up. The api image sets it to `production`.
### `NODE_TLS_REJECT_UNAUTHORIZED`
With `0`, Node in the api and worker checks no certificates on outgoing TLS connections, except Postgres when `FLUXER_POSTGRES_SSL` is `true`. To trust your own CA, use `FLUXER_NODE_EXTRA_CA_CERTS`.
### `PGDATA`
The directory the bundled Postgres keeps its data in. The Fluxer Helm chart sets it on the Postgres pod.
### `PGSSLMODE`
The libpq TLS mode the api and worker use when `FLUXER_POSTGRES_SSL` isn't `true` and `FLUXER_POSTGRES_URL` has no `sslmode`. With `prefer`, `require`, `verify-ca` or `verify-full`, they connect over TLS and check the server certificate. With `no-verify`, they connect over TLS without checking it. The other services don't use it.
### `POD_IP`
The IP address of a gateway pod. The Fluxer Helm chart sets it on the gateway pods and builds `FLUXER_ERLANG_NODE_NAME` from it.
### `POD_NAME`
The name of the pod a service runs in. The api and gateway label their RPC timings with it, or with `HOSTNAME` when it's empty, and the gateway reports it in its node details. When `FLUXER_SVC_SHARD_ID` is empty, an internal service runs the shard numbered at the end of the pod name, such as `2` for `users-2`. The Fluxer Helm chart sets it on the shard pods of the internal services and on the NATS pods.
### `REDISCLI_AUTH`
The password of the bundled Valkey. The Fluxer Helm chart sets it on the Valkey pod from `FLUXER_VALKEY_PASSWORD` and starts Valkey with it.
### `RELEASE_CHANNEL`
The release channel the app-proxy service puts in the web app, `stable` or `canary`. The self-hosted app-proxy service serves the stable channel.
### `RELX_REPLACE_OS_VARS`
Whether the gateway release scripts fill in environment variables in the gateway config. The gateway entrypoint sets it.
### `SSL_CERT_DIR`
Directories of CA certificate files, separated by colons, that the Rust services trust for outgoing TLS. When it or `SSL_CERT_FILE` is set, they trust only those certificates.
### `SSL_CERT_FILE`
A PEM file of CA certificates that the Rust services trust for outgoing TLS, such as to your own object store or Postgres. When it or `SSL_CERT_DIR` is set, they trust only those certificates. Add your CA to a copy of the system bundle.
### `VIPS_CONCURRENCY`
How many threads libvips uses for each image transform. The media proxy always runs libvips with one thread per transform and ignores it. `FLUXER_MEDIA_PROXY_MAX_NATIVE_TRANSFORMS` sets how many transforms run at once.
### `VIPS_DISC_THRESHOLD`
The image size above which libvips in the media proxy decodes an image to a temporary file on disk. The media-proxy image sets it to `1g`.
### `YOUTUBE_API_KEY`
The older name for `FLUXER_YOUTUBE_API_KEY`, used only by the unfurl service. Docker Compose passes `FLUXER_YOUTUBE_API_KEY`.
### Hosted service only
Only Fluxer's hosted service uses these.
#### `FLUXER_API_AUTOMATED_MESSAGE_DELETION_DELAY_DAYS`
The delay before automated account actions delete messages, in days.
#### `FLUXER_APP_STORE_APPS`
The App Store apps Fluxer sells in.
#### `FLUXER_APP_STORE_ENABLED`
Whether App Store purchases are on.
#### `FLUXER_APP_STORE_ISSUER_ID`
The App Store Connect issuer ID.
#### `FLUXER_APP_STORE_KEY_ID`
The App Store Connect key ID.
#### `FLUXER_APP_STORE_PRIVATE_KEY`
The App Store Connect private key.
#### `FLUXER_APP_STORE_PRIVATE_KEY_PATH`
The path to the App Store Connect private key.
#### `FLUXER_APP_STORE_PRODUCTS`
The App Store products and what they grant.
#### `FLUXER_GOOGLE_PLAY_CLIENT_EMAIL`
The Google Play service account email.
#### `FLUXER_GOOGLE_PLAY_ENABLED`
Whether Google Play purchases are on.
#### `FLUXER_GOOGLE_PLAY_PACKAGES`
The Android packages Fluxer sells in.
#### `FLUXER_GOOGLE_PLAY_PRIVATE_KEY`
The Google Play service account private key.
#### `FLUXER_GOOGLE_PLAY_PRIVATE_KEY_PATH`
The path to the Google Play service account private key.
#### `FLUXER_GOOGLE_PLAY_PRODUCTS`
The Google Play products and what they grant.
#### `FLUXER_GOOGLE_PLAY_PUSH_AUDIENCE`
The audience the API expects in the token on Google Play billing notifications from Pub/Sub.
#### `FLUXER_GOOGLE_PLAY_PUSH_SERVICE_ACCOUNT_EMAIL`
The service account email the API expects in the token on Google Play billing notifications from Pub/Sub.
#### `FLUXER_GOOGLE_PLAY_SELF_SERVICE_REFUNDS`
Whether people can request Google Play refunds themselves.
#### `FLUXER_GOOGLE_PLAY_SERVICE_ACCOUNT_JSON_PATH`
The path to the Google Play service account JSON file.
#### `FLUXER_GOOGLE_PLAY_TOKEN_URI`
The OAuth token URL for Google Play.
#### `FLUXER_PAYMENT_DISPUTE_CLOSURE_EFFECTIVE_AT`
When account closures for payment disputes take effect.
#### `FLUXER_STORE_BILLING_SANDBOX_ENTITLES_ALL`
Whether sandbox store purchases, gifts included, count for every account with no time limit.
#### `FLUXER_STORE_BILLING_SANDBOX_SUBSCRIPTIONS`
Whether sandbox App Store and Google Play subscriptions count for every account for 7 days after each purchase. On by default.
#### `FLUXER_STORE_BILLING_SANDBOX_USER_IDS`
The accounts whose sandbox store purchases count.
### Stripe price IDs
Set prices with `FLUXER_STRIPE_PRICES` or in the admin panel.
#### `FLUXER_STRIPE_PRICE_GIFT_1_MONTH_BRL`
The price ID of the one-month gift in BRL.
#### `FLUXER_STRIPE_PRICE_GIFT_1_MONTH_DKK`
The price ID of the one-month gift in DKK.
#### `FLUXER_STRIPE_PRICE_GIFT_1_MONTH_EUR`
The price ID of the one-month gift in EUR.
#### `FLUXER_STRIPE_PRICE_GIFT_1_MONTH_INR`
The price ID of the one-month gift in INR.
#### `FLUXER_STRIPE_PRICE_GIFT_1_MONTH_ISK`
The price ID of the one-month gift in ISK.
#### `FLUXER_STRIPE_PRICE_GIFT_1_MONTH_NOK`
The price ID of the one-month gift in NOK.
#### `FLUXER_STRIPE_PRICE_GIFT_1_MONTH_PLN`
The price ID of the one-month gift in PLN.
#### `FLUXER_STRIPE_PRICE_GIFT_1_MONTH_SEK`
The price ID of the one-month gift in SEK.
#### `FLUXER_STRIPE_PRICE_GIFT_1_MONTH_TRY`
The price ID of the one-month gift in TRY.
#### `FLUXER_STRIPE_PRICE_GIFT_1_MONTH_USD`
The price ID of the one-month gift in USD.
#### `FLUXER_STRIPE_PRICE_GIFT_1_YEAR_BRL`
The price ID of the one-year gift in BRL.
#### `FLUXER_STRIPE_PRICE_GIFT_1_YEAR_DKK`
The price ID of the one-year gift in DKK.
#### `FLUXER_STRIPE_PRICE_GIFT_1_YEAR_EUR`
The price ID of the one-year gift in EUR.
#### `FLUXER_STRIPE_PRICE_GIFT_1_YEAR_INR`
The price ID of the one-year gift in INR.
#### `FLUXER_STRIPE_PRICE_GIFT_1_YEAR_ISK`
The price ID of the one-year gift in ISK.
#### `FLUXER_STRIPE_PRICE_GIFT_1_YEAR_NOK`
The price ID of the one-year gift in NOK.
#### `FLUXER_STRIPE_PRICE_GIFT_1_YEAR_PLN`
The price ID of the one-year gift in PLN.
#### `FLUXER_STRIPE_PRICE_GIFT_1_YEAR_SEK`
The price ID of the one-year gift in SEK.
#### `FLUXER_STRIPE_PRICE_GIFT_1_YEAR_TRY`
The price ID of the one-year gift in TRY.
#### `FLUXER_STRIPE_PRICE_GIFT_1_YEAR_USD`
The price ID of the one-year gift in USD.
#### `FLUXER_STRIPE_PRICE_MONTHLY_BRL`
The price ID of the monthly plan in BRL.
#### `FLUXER_STRIPE_PRICE_MONTHLY_DKK`
The price ID of the monthly plan in DKK.
#### `FLUXER_STRIPE_PRICE_MONTHLY_EUR`
The price ID of the monthly plan in EUR.
#### `FLUXER_STRIPE_PRICE_MONTHLY_INR`
The price ID of the monthly plan in INR.
#### `FLUXER_STRIPE_PRICE_MONTHLY_ISK`
The price ID of the monthly plan in ISK.
#### `FLUXER_STRIPE_PRICE_MONTHLY_NOK`
The price ID of the monthly plan in NOK.
#### `FLUXER_STRIPE_PRICE_MONTHLY_PLN`
The price ID of the monthly plan in PLN.
#### `FLUXER_STRIPE_PRICE_MONTHLY_SEK`
The price ID of the monthly plan in SEK.
#### `FLUXER_STRIPE_PRICE_MONTHLY_TRY`
The price ID of the monthly plan in TRY.
#### `FLUXER_STRIPE_PRICE_MONTHLY_USD`
The price ID of the monthly plan in USD.
#### `FLUXER_STRIPE_PRICE_YEARLY_BRL`
The price ID of the yearly plan in BRL.
#### `FLUXER_STRIPE_PRICE_YEARLY_DKK`
The price ID of the yearly plan in DKK.
#### `FLUXER_STRIPE_PRICE_YEARLY_EUR`
The price ID of the yearly plan in EUR.
#### `FLUXER_STRIPE_PRICE_YEARLY_INR`
The price ID of the yearly plan in INR.
#### `FLUXER_STRIPE_PRICE_YEARLY_ISK`
The price ID of the yearly plan in ISK.
#### `FLUXER_STRIPE_PRICE_YEARLY_NOK`
The price ID of the yearly plan in NOK.
#### `FLUXER_STRIPE_PRICE_YEARLY_PLN`
The price ID of the yearly plan in PLN.
#### `FLUXER_STRIPE_PRICE_YEARLY_SEK`
The price ID of the yearly plan in SEK.
#### `FLUXER_STRIPE_PRICE_YEARLY_TRY`
The price ID of the yearly plan in TRY.
#### `FLUXER_STRIPE_PRICE_YEARLY_USD`
The price ID of the yearly plan in USD.
### Gateway clustering
The stack runs the gateway as one node.
#### `FLUXER_ERLANG_DIST_PORT`
The Erlang distribution port of the gateway.
#### `FLUXER_ERLANG_NODE_NAME`
The Erlang node name of the gateway.
#### `FLUXER_ERLANG_NODE_NAME_PREFIX`
A prefix that gives each gateway node a unique Erlang node name.
#### `FLUXER_GATEWAY_CLUSTER_DISCOVERY_DNS_NAME`
The DNS name gateway nodes find each other through.
#### `FLUXER_GATEWAY_CLUSTER_DISCOVERY_NODE_BASENAME`
The node name gateway nodes use when they find each other through DNS.
#### `FLUXER_GATEWAY_CLUSTER_DISCOVERY_POLL_INTERVAL_MS`
How often gateway nodes look for each other, in milliseconds.
#### `FLUXER_GATEWAY_CLUSTER_ENABLED`
Whether the gateway runs as a cluster.
#### `FLUXER_GATEWAY_CLUSTER_STATIC_PEERS`
A fixed list of the other gateway nodes.
#### `FLUXER_GATEWAY_GUILD_PIN_KEEPER_BASE_MD5S`
The module MD5s a node may have before the gateway patches it.
#### `FLUXER_GATEWAY_GUILD_PIN_KEEPER_BEAM`
The path of the BEAM file the gateway loads onto other nodes to pin communities.
#### `FLUXER_GATEWAY_GUILD_PIN_KEEPER_BEAM_MD5`
The MD5 that the `FLUXER_GATEWAY_GUILD_PIN_KEEPER_BEAM` file must have.
#### `FLUXER_GATEWAY_PINNED_GUILD_IDS`
The communities the gateway pins to particular nodes.
#### `FLUXER_GATEWAY_ROLE`
The role of a gateway node in a cluster.
### Push relay
Only the push relay Fluxer runs for the mobile apps uses these.
#### `FLUXER_PUSH_RELAY_MAX_BODY_BYTES`
The largest request the push relay accepts, in bytes.
#### `FLUXER_PUSH_RELAY_MAX_CONCURRENT`
How many requests the push relay handles at once.
#### `FLUXER_PUSH_RELAY_SOURCE_BUCKET_BURST`
How many requests the push relay allows from one client address in a burst.
#### `FLUXER_PUSH_RELAY_SOURCE_BUCKET_ENABLED`
Whether the push relay rate limits each client address itself.
#### `FLUXER_PUSH_RELAY_SOURCE_BUCKET_ENTRIES`
How many client addresses the push relay rate limit tracks.
#### `FLUXER_PUSH_RELAY_SOURCE_BUCKET_PER_MINUTE`
How many requests a minute the push relay allows from one client address.
#### `FLUXER_PUSH_RELAY_TOKEN_BUCKET_BURST`
How many requests the push relay allows for one device token in a burst.
#### `FLUXER_PUSH_RELAY_TOKEN_BUCKET_ENTRIES`
How many device tokens the push relay rate limit tracks.
#### `FLUXER_PUSH_RELAY_TOKEN_BUCKET_PER_MINUTE`
How many requests a minute the push relay allows for one device token.
#### `FLUXER_PUSH_RELAY_TRUSTED_PROXY_HOPS`
How many proxies in front of the push relay it trusts.
### Cassandra
The stack runs Postgres only.
#### `FLUXER_CASSANDRA_HOSTS`
The Cassandra hosts.
#### `FLUXER_CASSANDRA_KEYSPACE`
The Cassandra keyspace.
#### `FLUXER_CASSANDRA_LOCAL_DC`
The local Cassandra data centre.
#### `FLUXER_CASSANDRA_PASSWORD`
The Cassandra password.
#### `FLUXER_CASSANDRA_PORT`
The Cassandra port.
#### `FLUXER_CASSANDRA_USERNAME`
The Cassandra username.
### Docs site
The docs site isn't part of the compose stack.
#### `FLUXER_DOCS_ENDPOINT`
The public address of the docs site.
#### `FLUXER_DOCS_LISTEN_HOST`
The address the docs site listens on.
#### `FLUXER_DOCS_LISTEN_PORT`
The port the docs site listens on.
#### `FLUXER_DOCS_SEARCH_INDEXING`
Whether search engines may index the docs site.
### Tests and development
Only tests and development use these.
#### `FLUXER_DISABLE_RATE_LIMITS`
Whether rate limits are off.
#### `FLUXER_OPERATOR_SOCKET`
The socket path the operator relay connects to. The api listens on `/run/fluxer/operator.sock`.
#### `FLUXER_RELAX_REGISTRATION_RATE_LIMITS`
Whether registration rate limits are relaxed.
#### `FLUXER_TEST_HARNESS_TOKEN`
The token of the test harness.
#### `FLUXER_TEST_MODE_ENABLED`
Whether test mode is on.
#### `FLUXER_VALIDATE_RESPONSES`
Whether the API checks its responses against their schemas.