Security | Single Sign-on | Active Directory | HAProxy ALOHA 14.0

Note: the following caveats and limitations on using the “check_post”
extension with “

url_param

” must be considered :

– all POST requests are eligible for consideration, because there is no way
to determine if the parameters will be found in the body or entity which
may contain binary data. Therefore another method may be required to
restrict consideration of POST requests that have no URL parameters in
the body. (see acl http_end)

– using a value larger than the request buffer size does not
make sense and is useless. The buffer size is set at build time, and
defaults to 16 kB.

– Content-Encoding is not supported, the parameter search will probably
fail; and load balancing will fall back to Round Robin.

– Expect: 100-continue is not supported, load balancing will fall back to
Round Robin.

– Transfer-Encoding (RFC7230 3.3.1) is only supported in the first chunk.
If the entire parameter value is not present in the first chunk, the
selection of server is undefined (actually, defined by how little
actually appeared in the first chunk).

– This feature does not support generation of a 100, 411 or 501 response.

– In some cases, requesting “check_post” MAY attempt to scan the entire
contents of a message body. Scanning normally terminates when linear
white space or control characters are found, indicating the end of what
might be a URL parameter list. This is probably not a concern with SGML
type message bodies.

This keyword limits binding of certain instances to certain processes. This
is useful in order not to have too many processes listening to the same
ports. For instance, on a dual-core machine, it might make sense to set
‘nbproc 2’ in the global section, then distributes the listeners among ‘odd’
and ‘even’ instances.

At the moment, it is not possible to reference more than 32 or 64 processes
using this keyword, but this should be more than enough for most setups.
Please note that ‘all’ really means all processes regardless of the machine’s
word size, and is not limited to the first 32 or 64.

Each “

bind

” line may further be limited to a subset of the proxy’s processes,
please consult the “

process

” bind keyword in

section 5.1

.

When a frontend has no explicit “

bind-process

” line, it tries to bind to all
the processes referenced by its “

bind

” lines. That means that frontends can
easily adapt to their listeners’ processes.

If some backends are referenced by frontends bound to other processes, the
backend automatically inherits the frontend’s processes.

By default, requests are not dispatched to down servers. It is possible to
force this using “

option persist

“, but it is unconditional and redispatches
to a valid server if “

option redispatch

” is set. That leaves with very little
possibilities to force some requests to reach a server which is artificially
marked down for maintenance operations.

The “

force-persist

” statement allows one to declare various ACL-based
conditions which, when met, will cause a request to ignore the down status of
a server and still try to connect to it. That makes it possible to start a
server, still replying an error to the health checks, and run a specially
configured browser to test the service. Among the handy methods, one could
use a specific source IP address, or a specific cookie. The cookie also has
the advantage that it can easily be added/removed on the browser from a test
page. Once the service is validated, it is then possible to open the service
to the world by returning a valid response to health checks.

The forced persistence is enabled when an “if” condition is met, or unless an
“unless” condition is met. The final redispatch is always disabled when this
is used.

Specifying a “

hash-balance-factor

” for a server with “hash-type consistent”
enables an algorithm that prevents any one server from getting too many
requests at once, even if some hash buckets receive many more requests than
others. Setting to 0 (the default) disables the feature. Otherwise,
is a percentage greater than 100. For example, if is 150,
then no server will be allowed to have a load more than 1.5 times the average.
If server weights are used, they will be respected.

If the first-choice server is disqualified, the algorithm will choose another
server based on the request hash, until a server with additional capacity is
found. A higher allows more imbalance between the servers, while a
lower means that more servers will be checked on average, affecting
performance. Reasonable values are from 125 to 200.

This setting is also used by “balance random” which internally relies on the
consistent hashing mechanism.

By default, “

option httpchk

” considers that response statuses 2xx and 3xx
are valid, and that others are invalid. When “

http-check expect

” is used,
it defines what is considered valid or invalid. Only one “

http-check

”
statement is supported in a backend. If a server fails to respond or times
out, the check obviously fails. The available matches are :

status : test the status codes found parsing string. it
must be a comma-separated list of status codes or range
codes. A health check response will be considered as
valid if the response’s status code matches any status
code or is inside any range of the list. If the “

status

”
keyword is prefixed with “!”, then the response will be
considered invalid if the status code matches.

rstatus : test a regular expression for the HTTP status code.
A health check response will be considered valid if the
response’s status code matches the expression. If the
“rstatus” keyword is prefixed with “!”, then the response
will be considered invalid if the status code matches.
This is mostly used to check for multiple codes.

hdr { name | name-lf } [ -m ]
[ { value | value-lf } [ -m ] :
test the specified header pattern on the HTTP response
headers. The name pattern is mandatory but the value
pattern is optional. If not specified, only the header
presence is verified. is the matching method,
applied on the header name or the header value. Supported
matching methods are “

str

” (exact match), “beg” (prefix
match), “end” (suffix match), “

sub

” (substring match) or
“reg” (regex match). If not specified, exact matching
method is used. If the “name-lf” parameter is used,
is evaluated as a log-format string. If “value-lf”
parameter is used, is evaluated as a log-format
string. These parameters cannot be used with the regex
matching method. Finally, the header value is considered
as comma-separated list. Note that matchings are case
insensitive on the header names.

fhdr { name | name-lf } [ -m ]
[ { value | value-lf } [ -m ] :
test the specified full header pattern on the HTTP
response headers. It does exactly the same than “

hdr

”
keyword, except the full header value is tested, commas
are not considered as delimiters.

string : test the exact string match in the HTTP response body.
A health check response will be considered valid if the
response’s body contains this exact string. If the
“string” keyword is prefixed with “!”, then the response
will be considered invalid if the body contains this
string. This can be used to look for a mandatory word at
the end of a dynamic page, or to detect a failure when a
specific error appears on the check page (e.g. a stack
trace).

rstring : test a regular expression on the HTTP response body.
A health check response will be considered valid if the
response’s body matches this expression. If the “rstring”
keyword is prefixed with “!”, then the response will be
considered invalid if the body matches the expression.
This can be used to look for a mandatory word at the end
of a dynamic page, or to detect a failure when a specific
error appears on the check page (e.g. a stack trace).

string-lf : test a log-format string match in the HTTP response body.
A health check response will be considered valid if the
response’s body contains the string resulting of the
evaluation of , which follows the log-format rules.
If prefixed with “!”, then the response will be
considered invalid if the body contains the string.

It is important to note that the responses will be limited to a certain size
defined by the global “

tune.bufsize

” option, which defaults to 16384 bytes.
Thus, too large responses may not contain the mandatory pattern when using
“string” or “rstring”. If a large response is absolutely required, it is
possible to change the default max size by setting the global variable.
However, it is worth keeping in mind that parsing very large responses can
waste some CPU cycles, especially when regular expressions are used, and that
it is always better to focus the checks on smaller resources.

In an http-check ruleset, the last expect rule may be implicit. If no expect
rule is specified after the last “

http-check send

“, an implicit expect rule
is defined to match on 2xx or 3xx status codes. It means this rule is also
defined if there is no “

http-check

” rule at all, when only “

option httpchk

”
is set.

Last, if “

http-check expect

” is combined with “

http-check disable-on-404

“,
then this last one has precedence when the server responds with 404.

In addition to the request line defined by the “

option httpchk

” directive,
this one is the valid way to add some headers and optionally a body to the
request sent during HTTP health checks. If a body is defined, the associate
“Content-Length” header is automatically added. Thus, this header or
“Transfer-encoding” header should not be present in the request provided by
“

http-check send

“. If so, it will be ignored. The old trick consisting to add
headers after the version string on the “

option httpchk

” line is now
deprecated.

Also “

http-check send

” doesn’t support HTTP keep-alive. Keep in mind that it
will automatically append a “Connection: close” header, unless a Connection
header has already already been configured via a hdr entry.

Note that the Host header and the request authority, when both defined, are
automatically synchronized. It means when the HTTP request is sent, when a
Host is inserted in the request, the request authority is accordingly
updated. Thus, don’t be surprised if the Host header value overwrites the
configured request authority.

Note also for now, no Host header is automatically added in HTTP/1.1 or above
requests. You should add it explicitly.

When this option is set, HAProxy will systematically send a special header
“X-Haproxy-Server-State” with a list of parameters indicating to each server
how they are seen by HAProxy. This can be used for instance when a server is
manipulated without access to HAProxy and the operator needs to know whether
HAProxy still sees it up or not, or if the server is the last one in a farm.

The header is composed of fields delimited by semi-colons, the first of which
is a word (“UP”, “DOWN”, “NOLB”), possibly followed by a number of valid
checks on the total number before transition, just as appears in the stats
interface. Next headers are in the form “=”, indicating in
no specific order some values available in the stats interface :
– a variable “address”, containing the address of the backend server.
This corresponds to the

port

“, containing the port of the backend server. This
corresponds to the field in the server declaration. For unix
domain sockets, it will read “unix”.

– a variable “

name

“, containing the name of the backend followed by a slash
(“/”) then the name of the server. This can be used when a server is
checked in multiple backends.

– a variable “

node

” containing the name of the HAProxy node, as set in the
global “

node

” variable, otherwise the system’s hostname if unspecified.

– a variable “

weight

” indicating the weight of the server, a slash (“/”)
and the total weight of the farm (just counting usable servers). This
helps to know if other servers are available to handle the load when this
one fails.

– a variable “scur” indicating the current number of concurrent connections
on the server, followed by a slash (“/”) then the total number of
connections on all servers of the same backend.

– a variable “qcur” indicating the current number of requests in the
server’s queue.

Example of a header received by the application server :
>>> X-Haproxy-Server-State: UP 2/3; name=bck/srv2; node=lb1; weight=1/2;
scur=13/22; qcur=0

This directive may be used instead of “

errorfile

“, to define a custom error
message. As “

errorfile

” directive, it is used for errors detected and
returned by HAProxy. If an errorfile is defined, it is parsed when HAProxy
starts and must be valid according to the HTTP standards. The generated
response must not exceed the configured buffer size (BUFFSIZE), otherwise an
internal error will be returned. Finally, if you consider to use some
http-after-response rules to rewrite these errors, the reserved buffer space
should be available (see “

tune.maxrewrite

“).

The files are read at the same time as the configuration and kept in memory.
For this reason, the errors continue to be returned even when the process is
chrooted, and no file change is considered while the process is running.

Note: 400/408/500 errors emitted in early stage of the request parsing are
handled by the multiplexer at a lower level. No custom formatting is
supported at this level. Thus only static error messages, defined with
“

errorfile

” directive, are supported. However, this limitation only
exists during the request headers parsing or between two transactions.

This stops the evaluation of the rules and immediately returns a response. The
default status code used for the response is 200. It can be optionally
specified as an arguments to “

status

“. The response content-type may also be
specified as an argument to “content-type”. Finally the response itself may
be defined. It can be a full HTTP response specifying the errorfile to use,
or the response payload specifying the file or the string to use. These rules
are followed to create the response :

* If neither the errorfile nor the payload to use is defined, a dummy
response is returned. Only the “

status

” argument is considered. It can be
any code in the range [200, 599]. The “content-type” argument, if any, is
ignored.

* If “default-errorfiles” argument is set, the proxy’s errorfiles are
considered. If the “

status

” argument is defined, it must be one of the
status code handled by HAProxy (200, 400, 403, 404, 405, 408, 410, 413,
425, 429, 500, 501, 502, 503, and 504). The “content-type” argument, if
any, is ignored.

* If a specific errorfile is defined, with an “

errorfile

” argument, the
corresponding file, containing a full HTTP response, is returned. Only the
“

status

” argument is considered. It must be one of the status code handled
by HAProxy (200, 400, 403, 404, 405, 408, 410, 413, 425, 429, 500, 501,
502, 503, and 504). The “content-type” argument, if any, is ignored.

* If an http-errors section is defined, with an “

errorfiles

” argument, the
corresponding file in the specified http-errors section, containing a full
HTTP response, is returned. Only the “

status

” argument is considered. It
must be one of the status code handled by HAProxy (200, 400, 403, 404, 405,
408, 410, 413, 425, 429, 500, 501, 502, 503, and 504). The “content-type”
argument, if any, is ignored.

* If a “file” or a “lf-file” argument is specified, the file’s content is
used as the response payload. If the file is not empty, its content-type
must be set as argument to “content-type”. Otherwise, any “content-type”
argument is ignored. With a “lf-file” argument, the file’s content is
evaluated as a log-format string. With a “file” argument, it is considered
as a raw content.

* If a “string” or “lf-string” argument is specified, the defined string is
used as the response payload. The content-type must always be set as
argument to “content-type”. With a “lf-string” argument, the string is
evaluated as a log-format string. With a “string” argument, it is
considered as a raw string.

When the response is not based on an errorfile, it is possible to append HTTP
header fields to the response using “

hdr

” arguments. Otherwise, all “

hdr

”
arguments are ignored. For each one, the header name is specified in
and its value is defined by which follows the log-format rules.

Note that the generated response must be smaller than a buffer. And to avoid
any warning, when an errorfile or a raw file is loaded, the buffer space
reserved for the headers rewriting should also be free.

No further “

http-request

” rules are evaluated.

This stops the evaluation of the rules and immediately returns a response. The
default status code used for the response is 200. It can be optionally
specified as an arguments to “

status

“. The response content-type may also be
specified as an argument to “content-type”. Finally the response itself may
be defined. If can be a full HTTP response specifying the errorfile to use,
or the response payload specifying the file or the string to use. These rules
are followed to create the response :

* If neither the errorfile nor the payload to use is defined, a dummy
response is returned. Only the “

status

” argument is considered. It can be
any code in the range [200, 599]. The “content-type” argument, if any, is
ignored.

* If “default-errorfiles” argument is set, the proxy’s errorfiles are
considered. If the “

status

” argument is defined, it must be one of the
status code handled by HAProxy (200, 400, 403, 404, 405, 408, 410, 413,
425, 429, 500, 501, 502, 503, and 504). The “content-type” argument, if
any, is ignored.

* If a specific errorfile is defined, with an “

errorfile

” argument, the
corresponding file, containing a full HTTP response, is returned. Only the
“

status

” argument is considered. It must be one of the status code handled
by HAProxy (200, 400, 403, 404, 405, 408, 410, 413, 425, 429, 500, 501,
502, 503, and 504). The “content-type” argument, if any, is ignored.

* If an http-errors section is defined, with an “

errorfiles

” argument, the
corresponding file in the specified http-errors section, containing a full
HTTP response, is returned. Only the “

status

” argument is considered. It
must be one of the status code handled by HAProxy (200, 400, 403, 404, 405,
408, 410, 413, 425, 429, 500, 501, 502, 503, and 504). The “content-type”
argument, if any, is ignored.

* If a “file” or a “lf-file” argument is specified, the file’s content is
used as the response payload. If the file is not empty, its content-type
must be set as argument to “content-type”. Otherwise, any “content-type”
argument is ignored. With a “lf-file” argument, the file’s content is
evaluated as a log-format string. With a “file” argument, it is considered
as a raw content.

* If a “string” or “lf-string” argument is specified, the defined string is
used as the response payload. The content-type must always be set as
argument to “content-type”. With a “lf-string” argument, the string is
evaluated as a log-format string. With a “string” argument, it is
considered as a raw string.

When the response is not based an errorfile, it is possible to appends HTTP
header fields to the response using “

hdr

” arguments. Otherwise, all “

hdr

”
arguments are ignored. For each one, the header name is specified in
and its value is defined by which follows the log-format rules.

Note that the generated response must be smaller than a buffer. And to avoid
any warning, when an errorfile or a raw file is loaded, the buffer space
reserved to the headers rewriting should also be free.

No further “

http-response

” rules are evaluated.

By default, a connection established between HAProxy and the backend server
which is considered safe for reuse is moved back to the server’s idle
connections pool so that any other request can make use of it. This is the
“safe” strategy below.

The argument indicates the desired connection reuse strategy :

– “never” : idle connections are never shared between sessions. This mode
may be enforced to cancel a different strategy inherited from
a defaults section or for troubleshooting. For example, if an
old bogus application considers that multiple requests over
the same connection come from the same client and it is not
possible to fix the application, it may be desirable to
disable connection sharing in a single backend. An example of
such an application could be an old HAProxy using cookie
insertion in tunnel mode and not checking any request past the
first one.

– “safe” : this is the default and the recommended strategy. The first
request of a session is always sent over its own connection,
and only subsequent requests may be dispatched over other
existing connections. This ensures that in case the server
closes the connection when the request is being sent, the
browser can decide to silently retry it. Since it is exactly
equivalent to regular keep-alive, there should be no side
effects. There is also a special handling for the connections
using protocols subject to Head-of-line blocking (backend with
h2 or fcgi). In this case, when at least one stream is
processed, the used connection is reserved to handle streams
of the same session. When no more streams are processed, the
connection is released and can be reused.

– “aggressive” : this mode may be useful in webservices environments where
all servers are not necessarily known and where it would be
appreciable to deliver most first requests over existing
connections. In this case, first requests are only delivered
over existing connections that have been reused at least once,
proving that the server correctly supports connection reuse.
It should only be used when it’s sure that the client can
retry a failed request once in a while and where the benefit
of aggressive connection reuse significantly outweighs the
downsides of rare connection failures.

– “always” : this mode is only recommended when the path to the server is
known for never breaking existing connections quickly after
releasing them. It allows the first request of a session to be
sent to an existing connection. This can provide a significant
performance increase over the “safe” strategy when the backend
is a cache farm, since such components tend to show a
consistent behavior and will benefit from the connection
sharing. It is recommended that the “

http-keep-alive

” timeout
remains low in this mode so that no dead connections remain
usable. In most cases, this will lead to the same performance
gains as “aggressive” but with more risks. It should only be
used when it improves the situation over “aggressive”.

When http connection sharing is enabled, a great care is taken to respect the
connection properties and compatibility. Indeed, some properties are specific
and it is not possibly to reuse it blindly. Those are the SSL SNI, source
and destination address and proxy protocol block. A connection is reused only
if it shares the same set of properties with the request.

Also note that connections with certain bogus authentication schemes (relying
on the connection) like NTLM are marked private and never shared.

A connection pool is involved and configurable with “

pool-max-conn

“.

Note: connection reuse improves the accuracy of the “server maxconn” setting,
because almost no new connection will be established while idle connections
remain available. This is particularly true with the “always” strategy.

If the system supports it, it can be useful on big sites to raise this limit
very high so that HAProxy manages connection queues, instead of leaving the
clients with unanswered connection attempts. This value should not exceed the
global maxconn. Also, keep in mind that a connection contains two buffers
of tune.bufsize (16kB by default) each, as well as some other data resulting
in about 33 kB of RAM being consumed per established connection. That means
that a medium system equipped with 1GB of RAM can withstand around
20000-25000 concurrent connections if properly tuned.

Also, when is set to large values, it is possible that the servers
are not sized to accept such loads, and for this reason it is generally wise
to assign them some reasonable connection limits.

When this value is set to zero, which is the default, the global “

maxconn

”
value is used.

When an HTTP request referencing will be received on a frontend,
HAProxy will not forward it nor log it, but instead will return either
“HTTP/1.0 200 OK” or “HTTP/1.0 503 Service unavailable”, depending on failure
conditions defined with “

monitor fail

“. This is normally enough for any
front-end HTTP probe to detect that the service is UP and running without
forwarding the request to a backend server. Note that the HTTP method, the
version and all headers are ignored, but the request must at least be valid
at the HTTP level. This keyword may only be used with an HTTP-mode frontend.

Monitor requests are processed very early, just after the request is parsed
and even before any “

http-request

“. The only rulesets applied before are the
tcp-request ones. They cannot be logged either, and it is the intended
purpose. They are only used to report HAProxy’s health to an upper component,
nothing more. However, it is possible to add any number of conditions using
“

monitor fail

” and ACLs so that the result can be adjusted to whatever check
can be imagined (most often the number of available servers in a backend).

Note: if starts by a slash (‘/’), the matching is performed against the
request’s path instead of the request’s uri. It is a workaround to let
the HTTP/2 requests match the monitor-uri. Indeed, in HTTP/2, clients
are encouraged to send absolute URIs only.

In presence of very high loads, the servers will take some time to respond.
The per-instance connection queue will inflate, and the response time will
increase respective to the size of the queue times the average per-session
response time. When clients will wait for more than a few seconds, they will
often hit the “STOP” button on their browser, leaving a useless request in
the queue, and slowing down other users, and the servers as well, because the
request will eventually be served, then aborted at the first error
encountered while delivering the response.

As there is no way to distinguish between a full STOP and a simple output
close on the client side, HTTP agents should be conservative and consider
that the client might only have closed its output channel while waiting for
the response. However, this introduces risks of congestion when lots of users
do the same, and is completely useless nowadays because probably no client at
all will close the session while waiting for the response. Some HTTP agents
support this behavior (Squid, Apache, HAProxy), and others do not (TUX, most
hardware-based load balancers). So the probability for a closed input channel
to represent a user hitting the “STOP” button is close to 100%, and the risk
of being the single component to break rare but valid traffic is extremely
low, which adds to the temptation to be able to abort a session early while
still not served and not pollute the servers.

In HAProxy, the user can choose the desired behavior using the option
“

abortonclose

“. By default (without the option) the behavior is HTTP
compliant and aborted requests will be served. But when the option is
specified, a session with an incoming channel closed will be aborted while
it is still possible, either pending in the queue for a connection slot, or
during the connection establishment if the server has not yet acknowledged
the connection request. This considerably reduces the queue size and the load
on saturated servers when users are tempted to click on STOP, which in turn
reduces the response time for other users.

If this option has been enabled in a “defaults” section, it can be disabled
in a specific instance by prepending the “no” keyword before it.

Some high-level frameworks set application cookies everywhere and do not
always let enough control to the developer to manage how the responses should
be cached. When a session cookie is returned on a cacheable object, there is a
high risk of session crossing or stealing between users traversing the same
caches. In some situations, it is better to block the response than to let
some sensitive session information go in the wild.

The option “

checkcache

” enables deep inspection of all server responses for
strict compliance with HTTP specification in terms of cacheability. It
carefully checks “Cache-control”, “Pragma” and “Set-cookie” headers in server
response to check if there’s a risk of caching a cookie on a client-side
proxy. When this option is enabled, the only responses which can be delivered
to the client are :
– all those without “Set-Cookie” header;
– all those with a return code other than 200, 203, 204, 206, 300, 301,
404, 405, 410, 414, 501, provided that the server has not set a
“Cache-control: public” header field;
– all those that result from a request using a method other than GET, HEAD,
OPTIONS, TRACE, provided that the server has not set a ‘Cache-Control:
public’ header field;
– those with a ‘Pragma: no-cache’ header
– those with a ‘Cache-control: private’ header
– those with a ‘Cache-control: no-store’ header
– those with a ‘Cache-control: max-age=0’ header
– those with a ‘Cache-control: s-maxage=0’ header
– those with a ‘Cache-control: no-cache’ header
– those with a ‘Cache-control: no-cache=”

set-cookie

“‘ header
– those with a ‘Cache-control: no-cache=”set-cookie,’ header
(allowing other fields after set-cookie)

If a response doesn’t respect these requirements, then it will be blocked
just as if it was from an “

http-response deny

” rule, with an “HTTP 502 bad
gateway”. The session state shows “PH–” meaning that the proxy blocked the
response during headers processing. Additionally, an alert will be sent in
the logs so that admins are informed that there’s something to be fixed.

Due to the high impact on the application, the application should be tested
in depth with the option enabled before going to production. It is also a
good practice to always activate it during tests, even if it is not used in
production, as it will report potentially dangerous application behaviors.

If this option has been enabled in a “defaults” section, it can be disabled
in a specific instance by prepending the “no” keyword before it.

There is no standard case for header names because, as stated in RFC7230,
they are case-insensitive. So applications must handle them in a case-
insensitive manner. But some bogus applications violate the standards and
erroneously rely on the cases most commonly used by browsers. This problem
becomes critical with HTTP/2 because all header names must be exchanged in
lower case, and HAProxy follows the same convention. All header names are
sent in lower case to clients and servers, regardless of the HTTP version.

When HAProxy receives an HTTP/1 response, its header names are converted to
lower case and manipulated and sent this way to the clients. If a client is
known to violate the HTTP standards and to fail to process a response coming
from HAProxy, it is possible to transform the lower case header names to a
different format when the response is formatted and sent to the client, by
enabling this option and specifying the list of headers to be reformatted
using the global directives “

h1-case-adjust

” or “

h1-case-adjust-file

“. This
must only be a temporary workaround for the time it takes the client to be
fixed, because clients which require such workarounds might be vulnerable to
content smuggling attacks and must absolutely be fixed.

Please note that this option will not affect standards-compliant clients.

If this option has been enabled in a “defaults” section, it can be disabled
in a specific instance by prepending the “no” keyword before it.

There is no standard case for header names because, as stated in RFC7230,
they are case-insensitive. So applications must handle them in a case-
insensitive manner. But some bogus applications violate the standards and
erroneously rely on the cases most commonly used by browsers. This problem
becomes critical with HTTP/2 because all header names must be exchanged in
lower case, and HAProxy follows the same convention. All header names are
sent in lower case to clients and servers, regardless of the HTTP version.

When HAProxy receives an HTTP/1 request, its header names are converted to
lower case and manipulated and sent this way to the servers. If a server is
known to violate the HTTP standards and to fail to process a request coming
from HAProxy, it is possible to transform the lower case header names to a
different format when the request is formatted and sent to the server, by
enabling this option and specifying the list of headers to be reformatted
using the global directives “

h1-case-adjust

” or “

h1-case-adjust-file

“. This
must only be a temporary workaround for the time it takes the server to be
fixed, because servers which require such workarounds might be vulnerable to
content smuggling attacks and must absolutely be fixed.

Please note that this option will not affect standards-compliant servers.

If this option has been enabled in a “defaults” section, it can be disabled
in a specific instance by prepending the “no” keyword before it.

By default HAProxy operates in keep-alive mode with regards to persistent
connections: for each connection it processes each request and response, and
leaves the connection idle on both sides between the end of a response and
the start of a new request. This mode may be changed by several options such
as “

option http-server-close

” or “

option httpclose

“. This option allows to
set back the keep-alive mode, which can be useful when another mode was used
in a defaults section.

Setting “

option http-keep-alive

” enables HTTP keep-alive mode on the client-
and server- sides. This provides the lowest latency on the client side (slow
network) and the fastest session reuse on the server side at the expense
of maintaining idle connections to the servers. In general, it is possible
with this option to achieve approximately twice the request rate that the
“

http-server-close

” option achieves on small objects. There are mainly two
situations where this option may be useful :

– when the server is non-HTTP compliant and authenticates the connection
instead of requests (e.g. NTLM authentication)

– when the cost of establishing the connection to the server is significant
compared to the cost of retrieving the associated object from the server.

This last case can happen when the server is a fast static server of cache.
In this case, the server will need to be properly tuned to support high enough
connection counts because connections will last until the client sends another
request.

If the client request has to go to another backend or another server due to
content switching or the load balancing algorithm, the idle connection will
immediately be closed and a new one re-opened. Option “

prefer-last-server

” is
available to try optimize server selection so that if the server currently
attached to an idle connection is usable, it will be used.

At the moment, logs will not indicate whether requests came from the same
session or not. The accept date reported in the logs corresponds to the end
of the previous request, and the request time corresponds to the time spent
waiting for a new request. The keep-alive request time is still bound to the
timeout defined by “

timeout http-keep-alive

” or “

timeout http-request

” if
not set.

This option disables and replaces any previous “

option httpclose

” or “option
http-server-close”. When backend and frontend options differ, all of these 4
options have precedence over “

option http-keep-alive

“.

When running with “

option http-server-close

” or “

option httpclose

“, HAProxy
adds a “Connection: close” header to the request forwarded to the server.
Unfortunately, when some servers see this header, they automatically refrain
from using the chunked encoding for responses of unknown length, while this
is totally unrelated. The immediate effect is that this prevents HAProxy from
maintaining the client connection alive. A second effect is that a client or
a cache could receive an incomplete response without being aware of it, and
consider the response complete.

By setting “

option http-pretend-keepalive

“, HAProxy will make the server
believe it will keep the connection alive. The server will then not fall back
to the abnormal undesired above. When HAProxy gets the whole response, it
will close the connection with the server just as it would do with the
“

option httpclose

“. That way the client gets a normal response and the
connection is correctly closed on the server side.

It is recommended not to enable this option by default, because most servers
will more efficiently close the connection themselves after the last packet,
and release its buffers slightly earlier. Also, the added packet on the
network could slightly reduce the overall peak performance. However it is
worth noting that when this option is enabled, HAProxy will have slightly
less work to do. So if HAProxy is the bottleneck on the whole architecture,
enabling this option might save a few CPU cycles.

This option may be set in backend and listen sections. Using it in a frontend
section will be ignored and a warning will be reported during startup. It is
a backend related option, so there is no real reason to set it on a
frontend. This option may be combined with “

option httpclose

“, which will
cause keepalive to be announced to the server and close to be announced to
the client. This practice is discouraged though.

If this option has been enabled in a “defaults” section, it can be disabled
in a specific instance by prepending the “no” keyword before it.

By default, server health checks only consist in trying to establish a TCP
connection. When “

option httpchk

” is specified, a complete HTTP request is
sent once the TCP connection is established, and responses 2xx and 3xx are
considered valid, while all other ones indicate a server failure, including
the lack of any response.

Combined with “

http-check

” directives, it is possible to customize the
request sent during the HTTP health checks or the matching rules on the
response. It is also possible to configure a send/expect sequence, just like
with the directive “

tcp-check

” for TCP health checks.

The server configuration is used by default to open connections to perform
HTTP health checks. By it is also possible to overwrite server parameters
using “

http-check connect

” rules.

“

httpchk

” option does not necessarily require an HTTP backend, it also works
with plain TCP backends. This is particularly useful to check simple scripts
bound to some dedicated ports using the inetd daemon. However, it will always
internally relies on an HTX multiplexer. Thus, it means the request
formatting and the response parsing will be strict.

Note : For a while, there was no way to add headers or body in the request
used for HTTP health checks. So a workaround was to hide it at the end
of the version string with a “rn” after the version. It is now
deprecated. The directive “

http-check send

” must be used instead.

By default, the log output format is very poor, as it only contains the
source and destination addresses, and the instance name. By specifying
“

option httplog

“, each log line turns into a much richer format including,
but not limited to, the HTTP request, the connection timers, the session
status, the connections numbers, the captured headers and cookies, the
frontend, backend and server name, and of course the source address and
ports.

Specifying only “

option httplog

” will automatically clear the ‘clf’ mode
if it was set by default.

“

option httplog

” overrides any previous “

log-format

” directive.

If you specify a username, the check consists of sending two MySQL packet,
one Client Authentication packet, and one QUIT packet, to correctly close
MySQL session. We then parse the MySQL Handshake Initialization packet and/or
Error packet. It is a basic but useful test which does not produce error nor
aborted connect on the server. However, it requires an unlocked authorised
user without a password. To create a basic limited user in MySQL with
optional resource limits:

CREATE USER ”@”
/*!50701 WITH MAX_QUERIES_PER_HOUR 1 MAX_UPDATES_PER_HOUR 0 */
/*M!100201 MAX_STATEMENT_TIME 0.0001 */;

If you don’t specify a username (it is deprecated and not recommended), the
check only consists in parsing the Mysql Handshake Initialization packet or
Error packet, we don’t send anything in this mode. It was reported that it
can generate lockout if check is too frequent and/or if there is not enough
traffic. In fact, you need in this case to check MySQL “max_connect_errors”
value as if a connection is established successfully within fewer than MySQL
“max_connect_errors” attempts after a previous connection was interrupted,
the error count for the host is cleared to zero. If HAProxy’s server get
blocked, the “FLUSH HOSTS” statement is the only way to unblock it.

Remember that this does not check database presence nor database consistency.
To do this, you can use an external check with xinetd for example.

The check requires MySQL >=3.22, for older version, please use TCP check.

Most often, an incoming MySQL server needs to see the client’s IP address for
various purposes, including IP privilege matching and connection logging.
When possible, it is often wise to masquerade the client’s IP address when
connecting to the server using the “usesrc” argument of the “

source

” keyword,
which requires the transparent proxy feature to be compiled in, and the MySQL
server to route the client via the machine hosting HAProxy.

When clients or servers abort connections in a dirty way (e.g. they are
physically disconnected), the session timeouts triggers and the session is
closed. But it will remain in FIN_WAIT1 state for some time in the system,
using some resources and possibly limiting the ability to establish newer
connections.

When this happens, it is possible to activate “

option nolinger

” which forces
the system to immediately remove any socket’s pending data on close. Thus,
a TCP RST is emitted, any pending data are truncated, and the session is
instantly purged from the system’s tables. The generally visible effect for
a client is that responses are truncated if the close happens with a last
block of data (e.g. on a redirect or error response). On the server side,
it may help release the source ports immediately when forwarding a client
aborts in tunnels. In both cases, TCP resets are emitted and given that
the session is instantly destroyed, there will be no retransmit. On a lossy
network this can increase problems, especially when there is a firewall on
the lossy side, because the firewall might see and process the reset (hence
purge its session) and block any further traffic for this session,, including
retransmits from the other side. So if the other side doesn’t receive it,
it will never receive any RST again, and the firewall might log many blocked
packets.

For all these reasons, it is strongly recommended NOT to use this option,
unless absolutely needed as a last resort. In most situations, using the
“client-fin” or “server-fin” timeouts achieves similar results with a more
reliable behavior. On Linux it’s also possible to use the “

tcp-ut

” bind or
server setting.

This option may be used both on frontends and backends, depending on the side
where it is required. Use it on the frontend for clients, and on the backend
for servers. While this option is technically supported in “defaults”
sections, it must really not be used there as it risks to accidentally
propagate to sections that must no use it and to cause problems there.

If this option has been enabled in a “defaults” section, it can be disabled
in a specific instance by prepending the “no” keyword before it.

In HTTP mode, if a server designated by a cookie is down, clients may
definitely stick to it because they cannot flush the cookie, so they will not
be able to access the service anymore.

Specifying “

option redispatch

” will allow the proxy to break cookie or
consistent hash based persistence and redistribute them to a working server.

Active servers are selected from a subset of the list of available
servers. Active servers that are not down or in maintenance (i.e., whose
health is not checked or that have been checked as “up”), are selected in the
following order:

1. Any active, non-backup server, if any, or,

2. If the “

allbackups

” option is not set, the first backup server in the
list, or

3. If the “

allbackups

” option is set, any backup server.

When a retry occurs, HAProxy tries to select another server than the last
one. The new server is selected from the current list of servers.

Sometimes, if the list is updated between retries (e.g., if numerous retries
occur and last longer than the time needed to check that a server is down,
remove it from the list and fall back on the list of backup servers),
connections may be redirected to a backup server, though.

It also allows to retry connections to another server in case of multiple
connection failures. Of course, it requires having “

retries

” set to a nonzero
value.

If this option has been enabled in a “defaults” section, it can be disabled
in a specific instance by prepending the “no” keyword before it.

When “

option smtpchk

” is set, the health checks will consist in TCP
connections followed by an SMTP command. By default, this command is
“HELO localhost”. The server’s return code is analyzed and only return codes
starting with a “2” will be considered as valid. All other responses,
including a lack of response will constitute an error and will indicate a
dead server.

This test is meant to be used with SMTP servers or relays. Depending on the
request, it is possible that some servers do not log each connection attempt,
so you may want to experiment to improve the behavior. Using telnet on port
25 is often easier than adjusting the configuration.

Most often, an incoming SMTP server needs to see the client’s IP address for
various purposes, including spam filtering, anti-spoofing and logging. When
possible, it is often wise to masquerade the client’s IP address when
connecting to the server using the “usesrc” argument of the “

source

” keyword,
which requires the transparent proxy feature to be compiled in.

When this option is enabled either on a frontend or on a backend, HAProxy
will automatically evaluate the opportunity to use kernel tcp splicing to
forward data between the client and the server, in either direction. HAProxy
uses heuristics to estimate if kernel splicing might improve performance or
not. Both directions are handled independently. Note that the heuristics used
are not much aggressive in order to limit excessive use of splicing. This
option requires splicing to be enabled at compile time, and may be globally
disabled with the global option “

nosplice

“. Since splice uses pipes, using it
requires that there are enough spare pipes.

Important note: kernel-based TCP splicing is a Linux-specific feature which
first appeared in kernel 2.6.25. It offers kernel-based acceleration to
transfer data between sockets without copying these data to user-space, thus
providing noticeable performance gains and CPU cycles savings. Since many
early implementations are buggy, corrupt data and/or are inefficient, this
feature is not enabled by default, and it should be used with extreme care.
While it is not possible to detect the correctness of an implementation,
2.6.29 is the first version offering a properly working implementation. In
case of doubt, splicing may be globally disabled using the global “

nosplice

”
keyword.

This health check method is intended to be combined with “

tcp-check

” command
lists in order to support send/expect types of health check sequences.

TCP checks currently support 4 modes of operations :
– no “

tcp-check

” directive : the health check only consists in a connection
attempt, which remains the default mode.

– “

tcp-check send

” or “

tcp-check send-binary

” only is mentioned : this is
used to send a string along with a connection opening. With some
protocols, it helps sending a “QUIT” message for example that prevents
the server from logging a connection error for each health check. The
check result will still be based on the ability to open the connection
only.

– “

tcp-check expect

” only is mentioned : this is used to test a banner.
The connection is opened and HAProxy waits for the server to present some
contents which must validate some rules. The check result will be based
on the matching between the contents and the rules. This is suited for
POP, IMAP, SMTP, FTP, SSH, TELNET.

– both “

tcp-check send

” and “

tcp-check expect

” are mentioned : this is
used to test a hello-type protocol. HAProxy sends a message, the server
responds and its response is analyzed. the check result will be based on
the matching between the response contents and the rules. This is often
suited for protocols which require a binding or a request/response model.
LDAP, MySQL, Redis and SSL are example of such protocols, though they
already all have their dedicated checks with a deeper understanding of
the respective protocols.
In this mode, many questions may be sent and many answers may be
analyzed.

A fifth mode can be used to insert comments in different steps of the script.

For each tcp-check rule you create, you can add a “comment” directive,
followed by a string. This string will be reported in the log and stderr in
debug mode. It is useful to make user-friendly error reporting. The
“comment” is of course optional.

During the execution of a health check, a variable scope is made available to
store data samples, using the “

tcp-check set-var

” operation. Freeing those
variable is possible using “

tcp-check unset-var

“.

When an HTTP connection request comes in, the system acknowledges it on
behalf of HAProxy, then the client immediately sends its request, and the
system acknowledges it too while it is notifying HAProxy about the new
connection. HAProxy then reads the request and responds. This means that we
have one TCP ACK sent by the system for nothing, because the request could
very well be acknowledged by HAProxy when it sends its response.

For this reason, in HTTP mode, HAProxy automatically asks the system to avoid
sending this useless ACK on platforms which support it (currently at least
Linux). It must not cause any problem, because the system will send it anyway
after 40 ms if the response takes more time than expected to come.

During complex network debugging sessions, it may be desirable to disable
this optimization because delayed ACKs can make troubleshooting more complex
when trying to identify where packets are delayed. It is then possible to
fall back to normal behavior by specifying “

no option tcp-smart-accept

“.

It is also possible to force it for non-HTTP proxies by simply specifying
“

option tcp-smart-accept

“. For instance, it can make sense with some services
such as SMTP where the server speaks first.

It is recommended to avoid forcing this option in a defaults section. In case
of doubt, consider setting it back to automatic values by prepending the
“default” keyword before it, or disabling it using the “no” keyword.

When there is a firewall or any session-aware component between a client and
a server, and when the protocol involves very long sessions with long idle
periods (e.g. remote desktops), there is a risk that one of the intermediate
components decides to expire a session which has remained idle for too long.

Enabling socket-level TCP keep-alives makes the system regularly send packets
to the other end of the connection, leaving it active. The delay between
keep-alive probes is controlled by the system only and depends both on the
operating system and its tuning parameters.

It is important to understand that keep-alive packets are neither emitted nor
received at the application level. It is only the network stacks which sees
them. For this reason, even if one side of the proxy already uses keep-alives
to maintain its connection alive, those keep-alive packets will not be
forwarded to the other side of the proxy.

Please note that this has nothing to do with HTTP keep-alive.

Using option “

tcpka

” enables the emission of TCP keep-alive probes on both
the client and server sides of a connection. Note that this is meaningful
only in “defaults” or “listen” sections. If this option is used in a
frontend, only the client side will get keep-alives, and if this option is
used in a backend, only the server side will get keep-alives. For this
reason, it is strongly recommended to explicitly use “

option clitcpka

” and
“

option srvtcpka

” when the configuration is split between frontends and
backends.

By default, the log output format is very poor, as it only contains the
source and destination addresses, and the instance name. By specifying
“

option tcplog

“, each log line turns into a much richer format including, but
not limited to, the connection timers, the session status, the connections
numbers, the frontend, backend and server name, and of course the source
address and ports. This option is useful for pure TCP proxies in order to
find which of the client or server disconnects or times out. For normal HTTP
proxies, it’s better to use “

option httplog

” which is even more complete.

“

option tcplog

” overrides any previous “

log-format

” directive.

The “

source

” keyword is useful in complex environments where a specific
address only is allowed to connect to the servers. It may be needed when a
private address must be used through a public gateway for instance, and it is
known that the system cannot determine the adequate source address by itself.

An extension which is available on certain patched Linux kernels may be used
through the “usesrc” optional keyword. It makes it possible to connect to the
servers with an IP address which does not belong to the system itself. This
is called “full transparent proxy mode”. For this to work, the destination
servers have to route their traffic back to this address through the machine
running HAProxy, and IP forwarding must generally be enabled on this machine.

In this “full transparent proxy” mode, it is possible to force a specific IP
address to be presented to the servers. This is not much used in fact. A more
common use is to tell HAProxy to present the client’s IP address. For this,
there are two methods :

– present the client’s IP and port addresses. This is the most transparent
mode, but it can cause problems when IP connection tracking is enabled on
the machine, because a same connection may be seen twice with different
states. However, this solution presents the huge advantage of not
limiting the system to the 64k outgoing address port couples, because all
of the client ranges may be used.

– present only the client’s IP address and select a spare port. This
solution is still quite elegant but slightly less transparent (downstream
firewalls logs will not match upstream’s). It also presents the downside
of limiting the number of concurrent connections to the usual 64k ports.
However, since the upstream and downstream ports are different, local IP
connection tracking on the machine will not be upset by the reuse of the
same session.

This option sets the default source for all servers in the backend. It may
also be specified in a “defaults” section. Finer source address specification
is possible at the server level using the “

source

” server option. Refer to

section 5

for more information.

In order to work, “usesrc” requires root privileges.

Some protocols or applications require complex stickiness rules and cannot
always simply rely on cookies nor hashing. The “

stick match

” statement
describes a rule to extract the stickiness criterion from an incoming request
or connection. See

section 7

for a complete list of possible patterns and
transformation rules.

The table has to be declared using the “

stick-table

” statement. It must be of
a type compatible with the pattern. By default it is the one which is present
in the same backend. It is possible to share a table with other backends by
referencing it using the “

table

” keyword. If another table is referenced,
the server’s ID inside the backends are used. By default, all server IDs
start at 1 in each backend, so the server ordering is enough. But in case of
doubt, it is highly recommended to force server IDs using their “

id

” setting.

It is possible to restrict the conditions where a “

stick match

” statement
will apply, using “if” or “unless” followed by a condition. See

section 7

for
ACL based conditions.

There is no limit on the number of “

stick match

” statements. The first that
applies and matches will cause the request to be directed to the same server
as was used for the request which created the entry. That way, multiple
matches can be used as fallbacks.

The stick rules are checked after the persistence cookies, so they will not
affect stickiness if a cookie has already been used to select a server. That
way, it becomes very easy to insert cookies and match on IP addresses in
order to maintain stickiness between HTTP and HTTPS.

Note : Consider not using this feature in multi-process mode (nbproc > 1)
unless you know what you do : memory is not shared between the
processes, which can result in random behaviors.

Some protocols or applications require complex stickiness rules and cannot
always simply rely on cookies nor hashing. The “

stick store-request

” statement
describes a rule to decide what to extract from the request and when to do
it, in order to store it into a stickiness table for further requests to
match it using the “

stick match

” statement. Obviously the extracted part must
make sense and have a chance to be matched in a further request. Storing a
client’s IP address for instance often makes sense. Storing an ID found in a
URL parameter also makes sense. Storing a source port will almost never make
any sense because it will be randomly matched. See

section 7

for a complete
list of possible patterns and transformation rules.

The table has to be declared using the “

stick-table

” statement. It must be of
a type compatible with the pattern. By default it is the one which is present
in the same backend. It is possible to share a table with other backends by
referencing it using the “

table

” keyword. If another table is referenced,
the server’s ID inside the backends are used. By default, all server IDs
start at 1 in each backend, so the server ordering is enough. But in case of
doubt, it is highly recommended to force server IDs using their “

id

” setting.

It is possible to restrict the conditions where a “

stick store-request

”
statement will apply, using “if” or “unless” followed by a condition. This
condition will be evaluated while parsing the request, so any criteria can be
used. See

section 7

for ACL based conditions.

There is no limit on the number of “

stick store-request

” statements, but
there is a limit of 8 simultaneous stores per request or response. This
makes it possible to store up to 8 criteria, all extracted from either the
request or the response, regardless of the number of rules. Only the 8 first
ones which match will be kept. Using this, it is possible to feed multiple
tables at once in the hope to increase the chance to recognize a user on
another protocol or access method. Using multiple store-request rules with
the same table is possible and may be used to find the best criterion to rely
on, by arranging the rules by decreasing preference order. Only the first
extracted criterion for a given table will be stored. All subsequent store-
request rules referencing the same table will be skipped and their ACLs will
not be evaluated.

The “store-request” rules are evaluated once the server connection has been
established, so that the table will contain the real server that processed
the request.

Note : Consider not using this feature in multi-process mode (nbproc > 1)
unless you know what you do : memory is not shared between the
processes, which can result in random behaviors.

The data types that can be stored with an entry are the following :
– server_id : this is an integer which holds the numeric ID of the server a
request was assigned to. It is used by the “

stick match

“, “stick store”,
and “

stick on

” rules. It is automatically enabled when referenced.

– gpc0 : first General Purpose Counter. It is a positive 32-bit integer
integer which may be used for anything. Most of the time it will be used
to put a special tag on some entries, for instance to note that a
specific behavior was detected and must be known for future matches.

– gpc0_rate() : increment rate of the first General Purpose Counter
over a period. It is a positive 32-bit integer integer which may be used
for anything. Just like , it counts events, but instead of keeping
a cumulative number, it maintains the rate at which the counter is
incremented. Most of the time it will be used to measure the frequency of
occurrence of certain events (e.g. requests to a specific URL).

– gpc1 : second General Purpose Counter. It is a positive 32-bit integer
integer which may be used for anything. Most of the time it will be used
to put a special tag on some entries, for instance to note that a
specific behavior was detected and must be known for future matches.

– gpc1_rate() : increment rate of the second General Purpose Counter
over a period. It is a positive 32-bit integer integer which may be used
for anything. Just like , it counts events, but instead of keeping
a cumulative number, it maintains the rate at which the counter is
incremented. Most of the time it will be used to measure the frequency of
occurrence of certain events (e.g. requests to a specific URL).

– gpt0 : first General Purpose Tag. It is a positive 32-bit integer
integer which may be used for anything. Most of the time it will be used
to put a special tag on some entries, for instance to note that a
specific behavior was detected and must be known for future matches

– conn_cnt : Connection Count. It is a positive 32-bit integer which counts
the absolute number of connections received from clients which matched
this entry. It does not mean the connections were accepted, just that
they were received.

– conn_cur : Current Connections. It is a positive 32-bit integer which
stores the concurrent connection counts for the entry. It is incremented
once an incoming connection matches the entry, and decremented once the
connection leaves. That way it is possible to know at any time the exact
number of concurrent connections for an entry.

– conn_rate() : frequency counter (takes 12 bytes). It takes an
integer parameter which indicates in milliseconds the length
of the period over which the average is measured. It reports the average
incoming connection rate over that period, in connections per period. The
result is an integer which can be matched using ACLs.

– sess_cnt : Session Count. It is a positive 32-bit integer which counts
the absolute number of sessions received from clients which matched this
entry. A session is a connection that was accepted by the layer 4 rules.

– sess_rate() : frequency counter (takes 12 bytes). It takes an
integer parameter which indicates in milliseconds the length
of the period over which the average is measured. It reports the average
incoming session rate over that period, in sessions per period. The
result is an integer which can be matched using ACLs.

– http_req_cnt : HTTP request Count. It is a positive 32-bit integer which
counts the absolute number of HTTP requests received from clients which
matched this entry. It does not matter whether they are valid requests or
not. Note that this is different from sessions when keep-alive is used on
the client side.

– http_req_rate() : frequency counter (takes 12 bytes). It takes an
integer parameter which indicates in milliseconds the length
of the period over which the average is measured. It reports the average
HTTP request rate over that period, in requests per period. The result is
an integer which can be matched using ACLs. It does not matter whether
they are valid requests or not. Note that this is different from sessions
when keep-alive is used on the client side.

– http_err_cnt : HTTP Error Count. It is a positive 32-bit integer which
counts the absolute number of HTTP requests errors induced by clients
which matched this entry. Errors are counted on invalid and truncated
requests, as well as on denied or tarpitted requests, and on failed
authentications. If the server responds with 4xx, then the request is
also counted as an error since it’s an error triggered by the client
(e.g. vulnerability scan).

– http_err_rate() : frequency counter (takes 12 bytes). It takes an
integer parameter which indicates in milliseconds the length
of the period over which the average is measured. It reports the average
HTTP request error rate over that period, in requests per period (see
http_err_cnt above for what is accounted as an error). The result is an
integer which can be matched using ACLs.

– http_fail_cnt : HTTP Failure Count. It is a positive 32-bit integer which
counts the absolute number of HTTP response failures induced by servers
which matched this entry. Errors are counted on invalid and truncated
responses, as well as any 5xx response other than 501 or 505. It aims at
being used combined with path or URI to detect service failures.

– http_fail_rate() : frequency counter (takes 12 bytes). It takes
an integer parameter which indicates in milliseconds the length
of the period over which the average is measured. It reports the average
HTTP response failure rate over that period, in requests per period (see
http_fail_cnt above for what is accounted as a failure). The result is an
integer which can be matched using ACLs.

– bytes_in_cnt : client to server byte count. It is a positive 64-bit
integer which counts the cumulative number of bytes received from clients
which matched this entry. Headers are included in the count. This may be
used to limit abuse of upload features on photo or video servers.

– bytes_in_rate() : frequency counter (takes 12 bytes). It takes an
integer parameter which indicates in milliseconds the length
of the period over which the average is measured. It reports the average
incoming bytes rate over that period, in bytes per period. It may be used
to detect users which upload too much and too fast. Warning: with large
uploads, it is possible that the amount of uploaded data will be counted
once upon termination, thus causing spikes in the average transfer speed
instead of having a smooth one. This may partially be smoothed with
“

option contstats

” though this is not perfect yet. Use of byte_in_cnt is
recommended for better fairness.

– bytes_out_cnt : server to client byte count. It is a positive 64-bit
integer which counts the cumulative number of bytes sent to clients which
matched this entry. Headers are included in the count. This may be used
to limit abuse of bots sucking the whole site.

– bytes_out_rate() : frequency counter (takes 12 bytes). It takes
an integer parameter which indicates in milliseconds the length
of the period over which the average is measured. It reports the average
outgoing bytes rate over that period, in bytes per period. It may be used
to detect users which download too much and too fast. Warning: with large
transfers, it is possible that the amount of transferred data will be
counted once upon termination, thus causing spikes in the average
transfer speed instead of having a smooth one. This may partially be
smoothed with “

option contstats

” though this is not perfect yet. Use of
byte_out_cnt is recommended for better fairness.

There is only one stick-table per proxy. At the moment of writing this doc,
it does not seem useful to have multiple tables per proxy. If this happens
to be required, simply create a dummy backend with a stick-table in it and
reference it.

It is important to understand that stickiness based on learning information
has some limitations, including the fact that all learned associations are
lost upon restart unless peers are properly configured to transfer such
information upon restart (recommended). In general it can be good as a
complement but not always as an exclusive stickiness.

Last, memory requirements may be important when storing many data types.
Indeed, storing all indicators above at once in each entry requires 116 bytes
per entry, or 116 MB for a 1-million entries table. This is definitely not
something that can be ignored.

Some protocols or applications require complex stickiness rules and cannot
always simply rely on cookies nor hashing. The “

stick store-response

”
statement describes a rule to decide what to extract from the response and
when to do it, in order to store it into a stickiness table for further
requests to match it using the “

stick match

” statement. Obviously the
extracted part must make sense and have a chance to be matched in a further
request. Storing an ID found in a header of a response makes sense.
See

section 7

for a complete list of possible patterns and transformation
rules.

The table has to be declared using the “

stick-table

” statement. It must be of
a type compatible with the pattern. By default it is the one which is present
in the same backend. It is possible to share a table with other backends by
referencing it using the “

table

” keyword. If another table is referenced,
the server’s ID inside the backends are used. By default, all server IDs
start at 1 in each backend, so the server ordering is enough. But in case of
doubt, it is highly recommended to force server IDs using their “

id

” setting.

It is possible to restrict the conditions where a “

stick store-response

”
statement will apply, using “if” or “unless” followed by a condition. This
condition will be evaluated while parsing the response, so any criteria can
be used. See

section 7

for ACL based conditions.

There is no limit on the number of “

stick store-response

” statements, but
there is a limit of 8 simultaneous stores per request or response. This
makes it possible to store up to 8 criteria, all extracted from either the
request or the response, regardless of the number of rules. Only the 8 first
ones which match will be kept. Using this, it is possible to feed multiple
tables at once in the hope to increase the chance to recognize a user on
another protocol or access method. Using multiple store-response rules with
the same table is possible and may be used to find the best criterion to rely
on, by arranging the rules by decreasing preference order. Only the first
extracted criterion for a given table will be stored. All subsequent store-
response rules referencing the same table will be skipped and their ACLs will
not be evaluated. However, even if a store-request rule references a table, a
store-response rule may also use the same table. This means that each table
may learn exactly one element from the request and one element from the
response at once.

The table will contain the real server that processed the request.

The available matches are intentionally similar to their http-check cousins :

string : test the exact string matches in the response buffer.
A health check response will be considered valid if the
response’s buffer contains this exact string. If the
“string” keyword is prefixed with “!”, then the response
will be considered invalid if the body contains this
string. This can be used to look for a mandatory pattern
in a protocol response, or to detect a failure when a
specific error appears in a protocol banner.

rstring : test a regular expression on the response buffer.
A health check response will be considered valid if the
response’s buffer matches this expression. If the
“rstring” keyword is prefixed with “!”, then the response
will be considered invalid if the body matches the
expression.

string-lf : test a log-format string match in the response’s buffer.
A health check response will be considered valid if the
response’s buffer contains the string resulting of the
evaluation of , which follows the log-format rules.
If prefixed with “!”, then the response will be
considered invalid if the buffer contains the string.

binary : test the exact string in its hexadecimal form matches
in the response buffer. A health check response will
be considered valid if the response’s buffer contains
this exact hexadecimal string.
Purpose is to match data on binary protocols.

rbinary : test a regular expression on the response buffer, like
“rstring”. However, the response buffer is transformed
into its hexadecimal form, including NUL-bytes. This
allows using all regex engines to match any binary
content. The hexadecimal transformation takes twice the
size of the original response. As such, the expected
pattern should work on at-most half the response buffer
size.

binary-lf : test a log-format string in its hexadecimal form
match in the response’s buffer. A health check response
will be considered valid if the response’s buffer
contains the hexadecimal string resulting of the
evaluation of , which follows the log-format
rules. If prefixed with “!”, then the response will be
considered invalid if the buffer contains the
hexadecimal string. The hexadecimal string is converted
in a binary string before matching the response’s
buffer.

It is important to note that the responses will be limited to a certain size
defined by the global “

tune.bufsize

” option, which defaults to 16384 bytes.
Thus, too large responses may not contain the mandatory pattern when using
“string”, “rstring” or binary. If a large response is absolutely required, it
is possible to change the default max size by setting the global variable.
However, it is worth keeping in mind that parsing very large responses can
waste some CPU cycles, especially when regular expressions are used, and that
it is always better to focus the checks on smaller resources. Also, in its
current state, the check will not find any string nor regex past a null
character in the response. Similarly it is not possible to request matching
the null character.

Immediately after acceptance of a new incoming connection, it is possible to
evaluate some conditions to decide whether this connection must be accepted
or dropped or have its counters tracked. Those conditions cannot make use of
any data contents because the connection has not been read from yet, and the
buffers are not yet allocated. This is used to selectively and very quickly
accept or drop connections from various sources with a very low overhead. If
some contents need to be inspected in order to take the decision, the
“

tcp-request content

” statements must be used instead.

The “

tcp-request connection

” rules are evaluated in their exact declaration
order. If no rule matches or if there is no rule, the default action is to
accept the incoming connection. There is no specific limit to the number of
rules which may be inserted.

Four types of actions are supported :
– accept :
accepts the connection if the condition is true (when used with “if”)
or false (when used with “unless”). The first such rule executed ends
the rules evaluation.

– reject :
rejects the connection if the condition is true (when used with “if”)
or false (when used with “unless”). The first such rule executed ends
the rules evaluation. Rejected connections do not even become a
session, which is why they are accounted separately for in the stats,
as “denied connections”. They are not considered for the session
rate-limit and are not logged either. The reason is that these rules
should only be used to filter extremely high connection rates such as
the ones encountered during a massive DDoS attack. Under these extreme
conditions, the simple action of logging each event would make the
system collapse and would considerably lower the filtering capacity. If
logging is absolutely desired, then “

tcp-request content

” rules should
be used instead, as “

tcp-request session

” rules will not log either.

– expect-proxy layer4 :
configures the client-facing connection to receive a PROXY protocol
header before any byte is read from the socket. This is equivalent to
having the “

accept-proxy

” keyword on the “

bind

” line, except that using
the TCP rule allows the PROXY protocol to be accepted only for certain
IP address ranges using an ACL. This is convenient when multiple layers
of load balancers are passed through by traffic coming from public
hosts.

– expect-netscaler-cip layer4 :
configures the client-facing connection to receive a NetScaler Client
IP insertion protocol header before any byte is read from the socket.
This is equivalent to having the “

accept-netscaler-cip

” keyword on the
“

bind

” line, except that using the TCP rule allows the PROXY protocol
to be accepted only for certain IP address ranges using an ACL. This
is convenient when multiple layers of load balancers are passed
through by traffic coming from public hosts.

– capture len :
This only applies to “

tcp-request content

” rules. It captures sample
expression from the request buffer, and converts it to a
string of at most characters. The resulting string is stored into
the next request “

capture

” slot, so it will possibly appear next to
some captured HTTP headers. It will then automatically appear in the
logs, and it will be possible to extract it using sample fetch rules to
feed it into headers or anything. The length should be limited given
that this size will be allocated for each capture during the whole
session life. Please check

section 7.3

(Fetching samples) and “capture
request header” for more information.

– { track-sc0 | track-sc1 | track-sc2 } [table

These actions take one or two arguments :
is mandatory, and is a sample expression rule as described
in

section 7.3

. It describes what elements of the incoming
request or connection will be analyzed, extracted, combined,
and used to select which table entry to update the counters.
Note that “

tcp-request connection

” cannot use content-based
fetches.

Once a “track-sc*” rule is executed, the key is looked up in the table
and if it is not found, an entry is allocated for it. Then a pointer to
that entry is kept during all the session’s life, and this entry’s
counters are updated as often as possible, every time the session’s
counters are updated, and also systematically when the session ends.
Counters are only updated for events that happen after the tracking has
been started. For example, connection counters will not be updated when
tracking layer 7 information, since the connection event happens before
layer7 information is extracted.

If the entry tracks concurrent connection counters, one connection is
counted for as long as the entry is tracked, and the entry will not
expire during that time. Tracking counters also provides a performance
advantage over just checking the keys, because only one table lookup is
performed for all ACL checks that make use of it.

– sc-inc-gpc0():
The “sc-inc-gpc0” increments the GPC0 counter according to the sticky
counter designated by . If an error occurs, this action silently
fails and the actions evaluation continues.

– sc-inc-gpc1():
The “sc-inc-gpc1” increments the GPC1 counter according to the sticky
counter designated by . If an error occurs, this action silently
fails and the actions evaluation continues.

– sc-set-gpt0() { | }:
This action sets the 32-bit unsigned GPT0 tag according to the sticky
counter designated by and the value of /. The
expected result is a boolean. If an error occurs, this action silently
fails and the actions evaluation continues.

– set-mark :
Is used to set the Netfilter/IPFW MARK in all packets sent to the client
to the value passed in on platforms which support it. This value
is an unsigned 32 bit value which can be matched by netfilter/ipfw and by
the routing table or monitoring the packets through DTrace.
It can be expressed both in decimal or hexadecimal format (prefixed by
“0x”). This can be useful to force certain packets to take a different
route (for example a cheaper network path for bulk downloads). This works
on Linux kernels 2.6.32 and above and requires admin privileges, as well
on FreeBSD.

– set-src :
Is used to set the source IP address to the value of specified
expression. Useful if you want to mask source IP for privacy.
If you want to provide an IP from a HTTP header use “http-request
set-src”.

A request’s contents can be analyzed at an early stage of request processing
called “TCP content inspection”. During this stage, ACL-based rules are
evaluated every time the request contents are updated, until either an
“accept”, a “reject” or a “switch-mode” rule matches, or the TCP request
inspection delay expires with no matching rule.

The first difference between these rules and “

tcp-request connection

” rules
is that “

tcp-request content

” rules can make use of contents to take a
decision. Most often, these decisions will consider a protocol recognition or
validity. The second difference is that content-based rules can be used in
both frontends and backends. In case of HTTP keep-alive with the client, all
tcp-request content rules are evaluated again, so HAProxy keeps a record of
what sticky counters were assigned by a “

tcp-request connection

” versus a
“

tcp-request content

” rule, and flushes all the content-related ones after
processing an HTTP request, so that they may be evaluated again by the rules
being evaluated again for the next request. This is of particular importance
when the rule tracks some L7 information or when it is conditioned by an
L7-based ACL, since tracking may change between requests.

Content-based rules are evaluated in their exact declaration order. If no
rule matches or if there is no rule, the default action is to accept the
contents. There is no specific limit to the number of rules which may be
inserted.

Several types of actions are supported :
– accept : the request is accepted
– do-resolve: perform a DNS resolution
– reject : the request is rejected and the connection is closed
– capture : the specified sample expression is captured
– set-priority-class | set-priority-offset
– { track-sc0 | track-sc1 | track-sc2 } [table

tcp-request connection

”
so please refer to that section for a complete description.
For “do-resolve” action, please check the “

http-request do-resolve

”
configuration section.

While there is nothing mandatory about it, it is recommended to use the
track-sc0 in “

tcp-request connection

” rules, track-sc1 for “tcp-request
content” rules in the frontend, and track-sc2 for “

tcp-request content

”
rules in the backend, because that makes the configuration more readable
and easier to troubleshoot, but this is just a guideline and all counters
may be used everywhere.

Note that the “if/unless” condition is optional. If no condition is set on
the action, it is simply performed unconditionally. That can be useful for
“track-sc*” actions as well as for changing the default action to a reject.

Note also that it is recommended to use a “

tcp-request session

” rule to track
information that does *not* depend on Layer 7 contents, especially for HTTP
frontends. Some HTTP processing are performed at the session level and may
lead to an early rejection of the requests. Thus, the tracking at the content
level may be disturbed in such case. A warning is emitted during startup to
prevent, as far as possible, such unreliable usage.

It is perfectly possible to match layer 7 contents with “

tcp-request content

”
rules from a TCP proxy, since HTTP-specific ACL matches are able to
preliminarily parse the contents of a buffer before extracting the required
data. If the buffered contents do not parse as a valid HTTP message, then the
ACL does not match. The parser which is involved there is exactly the same
as for all other HTTP processing, so there is no risk of parsing something
differently. In an HTTP frontend or an HTTP backend, it is guaranteed that
HTTP contents will always be immediately present when the rule is evaluated
first because the HTTP parsing is performed in the early stages of the
connection processing, at the session level. But for such proxies, using
“

http-request

” rules is much more natural and recommended.

Tracking layer7 information is also possible provided that the information
are present when the rule is processed. The rule processing engine is able to
wait until the inspect delay expires when the data to be tracked is not yet
available.

The “set-dst” and “set-dst-port” are used to set respectively the destination
IP and port. More information on how to use it at “

http-request set-dst

“.

The “set-log-level” is used to set the log level of the current session. More
information on how to use it at “

http-request set-log-level

“.

The “set-mark” is used to set the Netfilter MARK in all packets sent to the
client. More information on how to use it at “

http-request set-mark

“.

The “set-nice” is used to set the “

nice

” factor of the current session. More
information on how to use it at “

http-request set-nice

“.

The “set-src” and “set-src-port” are used to set respectively the source IP
and port. More information on how to use it at “

http-request set-src

“.

The “set-tos” is used to set the TOS or DSCP field value of packets sent to
the client. More information on how to use it at “

http-request set-tos

“.

The “

set-var

” and “

set-var-fmt

” are used to set the contents of a variable.
The variable is declared inline. For “

tcp-request session

” rules, only
session-level variables can be used, without any layer7 contents. The
“

set-var

” action takes a regular expression while “

set-var-fmt

” takes a
format string.

The name of the variable starts with an indication about
its scope. The scopes allowed are:
“

proc

” : the variable is shared with the whole process
“sess” : the variable is shared with the whole session
“txn” : the variable is shared with the transaction
(request and response)
“req” : the variable is shared only during request
processing
“res” : the variable is shared only during response
processing
This prefix is followed by a name. The separator is a ‘.’.
The name may only contain characters ‘a-z’, ‘A-Z’, ‘0-9’,
‘.’ and ‘_’.

Is a standard HAProxy expression formed by a sample-fetch
followed by some converters.

This is the value expressed using log-format rules (see Custom
Log Format in

section 8.2.4

).

The “switch-mode” is used to perform a connection upgrade. Only HTTP
upgrades are supported for now. The protocol may optionally be
specified. This action is only available for a proxy with the frontend
capability. The connection upgrade is immediately performed, following
“

tcp-request content

” rules are not evaluated. This upgrade method should be
preferred to the implicit one consisting to rely on the backend mode. When
used, it is possible to set HTTP directives in a frontend without any
warning. These directives will be conditionally evaluated if the HTTP upgrade
is performed. However, an HTTP backend must still be selected. It remains
unsupported to route an HTTP connection (upgraded or not) to a TCP server.

See

section 4

about Proxies for more details on HTTP upgrades.

The “

unset-var

” is used to unset a variable. See above for details about
.

The “set-priority-class” is used to set the queue priority class of the
current request. The value must be a sample expression which converts to an
integer in the range -2047..2047. Results outside this range will be
truncated. The priority class determines the order in which queued requests
are processed. Lower values have higher priority.

The “set-priority-offset” is used to set the queue priority timestamp offset
of the current request. The value must be a sample expression which converts
to an integer in the range -524287..524287. Results outside this range will be
truncated. When a request is queued, it is ordered first by the priority
class, then by the current timestamp adjusted by the given offset in
milliseconds. Lower values have higher priority.
Note that the resulting timestamp is is only tracked with enough precision for
524,287ms (8m44s287ms). If the request is queued long enough to where the
adjusted timestamp exceeds this value, it will be misidentified as highest
priority. Thus it is important to set “

timeout queue

” to a value, where when
combined with the offset, does not exceed this limit.

The “send-spoe-group” is used to trigger sending of a group of SPOE
messages. To do so, the SPOE engine used to send messages must be defined, as
well as the SPOE group to send. Of course, the SPOE engine must refer to an
existing SPOE filter. If not engine name is provided on the SPOE filter line,
the SPOE agent name must be used.

The SPOE engine name.

The SPOE group name as specified in the engine configuration.

The “use-service” is used to executes a TCP service which will reply to the
request and stop the evaluation of the rules. This service may choose to
reply by sending any valid response or it may immediately close the
connection without sending anything. Outside natives services, it is possible
to write your own services in Lua. No further “

tcp-request

” rules are
evaluated.

Response contents can be analyzed at an early stage of response processing
called “TCP content inspection”. During this stage, ACL-based rules are
evaluated every time the response contents are updated, until either an
“accept”, “close” or a “reject” rule matches, or a TCP response inspection
delay is set and expires with no matching rule.

Most often, these decisions will consider a protocol recognition or validity.

Content-based rules are evaluated in their exact declaration order. If no
rule matches or if there is no rule, the default action is to accept the
contents. There is no specific limit to the number of rules which may be
inserted.

Several types of actions are supported :
– accept :
accepts the response if the condition is true (when used with “if”)
or false (when used with “unless”). The first such rule executed ends
the rules evaluation.

– close :
immediately closes the connection with the server if the condition is
true (when used with “if”), or false (when used with “unless”). The
first such rule executed ends the rules evaluation. The main purpose of
this action is to force a connection to be finished between a client
and a server after an exchange when the application protocol expects
some long time outs to elapse first. The goal is to eliminate idle
connections which take significant resources on servers with certain
protocols.

– reject :
rejects the response if the condition is true (when used with “if”)
or false (when used with “unless”). The first such rule executed ends
the rules evaluation. Rejected session are immediately closed.

– set-log-level
The “set-log-level” is used to set the log level of the current
session. More information on how to use it at “http-response
set-log-level”.

– set-mark
The “set-mark” is used to set the Netfilter MARK in all packets sent to
the client. More information on how to use it at “http-response
set-mark”.

– set-nice
The “set-nice” is used to set the “

nice

” factor of the current
session. More information on how to use it at “http-response
set-nice”.

– set-tos
The “set-tos” is used to set the TOS or DSCP field value of packets
sent to the client. More information on how to use it at “http-response
set-tos”.

– set-var()
Sets a variable from an expression.

– set-var-fmt()
Sets a variable from a log format string.

– unset-var()
Unsets a variable.

– sc-inc-gpc0():
This action increments the GPC0 counter according to the sticky
counter designated by . If an error occurs, this action fails
silently and the actions evaluation continues.

– sc-inc-gpc1():
This action increments the GPC1 counter according to the sticky
counter designated by . If an error occurs, this action fails
silently and the actions evaluation continues.

– sc-set-gpt0() { | }
This action sets the 32-bit unsigned GPT0 tag according to the sticky
counter designated by and the value of /. The
expected result is a boolean. If an error occurs, this action silently
fails and the actions evaluation continues.

– “silent-drop” :
This stops the evaluation of the rules and makes the client-facing
connection suddenly disappear using a system-dependent way that tries
to prevent the client from being notified. The effect it then that the
client still sees an established connection while there’s none on
HAProxy. The purpose is to achieve a comparable effect to “tarpit”
except that it doesn’t use any local resource at all on the machine
running HAProxy. It can resist much higher loads than “tarpit”, and
slow down stronger attackers. It is important to understand the impact
of using this mechanism. All stateful equipment placed between the
client and HAProxy (firewalls, proxies, load balancers) will also keep
the established connection for a long time and may suffer from this
action. On modern Linux systems running with enough privileges, the
TCP_REPAIR socket option is used to block the emission of a TCP
reset. On other systems, the socket’s TTL is reduced to 1 so that the
TCP reset doesn’t pass the first router, though it’s still delivered to
local networks. Do not use it unless you fully understand how it works.

– send-spoe-group
Send a group of SPOE messages.

Note that the “if/unless” condition is optional. If no condition is set on
the action, it is simply performed unconditionally. That can be useful for
for changing the default action to a reject.

It is perfectly possible to match layer 7 contents with “tcp-response
content” rules, but then it is important to ensure that a full response has
been buffered, otherwise no contents will match. In order to achieve this,
the best solution involves detecting the HTTP protocol during the inspection
period.

The “

set-var

” is used to set the content of a variable. The variable is
declared inline.

The name of the variable starts with an indication about
its scope. The scopes allowed are:
“

proc

” : the variable is shared with the whole process
“sess” : the variable is shared with the whole session
“txn” : the variable is shared with the transaction
(request and response)
“req” : the variable is shared only during request
processing
“res” : the variable is shared only during response
processing
This prefix is followed by a name. The separator is a ‘.’.
The name may only contain characters ‘a-z’, ‘A-Z’, ‘0-9’,
‘.’ and ‘_’.

Is a standard HAProxy expression formed by a sample-fetch
followed by some converters.

This is the value expressed using log-format rules (see Custom
Log Format in

section 8.2.4

).

The “

unset-var

” is used to unset a variable. See above for details about
.

The “send-spoe-group” is used to trigger sending of a group of SPOE
messages. To do so, the SPOE engine used to send messages must be defined, as
well as the SPOE group to send. Of course, the SPOE engine must refer to an
existing SPOE filter. If not engine name is provided on the SPOE filter line,
the SPOE agent name must be used.

The SPOE engine name.

The SPOE group name as specified in the engine configuration.

See

section 7

about ACL usage.

Once a session is validated, (i.e. after all handshakes have been completed),
it is possible to evaluate some conditions to decide whether this session
must be accepted or dropped or have its counters tracked. Those conditions
cannot make use of any data contents because no buffers are allocated yet and
the processing cannot wait at this stage. The main use case it to copy some
early information into variables (since variables are accessible in the
session), or to keep track of some information collected after the handshake,
such as SSL-level elements (SNI, ciphers, client cert’s CN) or information
from the PROXY protocol header (e.g. track a source forwarded this way). The
extracted information can thus be copied to a variable or tracked using
“track-sc” rules. Of course it is also possible to decide to accept/reject as
with other rulesets. Most operations performed here could also be performed
in “

tcp-request content

” rules, except that in HTTP these rules are evaluated
for each new request, and that might not always be acceptable. For example a
rule might increment a counter on each evaluation. It would also be possible
that a country is resolved by geolocation from the source IP address,
assigned to a session-wide variable, then the source address rewritten from
an HTTP header for all requests. If some contents need to be inspected in
order to take the decision, the “

tcp-request content

” statements must be used
instead.

The “

tcp-request session

” rules are evaluated in their exact declaration
order. If no rule matches or if there is no rule, the default action is to
accept the incoming session. There is no specific limit to the number of
rules which may be inserted.

Several types of actions are supported :
– accept : the request is accepted
– reject : the request is rejected and the connection is closed
– { track-sc0 | track-sc1 | track-sc2 } [table

tcp-request connection

” and “

tcp-request content

“, so please refer to these
sections for a complete description.

Note that the “if/unless” condition is optional. If no condition is set on
the action, it is simply performed unconditionally. That can be useful for
“track-sc*” actions as well as for changing the default action to a reject.

The inactivity timeout applies when the client is expected to acknowledge or
send data. In HTTP mode, this timeout is particularly important to consider
during the first phase, when the client sends the request, and during the
response while it is reading data sent by the server. That said, for the
first phase, it is preferable to set the “

timeout http-request

” to better
protect HAProxy from Slowloris like attacks. The value is specified in
milliseconds by default, but can be in any other unit if the number is
suffixed by the unit, as specified at the top of this document. In TCP mode
(and to a lesser extent, in HTTP mode), it is highly recommended that the
client timeout remains equal to the server timeout in order to avoid complex
situations to debug. It is a good practice to cover one or several TCP packet
losses by specifying timeouts that are slightly above multiples of 3 seconds
(e.g. 4 or 5 seconds). If some long-lived sessions are mixed with short-lived
sessions (e.g. WebSocket and HTTP), it’s worth considering “

timeout tunnel

“,
which overrides “

timeout client

” and “

timeout server

” for tunnels, as well as
“

timeout client-fin

” for half-closed connections.

This parameter is specific to frontends, but can be specified once for all in
“defaults” sections. This is in fact one of the easiest solutions not to
forget about it. An unspecified timeout results in an infinite timeout, which
is not recommended. Such a usage is accepted and works but reports a warning
during startup because it may result in accumulation of expired sessions in
the system if the system’s timeouts are not configured either.

By default, the time to wait for a new request in case of keep-alive is set
by “

timeout http-request

“. However this is not always convenient because some
people want very short keep-alive timeouts in order to release connections
faster, and others prefer to have larger ones but still have short timeouts
once the request has started to present itself.

The “

http-keep-alive

” timeout covers these needs. It will define how long to
wait for a new HTTP request to start coming after a response was sent. Once
the first byte of request has been seen, the “

http-request

” timeout is used
to wait for the complete request to come. Note that empty lines prior to a
new request do not refresh the timeout and are not counted as a new request.

There is also another difference between the two timeouts : when a connection
expires during timeout http-keep-alive, no error is returned, the connection
just closes. If the connection expires in “

http-request

” while waiting for a
connection to complete, a HTTP 408 error is returned.

In general it is optimal to set this value to a few tens to hundreds of
milliseconds, to allow users to fetch all objects of a page at once but
without waiting for further clicks. Also, if set to a very small value (e.g.
1 millisecond) it will probably only accept pipelined requests but not the
non-pipelined ones. It may be a nice trade-off for very large sites running
with tens to hundreds of thousands of clients.

If this parameter is not set, the “

http-request

” timeout applies, and if both
are not set, “

timeout client

” still applies at the lower level. It should be
set in the frontend to take effect, unless the frontend is in TCP mode, in
which case the HTTP backend’s timeout will be used.

In order to offer DoS protection, it may be required to lower the maximum
accepted time to receive a complete HTTP request without affecting the client
timeout. This helps protecting against established connections on which
nothing is sent. The client timeout cannot offer a good protection against
this abuse because it is an inactivity timeout, which means that if the
attacker sends one character every now and then, the timeout will not
trigger. With the HTTP request timeout, no matter what speed the client
types, the request will be aborted if it does not complete in time. When the
timeout expires, an HTTP 408 response is sent to the client to inform it
about the problem, and the connection is closed. The logs will report
termination codes “cR”. Some recent browsers are having problems with this
standard, well-documented behavior, so it might be needed to hide the 408
code using “

option http-ignore-probes

” or “errorfile 408 /dev/null”. See
more details in the explanations of the “cR” termination code in

section 8.5

.

By default, this timeout only applies to the header part of the request,
and not to any data. As soon as the empty line is received, this timeout is
not used anymore. When combined with “

option http-buffer-request

“, this
timeout also applies to the body of the request..
It is used again on keep-alive connections to wait for a second
request if “

timeout http-keep-alive

” is not set.

Generally it is enough to set it to a few seconds, as most clients send the
full request immediately upon connection. Add 3 or more seconds to cover TCP
retransmits but that’s all. Setting it to very low values (e.g. 50 ms) will
generally work on local networks as long as there are no packet losses. This
will prevent people from sending bare HTTP requests using telnet.

If this parameter is not set, the client timeout still applies between each
chunk of the incoming request. It should be set in the frontend to take
effect, unless the frontend is in TCP mode, in which case the HTTP backend’s
timeout will be used.

The inactivity timeout applies when the server is expected to acknowledge or
send data. In HTTP mode, this timeout is particularly important to consider
during the first phase of the server’s response, when it has to send the
headers, as it directly represents the server’s processing time for the
request. To find out what value to put there, it’s often good to start with
what would be considered as unacceptable response times, then check the logs
to observe the response time distribution, and adjust the value accordingly.

The value is specified in milliseconds by default, but can be in any other
unit if the number is suffixed by the unit, as specified at the top of this
document. In TCP mode (and to a lesser extent, in HTTP mode), it is highly
recommended that the client timeout remains equal to the server timeout in
order to avoid complex situations to debug. Whatever the expected server
response times, it is a good practice to cover at least one or several TCP
packet losses by specifying timeouts that are slightly above multiples of 3
seconds (e.g. 4 or 5 seconds minimum). If some long-lived sessions are mixed
with short-lived sessions (e.g. WebSocket and HTTP), it’s worth considering
“

timeout tunnel

“, which overrides “

timeout client

” and “

timeout server

” for
tunnels.

This parameter is specific to backends, but can be specified once for all in
“defaults” sections. This is in fact one of the easiest solutions not to
forget about it. An unspecified timeout results in an infinite timeout, which
is not recommended. Such a usage is accepted and works but reports a warning
during startup because it may result in accumulation of expired sessions in
the system if the system’s timeouts are not configured either.

The tunnel timeout applies when a bidirectional connection is established
between a client and a server, and the connection remains inactive in both
directions. This timeout supersedes both the client and server timeouts once
the connection becomes a tunnel. In TCP, this timeout is used as soon as no
analyzer remains attached to either connection (e.g. tcp content rules are
accepted). In HTTP, this timeout is used when a connection is upgraded (e.g.
when switching to the WebSocket protocol, or forwarding a CONNECT request
to a proxy), or after the first response when no keepalive/close option is
specified.

Since this timeout is usually used in conjunction with long-lived connections,
it usually is a good idea to also set “

timeout client-fin

” to handle the
situation where a client suddenly disappears from the net and does not
acknowledge a close, or sends a shutdown and does not acknowledge pending
data anymore. This can happen in lossy networks where firewalls are present,
and is detected by the presence of large amounts of sessions in a FIN_WAIT
state.

The value is specified in milliseconds by default, but can be in any other
unit if the number is suffixed by the unit, as specified at the top of this
document. Whatever the expected normal idle time, it is a good practice to
cover at least one or several TCP packet losses by specifying timeouts that
are slightly above multiples of 3 seconds (e.g. 4 or 5 seconds minimum).

This parameter is specific to backends, but can be specified once for all in
“defaults” sections. This is in fact one of the easiest solutions not to
forget about it.

When doing content-switching, connections arrive on a frontend and are then
dispatched to various backends depending on a number of conditions. The
relation between the conditions and the backends is described with the
“

use_backend

” keyword. While it is normally used with HTTP processing, it can
also be used in pure TCP, either without content using stateless ACLs (e.g.
source address validation) or combined with a “

tcp-request

” rule to wait for
some payload.

There may be as many “

use_backend

” rules as desired. All of these rules are
evaluated in their declaration order, and the first one which matches will
assign the backend.

In the first form, the backend will be used if the condition is met. In the
second form, the backend will be used if the condition is not met. If no
condition is valid, the backend defined with “

default_backend

” will be used.
If no default backend is defined, either the servers in the same section are
used (in case of a “listen” section) or, in case of a frontend, no server is
used and a 503 service unavailable response is returned.

Note that it is possible to switch from a TCP frontend to an HTTP backend. In
this case, either the frontend has already checked that the protocol is HTTP,
and backend processing will immediately follow, or the backend will wait for
a complete HTTP request to get in. This feature is useful when a frontend
must decode several protocols on a unique port, one of them being HTTP.

When is a simple name, it is resolved at configuration time, and an
error is reported if the specified backend does not exist. If is
a log-format string instead, no check may be done at configuration time, so
the backend name is resolved dynamically at run time. If the resulting
backend name does not correspond to any valid backend, no other rule is
evaluated, and the default_backend directive is applied instead. Note that
when using dynamic backend names, it is highly recommended to use a prefix
that no other backend uses in order to ensure that an unauthorized backend
cannot be forced from the request.

It is worth mentioning that “

use_backend

” rules with an explicit name are
used to detect the association between frontends and backends to compute the
backend’s “

fullconn

” setting. This cannot be done for dynamic names.

By default, connections which arrive to a backend are load-balanced across
the available servers according to the configured algorithm, unless a
persistence mechanism such as a cookie is used and found in the request.

Sometimes it is desirable to forward a particular request to a specific
server without having to declare a dedicated backend for this server. This
can be achieved using the “

use-server

” rules. These rules are evaluated after
the “

redirect

” rules and before evaluating cookies, and they have precedence
on them. There may be as many “

use-server

” rules as desired. All of these
rules are evaluated in their declaration order, and the first one which
matches will assign the server.

If a rule designates a server which is down, and “

option persist

” is not used
and no force-persist rule was validated, it is ignored and evaluation goes on
with the next rules until one matches.

In the first form, the server will be used if the condition is met. In the
second form, the server will be used if the condition is not met. If no
condition is valid, the processing continues and the server will be assigned
according to other persistence mechanisms.

Note that even if a rule is matched, cookie processing is still performed but
does not assign the server. This allows prefixed cookies to have their prefix
stripped.

The “

use-server

” statement works both in HTTP and TCP mode. This makes it
suitable for use with content-based inspection. For instance, a server could
be selected in a farm according to the TLS SNI field when using protocols with
implicit TLS (also see “

req.ssl_sni

“). And if these servers have their weight
set to zero, they will not be used for other traffic.

Sample fetch methods may be combined with transformations to be applied on top
of the fetched sample (also called “converters”). These combinations form what
is called “sample expressions” and the result is a “sample”. Initially this
was only supported by “

stick on

” and “

stick store-request

” directives but this
has now be extended to all places where samples may be used (ACLs, log-format,
unique-id-format, add-header, …).

These transformations are enumerated as a series of specific keywords after the
sample fetch method. These keywords may equally be appended immediately after
the fetch keyword’s argument, delimited by a comma. These keywords can also
support some arguments (e.g. a netmask) which must be passed in parenthesis.

A certain category of converters are bitwise and arithmetic operators which
support performing basic operations on integers. Some bitwise operations are
supported (and, or, xor, cpl) and some arithmetic operations are supported
(add, sub, mul, div, mod, neg). Some comparators are provided (odd, even, not,
bool) which make it possible to report a match without having to write an ACL.

The currently available list of transformation keywords include :

Hashes a binary input sample into an unsigned 32-bit quantity using the CRC32
hash function. Optionally, it is possible to apply a full avalanche hash
function to the output if the optional argument equals 1. This
converter uses the same functions as used by the various hash-based load
balancing algorithms, so it will provide exactly the same results. It is
provided for compatibility with other software which want a CRC32 to be
computed on some input keys, so it follows the most common implementation as
found in Ethernet, Gzip, PNG, etc… It is slower than the other algorithms
but may provide a better or at least less predictable distribution. It must
not be used for security purposes as a 32-bit hash is trivial to break. See
also “

djb2

“, “

sdbm

“, “

wt6

“, “

crc32c

” and the “

hash-type

” directive.

Performs a signature verification for the JSON Web Token (JWT) given in input
by using the algorithm and the parameter, which should either
hold a secret or a path to a public certificate. Returns 1 in case of
verification success, 0 in case of verification error and a strictly negative
value for any other error. Because of all those non-null error return values,
the result of this converter should never be converted to a boolean. See
below for a full list of the possible return values.

For now, only JWS tokens using the Compact Serialization format can be
processed (three dot-separated base64-url encoded strings). Among the
accepted algorithms for a JWS (see

section 3.1

of RFC7518), the PSXXX ones
are not managed yet.

If the used algorithm is of the HMAC family, should be the secret used
in the HMAC signature calculation. Otherwise, should be the path to the
public certificate that can be used to validate the token’s signature. All
the certificates that might be used to verify JWTs must be known during init
in order to be added into a dedicated certificate cache so that no disk
access is required during runtime. For this reason, any used certificate must
be mentioned explicitely at least once in a jwt_verify call. Passing an
intermediate variable as second parameter is then not advised.

This converter only verifies the signature of the token and does not perform
a full JWT validation as specified in

section 7.2

of RFC7519. We do not
ensure that the header and payload contents are fully valid JSON’s once
decoded for instance, and no checks are performed regarding their respective
contents.

The possible return values are the following :

—- ———————————————————————-
| ID | message |
—- ———————————————————————-
| 0 | “Verification failure” |
| 1 | “Verification sucess” |
| -1 | “Unknown algorithm (not mentioned in RFC7518)” |
| -2 | “Unmanaged algorithm (PSXXX algorithm family)” |
| -3 | “Invalid token” |
| -4 | “Out of memory” |
| -5 | “Unknown certificate” |
—- ———————————————————————-

Please note that this converter is only available when HAProxy has been
compiled with USE_OPENSSL.

map_(

str

“. Likewise, if the is not set, it defaults to
“

str

“. For convenience, the “

map

” keyword is an alias for “map_str” and maps a
string to another string.

It is important to avoid overlapping between the keys : IP addresses and
strings are stored in trees, so the first of the finest match will be used.
Other keys are stored in lists, so the first matching occurrence will be used.

The following array contains the list of all map functions available sorted by
input type, match type and output type.

This extracts the protocol buffers message field in raw mode of an input binary
sample representation of a protocol buffer message with as field
number (dotted notation) if is not present, or as an integer sample
if this field is present (see also “

ungrpc

” below).
The list of the authorized types is the following one: “int32”, “int64”, “uint32”,
“uint64”, “sint32”, “sint64”, “

bool

“, “enum” for the “varint” wire type 0
“fixed64”, “sfixed64”, “double” for the 64bit wire type 1, “fixed32”, “sfixed32”,
“float” for the wire type 5. Note that “string” is considered as a length-delimited
type, so it does not require any argument to be extracted.
More information may be found here about the protocol buffers message field types:
https://developers.google.com/protocol-buffers/docs/encoding

This extracts the protocol buffers message field in raw mode of an input binary
sample representation of a gRPC message with as field number
(dotted notation) if is not present, or as an integer sample if this
field is present.
The list of the authorized types is the following one: “int32”, “int64”, “uint32”,
“uint64”, “sint32”, “sint64”, “

bool

“, “enum” for the “varint” wire type 0
“fixed64”, “sfixed64”, “double” for the 64bit wire type 1, “fixed32”, “sfixed32”,
“float” for the wire type 5. Note that “string” is considered as a length-delimited
type, so it does not require any argument to be extracted.
More information may be found here about the protocol buffers message field types:
https://developers.google.com/protocol-buffers/docs/encoding

let’s say a body request is made of a “Rectangle” object value (two PPoint
protocol buffers messages), the four protocol buffers fields could be
extracted with these “

ungrpc

” directives:

req.body,ungrpc(48.59.1,int32) # “latitude” of “lo” first PPoint
req.body,ungrpc(48.59.2,int32) # “longitude” of “lo” first PPoint
req.body,ungrpc(49.59.1,int32) # “latitude” of “hi” second PPoint
req.body,ungrpc(49.59.2,int32) # “longitude” of “hi” second PPoint

We could also extract the intermediary 48.59 field as a binary sample as follows:

req.body,ungrpc(48.59)

As a gRPC message is always made of a gRPC header followed by protocol buffers
messages, in the previous example the “latitude” of “lo” first PPoint
could be extracted with these equivalent directives:

req.body,ungrpc(48.59),protobuf(1,int32)
req.body,ungrpc(48),protobuf(59.1,int32)
req.body,ungrpc(48),protobuf(59),protobuf(1,int32)

Note that the first convert must be “

ungrpc

“, the remaining ones must be
“

protobuf

” and only the last one may have or not a second argument to
interpret the previous binary sample.