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 |