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 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 media proxy URLs. The api, worker, media-proxy, gifs and unfurl services must have the same value. 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

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_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, 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_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 admin@chat.example.com 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.

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. The default is http://livekit:7880. With rexctl, use rexctl config set FLUXER_LIVEKIT_INTERNAL_URL.

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_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.

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 straight 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:secret@db.example.com: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. The path is inside their containers. A file you set replaces the system bundle. Add your CA to a copy of that bundle. 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.

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 support@example.com. 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 straight 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, put the new key first. 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 upload the relay accepts, 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 URL. 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. With rexctl, use rexctl config set FLUXER_MEDIA_PROXY_ATTACHMENT_SIGNATURE_MODE.

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 sizes this. 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 answer 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_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 answers 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_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 Operator Pass 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. On an Instatus page, the web app also shows its current incidents and maintenance. 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_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.

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. 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. 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_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. 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. 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.47. 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.

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 answer 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 answer. 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 answer. 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_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 answers RPC requests over NATS. The gateway answers 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_LABS_GUILD_ID

The community Operator Pass holders join.

FLUXER_LABS_OPERATOR_ROLE_ID

The role Operator Pass holders get in that community.

FLUXER_OPERATOR_PASS_GRACE_MINUTES

The grace period of the Operator Pass sale, in minutes.

FLUXER_OPERATOR_PASS_MAX_QUANTITY

The largest Operator Pass quantity in one purchase.

FLUXER_OPERATOR_PASS_PRICE_BRL_ENABLED

Whether the Operator Pass is sold in BRL.

FLUXER_OPERATOR_PASS_PRICE_DKK_ENABLED

Whether the Operator Pass is sold in DKK.

FLUXER_OPERATOR_PASS_PRICE_INR_ENABLED

Whether the Operator Pass is sold in INR.

FLUXER_OPERATOR_PASS_PRICE_NOK_ENABLED

Whether the Operator Pass is sold in NOK.

FLUXER_OPERATOR_PASS_PRICE_PLN_ENABLED

Whether the Operator Pass is sold in PLN.

FLUXER_OPERATOR_PASS_PRICE_RISES_AT

When the Operator Pass price rises.

FLUXER_OPERATOR_PASS_PRICE_SEK_ENABLED

Whether the Operator Pass is sold in SEK.

FLUXER_OPERATOR_PASS_PRICE_TRY_ENABLED

Whether the Operator Pass is sold in TRY.

FLUXER_OPERATOR_PASS_RELEASE_LISTS

The release lists of the Operator Pass sale.

FLUXER_OPERATOR_PASS_SALE_OPENS_AT

When the Operator Pass sale opens.

FLUXER_OPERATOR_PASS_STANDARD_PRICE_BRL

The standard Operator Pass price in BRL.

FLUXER_OPERATOR_PASS_STANDARD_PRICE_DKK

The standard Operator Pass price in DKK.

FLUXER_OPERATOR_PASS_STANDARD_PRICE_EUR

The standard Operator Pass price in EUR.

FLUXER_OPERATOR_PASS_STANDARD_PRICE_INR

The standard Operator Pass price in INR.

FLUXER_OPERATOR_PASS_STANDARD_PRICE_NOK

The standard Operator Pass price in NOK.

FLUXER_OPERATOR_PASS_STANDARD_PRICE_PLN

The standard Operator Pass price in PLN.

FLUXER_OPERATOR_PASS_STANDARD_PRICE_SEK

The standard Operator Pass price in SEK.

FLUXER_OPERATOR_PASS_STANDARD_PRICE_TRY

The standard Operator Pass price in TRY.

FLUXER_OPERATOR_PASS_STANDARD_PRICE_USD

The standard Operator Pass price in USD.

FLUXER_OPERATOR_PASS_STOPPED_COUNTRIES

Countries where Operator Pass sales are stopped.

FLUXER_OPERATOR_PASS_TRANSFER_LOCK_HOURS

How long an Operator Pass transfer stays locked, in hours.

FLUXER_OPERATOR_PASS_WALL_TIERS

The wall tiers of the Operator Pass sale.

FLUXER_OPERATOR_PASS_WITHDRAWAL_COUNTRIES

The Operator Pass withdrawal rules for each country.

FLUXER_PAYMENT_DISPUTE_CLOSURE_EFFECTIVE_AT

When account closures for payment disputes take effect.

FLUXER_STORE_BILLING_SANDBOX_ENTITLES_ALL

Whether sandbox store purchases count for every account.

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_PASS_NOW

A clock override for the Operator Pass sale.

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.