proxyfile

Portability

proxyfile writes Envoy's configuration, nginx's and HAProxy's from the same file. In this version nginx's and HAProxy's generators accept the keys their columns of the support table mark supported or partial, where a partial cell says what differs, and each refuses by name every other core key. Every key is core or belongs to one proxy. A core key is one every proxy can carry, at times with a difference this page names, or one a proxy refuses by name where it cannot carry it. A key that belongs to one proxy lives in that proxy's block at the top of the file: envoy, nginx or haproxy. A render for one target reads the core keys and its own block and leaves the other blocks alone, so one file can hold what each proxy needs. The split follows the Kubernetes Gateway API, which sorts its features into core, extended and implementation-specific ones and is implemented by Envoy, nginx and HAProxy alike.

proxyfile render --target envoy is the default. Any key written in the nginx or haproxy block is refused, as neither block takes a key yet. A target that cannot carry a key the file uses refuses the file, naming the key and what that proxy offers instead; it never writes a quietly weaker configuration.

The keys, by proxy

The Envoy column is what proxyfile writes today. The nginx and HAProxy columns name what each proxy offers: nginx's ngx_otel_module; for the external check of both, what proxyfile writes: for nginx a function in proxyfile.js, beside the configuration, that asks the check through a location of the file and a stream relay, and for HAProxy a Lua action in proxyfile.lua, beside the configuration, that asks the check through a TCP listen section of the file; HAProxy's own OpenTelemetry filter from 3.4 on, where its OpenTracing filter is deprecated (it goes in 3.5).

Key Envoy nginx HAProxy Class
listen the listener listen bind core
admin the admin listener: /ready, /stats, /server_info a server on the admin port: /ready answered as Envoy answers it, /stats with stub_status's seven counters, /server_info with nginx's version, and any other path or a query 404 the stats page or monitor-uri, other paths core; the paths differ by proxy
tls.certificate, tls.key the listener's TLS transport socket, with ALPN h2 and http/1.1 listen <port> ssl, ssl_certificate, ssl_certificate_key bind :<port> ssl crt <file>, which reads the key from the certificate file or a .key file beside it core
tls.clients.ca validation_context.trusted_ca with require_client_certificate ssl_client_certificate with ssl_verify_client on verify required ca-file <ca> core
client_address use_remote_address false (forwarded) or true (connection) forwarded writes no address rule, so the client's X-Forwarded-For passes as received; connection is proxy_set_header X-Forwarded-For with the client's list and $remote_addr appended, and x-envoy-external-address set to $remote_addr forwarded writes no address rule, so the client's X-Forwarded-For passes as sent; connection is http-request set-header x-forwarded-for with the peer's address, %[src], after the client's, and x-envoy-external-address set to it core
limits.connections the overload manager limit_conn on one text key in each environment's server: a request to a service past the number in flight is answered 503, an HTTP/2 stream counted as one; up to 65535 maxconn on the listener and on each server core
envoy.heap the overload manager: shrink at 90%, refuse at 98% none none envoy
limits.request_headers.size max_request_headers_kb client_header_buffer_size of 64 bytes and large_client_header_buffers, as many buffers of at most 64 KiB as the size needs, so a head within 64 bytes of the size can be refused tune.bufsize core
limits.request_headers.count the header count limit max_headers, and over HTTP/2 the script's count, which takes in the four pseudo-headers and each cookie field as Envoy does, where max_headers counts neither tune.http.maxhdr core
timeouts.request the route timeout, for the whole request none: proxy_read_timeout counts the time between two reads, 15 s without the key and 5 minutes with none timeout http-request for the headers, timeout server after them core; nginx takes none and refuses a time, HAProxy's differs as its column says
timeouts.idle the stream idle timeout four timers of the time between two reads or writes for Envoy's one: client_body_timeout, send_timeout, proxy_send_timeout and grpc_send_timeout, and proxy_read_timeout and grpc_read_timeout when the idle time is under the route's 15 s or timeouts.request is none timeout client, timeout server core
timeouts.upstream_idle the cluster idle timeout keepalive_timeout in upstream no line: a connection to a service carries one request core; HAProxy differs as its column says
services.<name>.http, .grpc, .address, .host_header clusters upstream with proxy_pass or grpc_pass, proxy_set_header Host backend with server ... proto h2, http-request set-header Host core
services.<name>.addresses, a DNS name in .address one endpoint per address in a STATIC cluster; for a name, a cluster whose cluster_type is DnsCluster, which looks it up every 5 seconds for its IPv4 and IPv6 addresses both (dns_lookup_family: ALL), each a backend upstream with one server per address; for a name, server <name>:<port> resolve with a zone, in open source from 1.27.3 one server line per address; for a name, server-template with resolvers core
services.<name>.balance lb_policy ROUND_ROBIN, LEAST_REQUEST, RANDOM, RING_HASH (LEAST_REQUEST compares two backends chosen at random) round robin, random two least_conn (of two backends chosen at random, the one with fewer requests open), random, hash ... consistent; hash on the service auth.ask names is refused roundrobin (the default), leastconn, random(1) core
services.<name>.hash.header, .hash.client the cluster's hash_policy: header, or connection_properties with source_ip hash $pf_hash_key consistent, the header's lines that proxyfile.js reads and joins in sorted order, as Envoy joins them; hash $binary_remote_addr consistent under client_address: connection, and hash $pf_client_key consistent, the client proxyfile.js reads from X-Forwarded-For as Envoy does, under forwarded balance hdr(<name>); balance source, or under forwarded balance hash req.hdr_ip(x-forwarded-for,-1) core
services.<name>.health health_checks on the cluster, with the panic threshold at 0 passive checks: max_fails=<unhealthy> on each server of a service of two addresses or more, the upstream in a zone; no check request of its own (health_check is NGINX Plus's); up to 1,000 addresses option httpchk GET <path>, check inter fall rise; grpc refused: no gRPC health check core
dns.resolver c-ares resolvers in the DnsCluster of each cluster that looks a name up; the host's configuration without it resolver <address>:<port> valid=5s in the http block and in the check relay's stream block, which a service's name and the collector's name are looked up through; a name without dns.resolver is refused a resolvers section, or parse-resolv-conf without it core; nginx refuses a name without it
auth.ask, .timeout, .enabled, .send, .accept ext_authz in HTTP mode js_access with a function of proxyfile.js that asks the check through a subrequest and a stream relay; a proxy_set_header for each accepted header the Lua action pf_auth, which asks the check through a TCP listen section; the path, the time, the send and accept lists are its arguments core; nginx and HAProxy differ as their columns say
auth.when_unavailable = allow failure_mode_allow in part: the function lets an unanswered check through, and the location sets x-envoy-auth-failure-mode-allowed; a connection to the relay that nginx never made is no unanswered check, and is refused with 403, with allow too the action's allow argument core; partial on nginx
auth.only_with_header a header match on the filter in part: the function reads the header's lines and asks when one holds a byte, or the header comes on two lines or more; a header that remove_from_clients or auth.accept also names is refused an ACL on the header in the action's if core; partial on nginx
auth.accept with a * prefix allowed upstream header prefixes each header named in a proxy_set_header that holds the function's variable; no prefix the action's accept argument, the prefix with its *; a header HAProxy frames a request by is never set core; nginx refuses the prefix form
auth.send_request the check's headers_to_add four proxy_set_header lines on the check location the action's last argument, which sends the four forwarded headers core; nginx and HAProxy differ as their columns say
auth.jwt the jwt_authn filter with one provider none in nginx open source (nginx Plus's auth_jwt only), so its generator refuses the key jwt_verify takes one PEM key, no key set and no URL, so its generator refuses the key until it has a faithful form core; nginx and HAProxy refuse it
remove_from_clients removal by name and by prefix proxy_set_header X "" for each name; no prefix http-request del-header, by name or -m beg core; nginx refuses the prefix form, HAProxy a name or prefix that covers content-length, connection or upgrade
cors.*, origins.<env>.origins, .patterns the CORS filter map on the Origin, add_header, a preflight return 200 ACLs, http-request return for the preflight, http-after-response set-header core
origins.<env>.hosts virtual host domains server_name hdr(host) ACLs and use_backend core
routes[].name the route's name, in the logs none beyond a log variable the ACL's name core; nginx keeps it in the log only
routes[].prefix, .path prefix and path matches location ^~, location = path_beg, path core
routes[].pattern RE2 PCRE, location ~ PCRE, path_reg core, on the part of regular-expression syntax the three share
routes[].method a header match limit_except or if ($request_method) the method ACL core
routes[].to the cluster proxy_pass use_backend core
routes[].rewrite a prefix rewrite rewrite, or the URI on proxy_pass http-request replace-path core
routes[].auth = off the check and the token filter turned off for the route a location without js_access an ACL on the route that skips the action core
routes[].retries, rpc.retries a retry policy with Envoy's conditions, to a backend not tried yet when the service has one (the previous_hosts predicate) for a route, proxy_next_upstream off and an error_page that sends a request no service read to a copy of the route's location for the next backend, the body read first; for the rpc entry grpc_next_upstream error timeout and grpc_next_upstream_tries, on calls whose method is POST set-retries per route, retry-on conn-failure (the default) and option redispatch; rpc.retries refused core; what "never reached the service" means differs by proxy, and nginx tries again only a request whose body it reads whole first, within 1 MiB
routes[].rate_limit, routes[].rpc.rate_limit the local rate limit filter, before the check, with one token bucket for each route, which the route's metadata names a limit_req_zone of 16 MiB for each limited entry, keyed by $binary_remote_addr under client_address: connection, by the client proxyfile.js reads from X-Forwarded-For as Envoy does under forwarded, or by a constant for all, with rate=<r>r/s or r/m, so a rate of no whole number of requests a second or a minute is refused; limit_req ... burst=<requests + burst - 1> nodelay, and a location for each kind of answer Envoy gives a request over the limit: 429 with local_rate_limited, the Connect error resource_exhausted, and for a gRPC call 200 with grpc-status 8 a stick-table storing http_req_rate(<per>), http-request track-sc0, and http-request deny deny_status 429 if { sc_http_req_rate(0) gt <requests> }, a sliding window, so a burst above 0 is refused core; nginx and HAProxy differ as their columns say
the rpc entry of routes, rpc.to, rpc.methods, rpc.proto one exact-path route for each method a location = /<package>.<Service>/<Method> with grpc_pass for each method a path ACL for each method, to an HTTP/2 backend core
the action and the reports each RPC route tells the check the route's own check settings a set of $pf_action and $pf_reports in the location of each method, which the check location sends as x-gateway-action and x-gateway-reports http-request set-header of x-gateway-action and x-gateway-reports by the method's path, for the check alone core
envoy.connect_bridge the Connect-gRPC bridge and the Lua status fix on RPC routes none none envoy
log.status_from, log.sample access log filters access_log ... if=, with a map of $status for status_from and split_clients on the request id for sample a log-format of HAProxy's own fields on standard output; http-after-response set-log-level silent by status and rand(100) core
tracing, with its provider xray Envoy's X-Ray tracer none: nginx has no X-Ray tracer, so the generator refuses the provider and says to write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, a collector the generator does not write the OpenTelemetry filter (3.4 and later), then the same collector core
tracing, with its provider otel Envoy's OpenTelemetry tracer ngx_otel_module, in the images tagged -otel: otel_exporter { endpoint } with the collector's address, or for a collector by name the socket of a relay in the http block, an upstream that looks the name up and a server that passes each call on with grpc_pass, otel_service_name, otel_trace $pf_otel_trace, which proxyfile.js sets by the Envoy output's draw, otel_trace_context extract, with the traceparent and tracestate the service and the check receive written by proxyfile.js, otel_span_name with the route's name, and an otel_span_attr for each field of the Envoy output's span and for each tag the OpenTelemetry filter (3.4 and later) core
envoy.tracing the same as tracing with xray none none envoy, the old place of tracing
envoy.namespace the namespace of the gateway's metadata none none envoy

Everything else in the format, such as the origins file form, the entries of rpc.methods and the name of an RPC mapping, is core. The cost of another proxy is its generator and its rows in the conformance battery.

Support by proxy, from the generators

Each generator declares, for every core key, how it carries the key: supported, partial with the difference, or refused with what that proxy offers instead. Its last two rows are the two behaviours every configuration holds with no key (below): each generator declares them as it declares a key, and none may refuse them. proxyfile render and proxyfile check with --target <proxy> refuse a file that writes a key its target refuses, naming the key where it is written and what the proxy offers instead. This table is written from those declarations and has a column for each proxy with a generator; the table above names what each proxy offers for a key, and this one how each generator carries it. A partial cell that names a refused form (refuses <form>: <what to write instead>) is refused as a refused key is: render and check name the key where it is written. What a proxy writes differently with no key is on its own page: nginx, HAProxy. The conformance battery sends the same requests to each proxy, and checks the refusal for a key the proxy refuses.

Key Envoy nginx HAProxy
listen supported supported supported
admin supported partial: /stats is nginx's seven counters (active connections, accepts, handled, requests, reading, writing and waiting) and /server_info its version, not Envoy's; any other path or a query is answered 404, where the Envoy output answers 403; TRACE is answered 405 with no body, where the Envoy output answers it as GET; an absolute target nginx or the public listener's checks refuse, as one of a scheme other than http and https, with an empty port, user information or a query right after its host, is answered 400, where the Envoy output answers 404; less strict than the Envoy output: the admin listener serves an absolute target of http or https as the path it names partial: /ready answers 200 while HAProxy runs, not when the server is ready; no other admin path in this version
tls supported partial: plain HTTP sent to the TLS port is answered 400, where the Envoy output closes the connection; from the same ciphers and key exchange groups nginx can choose others for the same client partial: of the TLS 1.2 suites both take, HAProxy picks by its own order, where Envoy takes the client's among suites it holds equal: a client that offers OpenSSL's default list is given ECDHE-RSA-AES128-GCM-SHA256, where Envoy gives ECDHE-RSA-CHACHA20-POLY1305
tls.certificate supported partial: a path without $; refuses holding $: nginx reads a $ in a certificate's or a key's path as the start of a variable, and a path written to keep the $ is read at each handshake, which nginx -t does not check; put the file at a path without $, or render it for envoy supported
tls.key supported partial: a path without $; refuses holding $: nginx reads a $ in a certificate's or a key's path as the start of a variable, and a path written to keep the $ is read at each handshake, which nginx -t does not check; put the file at a path without $, or render it for envoy supported
tls.clients supported supported supported
tls.clients.ca supported partial: a client certificate that is missing or fails is answered 400 after the handshake, where the Envoy output ends the handshake; a request whose Host names another host than its TLS server name, a host of an environment, is answered 421; neither reaches a service partial: a client certificate that is not valid yet is refused with the alert bad_certificate, where Envoy sends certificate_expired
client_address supported partial: with forwarded, an X-Forwarded-Proto line with no colon is answered 404, where the Envoy output answers 400; less strict than the Envoy output: under connection, an absolute https target sent over plain HTTP is served partial: under forwarded, a client's own X-Request-Id longer than 980 bytes, or than 908 bytes less an echoed Origin and cors.expose_headers, is answered 400 before the check and the service, where the Envoy output serves it: HAProxy echoes the id in the 1,024 bytes it keeps for the lines it adds to an answer; over HTTP/2 an X-Forwarded-Proto of spaces alone is answered 404, where the Envoy output serves it
limits supported supported supported
limits.connections supported partial: nginx's own limit_conn: a request on its way to a service past the number of such requests in flight is answered 503, before its check, if any, is asked, each HTTP/2 stream counted as one and an idle connection as none; an answer the file gives itself, such as a 404 or a preflight's 200, is neither counted nor refused, and no line limits a service's connections; refuses above 65535: nginx's limit_conn takes at most 65535; write 65535 or less, or render it for envoy partial: HAProxy's own maxconn on the listener and on each server: a connection past it waits in the listen queue, and a request past a server's waits up to 5 s in HAProxy's queue and is then answered 503; the limit to a service counts on each of its addresses
limits.request_headers supported supported supported
limits.request_headers.size supported partial: a header block within 64 bytes of the limit can be refused, where the Envoy output takes it; above 64 KiB a line longer than one of nginx's buffers (32 KiB to 64 KiB) is refused, and a block of long lines can be refused under the limit; a request over it is answered 400, or 414 for a request line, where the Envoy output answers 431, and over HTTP/2 it ends the connection, where the Envoy output resets the stream; less strict than the Envoy output: a request trailer larger than the header limit is served over HTTP/1.1 partial: HAProxy's own tune.bufsize, the size of every buffer, written as the size and the 1,024 bytes HAProxy keeps for rewrites: a request whose head does not fit is answered 400, an answer whose head does not fit 502, and the byte bounds the other rows of this column give were found with HAProxy's default buffer of 16,384 bytes; refuses below 15KiB: HTTP/2 needs a buffer of 16,384 bytes, of which HAProxy keeps 1,024 for rewrites, so its smallest header limit is 15KiB; write 15KiB or more, or render it for envoy
limits.request_headers.count supported partial: a request over it is answered 400, where the Envoy output answers 431 or resets the HTTP/2 stream; the lines of a header Envoy joins into one, such as accept, count once each; over HTTP/2 a cookie field holding several cookies counts once for each, where the Envoy output counts it once, and a request that sends :authority alone or a host field alone is refused one field under the limit, where the Envoy output takes it partial: HAProxy's own tune.http.maxhdr, written as the count and one because it counts the request line: a request over it is answered 400; refuses above 32766: HAProxy's tune.http.maxhdr takes at most 32,767 lines, the request line among them; write 32766 or less
timeouts supported supported supported
timeouts.request supported partial: without the key nginx answers 504 to a service silent for 15 s after the request, as the Envoy output does; with none, nginx ends a request after 5 minutes with nothing read or written, as Envoy does; refuses a time: nginx has no limit on a whole request (its time limits count the time between two reads or writes); write timeouts.request: none, or render it for envoy; less strict than the Envoy output: without timeouts.request, an answer that keeps arriving runs past 15 s; without timeouts.request, a request body its service does not read, or reads slowly, runs past 15 s partial: without the key a service that sends nothing for 15 s is answered 504, as by Envoy; HAProxy's limits count the time without data; refuses a time: HAProxy has no limit on a whole request (timeout server is the time without data, timeouts.idle); write timeouts.request: none; less strict than the Envoy output: without timeouts.request, an answer that keeps arriving runs past 15 s
timeouts.idle supported partial: a request body that stops for longer is ended with no answer, where the Envoy output answers 408; four per-operation timers stand for Envoy's one; none is written as 9223372036854775807ms, the longest time nginx loads, its form of no limit; a gRPC call it ends is answered 504 with the text stream timeout, where the Envoy output answers grpc-status 14 with that message partial: HAProxy's own timeout client and timeout server, the time without data on each side; timeout client also closes a kept-alive client connection idle that long, and none is HAProxy's longest timer, 2147483647 ms; refuses a time above 2147483647 ms: HAProxy's timers hold at most 2147483647 ms; write a shorter time, or none
timeouts.upstream_idle supported supported partial: HAProxy opens a connection to a service for each request and closes it after the answer, so no connection to a service waits idle and the key writes no line
services supported supported supported
services.<service name> supported supported supported
services.<service name>.http supported supported supported
services.<service name>.grpc supported partial: a call whose service resets its stream, or answers in HTTP/1.1, is answered 200 with grpc-status 14 and no grpc-message, where the Envoy output adds the grpc-message upstream connect error or disconnect/reset before headers. reset reason: remote reset, or for the HTTP/1.1 answer reset reason: protocol error; a request that is not a gRPC call is answered 502 with no body in both cases, where the Envoy output answers the stream reset 503 and the HTTP/1.1 answer 502, each with that text as text/plain partial: a service that never takes the connection is answered after 15 s, where Envoy answers after its 5 s connect timeout, a gRPC call with 200 and grpc-status 14 as by Envoy and any other request with 504 and upstream request timeout, where Envoy's is an empty 502: HAProxy does not bound an HTTP/2 connection to a service by its connect timeout, and the 15 s a service that sends nothing gets end the wait (measured without timeouts.request); a gRPC call HAProxy alone refuses before any service, such as one with a client's X-Request-Id of 1,000 bytes under forwarded, gets HAProxy's plain answer, here 400, where Envoy serves the call; a request that is not a gRPC call, to a gRPC service that resets its stream or answers in HTTP/1.1, is answered 502 with no body, where the Envoy output answers the stream reset 503 and the HTTP/1.1 answer 502, each with the text upstream connect error or disconnect/reset before headers. reset reason: remote reset, or protocol error, as text/plain
services.<service name>.host_header supported supported supported
services.<service name>.address supported partial: a name gives at most about 1,000 addresses for each port; refuses a DNS name with no dns.resolver: nginx looks a name up only through the name server it is given; write dns.resolver; refuses a zoned IPv6 address: nginx reads no zone in a backend's address; give the service an address without one partial: an IP address with no zone, or a DNS name HAProxy's own resolvers look up every second, with up to 100 of its addresses, of one family, IPv6 when the name has one, from DNS answers of up to 4,096 bytes, which held 99 to 100 of a name's 100 IPv4 addresses where HAProxy's default answer size held 30; refuses a zoned IPv6 address: HAProxy 3.2 and 3.4 load no zone in a server's address; give the service an address without one
services.<service name>.addresses supported partial: IP addresses with no zone; refuses holding a zoned IPv6 address: nginx reads no zone in a backend's address; give the service an address without one partial: IP addresses with no zone; refuses holding a zoned IPv6 address: HAProxy 3.2 and 3.4 load no zone in a server's address; give the service an address without one
services.<service name>.balance supported partial: hash on the check's service is refused; refuses hash on the service auth.ask names: nginx's check relay cannot read the check's headers to hash them; write another balance on the service partial: HAProxy's own balance: round_robin is roundrobin, its default, least_requests leastconn, which counts connections, one a request here, and random random(1), one draw
services.<service name>.hash supported supported supported
services.<service name>.hash.header supported supported partial: HAProxy's own balance hdr(): a request without the header, or with it empty, goes round robin; the check relay of the service auth.ask names, whose one client is HAProxy itself, goes round robin
services.<service name>.hash.client supported supported partial: HAProxy's own balance source, or under forwarded a hash of the last X-Forwarded-For address; a request with no such address goes round robin; the check relay of the service auth.ask names, whose one client is HAProxy itself, goes round robin
services.<service name>.health supported partial: nginx's own passive check (max_fails): a backend whose requests fail unhealthy times within 10 s, by an error, a timeout or an invalid answer, takes no request for 10 s; nginx sends no check request of its own, and keeps a service's one backend in use; refuses on a service with more than 1,000 addresses: nginx's passive check keeps a service's backends in a zone of 1 MiB, which holds 1,000 of them; give the service 1,000 addresses or fewer, remove health, or render it for envoy supported
services.<service name>.health.path supported partial: not read: open-source nginx sends no check request (health_check is NGINX Plus's), so its passive check reads the service's own requests partial: HAProxy's own option httpchk, GET over HTTP/1.0 with no Host header, and a backend is in the pool from HAProxy's start until it fails its checks; the gRPC backends of a service at IP addresses leave the pool with its HTTP ones (track), where a service found by a DNS name keeps every gRPC backend
services.<service name>.health.grpc supported partial: not read: open-source nginx sends no check request (health_check is NGINX Plus's), so its passive check reads the service's own requests refused: HAProxy has no gRPC health check: http-check send writes a text body, not the health service's gRPC message; write health.path on the service's http port
services.<service name>.health.interval supported partial: not read: open-source nginx sends no check request (health_check is NGINX Plus's), so its passive check reads the service's own requests partial: HAProxy's own check inter, at most 2147483647 ms; refuses a time above 2147483647 ms: HAProxy's timers hold at most 2147483647 ms; write a shorter time, or render it for envoy
services.<service name>.health.timeout supported partial: not read: open-source nginx sends no check request (health_check is NGINX Plus's), so its passive check reads the service's own requests partial: HAProxy's own timeout check, the wait for the answer, where the connection has the shorter of 5 s and the interval; refuses a time above 2147483647 ms: HAProxy's timers hold at most 2147483647 ms; write a shorter time, or render it for envoy
services.<service name>.health.healthy supported partial: not read: open-source nginx sends no check request (health_check is NGINX Plus's), so its passive check reads the service's own requests supported
services.<service name>.health.unhealthy supported partial: the failed requests within 10 s that take a backend out (max_fails), not checks in a row supported
dns supported supported supported
dns.resolver supported supported supported
auth supported supported supported
auth.ask supported partial: a request whose check answers in one of these forms is answered 403: a status outside 100 to 599, such as 2, 99, 600 or 2000, or 101, where Envoy passes the status on to the client; HTTP/2.0 or HTTP/1.2, two spaces or a tab after the version, a + before the status, a tab between the status and the reason, a lone CR, a space or a tab after a chunk size, a chunk size of nine hex digits, a chunk extension holding a control byte or a quoted CR LF, a chunk-size line past 1,024 bytes, bytes between a chunk's data and its line end, a folded trailer line, or a head of exactly 81,920 bytes with a line in a bare LF, which nginx counts a byte longer, where Envoy reads the answer; a 200 whose body passes 1 MiB, where Envoy serves the request; a denial whose body passes 1 MiB, where Envoy passes the denial on; a denial whose head has more than 100 header lines, folded lines not counted, with a name on two of them, where Envoy counts a name it keeps inline, such as date, once and passes the denial on; over HTTP/2, a gRPC call refused for the check's denial, or with deny for want of a readable answer, is answered as Envoy answers it, with one more header, content-length: 0; a check's 301, 302, 303, 307 or 308 to an HTTP/1.1 request that carries a body reaches the client with nginx's own page in place of the check's body, and a check's 304 to such a request with content-length: 0, as nginx discards the request's body, so that no byte of it is read as the next request; a denial reaches the client with Server: nginx where the check sent no Server header, with nginx's own reason phrase (302 Moved Temporarily, where Envoy writes Found), without a header line the check sent with an empty value, with the check's Access-Control-Allow-Origin beside the listed origin's own, where Envoy sends the origin's alone, and, to a HEAD request, with Content-Length: 0, where Envoy sends transfer-encoding: chunked; an error in proxyfile.js itself as it asks the check or reads its answer is answered 403, with allow too, and writes no log line; the check is sent connection: close on a new connection for each check, where Envoy sends no Connection header and keeps its connections to the check open, so nginx's local ports bound how many checks a second it can send to one check address: near 340,000 a second when the check closes its connection first after it answers, derived from the 0.13% of connections nginx's side then kept in TIME_WAIT and not reached, and about 470 a second when it does not, at most 28,231 checks to one address in any 60 s from the 28,232 ports of 32768 to 60999 (measured on nginx 1.30.6 and 1.31.8 beside Envoy 1.40.2); past that bound a check fails for want of a port, and its request is answered 403 with deny and served with the unchecked mark with allow; the relay listens on a socket file, /run/proxyfile-<listen>/check.sock, which nginx removes when it stops and a kill leaves, and nginx then does not start, its bind() to the file failing (98: Address already in use), until the file is removed or /run is a tmpfs; less strict than the Envoy output: a request whose client closes its connection during the check can still reach the service partial: an answer of the check HAProxy cannot read whole is answered 403, where Envoy passes it on: a denial whose header lines and body pass 15,100 bytes, each line counted as its name, its value and 8 bytes, a header line of 16,383 bytes or more, a 200 whose body passes 1 MiB, a head of more than 100 header lines, folded lines not counted, with a name on two of them, where Envoy counts a name it keeps inline, such as date, once, and a status of 101, which a gRPC call gets as grpc-status 7, where Envoy gives 2; an answer in HTTP/1.2, a chunk size of 9 hexadecimal digits or more, a chunk extension or a space or a tab after a chunk size, CR CR LF after a chunk's data or a trailer value, a folded trailer line, two spaces or a tab after the version, a lone CR in the status line or in a header value, a status line of 16,383 bytes or more, or a line other than a chunk-size line whose CR falls at a multiple of 16,384 bytes into the answer (measured at 16,384, 32,768 and 81,920), which HAProxy's socket hands to the script with the CR kept, is answered 403, where Envoy reads it; each head of the answer and its trailer section are read to 81,920 bytes, Envoy's bound, each line counted with a CR and an LF, so lines that end in LF alone reach it sooner; a status outside 100 to 599 or a status line in HTTP/2.0 is answered 403, where Envoy passes the check's status on; the check is sent connection: close on a connection of its own, where Envoy sends no Connection header and keeps its connections to the check open; after a check's 304 HAProxy closes the client's connection, so a request the client sends next on it gets no answer, where Envoy answers it
auth.timeout supported partial: with allow, the request goes on with the unchecked mark at the first byte the check sends after auth.timeout, or after one auth.timeout with no byte from it, so a check that sends a byte just before each auth.timeout of silence holds the request up to twice auth.timeout, where Envoy goes on at auth.timeout supported
auth.enabled supported supported supported
auth.when_unavailable supported partial: with allow, a request whose check answers in a form Envoy reads as no answer (a malformed header line, framing or status line, a head or a trailer section past the 81,920 bytes Envoy reads, a head of more than 100 header lines with a name on two of them, such as set-cookie, or a body that never ends) is answered 403, where Envoy serves it with the unchecked mark, x-envoy-auth-failure-mode-allowed: true; less strict than the Envoy output: with allow, a check service that does not close its connection right after its answer leaves requests unchecked past about 470 checks a second; with allow, a worker with none of its 8192 connections left serves requests unchecked partial: with allow, an answer that breaks off inside its header lines, a chunk-size line or a trailer line, by a close or by passing auth.timeout, a 200 or a denial whose body never ends, an answer whose head or trailer section passes 81,920 bytes, a head of more than 100 header lines with a name on two of them, such as set-cookie, and an answer HAProxy cannot read as RFC 9112 writes one (a Content-Length that is not one line of digits, a control byte in a header value, a status line that does not end, a chunk-size line that ends in a bare LF) are answered 403, where Envoy serves the request with the unchecked mark, x-envoy-auth-failure-mode-allowed: true
auth.only_with_header supported partial: over HTTP/1.1 a request whose header is a lone tab is asked, where Envoy does not ask it: nginx keeps the tab, which Envoy removes; over HTTP/2 a cookie sent as two or three empty cookie fields is asked, where Envoy does not ask it; refuses naming a header that remove_from_clients, auth.accept or the proxy itself removes from clients: the Envoy output removes that header before it reads it and never asks the check, where nginx asks it; name a header the proxy passes on partial: over HTTP/2 a request that carries the header with every value empty is asked, where Envoy does not ask it: HAProxy reads an HTTP/2 value of spaces alone as empty, and Envoy asks one, so HAProxy asks both
auth.send supported partial: a client's own x-proxyfile-method and x-proxyfile-path are not sent to the check when send covers them, where Envoy sends them; what the check is asked does not change partial: the check receives each byte of 0x80 or more that is not part of well-formed UTF-8 in a header it is sent as the client sent it, where Envoy writes a ! for each such byte
auth.accept supported partial: names written in full, none of them a header nginx writes itself on the request it passes on; a request the accepted headers take past limits.request_headers is answered 500 as by Envoy, counted with the client's own Connection line, its own copies of the headers the proxy sets, each line of a name sent on several lines and each cookie field over HTTP/2, which Envoy drops, replaces or joins into one before it counts, so such a request can be answered 500 by those lines sooner; an accepted header the check sends empty reaches a gRPC service as no header, where Envoy sends it empty; refuses holding a name with a * prefix: nginx sets a request header only by a name its configuration writes; write each name in full; refuses naming a header nginx frames or routes a request by: nginx writes this header itself on the request it passes on, to frame or route it or to keep a client's copy from the service, x-forwarded-for, x-envoy-external-address and the five x-envoy- names Envoy removes from clients only with client_address: connection, and a check service must never change how nginx frames or routes that request; each is refused with either client_address, so a list stays valid when it changes; remove the name from auth.accept partial: an accepted header that does not fit beside the request's own header lines in HAProxy's request buffer is answered 403, where Envoy sets it on the request (measured up to 50,000 bytes; it answered 500 at 70,000): beside a request of 118 bytes, one of 8,000 or 15,000 bytes is set by both versions and one of 15,843 bytes or more (3.4.7: 15,851) is answered 403, a bound the request's own header lines lower by as many bytes as they hold; an accepted header whose line reaches 16,383 bytes is answered 403 by auth.ask's line bound first; a * prefix never sets transfer-encoding, host or te from the check's answer, where Envoy sets each; a folded header line of the check's answer reaches the service joined to the value before it by one space, where Envoy keeps the spaces and tabs of both lines and drops the line end; refuses naming content-length, transfer-encoding, host, te, connection or upgrade in full: HAProxy frames or routes a request by these headers, so the check's answer never sets them; remove the name from auth.accept; refuses holding a * prefix that covers content-length, connection or upgrade: the Envoy output sends the body chunked once Content-Length is removed, and leaves a WebSocket upgrade unanswered once Connection or Upgrade is removed, which HAProxy cannot write; write the other names in full, or a longer prefix, or render it for envoy
auth.send_request supported partial: in a file with no pattern route, a path holding a character Envoy escapes before it picks a route (" < > ^ ` { | }) is told in x-forwarded-uri as the client wrote that character, where Envoy tells it escaped; the service receives it escaped from both; over HTTP/2 a request whose :scheme differs from its connection's scheme is told in x-forwarded-proto the connection's under client_address connection, and under forwarded the x-forwarded-proto it arrived with, or the connection's when it arrived with none, where Envoy tells it the :scheme; under client_address connection, so is an absolute target over HTTP/1.1 whose scheme differs from its connection's: an http target sent over TLS is told https, where Envoy tells it http; under client_address forwarded, an x-forwarded-proto that is neither http nor https, such as ftp, is told as it arrived, where Envoy tells the connection's scheme; less strict than the Envoy output: under forwarded, an x-forwarded-proto that is neither http nor https is told to the check as it arrived partial: over HTTP/2 a request whose :scheme differs from its connection's scheme is told in x-forwarded-proto the connection's under client_address connection, and under forwarded the x-forwarded-proto it arrived with, or the connection's when it arrived with none, where Envoy tells it the :scheme; under client_address forwarded, an x-forwarded-proto that is neither http nor https, such as ftp, is told as it arrived, where Envoy tells the connection's scheme; less strict than the Envoy output: under forwarded, an x-forwarded-proto that is neither http nor https is told to the check as it arrived
auth.jwt supported refused: nginx open source cannot verify a token (nginx Plus's auth_jwt); verify it in the service, or render it for envoy refused: HAProxy's jwt_verify takes one key file, with no key set, URL, issuer or audience check; verify the token in the service auth.ask names
auth.jwt.issuer supported refused: nginx open source cannot verify a token (nginx Plus's auth_jwt); verify it in the service, or render it for envoy refused: HAProxy's jwt_verify takes one key file, with no key set, URL, issuer or audience check; verify the token in the service auth.ask names
auth.jwt.audiences supported refused: nginx open source cannot verify a token (nginx Plus's auth_jwt); verify it in the service, or render it for envoy refused: HAProxy's jwt_verify takes one key file, with no key set, URL, issuer or audience check; verify the token in the service auth.ask names
auth.jwt.keys supported refused: nginx open source cannot verify a token (nginx Plus's auth_jwt); verify it in the service, or render it for envoy refused: HAProxy's jwt_verify takes one key file, with no key set, URL, issuer or audience check; verify the token in the service auth.ask names
auth.jwt.ca supported refused: nginx open source cannot verify a token (nginx Plus's auth_jwt); verify it in the service, or render it for envoy refused: HAProxy's jwt_verify takes one key file, with no key set, URL, issuer or audience check; verify the token in the service auth.ask names
auth.jwt.header supported refused: nginx open source cannot verify a token (nginx Plus's auth_jwt); verify it in the service, or render it for envoy refused: HAProxy's jwt_verify takes one key file, with no key set, URL, issuer or audience check; verify the token in the service auth.ask names
auth.jwt.optional supported refused: nginx open source cannot verify a token (nginx Plus's auth_jwt); verify it in the service, or render it for envoy refused: HAProxy's jwt_verify takes one key file, with no key set, URL, issuer or audience check; verify the token in the service auth.ask names
auth.jwt.claims supported refused: nginx open source cannot verify a token (nginx Plus's auth_jwt); verify it in the service, or render it for envoy refused: HAProxy's jwt_verify takes one key file, with no key set, URL, issuer or audience check; verify the token in the service auth.ask names
auth.jwt.claims.<header name> supported refused: nginx open source cannot verify a token (nginx Plus's auth_jwt); verify it in the service, or render it for envoy refused: HAProxy's jwt_verify takes one key file, with no key set, URL, issuer or audience check; verify the token in the service auth.ask names
remove_from_clients supported partial: names written in full, none of them a header nginx frames or routes the request by; refuses holding a name with a * prefix: nginx takes each header by name; write each name in full; refuses holding host, content-length, transfer-encoding, connection, upgrade, te, keep-alive or http2-settings: nginx reads these headers itself to frame and route the request; remove the name from remove_from_clients partial: names and * prefixes that cover none of content-length, connection and upgrade; refuses holding content-length, connection or upgrade, in full or under a * prefix: the Envoy output sends the body chunked once Content-Length is removed, and leaves a WebSocket upgrade unanswered once Connection or Upgrade is removed, which HAProxy cannot write; write the other names in full, or a longer prefix, or render it for envoy
cors supported supported supported
cors.allow_methods supported partial: two Access-Control-Request-Method lines are answered joined with a comma and a space, where the Envoy output joins them with a comma supported
cors.allow_headers supported partial: nginx sends no Access-Control-Allow-Headers line where the Envoy output sends an empty one, for a preflight that asks for no header; two Access-Control-Request-Headers lines are answered joined with a comma and a space, where the Envoy output joins them with a comma partial: an empty Access-Control-Allow-Headers is left out of a preflight's answer, where Envoy sends it empty
cors.expose_headers supported supported supported
cors.max_age supported supported supported
origins supported supported supported
origins.<environment name> supported supported supported
origins.<environment name>.hosts supported partial: a foreign or empty Origin to a path no route takes gets 403, where Envoy answers 404; refuses holding a host that starts or ends with .: nginx reads a dot at a host's start as every name under it and drops one at its end; write the host without it, or render it for envoy supported
origins.<environment name>.origins supported supported partial: an admitted Origin longer than 872 bytes less the length of cors.expose_headers is answered 403 with the body Invalid CORS request before the check and the service, where the Envoy output echoes it: HAProxy has 1,024 bytes for the lines it adds to an answer
origins.<environment name>.patterns supported partial: an Origin holding a comma is answered 403, where the Envoy output can match two Origin lines joined with a comma; an Origin longer than 8,192 bytes is not matched against the patterns, so one a pattern would take is refused partial: an admitted Origin longer than 872 bytes less the length of cors.expose_headers is answered 403 with the body Invalid CORS request before the check and the service, where the Envoy output echoes it: HAProxy has 1,024 bytes for the lines it adds to an answer
routes supported supported supported
routes[].rpc supported supported supported
routes[].rpc.retries supported partial: a call whose method is not POST is not tried again; a service with one backend is not tried again, where the Envoy output tries the same backend; less strict than the Envoy output: a retried request or call is sent again at once and with no limit on retries at the same time refused: with retry-on at HAProxy's default, a gRPC call whose connection to the service failed was not sent again, and the wider retry-on that sends it also sends again a request a service may have read; leave retries out of the rpc entry, or render it for envoy
routes[].rpc.rate_limit supported supported partial: HAProxy's own stick table and http_req_rate: requests are counted over the last period, refused ones too, so a client that keeps sending stays refused, and a request over the limit, a gRPC call too, gets HAProxy's own 429
routes[].rpc.rate_limit.requests supported supported supported
routes[].rpc.rate_limit.per supported partial: a rate a minute is kept in thousandths of a request a second, rounded down, so 1 a minute refills every 62.5 s where the Envoy output refills every 60 s (nginx refused at 62.1 s and admitted at 63.3 s); refuses giving no whole number of requests a second or a minute: nginx's rate is a whole number of requests a second or a minute; write requests and per so that one of them is whole partial: the period of HAProxy's own http_req_rate, at most 2147483647 ms; refuses a time above 2147483647 ms: HAProxy's timers hold at most 2147483647 ms; write a shorter period, or render it for envoy
routes[].rpc.rate_limit.burst supported supported partial: written as 0 alone, as HAProxy's own http_req_rate admits the requests of each period and no burst above them; refuses above 0: HAProxy's rate counts the requests of a period and has no burst; write burst: 0 or leave it out, or render it for envoy
routes[].rpc.rate_limit.by supported partial: each limited route remembers about 120,000 clients in up to 16 MiB of shared memory, where the Envoy output remembers 65,536, so a client is forgotten later partial: an IPv4 client is counted by its address and an IPv6 client by its /64 network, HAProxy's own ipmask(32,64), so the addresses of one IPv6 network share a count
routes[].rpc.to supported supported supported
routes[].rpc.to.<package pattern> supported supported supported
routes[].rpc.to.<package pattern>.service supported supported supported
routes[].rpc.to.<package pattern>.name supported supported supported
routes[].name supported supported supported
routes[].prefix supported partial: any character but %, one Envoy escapes before it picks a route (" < > ^ ` { | }) and one outside ASCII; refuses holding %, a character Envoy escapes before it picks a route (" < > ^ ` { | }) or one outside ASCII: nginx matches a path holding a character Envoy escapes as it decodes it, where Envoy matches the escape, so a prefix or a path with % or such a character would take other requests on nginx than on Envoy; write it without them, as a pattern, or render it for envoy supported
routes[].path supported partial: any character but %, one Envoy escapes before it picks a route (" < > ^ ` { | }) and one outside ASCII; refuses holding %, a character Envoy escapes before it picks a route (" < > ^ ` { | }) or one outside ASCII: nginx matches a path holding a character Envoy escapes as it decodes it, where Envoy matches the escape, so a prefix or a path with % or such a character would take other requests on nginx than on Envoy; write it without them, as a pattern, or render it for envoy supported
routes[].pattern supported partial: matched on the path as the client wrote it, or on the one nginx has normalised when it holds //, a dot segment, an escaped unreserved character or %2F, as Envoy matches it; in a file with a pattern route, a path holding a character Envoy escapes before it matches (" < > ^ ` { | } or one outside ASCII) is answered 400, where Envoy matches the escape; a path PCRE2 gives up on past the 100,000 steps the generator gives each pattern, as it does for (a+)+ and a run of 20 a with another character after it, is answered 400, where Envoy's RE2 always decides whether the pattern takes it partial: a request whose pattern routes take more than proxyfile.lua's budget of work, about 24 ms of CPU for one request alone and 33 ms for each of many at once, such as a path of 14,000 bytes that 80 pattern routes read to its end, is answered 400, where Envoy's RE2 always decides, in under 1 ms of CPU; the states the patterns build take up to about 1 MB on each HAProxy thread, and a flood of new paths grew HAProxy by about 48 MB with 12 threads, where it grew Envoy by about 76 MB; a pattern whose program is longer than 65,536 bytes is refused, where Envoy refuses an RE2 program of more than 100 instructions
routes[].method supported supported supported
routes[].to supported supported supported
routes[].rewrite supported partial: letters, digits and - . _ ~ / ! $ & ' ( ) * + , ; = : @ [ ] alone; a request whose path keeps an escape Envoy does not decode, such as %3B or %20, or whose target ends in an empty query, a ? with nothing after it, is answered 400 on a route with a rewrite, where Envoy sends the rewritten path on; refuses holding ?: nginx reads a ? in a rewrite as the start of new arguments, after which it adds the client's; write the path without ?; refuses holding a character nginx escapes again: nginx escapes the new path before it sends it, so the service would receive that character escaped, where the Envoy output sends it as written; write the rewrite without it, or render it for envoy supported
routes[].auth supported supported supported
routes[].retries supported partial: a request is tried again only when its last try sent the service nothing, at once and with no limit on retries at the same time, which the less strict list names, on the next backend in the service's order rather than one the balance or the hash picks, at most as many times as the service has other backends and never more than 6; a service with one backend is not tried again, where the Envoy output tries the same backend; a service found by a DNS name is tried again on the same name, where nginx may pick the backend that failed; a request is tried again only when it has no Transfer-Encoding and a Content-Length of at most 1 MiB, when it has neither header over HTTP/1.x, which gives it no body, or when it is a GET, HEAD, OPTIONS or DELETE over HTTP/2 with no content-length, and nginx reads its body into memory before the first try, so the service gets it only once all of it arrived, and with a slow client a request whose tries fail ends up to the upload's time later than through the Envoy output, which tries while the body arrives, and can be answered 504 where the Envoy output answers 502 or serves it; such a GET, HEAD, OPTIONS or DELETE over HTTP/2 with more than 1 MiB of body is answered 413, where the Envoy output serves it; any other request, a body longer than 1 MiB, a body sent in chunks whatever its method, or one of another method over HTTP/2 with no content-length, a gRPC call's among them, is sent as it arrives and never tried again, and a first try of it that fails is answered as on a route with no retries, where the Envoy output tries again a body of unknown length under its bound of 1 MiB, holds up to 16 MiB over HTTP/2, and answers 507 to a client that sent a longer body quickly and serves one still sending; a request nginx wrote on a kept-alive connection the service had closed is not tried again, where the Envoy output tries it again on another backend partial: HAProxy's own retries: a request whose connection failed is tried again, at once on another address of a service that balances round robin or by least_requests, on the address its hash picks again for a hashed service, and on the same address after a pause of up to 1 s for a service of one address; refuses above 100: HAProxy's set-retries takes 0 to 100; write 100 or less
routes[].rate_limit supported supported partial: HAProxy's own stick table and http_req_rate: requests are counted over the last period, refused ones too, so a client that keeps sending stays refused, and a request over the limit, a gRPC call too, gets HAProxy's own 429
routes[].rate_limit.requests supported supported supported
routes[].rate_limit.per supported partial: a rate a minute is kept in thousandths of a request a second, rounded down, so 1 a minute refills every 62.5 s where the Envoy output refills every 60 s (nginx refused at 62.1 s and admitted at 63.3 s); refuses giving no whole number of requests a second or a minute: nginx's rate is a whole number of requests a second or a minute; write requests and per so that one of them is whole partial: the period of HAProxy's own http_req_rate, at most 2147483647 ms; refuses a time above 2147483647 ms: HAProxy's timers hold at most 2147483647 ms; write a shorter period, or render it for envoy
routes[].rate_limit.burst supported supported partial: written as 0 alone, as HAProxy's own http_req_rate admits the requests of each period and no burst above them; refuses above 0: HAProxy's rate counts the requests of a period and has no burst; write burst: 0 or leave it out, or render it for envoy
routes[].rate_limit.by supported partial: each limited route remembers about 120,000 clients in up to 16 MiB of shared memory, where the Envoy output remembers 65,536, so a client is forgotten later partial: an IPv4 client is counted by its address and an IPv6 client by its /64 network, HAProxy's own ipmask(32,64), so the addresses of one IPv6 network share a count
rpc supported supported supported
rpc.methods supported supported supported
rpc.methods[].service supported supported supported
rpc.methods[].method supported supported supported
rpc.methods[].action supported supported supported
rpc.methods[].reports supported supported supported
rpc.proto supported supported supported
rpc.proto.roots supported supported supported
rpc.proto.option supported supported supported
log supported partial: the time is the moment nginx writes the line, in whole seconds with the offset of nginx's time zone (+00:00 in UTC), where the Envoy output writes the request's start in milliseconds with Z; over HTTP/1.1 bytes_out counts the chunk lines of an answer nginx sends chunked, where the Envoy output counts its body alone; an answer whose status has one, two or four digits, or that has no status line, logs the status 9, where the Envoy output logs the four digits or 502; a status that starts with 0 logs its number without the zeros (050 as 50), one with spaces between its digits the digits joined (2 0 0 as 200) and one with a fraction its whole number (403.1 as 403), each written only when that number is status_from or above or sample takes the request, where the Envoy output writes 502 whatever status_from says; bytes_in counts the whole request, not its body; upstream_ms counts from the opening of the service connection of the try that answered, not from the request's start; authz_us counts the check's time in whole milliseconds, 0, 1000, 2000 and so on, where the Envoy output counts microseconds; there are no flags and details fields; a request of a retried route that is not tried again because of its body, longer than 1 MiB or of a length nginx does not know, writes the upstream-failure flag UF after its one try failed, where the Envoy output, which tries it again, writes URX,UF; a value the Envoy output writes null is written empty, but upstream_ms; a request the origin or upgrade check refuses logs route and upstream empty, where the Envoy output names them; a request refused for a dot segment with a ; parameter logs route empty on each of its lines, where the Envoy output names the route that refuses it, refused:dot-segment-with-parameter; a request Envoy refuses as it reads it logs its host, method, request id and protocol, which Envoy writes null and HTTP/1.1; a request id or Host holding a byte above 0x7F is logged empty; less strict than the Envoy output: a chunked answer its service cuts short writes no upstream-failure line partial: HAProxy's own log-format on standard output, one line a request of HAProxy's own fields: the date, the frontend, the backend and server, the timers, the status, the bytes each way, the termination state, the method, the HTTP version and the request id, quoted, where the Envoy output writes a JSON line of its own fields; a request below status_from is logged by its sample alone, where the Envoy output also logs each one with a response flag
log.status_from supported supported supported
log.sample supported partial: the share is drawn by a hash of the request id, not by its first eight hex digits partial: drawn for each request with HAProxy's own rand, where the Envoy output chooses by the request id
tracing supported partial: needs ngx_otel_module, in the nginx images tagged -otel, where the plain images stop at load_module; refuses without path_in_url: true: nginx's tracer always puts the request's path and query in the span, which path_in_url: false keeps out; write path_in_url: true, or render it for envoy; refuses beside a remove_from_clients, auth.accept or auth.send that names traceparent or tracestate: nginx writes both headers from the trace for the service and the check; leave the name out, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider supported supported refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray.agent supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray.segment supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray.sample supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray.sample.first supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray.sample.rate supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray.sample.rules supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray.sample.rules[].host supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray.sample.rules[].method supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray.sample.rules[].path supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray.sample.rules[].first supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.xray.sample.rules[].rate supported refused: nginx has no X-Ray tracer; write the otel provider and send its spans to an OpenTelemetry Collector with the AWS X-Ray exporter, or render it for envoy refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.otel supported partial: spans carry the Envoy output's attribute names with nginx's own beside them, http.route holding the name of the location nginx generated; http.status_code is a number, response_flags, error and the gRPC attributes are not set, and an attribute with no value, such as upstream_cluster on a request no route takes, is sent empty, where Envoy sets none; over HTTP/2 http.url holds the connection's scheme, where Envoy writes the client's :scheme when it is http or https; a span's tracestate holds the client's first tracestate line, where Envoy's holds the lines joined; a traceparent of another version than 00, or one whose line or first tracestate line has a tab at either end over HTTP/1.1, reaches the service and the check with the client's version, trace id and parent id and the sampled flag the Envoy output sends, and no span is written, where Envoy continues the trace with version 00, a parent id and a span of its own; a request whose User-Agent has a tab at either end over HTTP/1.1, which nginx's own http.user_agent would hold, gets no span and is sent on not sampled, where Envoy traces it; a gRPC call whose malformed traceparent comes with a second traceparent or tracestate line is answered 400 and reaches no service, where Envoy passes each line on as a field of its own; the auth check gets the trace, with the request's span as its parent, but no span of its own, where Envoy writes a span for the check; a preflight and a request refused for its origin get a span named ingress with upstream_cluster empty, where the Envoy output names the span after the route and sets its service; and no empty tracestate line is sent to the service or the check, where Envoy adds one beside each traceparent of its own when no tracestate goes on, nor a traceparent or tracestate sent as one empty line, which Envoy passes on beside a malformed traceparent refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.otel.endpoint supported partial: an IP address, or a DNS name with dns.resolver, which nginx follows through a relay of its own, a name giving at most about 1,000 addresses, as a service's does; the admin port's /stats counts each call of the tracer through the relay as a request; the relay listens on a socket file, /run/proxyfile-<listen>/collector.sock, which nginx removes when it stops and a kill leaves, and nginx then does not start, its bind() to the file failing (98: Address already in use), until the file is removed or /run is a tmpfs; refuses a DNS name with no dns.resolver: nginx looks a name up only through the name server it is given; write dns.resolver, or write the collector's IP address refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.otel.service supported supported refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.otel.sample supported supported refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.provider.otel.sample.rate supported supported refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.tags supported supported refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.tags.<tag name> supported supported refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.tags.<tag name>.env supported partial: a variable set to an empty value, or unset with no default, gives the span an empty tag, where Envoy sets none, except a tag named like a field of the Envoy output's span, such as component, which keeps the field's value, as through Envoy; a variable named like a property every object has, such as constructor or toString, is read as unset, where Envoy reads it refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.tags.<tag name>.header supported partial: a header absent with no default, or sent empty, gives the span an empty tag, where Envoy sets none, except a tag named like a field of the Envoy output's span, such as component, which keeps the field's value, as through Envoy; refuses naming a header nginx writes itself: nginx rewrites each of host, origin, te, connection, upgrade, http2-settings, content-length, transfer-encoding, keep-alive, x-envoy-auth-failure-mode-allowed, x-envoy-external-address, traceparent and tracestate for the service, and its value in a span was not compared with the Envoy output's; tag another header; refuses naming referer: the Envoy output removes a Referer it does not accept before its tags read the request, where nginx's tag would read the client's line; tag another header; refuses naming expect: the Envoy output answers an Expect itself and removes it before its tags read the request, where nginx's tag would read the client's line; tag another header refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.tags.<tag name>.default supported supported refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
tracing.path_in_url supported partial: true only; a span is written only for a request whose target nginx sends on as the client wrote it, at most 256 bytes, on a route with no rewrite and, under client_address forwarded, with no x-envoy-original-path, and any other is sent on not sampled with no span, where Envoy writes the path it normalised, escaped or rewrote, cut to 256 characters, or a client's x-envoy-original-path refused: the official HAProxy images have no tracing filter (the OpenTelemetry filter is an addon built from source); remove tracing, or render it for envoy
the request's path normalised before a route is picked supported partial: a path that holds //, a dot segment, an escaped unreserved character or %2F and also an escape Envoy keeps, such as %3B, is answered 400, and so is one that holds such an escape beside a character Envoy escapes before it matches (" < > ^ ` { | } or one outside ASCII), where Envoy normalises the path and keeps the escape; an empty query, a ? with nothing after it, after a path that needs normalising or holds such a character is answered 400, where Envoy sends the ? on; a backslash, %5C and a control character, written or escaped, are answered 400, and so is an invalid escape such as %zz, which Envoy passes on; a path with an empty segment before a dot-dot segment, / and . written or escaped, such as /catalog//../products/1, is answered 400, where Envoy resolves the dot-dot segment before it merges the slashes and routes /catalog/products/1 partial: an escape of an unreserved character in the query, such as ?q=%41 or ?q=%7e, reaches the service and the check decoded, as ?q=A and ?q=~, with or without a dot segment in the path, where Envoy passes the query as the client wrote it; an escape of a reserved character, such as %2F, %26 or %3d, reaches both as written, as through Envoy
a dot segment with a ; parameter answered 400 supported partial: /a/..;/b is answered 400 where Envoy 1.40 resolves it, and nginx closes the connection after it, as after every 400 it answers for a path before a route; so is a CORS preflight through such a segment, where Envoy answers it as the preflight of the path it resolves partial: a dot segment whose ; parameter is written with dots, such as /a/..;/b, is answered 400, and a gRPC call 200 with grpc-status 13, where Envoy 1.40 drops the parameter and resolves the segment; with the auth check, such a request is asked about whatever route its resolved path takes, and gets the check's denial or, once the check lets it through, 400, where Envoy asks only when that route is checked and, with send_request, sends the check the resolved path; after the 400 of such a segment with the ; written %3B, which both answer, HAProxy keeps the connection open, where Envoy closes it
the request line and header names read before a route is picked supported partial: a tab between the method and the target, an absolute target with user information, with no Host header or with a query or a fragment right after its host, and OPTIONS * are answered 400 and the connection closed, TRACE and CONNECT 405, and a request line with no version, HTTP/0.9's form, gets the text Bad Request alone, with no status line, where Envoy serves the first two and TRACE, answers OPTIONS *, CONNECT and that absolute target 404, and that request line 426; HTTP/0.0 to HTTP/0.9 with headers are answered 400 and HTTP/2.0 to HTTP/9.9 on an HTTP/1 connection 505, where Envoy answers 426; a request nginx's own parser refuses before any rule of the file runs, such as one with a control byte in the target, a space in a header name or no Host line, is answered 400 with nginx's HTML page as text/html, where the Envoy output's 400 carries the body Bad Request as text/plain, or no body for a request with no Host line; the 426 nginx answers carries no reason phrase on its status line, HTTP/1.1 426 alone, where the Envoy output's reads 426 Upgrade Required; a header name outside RFC 9110's token characters, or a header value holding a control byte other than a tab, is answered 400 over HTTP/1.1 and HTTP/2, where Envoy answers 400 over HTTP/1.1 and closes the connection over HTTP/2; over HTTP/2 any request trailer ends the connection, where Envoy serves the request; a header line folded onto the next and a Host whose port is past 65535 or holds a sign are answered 400, where Envoy serves them; a request holding a header name with _ that nginx reads as one of its own headers, or a second X-Forwarded-For, X-Forwarded-Proto, X-Request-Id, Content-Type, User-Agent or Referer line, is refused with 400, where Envoy reads the name as another header and joins the lines with a comma; a Connection header that names a header other than close, keep-alive, upgrade, http2-settings and te is answered 400, where Envoy removes the header it names and serves the request; a second line of authorization, if-modified-since, if-unmodified-since, if-match, if-none-match or if-range is answered 400, where Envoy joins the lines with a comma and serves the request; the lines of accept, via and accept-encoding, each a list, reach the service as separate lines, where Envoy joins them with a comma into one line, the same message written as separate lines; two Host lines are answered 400, where Envoy answers 404; over HTTP/2 a host field that differs from :authority, and an empty :authority or host field, is answered 400 with nginx's own page, where Envoy routes by :authority and closes the connection with no answer to an empty one; over HTTP/1.1 a header block still arriving after 5 minutes is ended with no answer, where Envoy answers 408 then and closes the connection a second later, and a connection that sends nothing to a listener without tls is closed after 5 minutes, where Envoy keeps it for an hour; a client that closes its side of the connection right after its request gets nginx's answer when nginx refuses the request itself, an Origin on none of the hosts, a target holding a fragment, a dot segment with a ; parameter or HTTP/1.0, where Envoy closes the connection with no answer; without limits.request_headers nginx holds the Envoy output's 60 KiB and 100 header fields, with the differences the rows of its keys name; less strict than the Envoy output: a request trailer whose name is outside the token characters or whose value holds a control byte is served over HTTP/1.1; a header line with no colon reaches the service as a header with an empty value; a request with no body reaches the service without content-length: 0; a Referer the Envoy output removes reaches the service; over HTTP/1.1, a tab before or after a header value reaches the service; a WebSocket upgrade a service answers without switching passes the service's body; a service's answer with a malformed header line or a malformed status line reaches the client; over HTTP/2, empty frames in a row are served partial: over HTTP/1.1 an absolute target is answered 400, where Envoy routes it by its host and sends the path alone with that host as Host, or answers 404 when no environment has the host, and OPTIONS * and CONNECT are answered 400, where Envoy answers 404; a request line with no version, HTTP/0.9's form, is answered 400, where Envoy answers 426; after its 426 to HTTP/1.0 asking for keep-alive or to HTTP/1.2 to HTTP/1.9, and after its 403 to an upgrade other than WebSocket, from any origin, HAProxy keeps the connection and serves the next request on it, where Envoy closes it; a Connection token other than close, keep-alive, upgrade, HTTP2-Settings and te is answered 400, where Envoy removes the header the token names and serves the request; ten Connection elements or more, an empty one counted but for an empty last one, are answered 400, where Envoy counts no empty element and serves a token with ten; an h2c upgrade is answered 400, where Envoy serves it as a plain request; a header line folded onto the next, and a header value that holds three spaces or tabs in a row, are answered 400, where Envoy serves them; over HTTP/2 a cookie field that starts with two spaces or tabs, as one of spaces alone does, or ends with three is answered 400 too, where Envoy serves it, as HAProxy keeps the spaces around a cookie field's value and drops them around any other field's; a WebSocket upgrade with no Sec-WebSocket-Key is answered 400, where Envoy passes it on, or answers 403 to an origin it does not admit; more than 100 header lines are answered 431 or, from 102, 400, where Envoy answers 431, and 101 lines or more of a header Envoy joins into one line are answered 400, where Envoy serves them; two Host lines of different hosts, and a Host that holds a comma, are answered 400, where Envoy answers 404; Transfer-Encoding: chunked on two lines is answered 400, and Transfer-Encoding: gzip, chunked 422, where Envoy answers 501; a request line and header lines of more than 15,277 bytes together, counted as sent with their line ends, Host alone beside the line and 4 bytes fewer for each further header line (3.4.7: 8 bytes more), are answered 431, and a request line of 16,319 bytes or more (3.4.7: 16,327) 414, where Envoy serves both up to its default limit of 60 KiB; over HTTP/2 a request with 97 header fields or more is answered 400, where Envoy resets its stream, and so is one with fewer whose cookies, counted one a field, reach 97, and one with 97 fields or more of a header Envoy joins, which Envoy serves, is answered 400 or, with 120, its stream reset; a WebSocket, an extended CONNECT, is answered 400, where Envoy closes the connection; a path whose escaped form outgrows HAProxy's buffer, such as one of 7000 bytes above 0x7F, is answered 400 by HAProxy 3.4.7 and 500 by 3.2.26, where Envoy serves it; a header or trailer name outside RFC 9110's token characters resets the stream, where Envoy closes the connection; a # in :path resets the stream, where Envoy answers 400; and a request with neither :authority nor host is answered 404, where Envoy closes the connection; over HTTP/1.1 a request trailer whose name is outside those characters ends the connection with no answer when the body comes after the headers, where Envoy answers 400; over HTTP/2 a QUERY whose content-type field is spaces alone is answered 400, where Envoy serves it: HAProxy reads an HTTP/2 value of spaces alone as empty, and Envoy answers 400 to a QUERY with no Content-Type or an empty one; less strict than the Envoy output: an HTTP/2 :authority with a default or empty port reaches the service without it; ten Connection tokens close or keep-alive are served; a request with no body reaches the service without content-length: 0; two Host lines of one host are served; two Content-Length lines of one value are served; Content-Length beside Transfer-Encoding: chunked is served; over HTTP/2, two host fields and no :authority are served; a WebSocket upgrade a service answers without switching passes the service's body; a trailer value holding a control byte is served

Written with no key

Each of these is part of every configuration the Envoy generator writes, with no key for it. Defaults says what each does. Path normalisation, the refusal of a dot segment with a ; parameter and the reading of the request line and header names are core. All three are rows of the table above too, where every generator declares how it writes them. The nginx and HAProxy columns say what each of their generators writes for them:

What Envoy nginx HAProxy Class
The request's path normalised before a route is picked normalize_path: true, merge_slashes: true and path_with_escaped_slashes_action: UNESCAPE_AND_FORWARD: dot segments resolved, repeated slashes merged, %2F read as / maps read the path as the client wrote it: with nothing to normalise, or only an escape Envoy keeps (such as %3B), routes are matched on it and the request is sent on as written; with //, a dot segment, an escaped unreserved character or %2F and no kept escape, on nginx's normalised URI, $uri, which is sent; a path that needs both, or holds a character Envoy escapes before it matches beside a kept escape or in a file with a pattern route, is answered 400, and so is an empty query, a ? with nothing after it, after a path matched on $uri, and a path with an empty segment before a dot-dot segment (/a//../b), which Envoy resolves before it merges the slashes proxyfile.lua, the script beside the file, escapes a raw ", <, >, ^, a backquote, {, a vertical bar, } and every byte above 0x7F in upper case hex, as Envoy does, then regsub rules read %2F, %5C and a backslash as / (set-path), then http-request normalize-uri with percent-decode-unreserved, path-strip-dot, path-strip-dotdot full and path-merge-slashes, which its manual calls an experimental technical preview that needs expose-experimental-directives: dot segments resolved and then repeated slashes merged as by Envoy, every escape not decoded kept as written, an invalid one such as %zz too, and %00 answered 400, measured on HAProxy 3.2.26 and 3.4.7; the script matches a pattern route with the program Go's regexp/syntax compiles the pattern to, as an automaton built while it reads the path, and answers 400 to a request whose patterns pass the budget HAProxy's page gives, where RE2 always decides core; nginx differs as its column says
A path that still holds a dot segment with a ; parameter after normalisation answered 400, the ; written or escaped once (%3B, %3b) the first route of every virtual host, refused:dot-segment-with-parameter: safe_regex .*/\.\.?(?:;|%3[Bb]).* with direct_response 400 a map on the decoded path, $uri, sets a flag for /..; and /.;, where an escaped ; is decoded already, and the server answers the flag 400 before any route and closes the connection after it, as Envoy does; with auth.ask the flag leads to a location that asks the check first, and answers 400 once the check lets the request through acl dot_segment path_reg '/\.\.?(;|%3[Bb])' and http-request return status 400 if dot_segment after the route rules, the 404 of a request no route takes, the upgrade and the origin check, as Envoy orders its answers, and before every replace-path, on the path HAProxy has normalised, where an escaped dot is decoded already; /..;/, which path-strip-dotdot keeps, is answered 400, where Envoy resolves it core
The request line and the header names read before a route is picked no setting: Envoy's own codecs take an absolute target's host as the request's authority and answer a header name outside RFC 9110's token characters 400 over HTTP/1.1, closing the connection over HTTP/2 a map on $request takes an absolute target's host, after one or more spaces, as the authority, and an empty one is answered 400; the njs script proxyfile.js, written beside the configuration, reads each header name as the client sent it, and a name outside the token characters is answered 400 http-request rules before any other answer what Envoy refuses and HAProxy's own parsers pass: HTTP/1.0 with 426, and with 400 a method Envoy's HTTP/1 parser does not know, an absolute target, a Connection token other than close, keep-alive, upgrade, HTTP2-Settings and te, ten Connection elements, an h2c upgrade, a WebSocket over HTTP/2, a folded header line and an HTTP/2 request past Envoy's 100 header fields; HAProxy's parsers answer a header name outside RFC 9110's token characters 400 over HTTP/1.1 and reset the stream over HTTP/2, measured on HAProxy 3.2.26 and 3.4.7; the differences that stay are HAProxy's row in the table above core

The rest belong to Envoy:

What In the Envoy configuration Class
The runtime switches gateway.ext_authz.enabled, gateway.request_log.min_status, gateway.request_log.sample, gateway.local_reply.origin_refused_status and, with a rate_limit, gateway.local_reply.rate_limited_status envoy
The retry conditions and the backend a retry goes to connect-failure,reset-before-request, and the previous_hosts predicate with host_selection_retry_max_attempts: 20 envoy
The local replies 502 with an empty body when a service cannot be reached, 403 with Invalid CORS request for a refused origin, with auth.ask, 403 for a check's 2xx other than 200, and, with a rate_limit, the Connect error resource_exhausted for a Connect call over a limit envoy
The Lua status fix the Lua filter that sets Connect's current status on the bridge's errors, with envoy.connect_bridge envoy
The auth check's mode ext_authz in HTTP mode envoy

The nginx and haproxy blocks

Each block holds the settings only its proxy reads beyond the core keys, and this version holds none. Written empty, it is accepted; a key written in it is refused with the nginx block takes no key in this version (or haproxy), so a file meant for a later version is never rendered as if the key were not there.

Key Meaning Rule Class
nginx The settings only nginx reads beyond the core keys; this version holds none, so the block takes no key. A mapping. nginx
Key Meaning Rule Class
haproxy The settings only HAProxy reads beyond the core keys; this version holds none, so the block takes no key. A mapping. haproxy