本文档涵盖了上述版本中实现的配置语言。它不提供任何提示、示例或建议。有关此类文档，请参阅参考手册或架构手册。以下摘要旨在帮助您按名称查找章节并在文档中导航。文档贡献者须知：本文档每行格式化为80列，使用偶数个空格进行缩进，不使用制表符。请严格遵守这些规则，以便在任何地方都能轻松打印。如果某行需要逐字打印且不适合，请在每行末尾加上反斜杠（'\'），并在下一行继续，缩进两个字符。有时，为了强调输入和输出之间的差异，当它们可能模糊不清时，用三个闭合尖括号（'>>>'）作为所有输出行（日志、控制台输出）的前缀也很有用。如果添加新章节，请更新下面的摘要以便于搜索。

当 HAProxy 在 HTTP 模式下运行时，请求和响应都会被完全分析和索引，因此可以根据内容中找到的几乎任何信息构建匹配标准。然而，了解 HTTP 请求和响应的构成方式以及 HAProxy 如何分解它们是很重要的。这样一来，编写正确的规则和调试现有配置就会变得更加容易。首先，HTTP 由一系列 RFC 标准化，HAProxy 尽可能地遵循这些标准： - RFC 9110: HTTP 语义 (解释协议元素的含义) - RFC 9111: HTTP 缓存 (解释 HTTP 缓存应遵循的规则) - RFC 9112: HTTP/1.1 (表示、互操作性规则、安全) - RFC 9113: HTTP/2 (表示、互操作性规则、安全) - RFC 9114: HTTP/3 (表示、互操作性规则、安全) 除此之外，RFC 8999 到 9002 规定了 HTTP/3 协议使用的 QUIC 传输层。

HTTP 协议是事务驱动的。这意味着每个请求只会产生一个响应。最初，在协议 1.0 版本中，每个连接只有一个请求：客户端与服务器建立 TCP 连接，客户端通过连接发送请求，服务器响应，然后连接关闭。新的请求需要新的连接：[CON1] [REQ1] ... [RESP1] [CLO1] [CON2] [REQ2] ... [RESP2] [CLO2] ... 在这种模式下，通常称为“HTTP close”模式，有多少 HTTP 事务就有多少连接建立。由于服务器在响应后关闭连接，客户端不需要知道内容长度，它认为当连接关闭时响应就完成了。这也意味着如果某些响应由于网络错误而被截断，客户端可能会错误地认为响应已完成，这曾导致截断的图像有时会呈现在屏幕上。由于协议的事务性质，可以对其进行改进，以避免在两个后续事务之间关闭连接。然而，在这种模式下，服务器必须为每个响应指示内容长度，以便客户端不会无限期地等待。为此，使用了一个特殊的标头：“Content-length”。这种模式被称为“keep-alive”模式，随 HTTP/1.1 出现（某些 HTTP/1.0 代理支持它），在请求之间重用的连接被称为“持久连接”：[CON] [REQ1] ... [RESP1] [REQ2] ... [RESP2] [CLO] ... 它的优点是事务之间的延迟减少，服务器端所需的处理能力更少，并且能够检测到被截断的响应。它通常比关闭模式更快，但并非总是如此，因为有些客户端通常将其并发连接限制在较小的值，这在网络连接较差的情况下补偿较少。此外，一些服务器必须长时间保持连接活动，等待可能的新的请求，并且由于连接数量过多，可能会经历较高的内存使用量，而关闭过快可能会破坏在连接关闭时到达的某些请求。在这种模式下，响应大小需要事先知道，因此对于动态生成或压缩的内容来说并不总是可行。出于这个原因，实现了另一种模式，即“chunked mode”（分块模式），在这种模式下，发送方不是一次性宣布整个大小，而是只宣布它在缓冲区中已有的下一个“块”的块大小，并且可以随时以大小为零的块终止。在这种模式下，不使用 Content-Length 标头。通信中的另一个改进是管道模式。它仍然使用 keep-alive，但客户端在发送第二个请求时不需要等待第一个响应。这对于获取构成页面的大量图像很有用：[CON] [REQ1] [REQ2] ... [RESP1] [RESP2] [CLO] ... 这显然对性能有巨大的好处，因为后续请求之间的网络延迟被消除了。许多 HTTP 代理不支持管道操作，因为在 HTTP 中无法将响应与相应的请求关联起来。出于这个原因，服务器必须按照接收请求的完全相同的顺序回复。在实践中，在各种客户端尝试部署它几次后，由于它在某些服务器上缺乏可靠性而被完全放弃。但服务器必须支持它。下一个改进是多路复用模式，如 HTTP/2 和 HTTP/3 中实现的那样。在这种模式下，多个事务（即请求-响应对）在单个连接上并行传输，并且它们都以自己的速度进展，彼此独立。对于多路复用协议，引入了“流”（stream）的新概念，以表示在同一连接上发生的这些并行通信。每个流通常被分配一个给定连接的唯一标识符，两端都使用该标识符来知道将数据传送到何处。客户端在同一连接上并行启动许多（最多 100 个，有时更多）流是很常见的，并让服务器对它们进行排序，并根据哪个响应可用以任何顺序响应。多路复用模式的主要好处是它显著减少了往返次数，并加快了高延迟网络上的页面加载时间。这在使用许多图像的网站上有时可见，所有图像似乎都在并行加载。这些协议还通过采用一些机制来压缩标头字段以减少网络上的字节数来提高效率，因此如果没有适当的工具，它们不像 HTTP/1 那样可以手动操作，也无法肉眼读取。出于这个原因，HTTP 消息的各种示例继续在文献中（包括本文档）使用 HTTP/1 语法表示，即使是针对较新版本的协议。HTTP/2 存在一些设计限制，例如数据包丢失会同时影响所有流，如果客户端花费太多时间来检索对象（例如需要将其存储在磁盘上），它可能会减慢检索速度，并使得在此期间无法访问其后面待处理的数据。这被称为“队头阻塞”（"head of line blocking" 或 "HoL blocking"，有时简称 "HoL"）。HTTP/3 是在 QUIC 上实现的，QUIC 本身是在 UDP 上实现的。QUIC 通过独立处理流的方式在传输层解决了队头阻塞问题。事实上，当遇到丢失时，受影响的流不会影响其他流，并且所有流都可以并行访问。QUIC 还提供连接迁移支持，但目前 haproxy 不支持它。默认情况下，HAProxy 在持久连接方面以 keep-alive 模式运行：对于每个连接，它处理每个请求和响应，并在响应结束和新请求开始之间将连接在两端保持空闲。当它从客户端接收到 HTTP/2 连接时，它并行处理所有请求并使连接空闲，等待新请求，就像它是一个 keep-alive HTTP 连接一样。HAProxy 主要支持 3 种连接模式：- keep alive：处理所有请求和响应，并且面向客户端和面向服务器的连接保持活动以进行新请求。这是默认设置，适用于现代 Web 和现代协议（HTTP/2 和 HTTP/3）。- server close：在响应后关闭面向服务器的连接。- close：在两端响应结束后主动关闭连接。除此之外，默认情况下，面向服务器的连接可以被来自任何客户端的任何请求重用，正如 HTTP 协议规范所要求的那样，因此如果需要（例如客户端的源地址等），任何与特定客户端相关的信息都必须随每个请求一起传递。当 HTTP/2 与服务器一起使用时，默认情况下 HAProxy 会将此连接专用于同一客户端，以避免客户端之间发生队头阻塞的风险。

在 HAProxy 内部，术语随着 HTTP 协议及其用法的演变而有所发展。虽然最初连接、会话、流或事务之间没有显著差异，但随着时间的推移，这些术语变得清晰，以密切匹配现代 HTTP 协议版本中存在的术语，尽管某些术语为了历史兼容性仍然在配置或命令行界面中可见。以下是适用于当前 HAProxy 版本的定义：- connection（连接）：连接是远程代理（客户端或服务器）与 HAProxy 之间在最低级别上的单个双向通信通道。它通常对应于一对 IP 和端口之间建立的 TCP 套接字。在面向客户端的一侧，当客户端连接到 HAProxy 时，连接是实例化​​的第一个实体，并且在连接级别应用的规则是最早应用的规则。- session（会话）：会话添加了一些与连接关联的上下文信息。这包括特定于传输层的信息（例如 TLS 密钥等）或变量。这个术语在 HAProxy 内部长期用于表示两端之间的端到端 HTTP/1.0 通信，因此尽管现在它表示流，但它仍然在某些 CLI 命令或统计信息的名称中可见，但帮助消息和描述试图使其明确。它在网络级别术语（例如操作系统内部的 TCP 会话，或跨防火墙的 TCP 会话）或非 HTTP 用户级别应用程序（例如 telnet 会话或 SSH 会话）方面仍然有效。它不得与用于在 cookie 中存储完整用户上下文并要求发送到同一服务器的“应用程序会话”混淆。- stream（流）：流精确地对应于应用程序级别的端到端双向通信，可以在其中应用分析和转换。在 HTTP 中，它包含单个请求及其关联的响应，并通过请求的到达实例化，并在响应交付结束时完成。在这种上下文中，这种流与多路复用协议的流之间存在 1:1 的关系。在 TCP 通信中，每个连接只有一个流。- transaction（事务）：事务仅是一对请求和关联的响应。在流出现之前，该术语与会话结合使用，但现在事务与流之间存在 1:1 的关系。它主要在变量范围“txn”中可见，该范围在整个事务期间有效，因此在流期间有效。- request（请求）：它表示从客户端流向服务器的流量。它主要用于 HTTP，以指示执行操作的位置。此术语也存在于 TCP 操作中，以指示处理数据的位置。请求通常作为流量或活动的单位出现在计数器中。它们并不总是意味着响应（例如由于错误），但由于没有自发的响应而没有请求，请求仍然是总体活动的相关指标。在 TCP 中，请求数量与连接数量相同。- response（响应）：这表示从服务器流向客户端的流量，或者有时是 HAProxy 自己生成的响应（例如 HTTP 重定向）时从 HAProxy 流向客户端的流量。- service（服务）：这通常表示 HAProxy 中的一些内部处理，不需要服务器，例如 stats 页面、缓存或一些用于实现小型应用程序的 Lua 代码。服务通常读取请求，执行一些操作并生成响应。

首先，让我们考虑这个 HTTP 请求： 行号 内容 1 GET /serv/login.php?lang=en&profile=2 HTTP/1.1 2 Host: www.mydomain.com 3 User-agent: my small browser 4 Accept: image/jpeg, image/gif 5 Accept: image/png

第 1 行是“请求行”。它始终由 3 个字段组成：- 方法（METHOD）：GET- URI：/serv/login.php?lang=en&profile=2- 版本标签（version tag）：HTTP/1.1所有这些都由标准所称的 LWS（线性空格）分隔，通常是空格，但也可能是制表符或换行符/回车符后跟空格/制表符。方法本身不能包含任何冒号（':'），并且仅限于字母。所有这些各种组合使得 HAProxy 最好自己执行拆分，而不是让用户编写复杂或不准确的正则表达式。URI 本身可以有几种形式：- “相对 URI”：/serv/login.php?lang=en&profile=2它是一个完整的 URL，不包含主机部分。这通常是服务器、反向代理和透明代理接收到的内容。- “绝对 URI”，也称为“URL”：http://192.168.0.12:8080/serv/login.php?lang=en&profile=2它由“方案”（协议名称后跟 '://'）、主机名或地址、可选的冒号（':'）后跟端口号，然后是在地址部分之后的第一个斜杠（'/'）开始的相对 URI 组成。这通常是代理接收到的内容，但支持 HTTP/1.1 的服务器也必须接受这种形式。- 星号（'*'）：这种形式仅与 OPTIONS 方法关联时才被接受，并且不可中继。它用于查询下一跳的能力。- address:port 组合：192.168.0.12:80这与 CONNECT 方法一起使用，CONNECT 方法用于通过 HTTP 代理建立 TCP 隧道，通常用于 HTTPS，但有时也用于其他协议。在相对 URI 中，识别出两个子部分。问号之前的部分称为 "path"（路径）。它通常是服务器上静态对象的相对路径。问号之后的部分称为“query string”（查询字符串）。它主要用于发送给动态脚本的 GET 请求，并且非常特定于正在使用的语言、框架或应用程序。HTTP/2 和 HTTP/3 不会随请求传输版本信息，因此版本被假定与底层协议的版本相同（即“HTTP/2”）。此外，这些协议不会将请求行作为一个部分发送，而是将其拆分为称为“伪标头”（pseudo-headers）的单个字段，其名称以冒号开头，并且 HAProxy 会方便地将它们重新组合成等效的请求行。因此，日志中发现的请求行在 HTTP/1.x 和 HTTP/2 或 HTTP/3 之间可能略有不同。

标头从第二行开始。它们由行开头的名称组成，紧跟着冒号（':'）。传统上，在冒号后添加 LWS，但这不是必需的。然后是值。多个相同的标头可以折叠成一行，用逗号分隔值，前提是它们的顺序得到尊重。这在“Cookie:”字段中很常见。如果后续行以 LWS 开头，则标头可以跨多行。在 1.3 的示例中，第 4 行和第 5 行总共为“Accept:”标头定义了 3 个值。最后，根据规范，忽略标头开头或结尾处的所有 LWS，它们不属于值的一部分。与常见的误解相反，标头名称不区分大小写，如果它们引用其他标头名称（例如“Connection:”标头），则它们的值也不区分大小写。在 HTTP/2 和 HTTP/3 中，标头名称始终以小写字母发送，这可以在调试模式下运行时看到。在内部，所有标头名称都被规范化为小写，以便 HTTP/1.x 和 HTTP/2 或 HTTP/3 使用完全相同的表示形式，并且它们被原样发送到另一端。这解释了为什么使用驼峰式大小写的 HTTP/1.x 请求会以小写形式交付。标头的结束由第一个空行指示。人们常说它是双换行符，这不准确，即使双换行符是空行的一种有效形式。幸运的是，HAProxy 在索引标头、检查值和计数它们时会处理所有这些复杂的组合，因此无需担心它们的写入方式，但重要的是不要指责应用程序如果它做了不寻常但有效的事情就是有错误的。重要提示：根据 RFC7231 的建议，HAProxy 通过用 LWS 替换标头中间的换行符来规范化标头，以便连接多行标头。这对于正确的分析是必要的，并有助于能力较差的 HTTP 解析器正常工作，不被这种复杂的结构所迷惑。

HTTP 响应看起来与 HTTP 请求非常相似。两者都称为 HTTP 消息。让我们考虑一下这个 HTTP 响应：行号 内容1 HTTP/1.1 200 OK2 Content-length: 3503 Content-Type: text/html作为一个特例，HTTP 支持所谓的“信息性响应”，状态码为 1xx。这些消息很特别，因为它们不传达响应的任何部分，它们只用作一种信号消息，例如要求客户端继续发送其请求。在状态 100 响应的情况下，请求的信息将由跟随信息性响应的下一个非 100 响应消息携带。这意味着可以向单个请求发送多个响应，并且这仅在启用 keep-alive 时才有效（1xx 消息出现在 HTTP/1.1 中）。HAProxy 处理这些消息，并能够正确转发和跳过它们，只处理下一个非 100 响应。因此，除非另有明确说明，否则这些消息既不会被记录也不会被转换。状态 101 消息表示协议正在同一连接上更改，HAProxy 必须切换到隧道模式，就像发生了 CONNECT 一样。然后 Upgrade 标头将包含有关连接切换到的协议类型的附加信息。

第 1 行是“响应行”。它始终由 3 个字段组成：- 版本标签（version tag）：HTTP/1.1- 状态码（status code）：200- 原因短语（reason phrase）：OK状态码始终是 3 位数字。第一位数字表示一般状态：- 1xx = 要跳过的信息性消息（例如 100, 101）- 2xx = OK，内容正在跟随（例如 200, 206）- 3xx = OK，没有内容跟随（例如 302, 304）- 4xx = 客户端引起​​的错误（例如 401, 403, 404）- 5xx = 服务器引起的错误（例如 500, 502, 503）状态码大于 599 不得在通信中发出，尽管某些代理可能会在日志中生成它们以报告其内部状态。有关所有此类代码的详细含义，请参阅 RFC9110。HTTP/2 及更高版本没有版本标签，并使用“:status”伪标头来报告状态码。“原因”字段只是一个提示，但客户端不解析它。那里可以找到任何东西，但尊重既定的消息是一种常见做法。它可以由一个或多个单词组成，例如“OK”、“Found”或“Authentication Required”。它在 HTTP/2 及更高版本中不存在，并且在那里不发出。当来自 HTTP/2 或更高版本的响应传输到 HTTP/1 客户端时，HAProxy 将生成与状态码匹配的常见原因字段。HAProxy 可能会自行发出以下状态码：代码 何时/原因200 访问统计信息页面，以及回复监控请求时301 执行重定向时，具体取决于配置的代码302 执行重定向时，具体取决于配置的代码303 执行重定向时，具体取决于配置的代码307 执行重定向时，具体取决于配置的代码308 执行重定向时，具体取决于配置的代码400 对于无效或过大的请求401 执行操作需要身份验证时（访问统计信息页面时）403 当请求被“http-request deny”规则禁止时404 当请求的资源找不到时408 在请求完成之前请求超时时410 当请求的资源不再可用且以后也不会再次可用时413 当 HTTP/1.0 GET/HEAD/DELETE 请求带有有效载荷时，另请参阅 "h1-accept-payload-with-any-method" 选项500 当 HAProxy 遇到不可恢复的内部错误时，例如内存分配失败，这不应该发生501 当 HAProxy 因不支持的功能而无法满足客户端请求时502 当服务器返回空、无效或不完整的响应时，或者当“http-response deny”规则阻止响应时。503 当没有可用的服务器来处理请求时，或者响应与 "monitor fail" 条件匹配的监控请求时504 在服务器响应之前响应超时时上面的错误 4xx 和 5xx 代码可以自定义（请参阅 4.2 节中的 "errorloc"）。其他状态码可以通过特定操作有意发出（例如，请参阅 4.3 节中的 "deny"、"return" 和 "redirect
This keyword is available in sections :
Alphabetically sorted keywords reference
Alphabetically sorted actions reference" 操作）。

响应头的工作方式与请求头完全相同，因此，HAProxy 对两者使用相同的解析函数。有关更多详细信息，请参阅第 1.3.2 段。

HAProxy 的配置过程涉及 3 个主要参数来源：- 命令行参数，它始终优先- 配置文件，其格式在此处描述- 运行进程的环境，以防某些环境变量被明确引用配置文件遵循一个相当简单的层次结构格式，它遵循一些基本规则：1. 配置文件是一个有序的语句序列2. 语句是在任何未受保护的“#”（哈希）之前的一行非空行3. 一行是由未受保护的空格或制表符分隔的一系列令牌或“单词”4. 一行的第一个单词或单词序列是本文档中列出的关键字或关键字序列之一5. 所有其他单词都是第一个单词的所有参数，其中一些是本文档中列出的众所周知的关键字，其他是值、对配置其他部分的引用或表达式6. 某些关键字界定了一个部分，在该部分内只支持关键字的一个子集7. 一个部分在文件末尾或在新部分开始的特殊关键字处结束要编写简单可靠的配置生成器，只需要知道这些，但这不足以可靠地解析任何配置或弄清楚如何处理某些极端情况。首先，上面规则有一些推论。规则 6 和 7 意味着用于定义新部分的关键字在任何地方都有效，并且不能在特定部分中具有不同的含义。这些关键字始终是单个单词（而不是单词序列），并且传统上，跟随它们的部分使用相同的名称来指定。例如，当谈论“global section”（全局部分）时，它指的是跟随“global”关键字的配置部分。这种用法在错误消息中经常使用，以帮助定位需要处理的部分。许多部分创建了一个内部对象或配置空间，需要将其与其他对象区分开来。在这种情况下，它们将采用一个额外的单词来设置此特定部分的名称。对于其中一些，部分名称是强制性的。例如，“frontend foo”将创建一个名为“foo”的“frontend”类型的新部分。通常，名称特定于其部分，不同类型的两个部分可以使用相同的名称，但不推荐这样做，因为它往往会使配置管理复杂化。规则 7 的直接推论是，当同时读取多个文件时，每个文件必须以新部分开头，并且每个文件的末尾将结束一个部分。文件不能包含子部分，也不能结束现有部分并开始新部分。规则 1 提到顺序很重要。事实上，某些关键字会创建指令，这些指令可以重复多次以创建有序的规则序列，这些规则将按特定顺序应用。例如，“tcp-request”可用于在不同标准上交替使用“accept”和“reject”规则。因此，配置文件处理器在编辑文件时必须始终保留部分的顺序。部分的顺序通常不重要，除了全局部分必须放置在其他部分之前，但如果需要可以重复。此外，一些自动标识符可能会自动分配给某些创建的对象（例如代理），并且通过重新排序部分，它们的标识符将发生变化。这些出现在统计信息中。因此，下面的配置将为“foo”分配 ID 号 1，为“bar”分配 ID 号 2，如果两个部分颠倒，则会交换：listen foo bind :80 listen bar bind :81另一个重要点是，根据上面的规则 2 和 3，空行、空格、制表符以及跟随未受保护的“#”字符的注释不属于配置的一部分，因为它们仅用作分隔符。这意味着以下配置是完全等效的：global#这是全局部分daemon#守护进程frontend foo mode http # 或者 tcpand: global daemon # 这是公共 web 前端frontend foo mode http通常的做法是只将启动新部分的关键字左对齐，并缩进（即在前面加上制表符或几个空格）所有其他关键字，以便立即看出它们属于同一部分（如上例中的第二个示例所示）。在新部分之前放置注释有助于读者判断它是否是所需的部分。在部分末尾留一个空行也有助于在编辑时直观地发现末尾。制表符非常方便用于缩进，但它们复制粘贴效果不佳。如果使用空格代替，建议不要放置太多（2 到 4 个），这样在没有自动缩进支持的有限编辑器中编辑时不会成为负担。在早期，在固定制表符位置拆分参数是很常见的，因为大多数关键字不会接受超过两个参数。随着具有复杂表达式的现代版本，这种做法不再适用，也不推荐。

在现代配置中，某些参数需要使用以前被认为是纯分隔符的字符。为了使这成为可能，HAProxy 支持通过在要转义的字符前面加上反斜杠（'\'）来转义字符，使用双引号（'"'）进行弱引用，以及使用单引号（"'"）进行强引用。这与许多编程语言中所做的工作非常相似，并且非常接近于 Bourne shell 中常见的做法。原理如下：当配置解析器将行切割成单词时，它还会处理引号和反斜杠，以决定一个字符是分隔符还是当前单词中该字符的原始表示形式。然后删除转义字符，删除引号，剩余的单词原样用作关键字或参数。如果单词中需要反斜杠，则必须使用自身进行转义（即双反斜杠）或使用强引用。在引号外部转义是通过在特殊字符前加上反斜杠（'\'）实现的：\ 标记空格并将其与分隔符区分开来\# 标记哈希并将其与注释开头区分开来\\ 使用反斜杠\' 使用单引号并将其与强引用分隔符区分开来\" 使用双引号并将其与弱引用分隔符区分开来此外，可以使用通常的 C 语言表示法发出一些不可打印字符：\n 插入换行符（LF，字符 \x0a 或 ASCII 10 十进制）\r 插入回车符（CR，字符 \x0d 或 ASCII 13 十进制）\t 插入制表符（字符 \x09 或 ASCII 9 十进制）\xNN 插入 ASCII 码为十六进制 NN 的字符（例如 \x0a 表示 LF）。弱引用是通过在要保护的字符或字符序列周围加上双引号（""）实现的。弱引用会阻止以下内容的解释：空格或制表符作为单词分隔符' 单引号作为强引用分隔符# 哈希作为注释开头弱引用允许解释环境变量（在引号外部不评估），方法是在其前面加上美元符号（'$'）。如果双引号内需要美元字符，则必须使用反斜杠转义。强引用是通过在要保护的字符或字符序列周围加上单引号（''）实现的。在单引号内，不解释任何内容，这是引用正则表达式的有效方式。因此，这里是表示特殊字符在不同上下文中如何输入的矩阵（不可打印字符替换为其名称）。请注意，某些只能转义表示的字符在单引号内没有可能的表示，因此此处缺失

# 以下这些都是完全等效的： log-format %{+Q}o\ %t\ %s\ %{-Q}r log-format "%{+Q}o %t %s %{-Q}r" log-format '%{+Q}o %t %s %{-Q}r' log-format "%{+Q}o %t"' %s %{-Q}r' log-format "%{+Q}o %t"' %s'\ %{-Q}r

There is one particular case where a second level of quoting or escaping may be necessary. Some keywords take arguments within parenthesis, sometimes delimited by commas. These arguments are commonly integers or predefined words, but when they are arbitrary strings, it may be required to perform a separate level of escaping to disambiguate the characters that belong to the argument from the characters that are used to delimit the arguments themselves. A pretty common case is the "regsub" converter. It takes a regular expression in argument, and if a closing parenthesis is needed inside, this one will require to have its own quotes. The keyword argument parser is exactly the same as the top-level one regarding quotes, except that the \#, \$, and \xNN escapes are not processed. But what is not always obvious is that the delimiters used inside must first be escaped or quoted so that they are not resolved at the top level. Let's take this example making use of the "regsub" converter which takes 3 arguments, one regular expression, one replacement string and one set of flags: # replace all occurrences of "foo" with "blah" in the path: http-request set-path %[path,regsub(foo,blah,g)] Here no special quoting was necessary. But if now we want to replace either "foo" or "bar" with "blah", we'll need the regular expression "(foo|bar)". We cannot write: http-request set-path %[path,regsub((foo|bar),blah,g)] because we would like the string to cut like this: http-request set-path %[path,regsub((foo|bar),blah,g)] |---------|----|-| arg1 _/ / / arg2 __________/ / arg3 ______________/ but actually what is passed is a string between the opening and closing parenthesis then garbage: http-request set-path %[path,regsub((foo|bar),blah,g)] |--------|--------| arg1=(foo|bar _/ / trailing garbage _________/ The obvious solution here seems to be that the closing parenthesis needs to be quoted, but alone this will not work, because as mentioned above, quotes are processed by the top-level parser which will resolve them before processing this word: http-request set-path %[path,regsub("(foo|bar)",blah,g)] ------------ -------- ---------------------------------- word1 word2 word3=%[path,regsub((foo|bar),blah,g)] So we didn't change anything for the argument parser at the second level which still sees a truncated regular expression as the only argument, and garbage at the end of the string. By escaping the quotes they will be passed unmodified to the second level: http-request set-path %[path,regsub(\"(foo|bar)\",blah,g)] ------------ -------- ------------------------------------ word1 word2 word3=%[path,regsub("(foo|bar)",blah,g)] |---------||----|-| arg1=(foo|bar) _/ / / arg2=blah ___________/ / arg3=g _______________/ Another approach consists in using single quotes outside the whole string and double quotes inside (so that the double quotes are not stripped again): http-request set-path '%[path,regsub("(foo|bar)",blah,g)]' ------------ -------- ---------------------------------- word1 word2 word3=%[path,regsub("(foo|bar)",blah,g)] |---------||----|-| arg1=(foo|bar) _/ / / arg2 ___________/ / arg3 _______________/ But in this case it's important to note that delimiters embedded into the higher level string remain pure characters and are not delimiters anymore. It particularly means that spaces and tabs around commas are part of the string. The example below is wrong on multiple points: http-request set-path '%[path, regsub("(foo|bar)", blah, g)]' ------------ -------- -------------------------------------- word1 word2 word3=%[path, regsub("(foo|bar)", blah, g)] |--------|---------||-----|--| converter=" regsub" _/ / / / arg1=(foo|bar) _/ / / arg2=" blah" ___________/ / arg3=" g" ______________/ The single fact of surrounding commas with spaces resulted in the spaces being part of the field itself, hence the converter " regsub" (starting with a space), which won't be found and will trigger an error, but more subtly, the replacement string " blah" will insert a space in the output. A good rule of thumb is to never insert unneeded spaces inside expressions. When using regular expressions, it can happen that the dollar ('$') character appears in the expression or that a backslash ('\') is used in the replacement string. In this case these ones will also be processed inside the double quotes thus single quotes are preferred (or double escaping). Example: http-request set-path '%[path,regsub("^/(here)(/|$)","my/\1",g)]' ------------ -------- ----------------------------------------- word1 word2 word3=%[path,regsub("^/(here)(/|$)","my/\1",g)] |-------------| |-----||-| arg1=(here)(/|$) _/ / / arg2=my/\1 ________________/ / arg3 ______________________/ Remember that backslashes are not escape characters within single quotes and that the whole word above is already protected against them using the single quotes. Conversely, if double quotes had been used around the whole expression, single the dollar character and the backslashes would have been resolved at top level, breaking the argument contents at the second level. Unfortunately, since single quotes can't be escaped inside of strong quoting, if you need to include single quotes in your argument, you will need to escape or quote them twice. There are a few ways to do this: http-request set-var(txn.foo) str("\\'foo\\'") http-request set-var(txn.foo) str(\"\'foo\'\") http-request set-var(txn.foo) str(\\\'foo\\\') When in doubt, simply do not use quotes anywhere, and start to place single or double quotes around arguments that require a comma or a closing parenthesis, and think about escaping these quotes using a backslash if the string contains a dollar or a backslash. Again, this is pretty similar to what is used under a Bourne shell when double-escaping a command passed to "eval". For API writers the best is probably to place escaped quotes around each and every argument, regardless of their contents. Users will probably find that using single quotes around the whole expression and double quotes around each argument provides more readable configurations.

HAProxy 的配置支持环境变量。这些变量仅在双引号内被解释。变量在配置解析期间被展开。变量名前必须有美元符号 ("$")，并且可以选择性地用大括号 ("{}") 括起来，类似于 Bourne shell 中的做法。变量名可以包含字母数字字符或下划线 ("_")，但不应以数字开头。如果变量包含由空格分隔的多个值列表，可以通过用大括号将变量括起来并在右大括号前附加后缀 '[*]' 来将其展开为单个参数。当变量未设置时，也可以通过在变量名旁边的破折号 '-' 后面附加该值来指定一个默认值。请注意，默认值只替换不存在的变量，而不是空变量。

bind "fd@${FD_APP1}" log "${LOCAL_SYLOG-127.0.0.1}:514" local0 notice # 发送到本地服务器 user "$HAPROXY_USER"

HAProxy 定义了一些变量，这些变量可以在配置文件中使用，也可以被程序继承（参见 3.7. Programs）。这些变量分为四类，如下表所示： * usable (可用)：变量可以从配置中访问，既可以按原样解析，也可以用于条件块或谓词中，以启用或禁用某些配置片段，如 section 2.4 "Conditional blocks" 中所述。 * modifiable (可修改)：变量可以通过 "setenv"/"unsetenv" 关键字在配置中重新定义或取消设置。 * listed (可列出)：变量列在 CLI 的 "show env" 命令输出中，如管理指南的 section 9.3 "Unix Sockets commands" 中所述。 * exported (已导出)：变量导出到修改后的环境中以启动程序（参见 section 3.7 "Programs"）。请注意，这不适用于外部检查，外部检查有自己的关于导出变量的规则。 还有两个子类别 "master" 和 "worker"，分别在下表中标记为 'M' 和 'W'，显示了 HAProxy 在 master-worker 模式下启动时，两个进程之间的差异。 * master：变量在 master 进程中设置并可访问。因此，它将出现在 master CLI 的 "show env" 输出中，并且可以用于条件块或指令中，以启用 master 的一些特殊设置（参见 section 2.4 "Conditional blocks" 中的示例）。 * worker：变量在 worker 进程中设置并可访问。它将出现在 worker CLI 的 "show env"（或 master CLI 的 "@1 show env"）中，并且也可以限制某些 worker 进程参数（参见 section 2.4 "Conditional blocks" 中的示例）。 在独立模式下（没有 "-W" 选项或 "master-worker" 关键字），进程的行为类似于 worker，除了变量 "HAPROXY_MASTER_CLI" 和 "HAPROXY_MWORKER" 未定义。 有些变量被标记为不可用且不可修改： * HAPROXY_CFGFILES * HAPROXY_MWORKER * HAPROXY_CLI * HAPROXY_MASTER_CLI * HAPROXY_LOCALPEER 它们的值在配置解析期间未定义，而是在初始化期间设置。因此，建议不要在条件块中使用这些变量，也不要在 global 部分的 "setenv"/"resetenv"/"unsetenv" 关键字中引用它们。 下表总结了每个变量在不同工作模式下的状态： +--------------------------+----------+---------+------------+-----------+ | variable | exported | usable | modifiable | listed | | | +---------+------------+-----------+ | | | M | W | M | W | M | W | +--------------------------+----------+----+----+------+-----+-----+-----+ | HAPROXY_STARTUP_VERSION | X | X | X | | | X | X | | HAPROXY_BRANCH | X | X | X | | | X | X | | HAPROXY_CFGFILES | X | | | | | X | X | | HAPROXY_MWORKER | X | | | | | X | X | | HAPROXY_CLI | | | | | | | X | | HAPROXY_MASTER_CLI | | | | | | X | | | HAPROXY_LOCALPEER | | | X | | | | X | | HAPROXY_HTTP_LOG_FMT | | | X | | X | | | | HAPROXY_HTTP_CLF_LOG_FMT | | | X | | X | | | | HAPROXY_HTTPS_LOG_FMT | | | X | | X | | | | HAPROXY_TCP_LOG_FMT | | | X | | X | | | +--------------------------+----------+----+----+------+-----+-----+-----+ 涉及到的变量如下： * HAPROXY_LOCALPEER：在进程启动时定义，包含本地对等体的名称。（参见管理指南中的 "-L"。） * HAPROXY_CFGFILES：HAProxy 加载的配置文件的列表，以分号分隔。在指定目录的情况下可能有用。 * HAPROXY_HTTP_LOG_FMT：包含默认 HTTP 日志格式的值，如 section 8.2.3 "HTTP log format" 中所定义。它可用于覆盖默认日志格式，而无需复制整个原始定义。 * HAPROXY_HTTP_CLF_LOG_FMT：包含默认 HTTP CLF 日志格式的值，如 section 8.2.3 "HTTP log format" 中所定义。它可用于覆盖默认日志格式，而无需复制整个原始定义。

# 将给出最终判决的规则添加到日志中 log-format "${HAPROXY_TCP_LOG_FMT} lr=last_rule_file:last_rule_line"

* HAPROXY_HTTPS_LOG_FMT：与 HAPROXY_HTTP_LOG_FMT 类似，但用于 HTTPS 日志格式，如 section 8.2.4 "HTTPS log format" 中所定义。 * HAPROXY_TCP_LOG_FMT：与 HAPROXY_HTTP_LOG_FMT 类似，但用于 TCP 日志格式，如 section 8.2.2 "TCP log format" 中所定义。 * HAPROXY_TCP_CLF_LOG_FMT：与 HAPROXY_HTTP_CLF_LOG_FMT 类似，但用于 TCP CLF 日志格式，如 section 8.2.2 "TCP log format" 中所定义。 * HAPROXY_MWORKER：在 master-worker 模式下，此变量设置为 1。 * HAPROXY_CLI：每个进程的 stats socket 的已配置监听器地址，这些地址以分号分隔。 * HAPROXY_MASTER_CLI：在 master-worker 模式下，master CLI 的监听器地址，以分号分隔。 * HAPROXY_STARTUP_VERSION：包含用于启动的版本，在 master-worker 模式下，这是用于启动 master 的版本，即使在更新二进制文件和重新加载之后也是如此。 * HAPROXY_BRANCH：包含 HAProxy 分支版本（例如 "2.8"）。它不包含完整的版本号。在迁移期间，如果资源（例如 map 或证书）位于包含分支号的路径中，这可能会很有用。 此外，一些伪变量会在内部解析并可作为常规变量使用。伪变量始终以点（'.'）开头，并且是唯一允许使用点的变量。当前的伪变量列表如下： * .FILE：当前正在解析的配置文件的名称。 * .LINE：当前正在解析的配置文件的行号，从一开始计数。 * .SECTION：当前正在解析的节的名称，如果该节没有名称，则为其类型（例如 "global"），或者在第一个节之前为空字符串。 这些变量在它们被解析的位置解析。例如，如果 ".LINE" 变量用于位于 defaults 节中的 "log-format" 指令中，它的行号将在解析和编译 "log-format" 指令之前解析，因此后续代理将重用相同的行号。通过这种方式，可以将信息发送到变量、日志、错误状态、健康检查、标头值中，以帮助定位规则，甚至可以使用行号来命名一些配置对象，例如服务器。

有时，有条件地启用或禁用配置的某些任意部分可能很方便，例如启用/禁用 SSL 或密码套件，启用或禁用某些预生产监听器而无需修改配置，或者调整配置语法以在迁移期间支持两个不同的 HAProxy 版本。 HAProxy 提供了一组可嵌套的类似预处理器的指令，允许集成或忽略某些文本块。这些指令必须放在自己的行上，并作用于其后的行。其中两个支持表达式，其他的只切换到备用块或结束当前级别。 定义了以下 4 个指令来形成条件块： - .if <condition> - .elif <condition> - .else - .endif ".if" 指令嵌套一个新的级别，".elif" 保持在同一级别，".else" 也是如此，".endif" 关闭一个级别。每个 ".if" 必须以匹配的 ".endif" 终止。".elif" 只能放在 ".if" 或 ".elif" 之后，并且可以链接的 ".elif" 数量没有限制。每个 ".if" 只能有一个 ".else"，并且它必须始终位于 ".if" 或块中最后一个 ".elif" 之后。 如果需要在 '#' 之后放置注释，它们将被忽略。 指令像其他配置指令一样被标记化，因此可以在条件中使用环境变量。条件也可以在启动时使用 -cc 参数进行评估。请参阅管理文档中的 "3. Starting HAProxy"。 条件要么是一个空字符串（返回 false），要么是由以下任意组合组成的表达式： - 整数零 ('0')，始终返回 "false" - 非零整数（例如 '1'），始终返回 "true"。 - 谓词，可选后跟括号中的参数。 - 放置在一对括号 '(' 和 ')' 之间的条件 - 位于上述非空元素之前的感叹号 ('!')，它将否定其状态。 - 使用逻辑 AND ('&&') 组合的表达式，将从左到右评估，直到一个返回 false - 使用逻辑 OR ('||') 组合的表达式，将从右到左评估，直到一个返回 true 使用与配置语言其余部分相同的行标记器和参数解析器。单词围绕连续的一个或多个非引用空格或制表符进行拆分，并在评估之前使用单个空格重新组合在一起以进行分隔，以避免用户必须引用整行。但这_也_意味着围绕逗号或括号的空格肯定是值的一部分，这并不总是预期的。 例如，下面的表达式： .if defined( HAPROXY_MWORKER ) 将测试变量 " HAPROXY_MWORKER "（带空格）是否存在，而这个： .if streq("$ENABLE_SSL", 1) 将把环境变量 "ENABLE_SSL" 与值 " 1"（带一个前导空格）进行比较。 原因是该行首先被拆分成单词，如下所示： .if streq("$ENABLE_SSL", 1) |---|--------------------| |--| 1 2 3 然后应用弱引用并解析环境变量 "$ENABLE_SSL"（假设 ENABLE_SSL=0），最后通过在单词之间放置单个空格将单词重新组合成单个字符串： .if streq(0, 1) |---|-------|--| 1 2 3 只有这样它才被解析为单个表达式。在逗号和 "1" 之间插入的空格仍然是参数值的一部分，使此参数成为 " 1"： .if streq(0, 1) |---|-----|-|--| \ \ \ \_ argument2: " 1" \ \ \___ argument1: "0" \ \_______ function: "streq" \___________ directive: ".if" 在这里可以看到，即使 ENABLE_SSL 等于 "1"，它也不会匹配 " 1"，因为字符串会相差一个空格。 注意：如 "2.2. Quoting and escaping" 部分所述，一个好的经验法则是永远不要在表达式中插入不必要的空格。 请注意，与在其他语言中一样，AND 运算符优先于 OR 运算符，因此 "A && B || C && D" 的评估结果为 "(A && B) || (C && D)"。 当前支持的谓词列表如下： - defined(<name>)：如果环境变量 <name> 存在，则返回 true，无论其内容如何 - feature(<name>)：如果特性 <name> 在 "haproxy -vv" 报告的特性列表中列出（这意味着 <name> 出现在 '+' 之后），则返回 true - openssl_version_atleast(<ver>)：如果当前 openssl 版本至少与 <ver> 一样新，则返回 true，否则返回 false。 LibreSSL、AWS-LC 和 WolfSSL 等库也提供了伪 OpenSSL 版本。

ssllib_name_startswith(OpenSSL) && openssl_version_atleast(1.1.1)

- openssl_version_before(<版本>)：如果当前的 openssl 版本严格早于 <版本>，则返回 true，否则返回 false。像 LibreSSL、AWS-LC 和 WolfSSL 这样的库也提供一个伪 OpenSSL 版本。

openssl_version_before(3.5.0)

- ssllib_name_startswith(<名称>)：如果 HAProxy 链接的 SSL 库名称以 <名称> 开头，则返回 true。

ssllib_name_startswith(wolfSSL)

- streq(<字符串1>,<字符串2>)：仅当两个字符串相等时返回 true - strneq(<字符串1>,<字符串2>)：仅当两个字符串不同时返回 true - strstr(<字符串1>,<字符串2>)：仅当第二个字符串在第一个字符串中找到时返回 true。 - version_atleast(<版本>)：如果当前的 haproxy 版本至少与 <版本> 一样新，则返回 true，否则返回 false。版本语法与 "haproxy -v" 显示的相同，缺失的组件被假定为零。 - version_before(<版本>)：如果当前的 haproxy 版本严格早于 <版本>，则返回 true，否则返回 false。版本语法与 "haproxy -v" 显示的相同，缺失的组件被假定为零。 - enabled(<选项>)：如果选项 <选项> 在运行时启用，则返回 true。仅支持一部分选项：POLL、EPOLL、KQUEUE、EVPORTS、SPLICE、GETADDRINFO、REUSEPORT、FAST-FORWARD、SERVER-SSL-VERIFY-NONE

# 1. HAPROXY_MWORKER 变量由 HAProxy 在 master 和 # worker 进程环境中自动设置（参见 2.3. Environment variables 中的 HAProxy 变量矩阵）。 # 它的存在会启用一个额外的监听器。 global master-worker .if defined(HAPROXY_MWORKER) listen mwcli_px bind :1111 ... .endif # 2. HAPROXY_BRANCH 由 HAProxy 在 master 和 worker # 进程环境中自动设置（参见 2.3. Environment variables 中的 HAProxy 变量矩阵）。 # 我们检查 HAPROXY_BRANCH 值并有条件地启用 # mworker-max-reloads 参数。 global master-worker .if streq("$HAPROXY_BRANCH",3.1) mworker-max-reloads 5 .endif # 3. 用户在 global 节中设置了一些任意环境变量。 # 如果 HAProxy 在 master-worker 模式下启动，它们会呈现在 # master 和 worker 进程环境中。我们检查这些变量的值 # 并有条件地启用端口 80 和 443。环境变量 # 检查可以与特性和版本检查混合使用。 global setenv WITH_SSL yes unsetenv SSL_ONLY .if strneq("$SSL_ONLY",yes) bind :80 .endif .if streq("$WITH_SSL",yes) .if feature(OPENSSL) bind :443 ssl crt ... .endif .endif .if feature(OPENSSL) && (streq("$WITH_SSL",yes) || streq("$SSL_ONLY",yes)) bind :443 ssl crt ... .endif .if version_atleast(2.4-dev19) profiling.memory on .endif .if !feature(OPENSSL) .alert "SSL support is mandatory" .endif

还提供了另外四个指令来报告某些状态： - .diag "message" : 仅在诊断模式（-dD）下发出此消息 - .notice "message" : 以 NOTICE 级别发出此消息 - .warning "message" : 以 WARNING 级别发出此消息 - .alert "message" : 以 ALERT 级别发出此消息 如果启用了 "zero-warning"，以 WARNING 级别发出的消息可能导致进程启动失败。以 ALERT 级别发出的消息将始终导致致命错误。这些可以用来检测一些不适当的条件并向用户提供建议。

.if "${A}" .if "${B}" .notice "A=1, B=1" .elif "${C}" .notice "A=1, B=0, C=1" .elif "${D}" .warning "A=1, B=0, C=0, D=1" .else .alert "A=1, B=0, C=0, D=0" .endif .else .notice "A=0" .endif .diag "WTA/2021-05-07: 切换到 2.4 后将 'redirect' 替换为 'return'" http-request redirect location /goaway if ABUSE

一些参数涉及表示时间的值，例如超时。这些值通常以毫秒表示（除非另有明确说明），但也可以通过在数值后附加单位来以任何其他单位表示。考虑这一点很重要，因为每个关键字都不会重复说明。支持的单位有：- us：微秒。1 微秒 = 1/1000000 秒 - ms：毫秒。1 毫秒 = 1/1000 秒。这是默认单位。 - s：秒。1s = 1000ms - m：分钟。1m = 60s = 60000ms - h：小时。1h = 60m = 3600s = 3600000ms - d：天。1d = 24h = 1440m = 86400s = 86400000ms

一些参数涉及表示大小的值，例如带宽限制。这些值通常以字节表示（除非另有明确说明），但也可以通过在数值后附加单位来以任何其他单位表示。考虑这一点很重要，因为每个关键字都不会重复说明。支持的单位不区分大小写：- k：千字节。1 千字节 = 1024 字节 - m：兆字节。1 兆字节 = 1048576 字节 - g：吉字节。1 吉字节 = 1073741824 字节 时间和大小格式都需要整数，不允许使用小数表示法。

可以对 map 或 ACL 使用模式列表。模式列表由其名称标识，可以在配置中的不同位置使用。模式列表根据名称格式分为三类： * 基于常规文件的模式列表：这是默认情况。文件名（绝对路径或相对路径）用作名称。文件必须存在，否则会触发错误。但它可以为空。也可以指定 "file@" 前缀，但它不是用于标识列表的名称的一部分。带前缀或不带前缀的文件名引用相同的模式列表。 * 基于可选文件的模式列表：文件名必须以 "opt@" 前缀开头。文件是否存在是可选的。如果文件存在，则加载其内容，否则不报告错误。前缀不是用于标识列表的名称的一部分。这意味着，对于给定的文件名，可选文件和常规文件引用相同的模式列表。 * 基于虚拟文件的模式列表：名称只是一个标识符。它不引用任何文件。必须使用 "virt@" 前缀。它是名称的一部分。因此，它不能与其他类型的列表混合使用。当模式完全动态管理，启动和重新加载时没有模式时，虚拟文件非常有用。可选文件可以在相同条件下使用。但是模式可以转储到文件中，例如通过基于 "show map" CLI 命令的外部脚本。通过这种方式，可以在重新加载时保留模式。 注意：尽管不太可能，这意味着不能加载以 "file@"、"opt@" 或 "virt@" 开头的常规文件，除非在文件名前面明确添加 "./"（例如 "file@./virt@map"）。

在 HAProxy 配置中，变量可用于样本获取函数、转换器、log-format 字符串或 TCP/HTTP 操作。可以定义进程范围的变量，在整个进程生命周期内全局可访问。其他一些变量的生命周期较短。 变量类似于 shell 脚本中找到的变量。它是一块内存的符号名称。变量大小不受限制，并且是动态分配的。因此，必须谨慎使用，尤其是对于密集使用。但是，可以通过设置 "tune.vars" 全局参数来限制变量使用的最大内存量。 变量必须使用 "<scope>.<name>" 格式指定。<scope> 是一个单词，指示变量的生命周期。<name> 部分在范围内，只能包含字符 'a-z'、'A-Z'、'0-9' 和 '_'。它在此范围内是唯一的，但不同范围中的相同名称可以用于引用不同的变量。 支持的范围包括： * proc：用于在整个进程生命周期内已知且全局可访问的变量。可以使用 CLI 中的 "get var" 和 "set var" 命令来操作 "proc" 变量。它们也可以通过 "set-var
This keyword is available in sections :
Process management and security
Alphabetically sorted actions reference
Converters" 和 "set-var-fmt
This keyword is available in sections :
Process management and security
Alphabetically sorted actions reference" 指令从 "global" 节设置。 * sess：用于在整个会话生命周期内已知的变量。"sess" 变量是会话私有的，从外部不可见，不与其他会话共享。 * txn：用于在整个事务生命周期内已知的变量。"txn" 变量是流私有的，从外部不可见，不与其他流共享。 * req：用于在特定流的请求处理期间已知的变量。"req" 变量从流创建开始可见，直到第一次服务器连接尝试。它们是流私有的，从外部不可见，不与其他流共享。 "req" 和 "res" 变量之间没有任何重叠。 * res：用于在特定流的响应处理期间已知的变量。"res" 变量从第一次服务器连接尝试开始可见，直到流销毁。它们是流私有的，从外部不可见，不与其他流共享。 "req" 和 "res" 变量之间没有任何重叠。 * check：用于在健康检查执行期间已知的变量。"check" 变量是健康检查私有的，从外部不可见，不与其他健康检查共享。它们可以使用专用的 "tcp-check" 或 "http-check" 指令设置。 根据上下文，可以使用引用当前流父级的额外范围： * psess：与 "sess" 相同，但使用父流的会话（如果有）。 * ptxn：与 "txn" 相同，但使用父流的事务（如果有）。 * preq：与 "req" 相同，但使用父流（如果有）。"preq" 变量仅在父流的请求处理期间可访问。 * pres：与 "res" 相同，但使用父流（如果有）。"pres" 变量仅在父流的响应处理期间可访问。 引用父流的范围从定义时起即可使用。大多数情况下，没有父流。但是，如果适用，将明确指定。目前，只能检索父流范围内定义的变量的值。无法设置或取消设置此类变量。 通常，子流在特定时刻为父流执行一些处理，并阻止父流继续进行，直到其完成操作。这意味着父流可能在请求处理或响应处理中间停止。因此，子流将无法访问某些范围。例如，如果请求需要由子流执行一些分析，则此子流将无法在 "pres" 范围中找到任何变量，因为父流没有在处理响应，因此其 "res" 范围中没有变量。 变量的内容是样本获取表达式评估的结果，它继承了该表达式的输出类型。当使用变量时，这很重要，因为其类型必须与其用法兼容。例如，在 "add()" 转换器中使用的包含字符串的变量必须可转换为有效的整数才能成功。当变量与静态值进行比较时，情况尤其如此。必须使用正确的匹配方法。

# 一个简单的 HTTP 代理配置，在所有接口的 80 端口上监听，# 并将请求转发到名为 "servers" 的单个后端，该后端有一个名为 "server1" 的服务器，# 监听于 127.0.0.1:8000 global daemon maxconn 256 defaults mode http timeout connect 5000ms timeout client 50000ms timeout server 50000ms frontend http-in bind *:80 default_backend servers backend servers server server1 127.0.0.1:8000 maxconn 32 # 使用单个 listen 块定义的相同配置。更短但表达力较差，尤其是在 HTTP 模式下。 global daemon maxconn 256 defaults mode http timeout connect 5000ms timeout client 50000ms timeout server 50000ms listen http-in bind *:80 server server1 127.0.0.1:8000 maxconn 32 假设 haproxy 在 $PATH 中，请在 shell 中使用以下命令测试这些配置：$ sudo haproxy -f configuration.conf -c

"global" 节中的参数是进程范围的，通常是特定于操作系统的。它们通常设置一次即可，一旦正确就不需要更改。其中一些有命令行等效项。 "global" 节中支持以下关键字： * 进程管理和安全性 - 51degrees-allow-unmatched - 51degrees-cache-size - 51degrees-data-file - 51degrees-difference - 51degrees-drift - 51degrees-property-name-list - 51degrees-property-separator - 51degrees-use-performance-graph - 51degrees-use-predictive-graph - ca-base - chroot - cluster-secret - cpu-map - crt-base - daemon - default-path - description - deviceatlas-json-file - deviceatlas-log-level - deviceatlas-properties-cookie - deviceatlas-separator - expose-deprecated-directives - expose-experimental-directives - external-check - fd-hard-limit - gid - grace - group - h1-accept-payload-with-any-method - h1-case-adjust - h1-case-adjust-file - h1-do-not-close-on-insecure-transfer-encoding - h2-workaround-bogus-websocket-clients - hard-stop-after - harden.reject-privileged-ports.tcp - harden.reject-privileged-ports.quic - insecure-fork-wanted - insecure-setuid-wanted - issuers-chain-path - key-base - limited-quic - localpeer - log - log-send-hostname - log-tag - lua-load - lua-load-per-thread - lua-prepend-path - mworker-max-reloads - nbthread - no-quic - node - numa-cpu-mapping - ocsp-update.disable - ocsp-update.maxdelay - ocsp-update.mindelay - ocsp-update.httpproxy - ocsp-update.mode - pidfile - pp2-never-send-local - presetenv - prealloc-fd - resetenv - set-dumpable - set-var - setenv - ssl-default-bind-ciphers - ssl-default-bind-ciphersuites - ssl-default-bind-client-sigalgs - ssl-default-bind-curves - ssl-default-bind-options - ssl-default-bind-sigalgs - ssl-default-server-ciphers - ssl-default-server-ciphersuites - ssl-default-server-client-sigalgs - ssl-default-server-curves - ssl-default-server-options - ssl-default-server-sigalgs - ssl-dh-param-file - ssl-propquery - ssl-provider - ssl-provider-path - ssl-security-level - ssl-server-verify - ssl-skip-self-issued-ca - stats - stats-file - strict-limits - uid - ulimit-n - unix-bind - unsetenv - user - wurfl-cache-size - wurfl-data-file - wurfl-information-list - wurfl-information-list-separator * 性能调优 - busy-polling - max-spread-checks - maxcompcpuusage - maxcomprate - maxconn - maxconnrate - maxpipes - maxsessrate - maxsslconn - maxsslrate - maxzlibmem - no-memory-trimming - noepoll - noevports - nogetaddrinfo - nokqueue - nopoll - noreuseport - nosplice - profiling.memory - profiling.tasks - server-state-base - server-state-file - spread-checks - ssl-engine - ssl-mode-async - tune.applet.zero-copy-forwarding - tune.buffers.limit - tune.buffers.reserve - tune.bufsize - tune.bufsize.small - tune.comp.maxlevel - tune.disable-fast-forward - tune.disable-zero-copy-forwarding - tune.epoll.mask-events - tune.events.max-events-at-once - tune.fail-alloc - tune.fd.edge-triggered - tune.h1.zero-copy-fwd-recv - tune.h1.zero-copy-fwd-send - tune.h2.be.glitches-threshold - tune.h2.be.initial-window-size - tune.h2.be.max-concurrent-streams - tune.h2.be.rxbuf - tune.h2.fe.glitches-threshold - tune.h2.fe.initial-window-size - tune.h2.fe.max-concurrent-streams - tune.h2.fe.max-total-streams - tune.h2.fe.rxbuf - tune.h2.header-table-size - tune.h2.initial-window-size - tune.h2.max-concurrent-streams - tune.h2.max-frame-size - tune.h2.zero-copy-fwd-send - tune.http.cookielen - tune.http.logurilen - tune.http.maxhdr - tune.idle-pool.shared - tune.idletimer - tune.lua.bool-sample-conversion - tune.lua.burst-timeout - tune.lua.forced-yield - tune.lua.log.loggers - tune.lua.log.stderr - tune.lua.maxmem - tune.lua.service-timeout - tune.lua.session-timeout - tune.lua.task-timeout - tune.max-checks-per-thread - tune.maxaccept - tune.maxpollevents - tune.maxrewrite - tune.memory.hot-size - tune.pattern.cache-size - tune.peers.max-updates-at-once - tune.pipesize - tune.pool-high-fd-ratio - tune.pool-low-fd-ratio - tune.pt.zero-copy-forwarding - tune.quic.cc-hystart - tune.quic.cc.cubic.min-losses - tune.quic.disable-udp-gso - tune.quic.frontend.glitches-threshold - tune.quic.frontend.max-idle-timeout - tune.quic.frontend.max-streams-bidi - tune.quic.frontend.default-max-window-size - tune.quic.max-frame-loss - tune.quic.reorder-ratio - tune.quic.retry-threshold - tune.quic.socket-owner - tune.quic.tx-pacing - tune.quic.zero-copy-fwd-send - tune.renice.runtime - tune.renice.startup - tune.rcvbuf.backend - tune.rcvbuf.client - tune.rcvbuf.frontend - tune.rcvbuf.server - tune.recv_enough - tune.ring.queues - tune.runqueue-depth - tune.sched.low-latency - tune.sndbuf.backend - tune.sndbuf.client - tune.sndbuf.frontend - tune.sndbuf.server - tune.stick-counters - tune.ssl.cachesize - tune.ssl.capture-buffer-size - tune.ssl.capture-cipherlist-size (deprecated) - tune.ssl.default-dh-param - tune.ssl.force-private-cache - tune.ssl.hard-maxrecord - tune.ssl.keylog - tune.ssl.lifetime - tune.ssl.maxrecord - tune.ssl.ssl-ctx-cache-size - tune.ssl.ocsp-update.maxdelay (deprecated) - tune.ssl.ocsp-update.mindelay (deprecated) - tune.vars.global-max-size - tune.vars.proc-max-size - tune.vars.reqres-max-size - tune.vars.sess-max-size - tune.vars.txn-max-size - tune.zlib.memlevel - tune.zlib.windowsize * 调试 - anonkey - force-cfg-parser-pause - quiet - warn-blocked-traffic-after - zero-warning * HTTPClient - httpclient.resolvers.disabled - httpclient.resolvers.id - httpclient.resolvers.prefer - httpclient.retries - httpclient.ssl.ca-file - httpclient.ssl.verify - httpclient.timeout.connect

用于提供设备检测服务的 51Degrees 数据文件的路径。该文件应该是解压缩的，并且 HAProxy 具有相关权限可以访问。请注意，此选项仅在 HAProxy 编译时启用了 USE_51DEGREES 的情况下可用。

要从数据集中加载的 51Degrees 属性名称列表。完整的名称列表可在 51Degrees 网站上找到：https://51degrees.com/resources/property-dictionary 请注意，此选项仅在 HAProxy 编译时启用了 USE_51DEGREES 的情况下可用。

一个字符，将附加到包含 51Degrees 结果的响应头中每个属性值的末尾。如果未设置，则默认为 ','。请注意，此选项仅在 HAProxy 编译时启用了 USE_51DEGREES 的情况下可用。

将 51Degrees 转换器缓存的大小设置为 <数字> 个条目。这是一个 LRU 缓存，用于记录以前的设备检测及其结果。默认情况下，此缓存是禁用的。请注意，此选项仅在 HAProxy 编译时启用了 USE_51DEGREES 的情况下可用。

启用（'on'）或禁用（'off'）在检测过程中使用性能图。默认值取决于 51Degrees 库。请注意，此选项仅在 HAProxy 编译时启用了 USE_51DEGREES 和 51DEGREES_VER=4 的情况下可用。

启用（'on'）或禁用（'off'）在检测过程中使用预测图。默认值取决于 51Degrees 库。请注意，此选项仅在 HAProxy 编译时启用了 USE_51DEGREES 和 51DEGREES_VER=4 的情况下可用。

设置检测可以允许的漂移值。请注意，此选项仅在 HAProxy 编译时启用了 USE_51DEGREES 和 51DEGREES_VER=4 的情况下可用。

设置检测可以允许的差异值。请注意，此选项仅在 HAProxy 编译时启用了 USE_51DEGREES 和 51DEGREES_VER=4 的情况下可用。

启用（'on'）或禁用（'off'）在检测过程中使用不匹配的节点。默认值取决于 51Degrees 库。请注意，此选项仅在 HAProxy 编译时启用了 USE_51DEGREES 和 51DEGREES_VER=4 的情况下可用。

当使用 "ca-file
This keyword is available in sections :
Bind options
Server and default-server options"、"ca-verify-file" 或 "crl-file
This keyword is available in sections :
Bind options
Server and default-server options" 指令时使用相对路径时，分配一个默认目录来获取 SSL CA 证书和 CRL。在 "ca-file
This keyword is available in sections :
Bind options
Server and default-server options"、"ca-verify-file" 和 "crl-file
This keyword is available in sections :
Bind options
Server and default-server options" 中指定的绝对位置优先，并忽略 "ca-base"。

在降低权限之前，将当前目录更改为 <jail dir> 并在那里执行 chroot()。这提高了安全级别，以防未知漏洞被利用，因为它会使攻击者很难利用系统。这仅在进程以超级用户权限启动时有效。确保 <jail_dir> 既为空又对任何人不可写非常重要。

定义一个时间窗口，在此期间，在软停止的情况下，空闲连接和活动连接的关闭将被分散进行。收到 SIGUSR1 并且宽限期结束后（如果有的话），如果没有设置此选项，空闲连接将立即全部关闭，而活动的 HTTP 或 HTTP2 连接将在收到下一个请求后结束，方法是在 HTTP 响应中附加“Connection: close”行，或者在 HTTP2 的情况下发送 GOAWAY 帧。当设置此选项时，连接关闭将在此设定的 <time> 内分散进行。如果 close-spread-time 设置为“infinite”，则在软停止期间将禁用活动连接的关闭。“Connection: close”头将不再添加到 HTTP 响应中（或 HTTP2 的 GOAWAY），空闲连接只有在其超时到达时（基于配置中设置的各种超时）才会被关闭。

<time> 是一个时间窗口（默认为毫秒），在此期间，连接关闭将在软停止操作期间分散进行，或者如果应禁用活动连接关闭，则为“infinite”。

如果使用了“hard-stop-after”选项，建议将此设置的值设置为低于该选项中使用的值，以便所有连接都有机会在进程停止前正常关闭。

定义一个由属于同一集群的多个节点共享的 ASCII 字符串密钥。它可以用于不同的用途。它至少用于为该进程实例化的所有 QUIC 连接派生无状态重置令牌。这也用于派生用于加密重试令牌的密钥。如果未设置此参数，则在进程启动时将选择一个随机值。这允许使用依赖于它的功能，尽管有一些限制。

在某些操作系统上，可以将线程组或线程绑定到特定的 CPU 集。这意味着指定的线程永远不会在其他 CPU 上运行。"cpu-map" 指令为单个线程或线程组指定 CPU 集。 第一个参数是线程组范围，可选后跟线程集。这些范围具有以下格式： all | odd | even | number[-[number]] <number> 必须是 1 到 32 或 64 之间的数字，具体取决于机器的字大小。任何超出 'thread-groups' 的组 ID 和超出机器字大小的线程 ID 都将被忽略。所有线程号都相对于它们所属的组。可以使用由短划线 ('-') 分隔的两个此类数字来指定范围。也可以使用 "all" 一次指定所有线程，使用 "odd" 指定奇数，或使用 "even" 指定偶数，就像使用 "thread
This keyword is available in sections :
Bind options
Fetching samples from internal states" bind 指令一样。 第二个和后续参数是 CPU 集。每个 CPU 集要么是一个唯一的数字（从第一个 CPU 的 0 开始），要么是由短划线 ('-') 分隔的两个此类数字的范围。这些 CPU 数字和范围可以通过逗号分隔重复，或者通过在同一行上传递更多范围作为新参数来重复。 在 Linux 和 BSD 操作系统之外，最大 CPU 索引可能限制为 31 或 63。 可以指定多个 "cpu-map" 指令，但当它们重叠时，每个 "cpu-map" 指令将替换前一个。范围可以部分定义。可以省略上限。在这种情况下，它会被替换为相应的最大值，具体取决于机器的字大小，可能是 32 或 64。 可以在线程集之前添加前缀 "auto:"，让 HAProxy 通过递增线程和 CPU 集自动将一组线程绑定到 CPU。为了有效，两个集必须具有相同的大小。无论 CPU 集的声明顺序如何，它都将从最低绑定到最高绑定。不支持同时具有组和线程范围且带有 "auto:" 前缀。只支持一个范围，另一个必须是固定数字。 请注意，支持组范围是出于历史原因。如今，一个单独的数字表示一个线程组，如果不使用线程组，则必须为 1，并且指定线程范围或数字需要在其前面加上 "1/"（如果不使用线程组）。最后，"1" 严格等同于 "1/all"，表示组中的所有线程。

cpu-map 1/all 0-3 # 将第一个组的所有线程绑定到 # 前 4 个 CPU cpu-map 1/1- 0- # 将替换为 "cpu-map 1/1-64 0-63" # 或 "cpu-map 1/1-32 0-31"，具体取决于机器的 # 字大小。 # 所有这些行都将线程 1 绑定到 cpu 0，线程 2 绑定到 cpu 1 # 等等。 cpu-map auto:1/1-4 0-3 cpu-map auto:1/1-4 0-1 2-3 cpu-map auto:1/1-4 3 2 1 0 cpu-map auto:1/1-4 3,2,1,0 # 使用 all/odd/even 关键字将每个线程绑定到恰好一个 CPU cpu-map auto:1/all 0-63 cpu-map auto:1/even 0-31 cpu-map auto:1/odd 32-63 # 无效的 cpu-map，因为线程集和 CPU 集的大小不同。 cpu-map auto:1/1-4 0 # 无效 cpu-map auto:1/1 0-3 # 无效 # 将这 4 个组的 40 个线程映射到单个 CPU cpu-map auto:1/1-10 0-9 cpu-map auto:2/1-10 10-19 cpu-map auto:3/1-10 20-29 cpu-map auto:4/1-10 30-39 # 将 80 个线程映射到一个物理套接字，将另外 80 个线程映射到另一个套接字 # 而不强制分配。这些被分成 4 个组，因为没有 # 组可以有超过 64 个线程。 cpu-map 1/1-40 0-39,80-119 # node0, siblings 0 & 1 cpu-map 2/1-40 0-39,80-119 cpu-map 3/1-40 40-79,120-159 # node1, siblings 0 & 1 cpu-map 4/1-40 40-79,120-159

当使用 "crtfile" 或 "crt
This keyword is available in sections :
Load options
Bind options
Server and default-server options" 指令时使用相对路径时，分配一个默认目录来获取 SSL 证书。指定的绝对位置优先，并忽略 "crt-base
This keyword is available in sections :
Process management and security
Certificate Storage"。

使进程 fork 到后台运行。这是推荐的操作模式。它等同于命令行参数 "-D"。它可以通过命令行参数 "-db" 禁用。此选项在 systemd 模式下被忽略。

默认情况下，HAProxy 从进程启动位置加载由相对路径指定的所有文件。在某些情况下，可能需要强制所有相对路径从不同位置开始，就好像进程是从这些位置启动一样。这就是此指令的目的。从技术上讲，它将在处理每个配置文件时执行对指定位置的临时 chdir()，并在处理完每个文件后返回原始目录。 它接受一个参数，指示加载路径不以斜杠 ('/') 开头的文件时使用的策略： - "current" 表示所有相对文件都从进程启动的目录加载；这是默认值。 - "config" 表示所有相对文件都应从包含配置文件的目录加载。更具体地说，如果配置文件包含斜杠 ('/')，则使用到最后一个斜杠的最长部分作为要更改的目录，否则使用当前目录。此模式便于将 map、errorfile、证书和 Lua 脚本捆绑为可重定位包。当加载多个配置文件时，目录会为每个文件更新。 - "parent" 表示所有相对文件都应从包含配置文件的目录的父目录加载。更具体地说，如果配置文件包含斜杠 ('/')，则将 ".." 附加到直到最后一个斜杠的最长部分作为要更改的目录，否则目录为 ".."。此模式便于将 map、errorfile、证书和 Lua 脚本捆绑为可重定位包，但每个部分位于不同的子目录中（例如 "config/"、"certs/"、"maps/" 等）。 - "origin" 表示所有相对文件都应从指定的（强制）路径加载。这可用于简化在系统上并行运行的不同 HAProxy 实例的管理，其中每个实例使用不同的前缀，但其余部分易于重定位。 每个 "default-path" 指令会立即替换任何前一个指令，并可能导致切换到不同的目录。虽然这应该始终导致所需的行为，但使用多个 default-path 指令确实不是一个好的做法，如果使用，策略应该在所有配置文件中保持一致。 警告：某些配置元素（例如 map 或证书）由其配置的路径唯一标识。通过使用可重定位布局，它们中的几个可能最终具有相同的唯一名称，从而难以在运行时更新它们，尤其是当从不同目录加载多个配置文件时。在采用相对路径之前，必须遵守严格的无冲突文件命名方案。一种健壮的方法可以是为所有文件名添加相应站点名称的前缀，或者在目录级别执行此操作。

添加描述实例的文本。请注意，需要转义某些字符（例如 #），并且此文本将插入 HTML 页面中，因此您应避免使用“<”和“>”字符。

设置要由 API 加载的 DeviceAtlas JSON 数据文件的路径。该路径必须是一个有效的 JSON 数据文件，并且 HAProxy 进程可以访问。

设置 API 返回的信息级别。此指令是可选的，如果未设置，则默认为 0。

设置用于检测请求期间是否使用了 DeviceAtlas 客户端组件的客户端 cookie 名称。此指令是可选的，如果未设置，则默认为 DAPROPS。

设置 API 属性结果的字符分隔符。此指令是可选的，如果未设置，则默认为 |。

此声明必须在使用一些标记为已弃用的指令之前出现，以消除警告并确保配置文件不会被拒绝。并非所有已弃用的指令都受此影响，只有那些没有任何替代解决方案的指令。

此语句必须出现在使用标记为实验性的指令之前，否则配置文件将被拒绝。请注意，此选项涵盖的功能不能保证运行良好，并且在维护周期中可能会中断。在开发下一个版本时，开发人员将尽最大努力维护它们，并将部署任何合理的努力来避免破坏它们，但不能保证。由于这些原因，这些功能预计在下一个 LTS 版本发布后不会得到支持。想要尝试实验性功能的用户应该尽快升级以受益于该功能的改进。

允许使用外部代理执行健康检查。出于安全预防措施，默认情况下禁用此功能，即使启用，检查仍可能失败，除非也启用了 "insecure-fork-wanted"。如果启动的程序使用 setuid 可执行文件（它真的不应该），您可能还需要在 global 节中设置 "insecure-setuid-wanted"。 默认情况下，检查以干净的环境开始，其中只包含后端节中 "external-check
This keyword is available in sections :
Process management and security
Alphabetically sorted keywords reference" 命令中定义的变量。但是，有时可能需要保留环境，例如当复杂脚本从那里检索额外的路径或信息时。这可以通过附加 "preserve-env" 关键字来完成。在这种情况下，强烈建议不要运行 setuid 或作为特权用户运行，因为这会将检查程序暴露给潜在的攻击。 有关详细信息，请参阅 "option external-check" 和 "insecure-fork-wanted" 和 "insecure-setuid-wanted"。

设置进程将使用的最大文件描述符数的上限，无论系统限制如何。虽然 "ulimit-n" 和 "maxconn
This keyword is available in sections :
Log forwarding
Performance tuning
Alphabetically sorted keywords reference
Bind options
Server and default-server options" 可用于强制执行某个值，但当未设置时，进程将受限于 "ulimit -n -H" 报告的 RLIMIT_NOFILE 设置的硬限制。但是一些现代操作系统现在允许在这里设置非常大的值（在 10 亿数量级），这对于常规使用会消耗过多的 RAM。 提供 fd-hard-limit 设置是为了对该限制强制执行可能较低的上限。这意味着当系统施加的限制低于 <number> 时，它将始终尊重系统施加的限制，但如果系统施加的限制更高，则将使用指定的值。默认情况下，fd-hard-limit 设置为 1048576。可以通过 DEFAULT_MAXFD 编译时变量更改此默认值，该变量可以用作最大（内核）系统限制，如果 RLIMIT_NOFILE 硬限制非常大。在 global 节中设置 fd-hard-limit 允许暂时覆盖构建时通过 DEFAULT_MAXFD 提供的值。 在下面的示例中，未指定其他设置，maxconn 值将自动适应 "fd-hard-limit" 和 RLIMIT_NOFILE 限制中的较低者： global # 尽可能多地使用 FD，但不超过 50000 fd-hard-limit 50000

将进程的组 ID 更改为 <number>。建议将组 ID 专用于 HAProxy 或一小组类似的守护程序。必须使用属于此组的用户或具有超级用户权限来启动 HAProxy。请注意，如果 HAProxy 是从具有补充组的用户启动的，则只有在具有超级用户权限的情况下才能删除这些组。另请参阅 "group
This keyword is available in sections :
Process management and security
Userlists
Programs (deprecated)
Bind options" 和 "uid
This keyword is available in sections :
Process management and security
Bind options"。

定义 SIGUSR1 和实际软停止之间的延迟。

<time> 是在接收到 SIGUSR1 信号后，在继续执行软停止操作之前将等待的额外延迟（默认为毫秒）。

这用于与需要停止 haproxy 进程但某些外部组件需要在解绑监听器之前检测状态的旧环境兼容。其原理是内部的 "stopping" 变量（由 "stopping" 样本获取函数报告）将被设置为 true，但监听器将继续无干扰地接受连接，直到延迟到期，之后将进行常规的软停止。这不能与重新加载的进程一起使用，否则会阻止旧进程解绑，并可能阻止新进程启动，或者只是引起麻烦。

global grace 10s # 在通过 SIGUSR1 设置 stopping 之前，返回 200 OK frontend ext-check bind :9999 monitor-uri /ext-check monitor fail if { stopping }

请注意，一个更灵活、更持久的方法是让编排系统从 CLI 设置一个全局变量，使用该变量来响应外部检查，然后在延迟后发送 SIGUSR1 信号。

# 在 proc.stopping 设置为非零之前返回 200 OK。可以通过 # HTTP 使用 set-var(proc.stopping) 或从 CLI 使用： # > set var proc.stopping int(1) frontend ext-check bind :9999 monitor-uri /ext-check monitor fail if { var(proc.stopping) -m int gt 0 }

与 "gid
This keyword is available in sections :
Process management and security
Bind options" 类似，但使用 /etc/group 中组名 <group name> 的 GID。另请参阅 "gid
This keyword is available in sections :
Process management and security
Bind options" 和 "user
This keyword is available in sections :
Process management and security
Userlists
Programs (deprecated)
Bind options"。

不拒绝带有负载的 HTTP/1.0 GET/HEAD/DELETE 请求，并返回 413 Payload Too Large HTTP 响应。虽然这在 HTTP/1.1 中是明确允许的，但 HTTP/1.0 在这一点上并不明确，一些旧服务器不期望任何负载，也从不查找正文长度（通过 Content-Length 或 Transfer-Encoding 头）。这意味着一些中间件可能正确处理 HTTP/1.0 GET/HEAD/DELETE 请求的负载，而另一些则可能完全忽略它。这可能导致安全问题，因为可能发生请求走私攻击。因此，默认情况下，HAProxy 拒绝带有负载的 HTTP/1.0 GET/HEAD/DELETE 请求。然而，这对于一些旧客户端可能是一个问题。在这种情况下，可以设置此全局选项。

根据 HTTP/1.1 规范（RFC9112#6.1）的要求，同一消息中同时存在 Transfer-Encoding 标头字段和 Content-Length 标头字段代表着严重的风险，如果上游或下游链中的任何地方存在 HTTP/1.0 代理，可能会导致内容走私攻击。面对这种情况，代理必须在响应后关闭连接，以防止任何利用。但这可能会对一些非常旧的客户端产生性能影响，特别是如果它们需要为每个请求重新协商 TLS 连接。 提供此选项是为了要求 HAProxy 不强制执行此规则，而只是清除消息，但在响应后保持连接活动。这只有在绝对确定链中没有 HTTP/1.0 代理，并且 HAProxy 之前的所有实现都完全符合 HTTP/1.1 关于这些标头字段规则时才能完成。在任何情况下，HAProxy 将继续忽略并丢弃多余的 Content-Length 标头，以免混淆下一个跳点。 当启用此选项来解决旧的损坏客户端或服务器时，重要的是要理解，无论是否需要此选项，违反此规则的代理都面临着其消息被旧代理截断的风险，这些旧代理会考虑 Content-Length 并忽略 Transfer-Encoding，因为未考虑编码块大小的累积大小。因此，上述规则不仅是安全问题，也是在处理由于与旧版本不兼容而可能面临通信问题的代理。

定义应用于标头名称 <from> 的大小写调整，当启用时，在将其发送到 HTTP/1 客户端或服务器之前，将其更改为 <to>。<from> 必须是小写，<from> 和 <to> 必须除了大小写之外没有区别。如果需要调整多个标头名称，可以重复此指令。不允许重复条目。 如果需要调整大量标头名称，使用 "h1-case-adjust-file" 可能会更方便。 请注意，除非在代理中指定了 "option h1-case-adjust-bogus-client" 或 "option h1-case-adjust-bogus-server"，否则不会应用任何转换。 标头名称没有标准大小写，因为如 RFC7230 所述，它们不区分大小写。因此，应用程序必须以不区分大小写的方式处理它们。但是一些错误的应用程序违反了标准，错误地依赖于浏览器最常用的大小写。HTTP/2 使这个问题变得至关重要，因为所有标头名称都必须以小写形式交换，HAProxy 也遵循相同的约定。所有标头名称都以小写形式发送给客户端和服务器，无论 HTTP 版本如何。未能正确处理请求或响应的应用程序可能需要暂时使用此类解决方法来调整发送给它们标头名称，以便在应用程序修复期间使用。请注意，需要此类解决方法的应用程序可能容易受到内容走私攻击，必须绝对修复。

global h1-case-adjust content-length Content-Length

请参阅 "h1-case-adjust-file"、"option h1-case-adjust-bogus-client" 和 "option h1-case-adjust-bogus-server"。

定义一个文件，其中包含键/值对列表，用于在将某些标头名称发送到 HTTP/1 客户端或服务器之前调整其大小写。文件 <hdrs-file> 每行必须包含 2 个标头名称。第一个必须是小写，并且两者除了大小写之外没有区别。以 '#' 开头的行将被忽略，空行也是如此。前导和尾随的制表符和空格被去除。不允许重复条目。 请注意，除非在代理中指定了 "option h1-case-adjust-bogus-client" 或 "option h1-case-adjust-bogus-server"，否则不会应用任何转换。 如果重复此指令，则只处理最后一个。如果需要调整大量标头名称，它是指令 "h1-case-adjust" 的替代方案。 请阅读与使用此功能相关的风险。请参阅 "h1-case-adjust"、"option h1-case-adjust-bogus-client" 和 "option h1-case-adjust-bogus-server"。

禁用向客户端宣布支持 h2 websockets。这可用于克服在实施相对较新的 RFC8441 时遇到问题的客户端，例如 Firefox 88。要允许客户端自动降级到 http/1.1 以进行 websocket 隧道，请在 bind 行上使用 "alpn
This keyword is available in sections :
Bind options
Server and default-server options" 指定 h2 支持，而无需显式 "proto
This keyword is available in sections :
Bind options
Server and default-server options" 关键字。如果此语句以前已激活，则可以通过在关键字前面加上 "no" 来禁用。

定义执行干净的软停止所允许的最长时间。

<time> 是实例在通过 SIGUSR1 信号接收到软停止时将保持活动的最长时间（默认为毫秒）。

这可用于确保即使在软停止期间连接保持打开（例如，在 tcp 模式下为代理设置了长超时），实例也会退出。它适用于 TCP 和 HTTP 模式。

global hard-stop-after 30s

切换每个协议的保护，禁止与使用特权端口作为其源端口的客户端进行通信。此端口范围根据 RFC 6335 定义。默认情况下，对 QUIC 协议启用保护，因为这种行为是可疑的，并可能被用作欺骗或 DNS/NTP 放大攻击。

替换、减少或扩展定义错误的状态码列表，这些错误被终止码和粘性表中的 "http_err_cnt" 计数器所考虑。错误的默认范围是 400 到 499，但在某些情况下，一些用户更喜欢排除特定的代码，特别是在跟踪客户端错误时（例如，在动态生成内容的系统上出现 404）。另请参阅 "http-fail-codes" 和 "http_err_cnt"。不带 '+' 或 '-' 的范围会将现有范围重新定义为新范围。以 '+' 开头的范围会将现有范围扩展以包含指定的范围，该范围可能与现有范围重叠，也可能不重叠。以 '-' 开头的范围会从现有范围中删除指定的范围。范围由一个 100 到 599 之间的数字组成，可选地后跟一个 "-" 和另一个大于或等于第一个数字的数字，以指示范围的上界。多个范围可以用逗号分隔，用于同一个添加/删除/替换操作。

http-err-codes 400,402-444,446-480,490 # 精确设置这些代码 http-err-codes 400-499 -450 +500 # 设置 400 到 500，除了 450 http-err-codes -450-459 # 从范围中移除 450 到 459 http-err-codes +501,505 # 将 501 和 505 添加到范围中

替换、减少或扩展定义失败的状态码列表，这些失败被终止码和粘性表中的 "http_fail_cnt" 计数器所考虑。失败的默认范围是 500 到 599，除了 501 和 505，它们可以由客户端触发，通常表示服务器处理请求失败。一些用户更喜欢在某些情况下排除某些代码，当已知它们不相关时，例如在某些 SOAP 环境中的 500，因为它在那里不表示服务器故障。语法与上面的 http-err-codes 完全相同。另请参阅 "http-err-codes" 和 "http_fail_cnt"。

By default HAProxy tries hard to prevent any thread and process creation after it starts. Doing so is particularly important when using Lua files of uncertain origin, and when experimenting with development versions which may still contain bugs whose exploitability is uncertain. And generally speaking it's good hygiene to make sure that no unexpected background activity can be triggered by traffic. But this prevents external checks from working, and may break some very specific Lua scripts which actively rely on the ability to fork. This option is there to disable this protection. Note that it is a bad idea to disable it, as a vulnerability in a library or within HAProxy itself will be easier to exploit once disabled. In addition, forking from Lua or anywhere else is not reliable as the forked process may randomly embed a lock set by another thread and never manage to finish an operation. As such it is highly recommended that this option is never used and that any workload requiring such a fork be reconsidered and moved to a safer solution (such as agents instead of external checks). This option supports the "no" prefix to disable it. This can also be activated with "-dI" on the haproxy command line.

HAProxy doesn't need to call executables at run time (except when using external checks which are strongly recommended against), and is even expected to isolate itself into an empty chroot. As such, there basically is no valid reason to allow a setuid executable to be called without the user being fully aware of the risks. In a situation where HAProxy would need to call external checks and/or disable chroot, exploiting a vulnerability in a library or in HAProxy itself could lead to the execution of an external program. On Linux it is possible to lock the process so that any setuid bit present on such an executable is ignored. This significantly reduces the risk of privilege escalation in such a situation. This is what HAProxy does by default. In case this causes a problem to an external check (for example one which would need the "ping" command), then it is possible to disable this protection by explicitly adding this directive in the global section. If enabled, it is possible to turn it back off by prefixing it with the "no" keyword.

Assigns a directory to load certificate chain for issuer completion. All files must be in PEM format. For certificates loaded with "crt
This keyword is available in sections :
Load options
Bind options
Server and default-server options" or "crt-list", if certificate chain is not included in PEM (also commonly known as intermediate certificate), HAProxy will complete chain if the issuer of the certificate corresponds to the first certificate of the chain loaded with "issuers-chain-path". A "crt
This keyword is available in sections :
Load options
Bind options
Server and default-server options" file with PrivateKey+Certificate+IntermediateCA2+IntermediateCA1 could be replaced with PrivateKey+Certificate. HAProxy will complete the chain if a file with IntermediateCA2+IntermediateCA1 is present in "issuers-chain-path" directory. All other certificates with the same issuer will share the chain in memory. The OCSP features are able to use the completed chain when no .issuer was used, or no chain was provided in the PEM.

Assigns a default directory to fetch SSL private keys from when a relative path is used with "key" directives. Absolute locations specified prevail and ignore "key-base
This keyword is available in sections :
Process management and security
Certificate Storage". This option only works with a crt-store load line.

当 haproxy 编译时所依赖的 TLS/SSL 库不支持 QUIC（通常是 OpenSSL）时，必须使用此设置来显式启用 QUIC 监听器绑定。当 haproxy 编译时所依赖的 TLS/SSL 库支持 QUIC（例如 quictls）时，此设置无效。请注意，设置此项后不支持 QUIC 0-RTT。

设置本地实例的对等名称。如果指定了 "-L" 命令行参数或在 "peers" 部分定义之后使用，它将被忽略。在这种情况下，在配置解析期间将发出警告消息。此选项还将设置 HAPROXY_LOCALPEER 环境变量。另请参阅管理指南中的 "-L" 和下面的 "peers" 部分。

Adds a global syslog server. Several global servers can be defined. They will receive logs for starts and exits, as well as all logs from proxies configured with "log global
This keyword is available in sections :
Log forwarding
Alphabetically sorted keywords reference". See "log
This keyword is available in sections :
Process management and security
Log forwarding
Peers
Alphabetically sorted keywords reference" option for proxies for more details.

设置 syslog 报头中的 hostname 字段。如果设置了可选的 "string" 参数，则报头将设置为该字符串内容，否则使用系统的主机名。通常在不通过中间 syslog 服务器中继日志或仅为自定义日志中打印的主机名时使用。

将 syslog 头中的标签字段设置为此字符串。它默认为从命令行启动的程序名称，通常是 "haproxy"。有时，区分在同一主机上运行的多个进程可能很有用。另请参阅每个代理的 "log-tag
此关键字在以下部分可用：
进程管理和安全
按字母排序的关键字参考
日志配置文件" 指令。

此全局指令在对所有线程可见的共享上下文中加载并执行一个 Lua 文件。在此类上下文中设置的任何变量对任何线程都可见。这是加载 Lua 程序的最简单和推荐的方法，但如果执行大量 Lua 调用，它将无法很好地扩展，因为一次只有一个线程可以在全局状态上运行。以这种方式加载的程序在 "core.thread" 变量中将始终看到 0。此指令可以多次使用。在 Lua 文件的主体中使用以下代码可以使用参数。不要忘记 Lua 数组的索引从 1 开始。在文件中声明的 "local" 变量在整个文件中可用，但在其他文件中不可用。 local args = table.pack(...)

This global directive loads and executes a Lua file into each started thread. Any global variable has a thread-local visibility so that each thread could see a different value. As such it is strongly recommended not to use global variables in programs loaded this way. An independent copy is loaded and initialized for each thread, everything is done sequentially and in the thread's numeric order from 1 to nbthread. If some operations need to be performed only once, the program should check the "core.thread" variable to figure what thread is being initialized. Programs loaded this way will run concurrently on all threads and will be highly scalable. This is the recommended way to load simple functions that register sample-fetches, converters, actions or services once it is certain the program doesn't depend on global variables. For the sake of simplicity, the directive is available even if only one thread is used and even if threads are disabled (in which case it will be equivalent to lua-load). This directive can be used multiple times. See lua-load for usage of args.

Prepends the given string followed by a semicolon to Lua's package.<type> variable. <type> must either be "path" or "cpath". If <type> is not given it defaults to "path". Lua's paths are semicolon delimited lists of patterns that specify how the `require` function attempts to find the source file of a library. Question marks (?) within a pattern will be replaced by module name. The path is evaluated left to right. This implies that paths that are prepended later will be checked earlier. As an example by specifying the following path: lua-prepend-path /usr/share/haproxy-lua/?/init.lua lua-prepend-path /usr/share/haproxy-lua/?.lua When `require "example"` is being called Lua will first attempt to load the /usr/share/haproxy-lua/example.lua script, if that does not exist the /usr/share/haproxy-lua/example/init.lua will be attempted and the default paths if that does not exist either. See https://lua.ac.cn/pil/8.1.html for the details within the Lua documentation.

主-从模式（Master-worker mode）。它等同于命令行参数“-W”。此模式将启动一个“主进程”，该进程在读取配置后会 fork 一个“工作进程”来处理流量。主进程用作进程管理器，将监控“工作进程”。使用此模式，您可以通过向主进程发送 SIGUSR2 信号直接重新加载 HAProxy。重新加载将要求主进程再次读取配置并 fork 一个新的工作进程。先前的工作进程将保留直到其作业结束。主-从模式与前台或守护进程模式兼容。默认情况下，如果工作进程因错误返回码退出，例如发生段错误，所有工作进程都将被杀死，主进程将退出。将此行为与 systemd 单元文件中的 Restart=on-failure 结合使用，以重新启动整个进程，是很方便的。如果您不希望此行为，必须使用关键字“no-exit-on-failure”。另请参阅管理指南中的“-W”。

在主-从模式下，此选项限制了工作进程可以承受的重载次数。如果工作进程在重载后没有退出，一旦其重载次数大于此数字，该工作进程将收到一个 SIGTERM 信号。此选项有助于控制工作进程的数量。另请参阅管理指南中的“show proc”。

此设置仅在内置线程支持时可用。它使 HAProxy 在 <number> 个线程上运行。“nbthread” 在 HAProxy 在前台启动时也有效。在某些支持 CPU 亲和性的平台上，默认的 “nbthread” 值会自动设置为启动时进程绑定的 CPU 数量。这意味着线程数可以轻松地从调用进程中使用 "taskset" 或 "cpuset" 等命令进行调整。否则，此值默认为 1。默认值在 "haproxy -vv" 的输出中报告。请注意，此处设置或自动检测的值受 “thread-hard-limit”（如果设置）设置的限制。

禁用 QUIC 传输协议。所有 QUIC 监听器仍将被创建，但它们不会绑定其地址。因此，haproxy 将不会处理任何 QUIC 流量。另请参阅“quic_enabled”样本获取。

如果在 NUMA 感知平台上运行，HAProxy 会在启动时检查机器的 CPU 拓扑。如果检测到多插槽机器，则会自动计算亲和性以在单个节点的 CPU 上运行。这样做是为了避免因插槽间总线延迟而导致的性能损失。但是，如果在特定架构上应用的绑定不是最优的，可以使用 'no numa-cpu-mapping' 语句禁用它。如果配置中存在 nbthread 语句，或者已指定进程的亲和性（例如通过 'cpu-map' 指令或 taskset 实用程序），则此自动绑定也不会应用。

完全禁用 HAProxy 中的 ocsp-update。任何 ocsp-update 配置都将被忽略。默认为 "off"。有关自动更新机制的更多信息，请参阅选项 "ocsp-update"。

允许为 OCSP 更新使用 HTTP 代理。这仅适用于 HTTP，不支持 HTTPS。此选项将允许 OCSP 更新器在请求中向代理发送绝对 URI。

设置同一 OCSP 响应两次自动更新之间的最大间隔。此时间以秒表示，默认为 3600（1 小时）。它必须设置为高于 “ocsp-update.mindelay” 的值。有关自动更新机制的更多信息，请参阅选项 “ocsp-update”。

设置同一 OCSP 响应两次自动更新之间的最小间隔。此时间以秒表示，默认为 300（5 分钟）。它对于没有明确过期时间的 OCSP 响应特别有用。它必须设置为低于 “ocsp-update.maxdelay” 的值。有关自动更新机制的更多信息，请参阅选项 “ocsp-update”。

为配置中使用的所有证书设置默认的 ocsp-update 模式。此全局选项可以被 crt-list 的 “ocsp-update” 选项覆盖。此选项默认设置为 "off"。有关自动更新机制的更多信息，请参阅选项 “ocsp-update”。

在守护进程模式下，将所有守护进程的 PID 写入文件 <pidfile>；在主-工作者模式下，将主进程的 PID 写入文件 <pidfile>。此选项等同于 "-p" 命令行参数。该文件必须对启动进程的用户可访问。另请参阅 "daemon" 和 "master-worker"。

PROXY 协议 v2 实现中的一个错误存在于 HAProxy 2.1 之前的版本中，导致它为健康检查发出 PROXY 命令而不是 LOCAL 命令。这问题特别微小，但会混淆一些服务器的日志。遗憾的是，这个错误发现得很晚，并揭示出一些可能只针对 HAProxy 测试其 PROXY 协议实现的服务器无法正确处理 LOCAL 命令，并在 HAProxy 检查它们时永久保持在 "down" 状态。当这种情况发生时，可以启用此全局选项以恢复到旧的（错误的）行为，直到联系受影响组件的供应商并修复它们。此选项默认禁用，并作用于所有具有 "send-proxy-v2" 语句的服务器。

将环境变量 <name> 设置为值 <value>。如果该变量已存在，则不会被覆盖。更改会立即生效，以便配置文件中的下一行可以看到新值。另请参阅 "setenv"、"resetenv" 和 "unsetenv"。

执行一次性打开最大文件描述符的操作，从而预分配内核的数据结构。这可以防止当 nbthread>1 且 HAProxy 打开一个需要内核扩展其数据结构的文件描述符时出现的短暂暂停。

删除除参数中指定的环境变量之外的所有环境变量。它允许在使用 setenv 或 unsetenv 设置新值之前，使用一个干净受控的环境。请注意，一些内部函数可能会使用某些环境变量，例如时间操作函数，以及 OpenSSL 甚至外部检查。此命令必须极其小心使用，并且只能在完全验证后使用。更改会立即生效，因此配置文件中的下一行将看到新的环境。另请参阅 “setenv”、“presetenv” 和 “unsetenv”。

指定目录前缀，该前缀将附加在所有不以“/”开头的服务器状态文件名前面。另请参阅 "server-state-file"、"load-server-state-from-file" 和 "server-state-file-name"。

指定包含服务器状态的文件路径。如果路径以斜杠（'/'）开头，则视为绝对路径，否则视为相对于使用 "server-state-base" 指定的目录（如果已设置）或当前目录。在重新加载 HAProxy 之前，可以使用统计命令 "show servers state" 保存服务器的当前状态。该命令的输出必须写入 <file> 指向的文件中。启动时，在处理流量之前，HAProxy 将读取、加载并应用文件中找到且在其当前运行配置中可用的每个服务器的状态。另请参阅 "server-state-base" 和 "show servers state"、"load-server-state-from-file" 和 "server-state-file-name"。

This option is better left disabled by default and enabled only upon a developer's request. If it has been enabled, it may still be forcibly disabled by prefixing it with the "no" keyword. It has no impact on performance nor stability but will try hard to re-enable core dumps that were possibly disabled by file size limitations (ulimit -f), core size limitations (ulimit -c), or "dumpability" of a process after changing its UID/GID (such as /proc/sys/fs/suid_dumpable on Linux). Core dumps might still be limited by the current directory's permissions (check what directory the file is started from), the chroot directory's permission (it may be needed to temporarily disable the chroot directive or to move it to a dedicated writable location), or any other system-specific constraint. For example, some Linux flavours are notorious for replacing the default core file with a path to an executable not even installed on the system (check /proc/sys/kernel/core_pattern). Often, simply writing "core", "core.%p" or "/var/log/core/core.%p" addresses the issue. When trying to enable this option waiting for a rare issue to re-appear, it's often a good idea to first try to obtain such a dump by issuing, for example, "kill -11" to the "haproxy" process and verify that it leaves a core where expected when dying.

将进程范围变量“<var-name>”设置为样本表达式 <expr> 的求值结果。变量“<var-name>”只能是进程范围变量（使用“proc.”前缀）。它的工作方式与 TCP 或 HTTP 规则中的“set-var”操作完全相同，不同之处在于表达式在配置解析时进行求值，并且变量会立即设置。表达式中允许的样本获取函数和转换器仅限于那些使用内部数据的函数，通常是“int(value)”或“str(value)”。也可以引用先前分配的变量。然后，这些变量将可以从常规规则集中读取（和修改）。

global set-var proc.current_state str(primary) set-var proc.prio int(100) set-var proc.threshold int(200),sub(proc.prio)

将进程范围变量“<var-name>”设置为日志格式 <fmt> 求值产生的字符串。变量“<var-name>”只能是进程范围变量（使用“proc.”前缀）。它的工作方式与 TCP 或 HTTP 规则中的“set-var-fmt”操作完全相同，不同之处在于表达式在配置解析时进行求值，并且变量会立即设置。表达式中允许的样本获取函数和转换器仅限于那些使用内部数据的函数，通常是“int(value)”或“str(value)”。也可以引用先前分配的变量。然后，这些变量将可以从常规规则集中读取（和修改）。有关自定义日志格式语法的详细信息，请参见第 8.2.6 节。

global set-var-fmt proc.current_state "primary" set-var-fmt proc.bootid "%pid|%t"

Sets a list of capabilities that must be preserved when starting and running either as a non-root user (uid > 0), or when starting with uid 0 (root) and switching then to a non-root. By default all permissions are lost by the uid switch, but some are often needed when trying to connect to a server from a foreign address during transparent proxying, or when binding to a port below 1024, e.g. when using "tune.quic.socket-owner connection", resulting in setups running entirely under uid 0. Setting capabilities generally is a safer alternative, as only the required capabilities will be preserved. The feature is OS-specific and only enabled on Linux when USE_LINUX_CAP=1 is set at build time. The list of supported capabilities also depends on the OS and is enumerated by the error message displayed when an invalid capability name or an empty one is passed. Multiple capabilities may be passed, delimited by commas. Among those commonly used, "cap_net_raw" allows to transparently bind to a foreign address, and "cap_net_bind_service" allows to bind to a privileged port and may be used by QUIC. If the process is started and run under the same non-root user, needed capabilities should be set on haproxy binary file with setcap along with this keyword. For more details about setting capabilities on haproxy binary, please see chapter 13.1 Linux capabilities support in the Management guide.

global setcap cap_net_bind_service,cap_net_admin

将环境变量 <name> 设置为值 <value>。如果该变量存在，则会被覆盖。更改会立即生效，因此配置文件中的下一行将看到新的值。另请参阅 “presetenv”、“resetenv” 和 “unsetenv”。

This setting is only available when support for OpenSSL was built in. It sets the default string describing the list of cipher algorithms ("cipher suite") that are negotiated during the SSL/TLS handshake up to TLSv1.2 for all "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" lines which do not explicitly define theirs. The format of the string is defined in "man 1 ciphers" from OpenSSL man pages. For background information and recommendations see e.g. (https://wiki.mozilla.org/Security/Server_Side_TLS) and (https://mozilla.github.io/server-side-tls/ssl-config-generator/). For TLSv1.3 cipher configuration, please check the "ssl-default-bind-ciphersuites" keyword. Please check the "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" keyword for more information.

This setting is only available when support for OpenSSL was built in and OpenSSL 1.1.1 or later was used to build HAProxy. It sets the default string describing the list of cipher algorithms ("cipher suite") that are negotiated during the TLSv1.3 handshake for all "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" lines which do not explicitly define theirs. The format of the string is defined in "man 1 ciphers" from OpenSSL man pages under the section "ciphersuites
This keyword is available in sections :
Bind options
Server and default-server options". For cipher configuration for TLSv1.2 and earlier, please check the "ssl-default-bind-ciphers" keyword. This setting might accept TLSv1.2 ciphersuites however this is an undocumented behavior and not recommended as it could be inconsistent or buggy. The default TLSv1.3 ciphersuites of OpenSSL are: "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256" TLSv1.3 only supports 5 ciphersuites: - TLS_AES_128_GCM_SHA256 - TLS_AES_256_GCM_SHA384 - TLS_CHACHA20_POLY1305_SHA256 - TLS_AES_128_CCM_SHA256 - TLS_AES_128_CCM_8_SHA256 Please check the "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" keyword for more information.

global ssl-default-bind-ciphers ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-RSA-AES128-GCM-SHA256 ssl-default-bind-ciphersuites TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256

This setting is only available when support for OpenSSL was built in. It sets the default string describing the list of signature algorithms related to client authentication for all "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" lines which do not explicitly define theirs. The format of the string is a colon-delimited list of signature algorithms. Each signature algorithm can use one of two forms: TLS1.3 signature scheme names ("rsa_pss_rsae_sha256") or the public key algorithm + digest form ("ECDSA+SHA256"). A list can contain both forms. For more information on the format, see SSL_CTX_set1_client_sigalgs(3). A list of signature algorithms is also available in RFC8446 section 4.2.3 and in OpenSSL in the ssl/t1_lib.c file. This setting is not applicable to TLSv1.1 and earlier versions of the protocol as the signature algorithms aren't separately negotiated in these versions. It is not recommended to change this setting unless compatibility with a middlebox is required.

此设置仅在编译时内置 OpenSSL 支持时可用。它设置了在 SSL/TLS 握手期间使用 ECDHE 协商的椭圆曲线算法列表（“曲线套件”）的默认字符串。字符串的格式是以冒号分隔的曲线名称列表。有关更多信息，请检查 "bind
此关键字可在以下部分使用：
日志转发
对等点
按字母顺序排序的关键字参考" 关键字。

This setting is only available when support for OpenSSL was built in. It sets default ssl-options to force on all "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" lines. Please check the "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" keyword to see available options.

global ssl-default-bind-options ssl-min-ver TLSv1.0 no-tls-tickets

This setting is only available when support for OpenSSL was built in. It sets the default string describing the list of signature algorithms that are negotiated during the TLSv1.2 and TLSv1.3 handshake for all "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" lines which do not explicitly define theirs. The format of the string is a colon-delimited list of signature algorithms. Each signature algorithm can use one of two forms: TLS1.3 signature scheme names ("rsa_pss_rsae_sha256") or the public key algorithm + digest form ("ECDSA+SHA256"). A list can contain both forms. For more information on the format, see SSL_CTX_set1_sigalgs(3). A list of signature algorithms is also available in RFC8446 section 4.2.3 and in OpenSSL in the ssl/t1_lib.c file. This setting is not applicable to TLSv1.1 and earlier versions of the protocol as the signature algorithms aren't separately negotiated in these versions. It is not recommended to change this setting unless compatibility with a middlebox is required.

This setting is only available when support for OpenSSL was built in. It sets the default string describing the list of cipher algorithms that are negotiated during the SSL/TLS handshake up to TLSv1.2 with the server, for all "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" lines which do not explicitly define theirs. The format of the string is defined in "man 1 ciphers" from OpenSSL man pages. For background information and recommendations see e.g. (https://wiki.mozilla.org/Security/Server_Side_TLS) and (https://mozilla.github.io/server-side-tls/ssl-config-generator/). For TLSv1.3 cipher configuration, please check the "ssl-default-server-ciphersuites" keyword. Please check the "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" keyword for more information.

This setting is only available when support for OpenSSL was built in and OpenSSL 1.1.1 or later was used to build HAProxy. It sets the default string describing the list of cipher algorithms that are negotiated during the TLSv1.3 handshake with the server, for all "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" lines which do not explicitly define theirs. The format of the string is defined in "man 1 ciphers" from OpenSSL man pages under the section "ciphersuites
This keyword is available in sections :
Bind options
Server and default-server options". For cipher configuration for TLSv1.2 and earlier, please check the "ssl-default-server-ciphers" keyword. Please check the "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" keyword for more information.

This setting is only available when support for OpenSSL was built in. It sets the default string describing the list of signature algorithms related to client authentication for all "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" lines which do not explicitly define theirs. The format of the string is a colon-delimited list of signature algorithms. Each signature algorithm can use one of two forms: TLS1.3 signature scheme names ("rsa_pss_rsae_sha256") or the public key algorithm + digest form ("ECDSA+SHA256"). A list can contain both forms. For more information on the format, see SSL_CTX_set1_client_sigalgs(3). A list of signature algorithms is also available in RFC8446 section 4.2.3 and in OpenSSL in the ssl/t1_lib.c file. This setting is not applicable to TLSv1.1 and earlier versions of the protocol as the signature algorithms aren't separately negotiated in these versions. It is not recommended to change this setting unless compatibility with a middlebox is required.

此设置仅在编译时内置 OpenSSL 支持时可用。它设置了在 SSL/TLS 握手期间使用 ECDHE 协商的椭圆曲线算法列表（“曲线套件”）的默认字符串。字符串的格式是以冒号分隔的曲线名称列表。有关更多信息，请检查 "server
此关键字可在以下部分使用：
对等点
环
按字母顺序排序的关键字参考" 关键字。

This setting is only available when support for OpenSSL was built in. It sets default ssl-options to force on all "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" lines. Please check the "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" keyword to see available options.

This setting is only available when support for OpenSSL was built in. It sets the default string describing the list of signature algorithms that are negotiated during the TLSv1.2 and TLSv1.3 handshake for all "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" lines which do not explicitly define theirs. The format of the string is a colon-delimited list of signature algorithms. Each signature algorithm can use one of two forms: TLS1.3 signature scheme names ("rsa_pss_rsae_sha256") or the public key algorithm + digest form ("ECDSA+SHA256"). A list can contain both forms. For more information on the format, see SSL_CTX_set1_sigalgs(3). A list of signature algorithms is also available in RFC8446 section 4.2.3 and in OpenSSL in the ssl/t1_lib.c file. This setting is not applicable to TLSv1.1 and earlier versions of the protocol as the signature algorithms aren't separately negotiated in these versions. It is not recommended to change this setting unless compatibility with a middlebox is required.

This setting is only available when support for OpenSSL was built in. It sets the default DH parameters that are used during the SSL/TLS handshake when ephemeral Diffie-Hellman (DHE) key exchange is used, for all "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" lines which do not explicitly define theirs. It will be overridden by custom DH parameters found in a bind certificate file if any. If custom DH parameters are not specified either by using ssl-dh-param-file or by setting them directly in the certificate file, DHE ciphers will not be used, unless tune.ssl.default-dh-param is set. In this latter case, pre-defined DH parameters of the specified size will be used. Custom parameters are known to be more secure and therefore their use is recommended. Custom DH parameters may be generated by using the OpenSSL command "openssl dhparam <size>", where size should be at least 2048, as 1024-bit DH parameters should not be considered secure anymore.

此设置仅在内置 OpenSSL 支持且 OpenSSL 版本至少为 3.0 时可用。它允许定义在提供程序中获取算法时使用的默认属性字符串。它的行为方式与 openssl propquery 选项相同，并遵循相同的语法（在 https://www.openssl.org/docs/man3.0/man7/property.html 中描述）。例如，如果您加载了两个提供程序，foo 和默认提供程序，则 propquery “?provider=foo” 允许默认选择由 foo 提供程序提供的算法实现，如果找不到，则回退到默认提供程序的实现。

This setting is only available when support for OpenSSL was built in and when OpenSSL's version is at least 3.0. It allows to load a provider during init. If loading is successful, any capabilities provided by the loaded provider might be used by HAProxy. Multiple 'ssl-provider' options can be specified in a configuration file. The providers will be loaded in their order of appearance. Please note that loading a provider explicitly prevents OpenSSL from loading the 'default' provider automatically. OpenSSL also allows to define the providers that should be loaded directly in its configuration file (openssl.cnf for instance) so it is not necessary to use this 'ssl-provider' option to load providers. The "show ssl providers" CLI command can be used to show all the providers that were successfully loaded. The default search path of OpenSSL provider can be found in the output of the "openssl version -a" command. If the provider is in another directory, you can set the OPENSSL_MODULES environment variable, which takes the directory where your provider can be found. See also "ssl-propquery" and "ssl-provider-path".

此设置仅在内置 OpenSSL 支持且 OpenSSL 版本至少为 3.0 时可用。它允许指定 OpenSSL 用于查找提供程序的搜索路径。它的行为方式与 OPENSSL_MODULES 环境变量相同。它将用于任何后续的 “ssl-provider” 选项，直到定义新的 “ssl-provider-path”。另请参阅 “ssl-provider”。

此设置允许配置 HAProxy 查找额外 SSL 文件的方式。默认情况下，HAProxy 会在文件名后添加一个新的扩展名。（例如：对于 “foobar.crt”，加载 “foobar.crt.key”）。启用此选项后，HAProxy 会在添加新扩展名之前删除原扩展名（例如：对于 “foobar.crt”，加载 “foobar.key”）。您的 crt 文件必须具有 “.crt” 扩展名才能使此选项生效。此选项与捆绑扩展名（.ecdsa、.rsa、.dsa）不兼容，并且不会尝试删除它们。此选项默认禁用。另请参阅 “ssl-load-extra-files”。

This setting alters the way HAProxy will look for unspecified files during the loading of the SSL certificates. This option applies to certificates associated to "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" lines as well as "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" lines but some of the extra files will not have any functional impact for "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" line certificates. By default, HAProxy discovers automatically a lot of files not specified in the configuration, and you may want to disable this behavior if you want to optimize the startup time. "none": Only load the files specified in the configuration. Don't try to load a certificate bundle if the file does not exist. In the case of a directory, it won't try to bundle the certificates if they have the same basename. "all": This is the default behavior, it will try to load everything, bundles, sctl, ocsp, issuer, key. "bundle": When a file specified in the configuration does not exist, HAProxy will try to load a "cert bundle". Certificate bundles are only managed on the frontend side and will not work for backend certificates. Starting from HAProxy 2.3, the bundles are not loaded in the same OpenSSL certificate store, instead it will loads each certificate in a separate store which is equivalent to declaring multiple "crt
This keyword is available in sections :
Load options
Bind options
Server and default-server options". OpenSSL 1.1.1 is required to achieve this. Which means that bundles are now used only for backward compatibility and are not mandatory anymore to do an hybrid RSA/ECC bind configuration. To associate these PEM files into a "cert bundle" that is recognized by HAProxy, they must be named in the following way: All PEM files that are to be bundled must have the same base name, with a suffix indicating the key type. Currently, three suffixes are supported: rsa, dsa and ecdsa. For example, if www.example.com has two PEM files, an RSA file and an ECDSA file, they must be named: "example.pem.rsa" and "example.pem.ecdsa". The first part of the filename is arbitrary; only the suffix matters. To load this bundle into HAProxy, specify the base name only

bind :8443 ssl crt example.pem

Note that the suffix is not given to HAProxy; this tells HAProxy to look for a cert bundle. HAProxy will load all PEM files in the bundle as if they were configured separately in several "crt
This keyword is available in sections :
Load options
Bind options
Server and default-server options". The bundle loading does not have an impact anymore on the directory loading since files are loading separately. On the CLI, bundles are seen as separate files, and the bundle extension is required to commit them. OCSP files (.ocsp), issuer files (.issuer), Certificate Transparency (.sctl) as well as private keys (.key) are supported with multi-cert bundling. "sctl": Try to load "<basename>.sctl" for each crt keyword. If provided for a backend certificate, it will be loaded but will not have any functional impact. "ocsp": Try to load "<basename>.ocsp" for each crt keyword. If provided for a backend certificate, it will be loaded but will not have any functional impact. "issuer": Try to load "<basename>.issuer" if the issuer of the OCSP file is not provided in the PEM file. If provided for a backend certificate, it will be loaded but will not have any functional impact. "key": If the private key was not provided by the PEM file, try to load a file "<basename>.key" containing a private key. The default behavior is "all".

ssl-load-extra-files bundle sctl ssl-load-extra-files sctl ocsp issuer ssl-load-extra-files none

此指令允许选择 OpenSSL 安全级别，如 https://www.openssl.org/docs/man1.1.1/man3/SSL_CTX_set_security_level.html 中所述。该安全级别将应用于 HAProxy 中的每个 SSL 上下文。仅支持 0 到 5 之间的值。默认值取决于您的 OpenSSL 版本、发行版以及库的编译方式。此指令至少需要 OpenSSL 1.1.1。

服务器端 SSL 验证的默认行为。如果指定为 'none'，则不验证服务器证书。默认值为 'required'，除非使用命令行选项 '-dV' 强制指定。

自签发 CA，即 x509 根 CA，是证书链验证的锚点：作为服务器发送它是无用的，客户端必须拥有它。标准配置需要不在 PEM 文件中包含此类 CA。此选项允许您在 PEM 文件中保留此类 CA 而不将其发送给客户端。用例是为 ocsp 提供颁发者，而无需“.issuer”文件，并能够与“issuers-chain-path”共享它。这涉及所有没有中间证书的证书。对于 BoringSSL 来说是无用的，.issuer 被忽略，因为 ocsp 位不需要它。至少需要 OpenSSL 1.0.2。

默认情况下，统计套接字限制为 10 个并发连接。可以使用 "stats maxconn" 更改此值。

将 UNIX 套接字绑定到 <path> 或将 TCPv4/v6 地址绑定到 <address:port>。对此套接字的连接将返回各种统计信息输出，甚至允许发出一些命令来更改某些运行时设置。有关更多详细信息，请参阅管理指南的 第 9.3 节 “Unix 套接字命令”。支持 "bind
此关键字可在以下部分使用：
日志转发
对等点
按字母顺序排序的关键字参考" 行支持的所有参数，例如限制某些用户或其访问权限。有关更多信息，请参阅 第 5.1 节。

统计套接字的默认超时时间设置为 10 秒。可以使用 "stats timeout" 更改此值。该值必须以毫秒为单位传递，或者带有时间单位后缀，如 { us, ms, s, m, h, d }。

生成的 haproxy stats-file 的路径。启动时，haproxy 会将值预加载到其内部计数器中。使用 CLI 命令 “dump stats-file” 生成此类 stats-file。有关更多详细信息，请参阅管理手册。

当 setrlimit 失败时，使进程在启动时失败。HAProxy 会根据计算结果尝试设置最佳的 setrlimit。如果失败，它将发出警告。此选项旨在保证当这些限制失败时 HAProxy 明确失败。它默认启用。仍可通过在其前添加“no”关键字来强制禁用它。

此设置仅在内置线程支持时可用。它枚举了将组成线程组 <group> 的线程列表。线程号和组号从 1 开始。线程范围可以一次使用单个线程号定义，也可以通过指定由破折号“-”分隔的下限和上限来定义（例如 “1-16”）。未分配的线程将自动分配给未分配的线程组，而使用此指令定义的线程组将永远不会接收超过定义的线程数。多次定义同一组会用新的定义覆盖以前的定义。另请参阅 “nbthread” 和 “thread-groups”。

此设置仅在内置线程支持时可用。它使 HAProxy 将其线程分成 <number> 个独立的组。目前，默认值为 1。线程组可以减少线程之间的共享以限制争用，但需要一些额外的配置工作。这也是使用超过 64 个线程的唯一方法，因为每个组最多可以配置 64 个线程。最大组数在编译时配置，默认为 16。另请参阅 “nbthread”。

此设置用于强制限制线程数，无论是检测到的还是配置的。这在线程数是自动检测的操作系统上特别有用，其中在通用和可移植的配置中希望线程数低于 CPU 数。实际上，虽然 “nbthread” 强制的线程数如果高于可用 CPU 数将导致警告和性能不佳，但 thread-hard-limit 只会限制最大值，并自动将线程数限制为不高于此值，但不会提高较低的值。如果 “nbthread” 被强制设置为更高的值，则 thread-hard-limit 生效，并发出警告，以便可以修复配置异常。默认情况下没有限制。另请参阅 “nbthread”。

Changes the process's user ID to <number>. It is recommended that the user ID is dedicated to HAProxy or to a small set of similar daemons. HAProxy must be started with superuser privileges in order to be able to switch to another one. See also "gid
This keyword is available in sections :
Process management and security
Bind options" and "user
This keyword is available in sections :
Process management and security
Userlists
Programs (deprecated)
Bind options".

将每个进程的文件描述符最大数量设置为 <number>。默认情况下，它是自动计算的，因此建议不要使用此选项。如果目的只是限制文件描述符的数量，最好改用 “fd-hard-limit”。请注意，在此自动资源计算中未考虑动态服务器。如果使用大量动态服务器，可能需要手动指定此值。

Fixes common settings to UNIX listening sockets declared in "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" statements. This is mainly used to simplify declaration of those UNIX sockets and reduce the risk of errors, since those settings are most commonly required but are also process-specific. The <prefix> setting can be used to force all socket path to be relative to that directory. This might be needed to access another component's chroot. Note that those paths are resolved before HAProxy chroots itself, so they are absolute. The <mode>, <user>, <uid>, <group> and <gid> all have the same meaning as their homonyms used by the "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" statement. If both are specified, the "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" statement has priority, meaning that the "unix-bind" settings may be seen as process-wide default settings.

删除参数中指定的环境变量。这对于隐藏某些操作期间偶尔从用户环境中继承的一些敏感信息很有用。不存在的变量会被静默忽略，因此操作后可以确定这些变量都不再存在。更改会立即生效，因此配置文件中的下一行将看不到这些变量。另请参阅 “setenv”、“presetenv” 和 “resetenv”。

Similar to "uid
This keyword is available in sections :
Process management and security
Bind options" but uses the UID of user name <user name> from /etc/passwd. See also "uid
This keyword is available in sections :
Process management and security
Bind options" and "group
This keyword is available in sections :
Process management and security
Userlists
Programs (deprecated)
Bind options".

只允许字母、数字、连字符和下划线，与 DNS 名称类似。此语句在 HA 配置中很有用，其中两个或多个进程或服务器共享相同的 IP 地址。通过在所有节点上设置不同的节点名称，可以轻松地立即发现哪个服务器正在处理流量。

设置 WURFL User-Agent 缓存大小。为了更快地查找，已处理的用户代理会保存在 LRU 缓存中：- “0”：不使用缓存。- <size>：lru 缓存的大小（以元素为单位）。请注意，此选项仅在 HAProxy 编译时带有 USE_WURFL=1 时可用。

WURFL 数据文件的路径，用于提供设备检测服务。HAProxy 应具有相关权限才能访问该文件。请注意，此选项仅在 HAProxy 编译时带有 USE_WURFL=1 时可用。

A space-delimited list of WURFL capabilities, virtual capabilities, property names we plan to use in injected headers. A full list of capability and virtual capability names is available on the Scientiamobile website : https://www.scientiamobile.com/wurflCapability Valid WURFL properties are: - wurfl_id Contains the device ID of the matched device. - wurfl_root_id Contains the device root ID of the matched device. - wurfl_isdevroot Tells if the matched device is a root device. Possible values are "TRUE" or "FALSE". - wurfl_useragent The original useragent coming with this particular web request. - wurfl_api_version Contains a string representing the currently used Libwurfl API version. - wurfl_info A string containing information on the parsed wurfl.xml and its full path. - wurfl_last_load_time Contains the UNIX timestamp of the last time WURFL has been loaded successfully. - wurfl_normalized_useragent The normalized useragent. Please note that this option is only available when HAProxy has been compiled with USE_WURFL=1.

一个将用于在包含 WURFL 结果的响应头中分隔值的字符。如果未设置，则默认使用逗号（‘,’）。请注意，此选项仅在 HAProxy 编译时带有 USE_WURFL=1 时可用。

WURFL 补丁文件路径列表。请注意，补丁在启动期间加载，因此在 chroot 之前。请注意，此选项仅在 HAProxy 编译时带有 USE_WURFL=1 时可用。

In some situations, especially when dealing with low latency on processors supporting a variable frequency or when running inside virtual machines, each time the process waits for an I/O using the poller, the processor goes back to sleep or is offered to another VM for a long time, and it causes excessively high latencies. This option provides a solution preventing the processor from sleeping by always using a null timeout on the pollers. This results in a significant latency reduction (30 to 100 microseconds observed) at the expense of a risk to overheat the processor. It may even be used with threads, in which case improperly bound threads may heavily conflict, resulting in a worse performance and high values for the CPU stolen fields in "show info" output, indicating which threads are misconfigured. It is important not to let the process run on the same processor as the network interrupts when this option is used. It is also better to avoid using it on multiple CPU threads sharing the same core. This option is disabled by default. If it has been enabled, it may still be forcibly disabled by prefixing it with the "no" keyword. It is ignored by the "select" and "poll" pollers. This option is automatically disabled on old processes in the context of seamless reload; it avoids too much cpu conflicts when multiple processes stay around for some time waiting for the end of their current connections.

默认情况下，HAProxy 会尝试将健康检查的开始时间分散在服务器场中所有服务器的最小健康检查间隔内。其原则是避免对在同一台服务器上运行的服务进行密集冲击。但是当使用大的检查间隔（10 秒或更长）时，服务器场中的最后一个服务器需要一些时间才能开始被测试，这可能是一个问题。此参数用于强制规定第一次和最后一次检查之间的延迟上限，即使服务器的检查间隔较大。当服务器以较短的间隔运行时，它们的间隔仍将得到尊重。

设置 HAProxy 在停止新请求的压缩或降低当前请求的压缩级别之前可以达到的最大 CPU 使用率。它的工作方式类似于“maxcomprate”，但测量的是 CPU 使用率而不是传入数据带宽。该值以 HAProxy 使用的 CPU 百分比表示。值 100 表示禁用限制。默认值为 100。设置较低的值将防止压缩工作减慢整个进程的速度并引入高延迟。

将每个进程的最大输入压缩速率设置为 <number> 千字节/秒。对于每个流，如果达到最大值，压缩级别将在流期间降低。如果在流开始时达到最大值，则该流将完全不压缩。如果未达到最大值，压缩级别将增加到 tune.comp.maxlevel。值为零表示没有限制，这是默认值。

Sets the maximum per-process number of concurrent connections to <number>. It is equivalent to the command-line argument "-n". The value provided in command-line argument via "-n" takes the precedence over the maxconn value set in the global section. Haproxy process could be also compiled with SYSTEM_MAXCONN compile-time variable, which is served in this case as the system maxconn maximum. Again, the command-line "-n" argument allows at runtime to bypass SYSTEM_MAXCONN limit, if set. Proxies will stop accepting connections when maxconn is reached. The process soft file descriptor limit (could be obtained with "ulimit -n" command) is automatically adjusted according to provided maxconn. See also "ulimit-n". Note: the "select" poller cannot reliably use more than 1024 file descriptors on some platforms. If your platform only supports select and reports "select FAILED" on startup, you need to reduce the maxconn until it works (slightly below 500 in general). If maxconn value is not set, it will be automatically calculated based on the current file descriptors limits, reported by the "ulimit -nH" command (we take the maximum between the hard and soft values), then automatic value will be possibly reduced by "fd-hard-limit" and by memory limit, if the latter was enforced via "-m" command line option. Automatic value is also dependent from the buffer size, memory allocated to compression, SSL cache size, and the use or not of SSL and the associated maxsslconn (which can also be automatic).

将每个进程每秒的最大连接数设置为 <number>。当达到此限制时，代理将停止接受连接。它可以用来限制全局容量，而不考虑每个前端的容量。需要注意的是，这只能用作服务保护措施，因为当达到限制时，前端之间不一定会公平分配，所以最好也为每个前端限制一个接近其预期份额的值。此外，降低 tune.maxaccept 可以提高公平性。

将每个进程的最大管道数设置为 <number>。目前，管道仅由基于内核的 tcp 拼接使用。由于一个管道包含两个文件描述符，"ulimit-n" 值将相应增加。默认值为 maxconn/4，这对于大多数重度使用情况来说似乎已经足够了。拼接代码动态分配和释放管道，并且可以回退到标准复制，因此将此值设置得太低可能只会影响性能。

将每个进程每秒的最大会话数设置为 <number>。当达到此限制时，代理将停止接受连接。它可以用来限制全局容量，而不考虑每个前端的容量。需要注意的是，这只能用作服务保护措施，因为当达到限制时，前端之间不一定会公平分配，所以最好也为每个前端限制一个接近其预期份额的值。此外，降低 tune.maxaccept 可以提高公平性。

Sets the maximum per-process number of concurrent SSL connections to <number>. By default there is no SSL-specific limit, which means that the global maxconn setting will apply to all connections. Setting this limit avoids having openssl use too much memory and crash when malloc returns NULL (since it unfortunately does not reliably check for such conditions). Note that the limit applies both to incoming and outgoing connections, so one connection which is deciphered then ciphered accounts for 2 SSL connections. If this value is not set, but a memory limit is enforced, this value will be automatically computed based on the memory limit, maxconn, the buffer size, memory allocated to compression, SSL cache size, and use of SSL in either frontends, backends or both. If neither maxconn nor maxsslconn are specified when there is a memory limit, HAProxy will automatically adjust these values so that 100% of the connections can be made over SSL with no risk, and will consider the sides where it is enabled (frontend, backend, both).

将每个进程每秒的最大 SSL 会话数设置为 <number>。当达到此限制时，SSL 侦听器将停止接受连接。它可以用来限制全局 SSL CPU 使用率，而不考虑每个前端的容量。需要注意的是，这只能用作服务保护措施，因为当达到限制时，前端之间不一定会公平分配，所以最好也为每个前端限制一个接近其预期份额的值。同样重要的是要注意，会话是在进入 SSL 堆栈之前而不是之后计算的，这也保护了堆栈免受不良握手的影响。此外，降低 tune.maxaccept 可以提高公平性。

设置 zlib 每个进程可用的最大 RAM 量（以兆字节为单位）。当达到最大量时，只要 RAM 不可用，未来的数据流将不会被压缩。当设置为 0 时，没有限制。默认值为 0。该值可以通过 UNIX 套接字上的“show info”命令在“MaxZlibMemUsage”行中以字节为单位获取，zlib 使用的内存是“ZlibMemUsage”（以字节为单位）。

在某些尝试回收大量内存的时刻（内存不足或重载时）禁用内存修剪（“malloc_trim”）。修剪内存会强制系统的分配器扫描所有未使用的区域并释放它们。这通常被视为一种好的做法，可以为新进程留出更多可用内存，而旧进程不太可能大量使用它。但某些处理成千上万并发连接的系统可能会经历大量的内存碎片，这可能导致此释放操作极其漫长。在此期间，没有更多的流量通过该进程，不再接受新的连接，一些健康检查甚至可能失败，看门狗（watchdog）甚至可能触发并杀死无响应的进程，留下一个巨大的核心转储文件。如果发生这种情况，建议使用此选项来禁用修剪，停止尝试对新进程友好。请注意，先进的内存分配器通常不会遇到此类问题。

禁用在 Linux 上使用 "epoll" 事件轮询系统。它等同于命令行参数 "-de"。下一个使用的轮询系统通常是 "poll"。另请参阅 "nopoll"。

在源自 Solaris 10 及更高版本的 SunOS 系统上禁用事件端口（event ports）事件轮询系统的使用。它等同于命令行参数“-dv”。下一个使用的轮询系统通常是“poll”。另请参阅“nopoll”。

禁用使用 getaddrinfo(3) 进行名称解析。它等同于命令行参数 "-dG"。将使用已弃用的 gethostbyname(3)。

禁用在 BSD 上使用 "kqueue" 事件轮询系统。它等同于命令行参数 "-dk"。下一个使用的轮询系统通常是 "poll"。另请参阅 "nopoll"。

禁用“poll”事件轮询系统的使用。它等同于命令行参数“-dp”。下一个使用的轮询系统将是“select”。通常不需要禁用“poll”，因为它在 HAProxy 支持的所有平台上都可用。另请参阅“nokqueue”、“noepoll”和“noevports”。

禁用 SO_REUSEPORT 的使用 - 请参阅 socket(7)。它等同于命令行参数 "-dR"。

禁用在 Linux 上使用内核在套接字之间进行 tcp 拼接。它等同于命令行参数 "-dS"。数据将使用传统的、更具可移植性的 recv/send 调用进行复制。内核 tcp 拼接仅限于一些非常近期的内核 2.6 实例。大多数 2.6.25 到 2.6.28 之间的版本都有错误，会转发损坏的数据，因此不得使用。此选项使得在有疑问时可以轻松地全局禁用内核拼接。另请参阅 "option splice-auto"、"option splice-request" 和 "option splice-response"。

启用（'on'）或禁用（'off'）按函数的内存分析。这将保留进程中任何地方（包括库）的 malloc/calloc/realloc/free 调用的使用统计信息，这些信息将通过 CLI 上的“show profiling”命令报告。这主要用于当观察到无法通过池信息解释的异常内存使用，并且需要其他信息时。性能损失通常在 1% 左右，在高度线程化的机器上可能会更高一些，因此通常适合在生产环境中使用。同样的功能也可以在运行时通过 CLI 上的“set profiling memory”命令实现，请查阅管理手册。

Enables ('on') or disables ('off') per-task CPU profiling. When set to 'auto' the profiling automatically turns on a thread when it starts to suffer from an average latency of 1000 microseconds or higher as reported in the "avg_loop_us" activity field, and automatically turns off when the latency returns below 990 microseconds (this value is an average over the last 1024 loops so it does not vary quickly and tends to significantly smooth short spikes). It may also spontaneously trigger from time to time on overloaded systems, containers, or virtual machines, or when the system swaps (which must absolutely never happen on a load balancer). CPU profiling per task can be very convenient to report where the time is spent and which requests have what effect on which other request. Enabling it will typically affect the overall's performance by less than 1%, thus it is recommended to leave it to the default 'auto' value so that it only operates when a problem is identified. This feature requires a system supporting the clock_gettime(2) syscall with clock identifiers CLOCK_MONOTONIC and CLOCK_THREAD_CPUTIME_ID, otherwise the reported time will be zero. This option may be changed at run time using "set profiling" on the CLI.

有时，希望避免以精确的间隔向服务器发送代理和健康检查，例如当许多逻辑服务器位于同一物理服务器上时。借助此参数，可以在检查间隔中添加 0 到 +/- 50% 之间的随机性。2 到 5 之间的值似乎效果很好。默认值仍为 0。

Sets the OpenSSL engine to <name>. List of valid values for <name> may be obtained using the command "openssl engine". This statement may be used multiple times, it will simply enable multiple crypto engines. Referencing an unsupported engine will prevent HAProxy from starting. Note that many engines will lead to lower HTTPS performance than pure software with recent processors. The optional command "algo" sets the default algorithms an ENGINE will supply using the OPENSSL function ENGINE_set_default_string(). A value of "ALL" uses the engine for all cryptographic operations. If no list of algo is specified then the value of "ALL" is used. A comma-separated list of different algorithms may be specified, including: RSA, DSA, DH, EC, RAND, CIPHERS, DIGESTS, PKEY, PKEY_CRYPTO, PKEY_ASN1. This is the same format that openssl configuration file uses: https://www.openssl.org/docs/man1.0.2/apps/config.html HAProxy Version 2.6 disabled the support for engines in the default build. This option is only available when HAProxy has been built with support for it. In case the ssl-engine is required HAProxy can be rebuild with the USE_ENGINE=1 flag.

向 SSL 上下文添加 SSL_MODE_ASYNC 模式。如果使用支持异步的 SSL 引擎，这将启用异步 TLS I/O 操作。当前实现最多支持 32 个引擎。Openssl ASYNC API 不支持移动读/写缓冲区，并且与 HAProxy 的缓冲区管理不兼容。因此，在读/写操作上禁用了异步模式（它仅在初始和重新协商握手期间启用）。

启用（'on'）或禁用（'off'）小程序（applet）的数据零拷贝转发。默认启用。

为每个进程可分配的缓冲区数量设置一个硬限制。默认值为零，表示无限制。该限制将自动重新调整以满足紧急情况下的保留缓冲区，这样用户就不必进行复杂的计算。强制设置此值对于限制进程可能占用的内存量，同时保持正常的行为特别有用。当达到此限制时，请求缓冲区的任务会等待另一个缓冲区被释放。只要限制合理，大多数情况下等待时间非常短且不易察觉。然而，一些历史上的限制在不同版本中削弱了这一机制，已知在某些持续短缺的情况下，一些任务可能会冻结直到超时，因此在非严格必要时，最好避免使用此选项。

设置每个线程预分配并保留的缓冲区数量，这些缓冲区仅在内存分配失败导致的内存短缺情况下使用。最小值为 0，默认值为 4。除非核心开发人员出于非常具体的原因建议更改，否则用户没有理由更改此值。

Sets the buffer size to this size (in bytes). Lower values allow more streams to coexist in the same amount of RAM, and higher values allow some applications with very large cookies to work. The default value is 16384 and can be changed at build time. It is strongly recommended not to change this from the default value, as very low values will break some services such as statistics, and values larger than default size will increase memory usage, possibly causing the system to run out of memory. At least the global maxconn parameter should be decreased by the same factor as this one is increased. In addition, use of HTTP/2 mandates that this value must be 16384 or more. If an HTTP request is larger than (tune.bufsize - tune.maxrewrite), HAProxy will return HTTP 400 (Bad Request) error. Similarly if an HTTP response is larger than this size, HAProxy will return HTTP 502 (Bad Gateway). Note that the value set using this parameter will automatically be rounded up to the next multiple of 8 on 32-bit machines and 16 on 64-bit machines.

设置小缓冲区的字节大小。默认值为 1024。这些缓冲区设计用于一些内存消耗受限但似乎不必分配完整缓冲区的特定上下文中。然而，如果小缓冲区不足，会自动进行重新分配以切换到标准大小的缓冲区。目前，它仅由 HTTP/3 协议用于发出响应头。

设置最大压缩级别。压缩级别影响压缩过程中的 CPU 使用率。此值影响压缩过程中的 CPU 使用率。每个使用压缩的数据流都使用此值初始化压缩算法。默认值为 1。

禁用数据快速转发。这是一种通过将数据直接从一侧传递到另一侧而不唤醒流来优化数据转发的机制。通过此指令，可以禁用此优化。请注意，它还禁用了任何内核 TCP 拼接以及零拷贝转发。此命令不适用于常规使用，通常只会在复杂的调试会话中由开发人员建议使用。因此，它在内部被标记为实验性的，这意味着 "expose-experimental-directives" 必须在此指令之前的行上出现。

全局禁用数据的零拷贝转发。这是一种通过避免使用通道缓冲区来优化数据快速转发的机制。通过此指令，可以禁用此优化。注意，它还禁用了任何内核 TCP 拼接。

Along HAProxy's history, a few complex issues were met that were caused by bugs in the epoll mechanism in the Linux kernel. These ones usually are very rare and unreproducible outside the reporter's environment, and may only be worked around by disabling epoll and switching to poll instead, which is not very satisfying for high performance environments. Each time, issues affect only very specific (and rare) event types, and offering the ability to mask them can constitute a more acceptable work-around. This options offers this possibility by permitting to silently ignore events a few uncommon events and replace them with an input (which reports an unspecified incoming event). The effect is to avoid the fast error processing paths in certain places and only use the common paths. This should never be used unless being invited to do so by an expert in order to diagnose or work around a kernel bug. The option takes a single argument which is a comma-delimited list of words each designating an event to be masked. The currently supported list of events is: - "err": mask the EPOLLERR event - "hup": mask the EPOLLHUP events - "rdhup": mask the EPOLLRDHUP events

# 屏蔽所有非流量的 epoll 事件： tune.epoll.mask-events err,hup,rdhup

设置异步任务处理程序（来自 event_hdl API）一次可以处理的事件数量。<number> 应在 1 到 10000 之间。较大的数字可能导致线程争用，因为任务在不中断的情况下进行繁重的工作；另一方面，较小的数字可能导致任务不断被重新调度，因为它每次运行无法消耗足够多的事件，也无法跟上事件生成者的速度。默认值可以在构建时强制设置，否则默认为 100。

如果使用 DEBUG_FAIL_ALLOC 编译或使用 "-dMfail" 启动，则给出分配尝试失败的百分比机会。必须在 0（无失败）和 100（无成功）之间。这对于调试并确保内存故障得到妥善处理非常有用。未设置时，比率为 0。但是，命令行 "-dMfail" 选项会自动将其设置为 1% 的失败率，因此无需更改配置进行测试。

为支持它的文件描述符（FD）启用（'on'）或禁用（'off'）边缘触发轮询模式。目前仅在 epoll 下支持。在某些情况下，它可能会显著减少 epoll_ctl() 调用的数量并略微提高性能。这仍然是实验性的，如果仍然存在错误，可能会导致连接冻结，并且默认禁用。

启用（'on'）或禁用（'off'）H1 多路复用器的数据零拷贝接收。默认启用。

启用（'on'）或禁用（'off'）H1 多路复用器的数据零拷贝发送。默认启用。

设置后端连接上故障数量的阈值，超过该阈值连接将自动被终止。这允许自动终止行为不当的连接，而无需为其编写明确的规则。默认值为零，表示未设置阈值，因此任何事件都不会导致连接关闭。请注意，一些 H2 服务器可能会在长时间持续的连接上偶尔引起一些故障，因此这里的任何非零值可能应该在几百或几千的范围内才能有效，而不会影响轻微有问题的服务器。

设置传出连接的 HTTP/2 初始窗口大小，即服务器在等待 HAProxy 确认之前可以响应的字节数。此设置仅影响有效负载内容，不影响头部。如果未设置，则应用由 tune.h2.initial-window-size 设置的通用默认值。稍微增加此值可以加快下载速度或减少服务器上的 CPU 使用率，但代价是在客户端之间造成不公平。最好使用 tune.h2.be.rxbuf，它不会引起任何不公平。它不影响资源使用。

设置每个传出连接的 HTTP/2 最大并发流数（即单个到服务器连接上的未完成请求数）。如果未设置，则应用由 tune.h2.max-concurrent-streams 设置的默认值。小于默认值 100 的值可能会提高站点的响应能力，但代价是需要维护更多到服务器的已建立连接。当“http-reuse”设置为“always”时，建议减小此值，以免在同一连接上混合过多不同的客户端，因为如果一个客户端比其他客户端慢，一种称为“队头阻塞”的机制往往会对共享连接的所有客户端的下载速度产生级联效应（在这种情况下，保持 tune.h2.be.initial-window-size 较低）。强烈建议不要增加此值；有些人可能会发现在较低的值（通常为 1..5）下运行是最佳的。

设置传出连接的 HTTP/2 接收缓冲区大小（以字节为单位）。此大小将向上取整到 tune.bufsize 的下一个倍数，并将在所有上传数据（HEADERS 和 DATA 帧）的流之间共享。在任何情况下，每个流都将始终被授予一个缓冲区，并且 7/8 的未使用缓冲区将在下载有效负载的流之间共享，从而在 http-reuse 设置为 "always" 时，显著提高上传性能并避免在多个客户端之间共享的后端连接上出现队头阻塞（HoL）。通告的每个流的窗口会自动调整以反映可用空间，因此实际上应该不需要调整 tune.h2.be.initial-window-size。如果设置的大小小于处理所有流所需的大小，则将使用此最小值。默认值约为 1600k（100 个流，每个流有 16kB 的缓冲区）。

设置前端连接上故障数量的阈值，超过该阈值连接将自动被终止。这允许自动终止行为不当的连接，而无需为其编写明确的规则。默认值为零，表示未设置阈值，因此任何事件都不会导致连接关闭。请注意，一些 H2 客户端可能会在长时间持续的连接上偶尔引起一些故障，因此这里的任何非零值可能应该在几百或几千的范围内才能有效，而不会影响轻微有问题的客户端。

设置传入连接的 HTTP/2 初始窗口大小，即客户端在等待 HAProxy 确认之前可以上传的字节数。此设置仅影响有效负载内容（即 POST 请求的主体），不影响头部。如果未设置，则应用由 tune.h2.initial-window-size 设置的通用默认值。增加此值可以加快上传速度。默认值等于 tune.bufsize (16384)，允许每个流在 100 毫秒 ping 时间下至少有 1.25 Mbps 的带宽，在 1 毫秒 ping 时间下有 125 Mbps 的带宽。它不影响资源使用。使用过大的值可能会导致客户端在并行访问页面与大文件上传时体验到响应性不足。最好使用 tune.h2.fe.rxbuf，它不会引起任何不公平。

设置每个传入连接的 HTTP/2 最大并发流数（即单个客户端连接上的未完成请求数）。如果未设置，则应用由 tune.h2.max-concurrent-streams 设置的默认值。对于具有大量小对象的复杂站点，在高延迟网络上，大于默认值 100 的值有时可能会略微改善页面加载时间，但也可能因允许客户端一次性分配更多资源而导致使用更多内存。默认值 100 通常很好，建议不要更改此值。

Sets the HTTP/2 maximum number of total streams processed per incoming connection. Once this limit is reached, HAProxy will send a graceful GOAWAY frame informing the client that it will close the connection after all pending streams have been closed. In practice, clients tend to close as fast as possible when receiving this, and to establish a new connection for next requests. Doing this is sometimes useful and desired in situations where clients stay connected for a very long time and cause some imbalance inside a farm. For example, in some highly dynamic environments, it is possible that new load balancers are instantiated on the fly to adapt to a load increase, and that once the load goes down they should be stopped without breaking established connections. By setting a limit here, the connections will have a limited lifetime and will be frequently renewed, with some possibly being established to other nodes, so that existing resources are quickly released. It's important to understand that there is an implicit relation between this limit and "tune.h2.fe.max-concurrent-streams" above. Indeed, HAProxy will always accept to process any possibly pending streams that might be in flight between the client and the frontend, so the advertised limit will always automatically be raised by the value configured in max-concurrent-streams, and this value will serve as a hard limit above which a violation by a non- compliant client will result in the connection being closed. Thus when counting the number of requests per connection from the logs, any number between max-total-streams and (max-total-streams + max-concurrent-streams) may be observed depending on how fast streams are created by the client. The default value is zero, which enforces no limit beyond those implied by the protocol (2^30 ~= 1.07 billion). Values around 1000 may already cause frequent connection renewal without causing any perceptible latency to most clients. Setting it too low may result in an increase of CPU usage due to frequent TLS reconnections, in addition to increased page load time. Please note that some load testing tools do not support reconnections and may report errors with this setting; as such it may be needed to disable it when running performance benchmarks. See also "tune.h2.fe.max-concurrent-streams".

设置传入连接的 HTTP/2 接收缓冲区大小（以字节为单位）。此大小将向上取整到 tune.bufsize 的下一个倍数，并将在所有上传数据（HEADERS 和 DATA 帧）的流之间共享。在任何情况下，每个流都将始终被授予一个缓冲区，并且 7/8 的未使用缓冲区将在上传有效负载的流之间共享，从而显著提高上传性能。通告的每个流的窗口会自动调整以反映可用空间，因此实际上应该不需要调整 tune.h2.fe.initial-window-size。如果设置的大小小于处理所有流所需的大小，则将使用此最小值。默认值 1600k（100 个流，每个流有 16kB 的缓冲区）允许具有 100ms RTT 的客户端大约有 130 Mbps 的上传速度。

设置 HTTP/2 动态头表大小。默认为 4096 字节，不能大于 65536 字节。较大的值可能有助于某些客户端发送更紧凑的请求，具体取决于它们的能力。每个 HTTP/2 连接都会消耗此数量的内存。建议不要更改它。

Sets the default value for the HTTP/2 initial window size, on both incoming and outgoing connections. This value is used for incoming connections when tune.h2.fe.initial-window-size is not set, and by outgoing connections when tune.h2.be.initial-window-size is not set. This setting is used both as the initial value and as a minimum per stream. The default value equals 16384 (tune.bufsize), which for uploads roughly allows at least 1.25 Mbps of bandwidth per stream over a network showing a 100 ms ping time, or 125 Mbps over a 1-ms local network. When less receive buffers than the maximum are in use, within the limits defined by tune.h2.be.rxbuf and tune.h2.fe.rxbuf, unused buffers will be shared between receiving streams. As such there is normally no point in changing this default setting. Given that changing this default value will both increase upload speeds and cause more unfairness between clients on downloads, it is recommended to instead use the side- specific settings tune.h2.fe.initial-window-size and tune.h2.be.initial-window-size.

设置每个连接的默认 HTTP/2 最大并发流数（即单个连接上的未完成请求数）。当未设置 tune.h2.fe.max-concurrent-streams 时，此值用于传入连接；当未设置 tune.h2.be.max-concurrent-streams 时，此值用于传出连接。默认值为 100。影响因方向而异，因此请参阅上述两个设置以获取更多详细信息。建议不要使用此设置，而是切换到按方向的设置。值为零将禁用限制，因此单个客户端可以创建 HAProxy 可分配的任意数量的流。强烈建议不要更改此值。

设置 HAProxy 向其对等方宣告愿意接收的 HTTP/2 最大帧大小。默认值是 16384 和缓冲区大小 (tune.bufsize) 之间的较大者。在任何情况下，HAProxy 都不会宣告支持大于缓冲区的帧大小。此设置的主要目的是允许在使用大缓冲区时限制最大帧大小设置。过大的帧大小可能会影响性能或导致某些对等方行为不当。强烈建议不要更改此值。

启用（'on'）或禁用（'off'）H2 多路复用器的数据零拷贝发送。默认启用。

设置捕获的 cookie 的最大长度。"capture cookie xxx len yyy" 允许的最大值将是此值，任何更高的值都将自动截断为此值。重要的是不要设置太高的值，因为所有 cookie 捕获无论其配置值如何都会分配此大小（它们共享一个池）。此值是每个请求每个响应的，因此每个连接分配的内存是此值的两倍。如果未指定，限制设置为 63 个字符。建议不要更改此值。

设置日志中请求 URI 的最大长度。这可以防止在日志行中截断带有有价值查询字符串的长请求 URI。这与 syslog 的限制无关。如果增加此限制，您可能还需要增加 'log ... len yyy' 参数。您的 syslog 守护进程可能也需要特定的配置指令。默认值为 1024。

Sets the maximum number of headers allowed in received HTTP messages. When a message comes with a number of headers greater than this value (including the first line), it is rejected with a "400 Bad Request" status code for a request, or "502 Bad Gateway" for a response. The default value is 101, which is enough for all usages, considering that the widely deployed Apache server uses the same limit. It can be useful to push this limit further to temporarily allow a buggy application to work by the time it gets fixed. The accepted range is 1..32767. Keep in mind that each new header consumes 32bits of memory for each stream, so don't push this limit too high. Note that HTTP/1.1 is a text protocol, so there is no special limit when the message is sent. The limit during the message parsing is sufficient. HTTP/2 and HTTP/3 are binary protocols and require an encoding step. A limit is set too when headers are encoded to comply to limitation imposed by the protocols. This limit is large enough but not documented on purpose. The same limit is applied on the first steps of the decoding for the same reason.

启用（'on'）或禁用（'off'）同一服务器的空闲连接池在线程间的共享。默认是共享它们，以最小化到服务器的持久连接数，并优化连接重用率。但为了帮助调试或当怀疑 HAProxy 在连接重用方面存在错误时，强制禁用多线程间的空闲池共享，并将此选项设置为 "off" 可能很方便。默认是 on。强烈建议在禁用此选项时，不要为所有依赖连接重用以实现高性能的服务器设置一个保守的“pool-low-conn”值，否则随着线程数的增加，连接可能会被频繁关闭。

设置一个持续时间，在此之后 HAProxy 将认为一个空缓冲区可能与一个空闲流相关联。这用于在交替转发大数据和小数据时优化调整某些数据包的大小。使用 splice() 或在 SSL 中发送大缓冲区的决定受此参数调节。该值以毫秒为单位，介于 0 和 65535 之间。值为零表示 HAProxy 不会尝试检测空闲流。默认值为 1000，这似乎能正确检测最终用户的暂停（例如，在点击前阅读页面）。应该没有理由更改此值。请检查下面的 tune.ssl.maxrecord。

Normally, all "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" lines will create a single shard, that is, a single socket that all threads of the process will listen to. With many threads, this is not very efficient, and may even induce some important overhead in the kernel for updating the polling state or even distributing events to the various threads. Modern operating systems support balancing of incoming connections, a mechanism that will consist in permitting multiple sockets to be bound to the same address and port, and to evenly distribute all incoming connections to these sockets so that each thread only sees the connections that are waiting in the socket it is bound to. This significantly reduces kernel-side overhead and increases performance in the incoming connection path. This is usually enabled in HAProxy using the "shards
This keyword is available in sections :
Peers
Bind options" setting on "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" lines, which defaults to 1, meaning that each listener will be unique in the process. On systems with many processors, it may be more convenient to change the default setting to "by-thread" in order to always create one listening socket per thread, or "by-group" in order to always create one listening socket per thread group. Be careful about the file descriptor usage with "by-thread" as each listener will need as many sockets as there are threads. Also some operating systems (e.g. FreeBSD) are limited to no more than 256 sockets on a same address. Note that "by-group" will remain equivalent to "by-process" for default configurations involving a single thread group, and will fall back to sharing the same socket on systems that do not support this mechanism. The default is "by-group" with a fallback to "by-process" for systems or socket families that do not support multiple bindings.

Enables ('on' / 'fair') or disables ('off') the listener's multi-queue accept which spreads the incoming traffic to all threads a "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" line is allowed to run on instead of taking them for itself. This provides a smoother traffic distribution and scales much better, especially in environments where threads may be unevenly loaded due to external activity (network interrupts colliding with one thread for example). The default mode, "on", optimizes the choice of a thread by picking in a sample the one with the less connections. It is often the best choice when connections are long-lived as it manages to keep all threads busy. A second mode, "fair", instead cycles through all threads regardless of their instant load level. It can be better suited for short- lived connections, or on machines with very large numbers of threads where the probability to find the least loaded thread with the first mode is low. Finally it is possible to forcefully disable the redistribution mechanism using "off" for troubleshooting, or for situations where connections are short-lived and it is estimated that the operating system already provides a good enough distribution. The default is "on".

Explicitly tell haproxy how haproxy sample objects should be handled when pushed to Lua. Indeed, when leveraging native converters, sample fetches or variables from Lua script (to name a few), haproxy converts the internal smp type to equivalent Lua type. Because of historical implementation, there is an ambiguity around boolean handling: when doing Lua -> haproxy smp conversion, booleans are properly preserved, but when doing haproxy smp -> Lua conversion, booleans were converted to integers by mistake. This means that a sample fetch or converter returning a boolean would return an integer 0 or 1 when leveraged from Lua. Unfortunately, in Lua, booleans and integers are not interchangeable. Thus, to avoid ambiguities, "tune.lua.bool-sample-conversion" must explicitly be set to either "normal" (which means dropping the historical behavior for better consistency) or "pre-3.1-bug" (enforce historical behavior to prevent existing script logic from misbehaving). If the option is not set explicitly and a Lua script is loaded from the configuration, haproxy will emit a warning, and the option will implicitly default to "pre-3.1-bug" to match with the historical behavior. It is recommended to set this option to "normal" after ensuring that in-use Lua scripts are properly handling bool haproxy samples as booleans.

The "burst" execution timeout applies to any Lua handler. If the handler fails to finish or yield before timeout is reached, it will be aborted to prevent thread contention, to prevent traffic from not being served for too long, and ultimately to prevent the process from crashing because of the watchdog kicking in. Unlike other lua timeouts which are yield-cumulative, burst-timeout will ensure that the time spent in a single lua execution window does not exceed the configured timeout. Yielding here means that the lua execution is effectively interrupted either through an explicit call to lua-yielding function such as core.(m)sleep() or core.yield(), or following an automatic forced-yield (see tune.lua.forced-yield) and that it will be resumed later when the related task is set for rescheduling. Not all lua handlers may yield: we have to make a distinction between yieldable handlers and unyieldable handlers. For yieldable handlers (tasks, actions..), reaching the timeout means "tune.lua.forced-yield" might be too high for the system, reducing it could improve the situation, but it could also be a good idea to check if adding manual yields at some key points within the lua function helps or not. It may also indicate that the handler is spending too much time in a specific lua library function that cannot be interrupted. For unyieldable handlers (lua converters, sample fetches), it could simply indicate that the handler is doing too much computation, which could result from an improper design given that such handlers, which often block the request execution flow, are expected to terminate quickly to allow the request processing to go through. A common resolution approach here would be to try to better optimize the lua function for speed since decreasing "tune.lua.forced-yield" won't help. This timeout only counts the pure Lua runtime. If the Lua does a core.sleep, the sleeping time is not taken in account. The default timeout is 1000ms. Note: if a lua GC cycle is initiated from the handler (either explicitly requested or automatically triggered by lua after some time), the GC cycle time will also be accounted for. Indeed, there is no way to deduce the GC cycle time, so this could lead to some false positives on saturated systems (where GC is having hard time to catch up and consumes most of the available execution runtime). If it were to be the case, here are some resolution leads: - checking if the script could be optimized to reduce lua memory footprint - fine-tuning lua GC parameters and / or requesting manual GC cycles (see: https://lua.ac.cn/manual/5.4/manual.html#pdf-collectgarbage) - increasing tune.lua.burst-timeout Setting value to 0 completely disables this protection.

此指令强制 Lua 引擎每执行 <number> 条指令就执行一次让出（yield）。这允许中断一个长脚本，并让 HAProxy 调度器处理其他任务，如接受连接或转发流量。对于使用“lua-load-per-thread”加载的脚本，默认值为 10000 条指令；对于使用“lua-load”加载的脚本，默认值为 MAX(500, 10000 / nbthread) 条指令（这被认为是性能的最佳值，同时注意不要因多个线程竞争全局 Lua 锁而造成线程争用）。如果 HAProxy 经常执行一些 Lua 代码但需要更高的响应性，可以降低此值。如果 Lua 代码相当长且其结果对于处理数据是绝对必需的，可以增加 <number>，但应明智地设置该值，因为在多线程环境中它可能会增加争用。

启用（'on'）或禁用（'off'）通过适用于当前代理的日志记录器（如果有）记录 LUA 脚本的输出。默认为 'on'。

启用（'on'）或禁用（'off'）通过 stderr 记录 LUA 脚本的输出。当设置为 'auto' 时，如果满足以下任一条件，则通过 stderr 进行日志记录为 'on'： - tune.lua.log.loggers 设置为 'off' - 脚本在没有全局日志记录器的非代理上下文中执行 - 脚本在没有附加日志记录器的代理上下文中执行。请注意，启用时，此日志记录是 tune.lua.log.loggers 配置的日志记录之外的补充。默认为 'auto'。

设置 Lua 每个进程可用的最大 RAM 量（以兆字节为单位）。默认情况下为零，表示无限制。设置限制很重要，以确保脚本中的错误不会导致系统内存耗尽。

这是 Lua 服务的执行超时。这对于防止无限循环或在 Lua 中花费太多时间很有用。此超时仅计算纯 Lua 运行时。如果 Lua 执行了休眠，休眠时间不计入。默认超时为 4 秒。

这是 Lua 会话的执行超时。这对于防止无限循环或在 Lua 中花费太多时间很有用。此超时仅计算纯 Lua 运行时。如果 Lua 执行了休眠，休眠时间不计入。默认超时为 4 秒。

目的与 "tune.lua.session-timeout" 相同，但此超时专用于任务。默认情况下，此超时未设置，因为任务可能在 HAProxy 的整个生命周期内保持活动状态。例如，用于检查服务器的任务。

设置每个线程的活动检查数，超过此数，线程将主动尝试寻找负载较轻的线程来运行健康检查，或者将其排队，直到其上运行的活动检查数量减少。默认值为零，表示没有设置此类限制。在某些运行大量昂贵检查且线程数众多的环境中，当负载出现不均并可能导致健康检查在启动时随机超时时，可能需要此设置，尤其是在使用 OpenSSL 3.0 时，其在健康检查上的 CPU 密集度比旧版本高约 20 倍。这将导致尝试在所有线程之间平均分配健康检查工作。绝大多数配置不需要调整此参数。请注意，如果检查执行缓慢，过低的值可能会显著减慢健康检查的速度。

设置一个进程在切换到其他工作之前可以连续接受的最大连接数。在单进程模式下，较高的数字曾经在高连接率下提供更好的性能，但现在有了多队列后，情况已非如此。此值单独应用于每个监听器，因此会考虑监听器绑定的进程数。此值默认为 4，表现出最佳结果。如果从旧配置中继承了一个明显更高的值，可能值得将其移除，因为这既能提高性能又能降低响应时间。在多进程模式下，它会被监听器绑定的进程数的两倍所除。将此值设置为 -1 会完全禁用该限制。通常不需要调整此值。

设置在一次调用轮询系统时可以处理的最大事件量。默认值根据操作系统进行调整。已经注意到，将其减少到 200 以下会以网络带宽为代价略微降低延迟，而将其增加到 200 以上则会以延迟为代价略微增加带宽。配置的值必须小于或等于 1000000。

将保留的缓冲区空间设置为此大小（以字节为单位）。保留空间用于报头重写或追加。套接字上的第一次读取永远不会超过 bufsize-maxrewrite。历史上，它默认为 bufsize 的一半，但这没有太大意义，因为很少有大量的报头需要添加。设置得太高会妨碍处理大的请求或响应。设置得太低会妨碍向已有的较大请求或 POST 请求添加新报头。通常明智的做法是将其设置为大约 1024。如果大于 bufsize 的一半，它会自动调整为 bufsize 的一半。这意味着您在更改 bufsize 时不必担心它。

Sets the per-thread amount of memory that will be kept hot in the local cache and will never be recoverable by other threads. Access to this memory is very fast (lockless), and having enough is critical to maintain a good performance level under extreme thread contention. The value is expressed in bytes, and the default value is configured at build time via CONFIG_HAP_POOL_CACHE_SIZE which defaults to 524288 (512 kB). A larger value may increase performance in some usage scenarios, especially when performance profiles show that memory allocation is stressed a lot. Experience shows that a good value sits between once to twice the per CPU core L2 cache size. Too large values will have a negative impact on performance by making inefficient use of the L3 caches in the CPUs, and will consume larger amounts of memory. It is recommended not to change this value, or to proceed in small increments. In order to completely disable the per-thread CPU caches, using a very small value could work, but it is better to use "-dMno-cache" on the command-line.

Sets the size of the pattern lookup cache to <number> entries. This is an LRU cache which reminds previous lookups and their results. It is used by ACLs and maps on slow pattern lookups, namely the ones using the "sub", "reg", "dir", "dom", "end", "bin" match methods as well as the case-insensitive strings. It applies to pattern expressions which means that it will be able to memorize the result of a lookup among all the patterns specified on a configuration line (including all those loaded from files). It automatically invalidates entries which are updated using HTTP actions or on the CLI. The default cache size is set to 10000 entries, which limits its footprint to about 5 MB per process/thread on 32-bit systems and 8 MB per process/thread on 64-bit systems, as caches are thread/process local. There is a very low risk of collision in this cache, which is in the order of the size of the cache divided by 2^64. Typically, at 10000 requests per second with the default cache size of 10000 entries, there's 1% chance that a brute force attack could cause a single collision after 60 years, or 0.1% after 6 years. This is considered much lower than the risk of a memory corruption caused by aging components. If this is not acceptable, the cache can be disabled by setting this parameter to 0.

设置 haproxy 在发送消息时一次将尝试处理的粘性表更新的最大数量。检索这些更新的数据需要一些锁定操作，这在高度线程化的机器上如果无限制可能会消耗大量 CPU，并且在旧进程和新进程之间的初始批量传输期间也可能增加流量延迟。相反，低值也可能导致更高的 CPU 开销，并需要更长的时间来完成。默认值为 200，建议不要更改它。

将内核管道缓冲区大小设置为此大小（以字节为单位）。默认情况下，管道是系统的默认大小。但有时在使用 TCP 拼接时，增加管道大小可以提高性能，特别是在怀疑管道未被填满且执行了许多 splice() 调用时。这对内核的内存占用有影响，因此如果影响不明确，则不应更改此值。

此设置设置 HAProxy 全局使用的文件描述符最大数量（百分比），相对于 HAProxy 在我们无法重用连接并且必须创建新连接时开始终止空闲连接之前可以使用的最大文件描述符数量。默认值为 25（四分之一的文件描述符将意味着大约一半的最大前端连接可以保留一个空闲的后端连接，任何超出此范围的在针对连接重用的通用情况下可能没有多大意义）。

此设置设置 HAProxy 全局使用的文件描述符最大数量（百分比），相对于 HAProxy 在我们停止将连接放入空闲池以供重用之前可以使用的最大文件描述符数量。默认值为 20。

启用（'on'）或禁用（'off'）直通（pass-through）多路复用器的数据零拷贝转发。要使用此功能，还必须配置内核拼接。默认启用。

启用（'on'）或禁用（'off'）用于 QUIC 连接的 HyStart++ (RFC 9406) 算法，作为拥塞控制算法慢启动阶段的替代方案，该阶段可能导致高丢包率。默认禁用。

Defines how many lost packets are needed for the Cubic congestion control algorithm to really consider a loss event. Normally, any loss event is considered as the result of a congestion and is sufficient for Cubic to restart from a smaller window. But experiments show that there can be a variety of causes for losses that are not at all caused by congestion and that can simply be qualified of spurious losses, and for which adjusting the window will have no effect, except slowing communication down. Poor radio signal, out-of-order delivery, high CPU usage on a client causing random delays, as well as system timer imprecision can be among the common causes for this. This setting allows to make Cubic a bit more tolerant to spurious losses, by changing the minimum number of cumulated losses between two ACKs to be considered as a loss event, which defaults to 1. Some significant gains have been observed experimentally, but always accompanied with an aggravation of the bandwidth wasted on retransmits, and an increased risk of saturation of congested links. The value 2 may be used for short periods of time to compare some metrics. Never go beyond 2 without an expert's prior analysis of the situation. The default and minimum value is 1. Always use 1.

Disable UDP GSO emission. This kernel feature allows to emit multiple datagrams via a single system call which is more efficient for large transfer. It may be useful to disable it on developers suggestion when suspecting an issue on emission.

Sets the threshold for the number of glitches on a frontend connection, where that connection will automatically be killed. This allows to automatically kill misbehaving connections without having to write explicit rules for them. The default value is zero, indicating that no threshold is set so that no event will cause a connection to be closed. Beware that some QUIC clients may occasionally cause a few glitches over long lasting connection, so any non- zero value here should probably be in the hundreds or thousands to be effective without affecting slightly bogus clients.

设置前端的 QUIC max_idle_timeout 传输参数（以毫秒为单位），该参数确定了连接在由两个端点宣告的两个 max_idle_timeout 值推导出的有效时间段内保持不活动后，静默关闭的时间段：- 如果两个值都不为空，则为两个值中的最小值，- 如果只有一个不为空，则为最大值，- 如果两个值都为空，则禁用此功能。默认值为 30000。

为前端设置 QUIC initial_max_streams_bidi 传输参数。这是远程对等方将被授权打开的初始最大双向流数。这决定了并发客户端请求的数量。默认值为 100。

Sets the default maximum window size for the congestion controller of a single QUIC connection. The value must be written as an integer with an optional suffix 'k', 'm' or 'g'. It must be between 10k and 4g. QUIC multiplexer also uses the current congestion window size to determine if it can allocate new stream buffers on data emission. As such, the maximum congestion window size also serves as a limit on this allocator. The default value is 480k. See also the "quic-cc-algo" bind option.

设置单个 QUIC 帧可以被标记为丢失的限制。如果超过此限制，连接将被视为失败并立即关闭。默认值为 10。

应用于计算出的数据包重排阈值的比率。如果太小，可能会触发高丢包检测。默认值为 50。

一旦半开连接数达到此数值，将为所有已配置的 QUIC 侦听器动态启用重试（Retry）功能。半开连接是指其握手尚未成功完成或失败的连接。要使此设置生效，需要设置集群密钥（cluster secret），否则它将被静默忽略（参见“cluster-secret”设置）。如果强制使用了 QUIC 重试（参见“quic-force-retry”），此设置也将被静默忽略。默认值为 100。有关 QUIC 重试的更多信息，请参阅 https://www.rfc-editor.org/rfc/rfc9000.html#section-8.1.2。

此选项全局指定 QUIC 连接如何使用套接字进行接收/发送操作。连接可以共享监听套接字，也可以每个连接分配自己的套接字。当设置为默认值 "connection" 时，每个 QUIC 连接都将分配一个专用的套接字。对于大量 QUIC 流量，这是实现最佳性能的首选选项。这也是确保 QUIC 连接正确执行软停止且不丢失数据，以及高效处理 sendto() 操作期间瞬态错误情况的唯一方法。然而，这依赖于 UDP 网络堆栈的一些高级功能。如果您的平台被认为不兼容，haproxy 将在启动时自动切换到 "listener" 模式。请注意，在特权端口上运行的 QUIC 监听器可能需要以 uid 0 身份运行，或者需要进行一些特定于操作系统的调整，以允许目标 uid 绑定此类端口，例如系统功能（system capabilities）。另请参阅 "setcap" 全局指令。值 "listener" 表示 QUIC 传输将发生在共享监听套接字上。此选项对于小流量可能是一个很好的折衷方案，因为它可以减少 FD 消耗。然而，如果监听器在许多线程之间共享或同时使用大量 QUIC 连接，由于较高的 CPU 使用率，性能将不会是最佳的。此设置与每个 "quic-socket" 绑定选项结合应用。如果在全局调优中使用了 "connection" 模式，它将为每个监听器激活，除非其绑定选项设置为 "listener"。然而，如果全局使用了 "listener"，它将被强制应用于每个监听器实例，无论其单独配置如何。

启用 ('on') 或禁用 ('off') QUIC 发送的速率控制支持。默认情况下它是禁用的。速率控制的目的是平滑数据发送以减少网络丢失。在大多数情况下，它可以通过避免重传显着提高网络吞吐量。然而，对于具有非常高带宽/低延迟特性的网络，禁用它可能很有用，以防止不必要的延迟并减少 CPU 消耗。速率控制支持仍处于实验阶段，因此它需要 "expose-experimental-directives"。另请参阅 "quic-cc-algo" 绑定选项。

启用（'on'）或禁用（'off'）QUIC 多路复用器的零拷贝数据发送。默认情况下启用。

此配置选项接受一个介于 -20 和 19 之间的值。它应用了 man 2 setpriority 中记录的调度优先级。此优先级在配置解析之后应用，这意味着只有工作进程或独立进程会应用它。通常配置它以设置比执行配置解析的进程（tune.renice.startup）更高的优先级。

此配置选项接受一个介于 -20 和 19 之间的值。它应用了 man 2 setpriority 中记录的调度优先级。此优先级在应用其余配置之前应用，如果您想降低配置解析的优先级，这可能很有用。这应用于独立进程或工作进程在配置解析之前。一旦配置被解析，除非使用 tune.renice.runtime，否则将恢复先前的优先级。

设置非连接套接字的内核套接字接收缓冲区大小。这可用于监听模式下的 QUIC 和前端的日志转发。默认系统缓冲区有时可能太小，无法接收大量聚合流量的套接字，导致一些丢失并可能导致重传（在 QUIC 的情况下），从而可能在重流量下减慢连接建立速度。该值以字节表示，应用于每个套接字。在监听模式下，套接字在所有连接之间共享，套接字的总数取决于 "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" 行的 "shards
This keyword is available in sections :
Peers
Bind options" 值。没有一个好的固定值，一个好的值对应于每连接预期大小乘以预期连接数。内核可能会修剪过大的值。另请参阅 "tune.rcvbuf.client" 和 "tune.rcvbuf.server" 了解其连接套接字对应项，以及 "tune.sndbuf.backend" 和 "tune.sndbuf.frontend" 了解发送设置。

强制将客户端或服务器端的内核套接字接收缓冲区大小设置为指定的字节值。此值适用于所有 TCP/HTTP 前端和后端。通常不应设置此值，默认大小（0）让内核根据可用内存量自动调整此值。但是，有时将其设置为非常低的值（例如 4096）有助于节省内核内存，因为它阻止内核缓冲过多的接收数据。不过，较低的值会显著增加 CPU 使用率。

HAProxy 使用一些提示来检测短读是否表示套接字缓冲区的末尾。其中之一是读取返回的字节数超过 <recv_enough>，默认为 10136（7 个 1448 字节的段）。此默认值可以通过此设置更改，以更好地处理涉及大量短消息的工作负载，例如 telnet 或 SSH 会话。

设置环形缓冲区前面的写队列数量。这可能会影响调试会话期间跟踪的 CPU 使用率，过低或过高的值都可能产生重要影响。合适的值是由开发人员通过实验确定的，除非被指示这样做以尝试解决特定问题，否则不应尝试更改它。在版本升级时不应将此类设置保留在配置中，因为其最佳值可能会随时间变化。

设置运行任务时一次可以处理的最大任务量。默认值取决于线程数，但在 35 到 280 之间，这往往显示出最高的请求率和最低的延迟。增加它可能会在处理 I/O 时产生延迟，使其太小可能会产生额外的开销。较高的线程数受益于较低的值。当尝试使用更大的值时，启用 tune.sched.low-latency 和可能启用 tune.fd.edge-triggered 以将最大延迟限制在最低可能值可能会很有用。

启用（'on'）或禁用（'off'）低延迟任务调度器。默认情况下，HAProxy 一次处理一个类别的多个类别的任务，因为这是最有效的。但是当使用较大的 tune.runqueue-depth 值运行时，这可能对请求或连接延迟产生可测量的影响。启用此低延迟设置后，如果存在较低优先级类别的任务，它们将始终在其他任务之前执行。这将允许在大量流量中降低新请求或连接所经历的最大延迟，但代价是对这种大流量产生更大的影响。对于常规使用，最好保持关闭。默认值为 off。

设置非连接套接字的内核套接字发送缓冲区大小。这可用于后端侧的 UNIX 套接字和 UDP 日志记录，以及前端监听模式下的 QUIC。默认系统缓冲区有时可能太小，无法在许多连接（或日志发送者）之间共享套接字，导致一些丢失并可能导致重传，从而在重流量下减慢新连接建立速度。该值以字节表示，应用于每个套接字。在监听模式下，套接字在所有连接之间共享，套接字的总数取决于 "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" 行的 "shards
This keyword is available in sections :
Peers
Bind options" 值。没有一个好的固定值，一个好的值对应于每连接预期大小乘以预期连接数。内核可能会修剪过大的值。另请参阅 "tune.sndbuf.client" 和 "tune.sndbuf.server" 了解其连接套接字对应项，以及 "tune.rcvbuf.backend" 和 "tune.rcvbuf.frontend" 了解接收设置。

强制将客户端或服务器端的内核套接字发送缓冲区大小设置为指定的字节值。此值适用于所有 TCP/HTTP 前端和后端。通常不应设置此值，默认大小（0）让内核根据可用内存量自动调整此值。然而，有时将其设置为非常低的值（例如 4096）有助于节省内核内存，防止其缓冲过多的接收数据。但较低的值会显著增加 CPU 使用率。另一个用例是，对于极慢的客户端，防止因内核等待大部分缓冲区被读取后才再次通知 HAProxy 而导致的写入超时。

设置全局 SSL 会话缓存的大小，以块为单位。一个块足够大，可以包含一个不带对等证书的编码会话。一个带对等证书的编码会话根据对等证书的大小存储在多个块中。一个块大约使用 200 字节的内存（基于用于 `shctx_init` 函数的 `sizeof(struct sh_ssl_sess_hdr) + SHSESS_BLOCK_MIN_SIZE` 计算）。默认值可在构建时强制指定，否则默认为 20000。当缓存满时，最空闲的条目将被清除并重新分配。较高的值会减少这种清除的发生，从而通过确保所有用户尽可能长时间地保留其会话来减少 CPU 密集型的 SSL 握手次数。所有条目在启动时预先分配。将此值设置为 0 会禁用 SSL 会话缓存。

设置用于捕获客户端 hello 密码列表、扩展列表、椭圆曲线列表和椭圆曲线点格式的缓冲区的最大大小。如果值为 0（默认值），则禁用捕获，否则将为每个 SSL/TLS 连接分配一个缓冲区。

在 DHE 密钥交换的情况下，设置用于生成临时/临时 Diffie-Hellman 密钥的 Diffie-Hellman 参数的最大大小。最终大小将尝试匹配服务器的 RSA（或 DSA）密钥的大小（例如，对于 2048 位 RSA 密钥，使用 2048 位临时 DH 密钥），但不会超过此最大值。只允许 1024 或更高的值。较高的值会增加 CPU 负载，而大于 1024 位的值不受 Java 7 及更早版本的客户端支持。如果直接在证书文件中或通过使用 ssl-dh-param-file 参数提供了静态 Diffie-Hellman 参数，则不使用此值。如果既没有定义 default-dh-param 也没有定义 ssl-dh-param-file，并且给定前端的服务器 PEM 文件没有指定其自己的 DH 参数，则 DHE 密码将对此前端不可用。

此选项禁用所有进程之间的 SSL 会话缓存共享。通常不应使用它，因为它会由于客户端命中随机进程而强制进行许多重新协商。但在某些操作系统上可能需要它，因为这些操作系统上可能无法使用任何 SSL 缓存同步方法。在这种情况下，在 SSL 层之前添加第一层基于哈希的负载均衡可能会限制缺少会话共享的影响。

设置在任何时候传递给 SSL_write() 的最大字节数。默认值 0 表示没有限制。与 tune.ssl.maxrecord 相反，此设置不会动态调整。较小的记录可能会降低吞吐量，但在处理低占用客户端时可能是必需的。

此选项激活 TLS 密钥的日志记录。应谨慎使用，因为它会消耗每个 SSL 会话更多的内存并可能降低性能。默认情况下禁用此功能。这些样本获取应用于生成 SSLKEYLOGFILE，这是使用 wireshark 解密流量所必需的。https://mdn.org.cn/en-US/docs/Mozilla/Projects/NSS/Key_Log_Format SSLKEYLOGFILE 是一系列行，格式如下：<Label> <space> <ClientRandom> <space> <Secret> ClientRandom 由 %[ssl_fc_client_random,hex] 样本获取提供，secret 和 Label 可以在下面的数组中找到。您需要生成包含此数组中所有标签的 SSLKEYLOGFILE。以下样本获取是十六进制字符串，无需转换。 SSLKEYLOGFILE Label | Secrets 的样本获取 --------------------------------|----------------------------------------- CLIENT_EARLY_TRAFFIC_SECRET | %[ssl_xx_client_early_traffic_secret] CLIENT_HANDSHAKE_TRAFFIC_SECRET | %[ssl_xx_client_handshake_traffic_secret] SERVER_HANDSHAKE_TRAFFIC_SECRET | %[ssl_xx_server_handshake_traffic_secret] CLIENT_TRAFFIC_SECRET_0 | %[ssl_xx_client_traffic_secret_0] SERVER_TRAFFIC_SECRET_0 | %[ssl_xx_server_traffic_secret_0] EXPORTER_SECRET | %[ssl_xx_exporter_secret] EARLY_EXPORTER_SECRET | %[ssl_xx_early_exporter_secret] 这些获取存在于前端 (fc) 或后端 (bc) 侧，将 "xx" 替换为 "fc" 或 "bc" 以使用正确的侧。这仅适用于 OpenSSL 1.1.1，并且对 TLS1.3 会话有用。如果您想生成 TLS < 1.3 的 SSLKEYLOGFILE 内容，您只需要这一行："CLIENT_RANDOM %[ssl_fc_client_random,hex] %[ssl_fc_session_key,hex]" 可以使用如下日志格式生成完整的密钥日志，尽管这对于 syslog 来说并不理想： log-format "CLIENT_EARLY_TRAFFIC_SECRET %[ssl_bc_client_random,hex] %[ssl_bc_client_early_traffic_secret]\n CLIENT_HANDSHAKE_TRAFFIC_SECRET %[ssl_bc_client_random,hex] %[ssl_bc_client_handshake_traffic_secret]\n SERVER_HANDSHAKE_TRAFFIC_SECRET %[ssl_bc_client_random,hex] %[ssl_bc_server_handshake_traffic_secret]\n CLIENT_TRAFFIC_SECRET_0 %[ssl_bc_client_random,hex] %[ssl_bc_client_traffic_secret_0]\n SERVER_TRAFFIC_SECRET_0 %[ssl_bc_client_random,hex] %[ssl_bc_server_traffic_secret_0]\n EXPORTER_SECRET %[ssl_bc_client_random,hex] %[ssl_bc_exporter_secret]\n EARLY_EXPORTER_SECRET %[ssl_bc_client_random,hex] %[ssl_bc_early_exporter_secret]"

设置缓存的 SSL 会话可以保持有效的时长。此时间以秒为单位表示，默认为 300（5 分钟）。重要的是要理解，这并不保证会话会持续那么长时间，因为如果缓存已满，最长时间空闲的会话将被清除，尽管它们配置了生命周期。此设置的真正用处是防止会话被使用太长时间。

设置在数据传输开始时传递给 SSL_write() 的最大字节数。默认值 0 表示没有限制。在 SSL/TLS 上，客户端只有在收到完整的记录后才能解密数据。对于大记录，这意味着客户端可能需要下载多达 16kB 的数据才能开始处理它们。限制该值可以改善位于高延迟或低带宽网络上的浏览器的页面加载时间。建议找到适合 1 或 2 个 TCP 段的最佳值（在启用 TCP 时间戳的以太网上通常为 1448 字节，或禁用时间戳时为 1460 字节），同时记住 SSL/TLS 会增加一些开销。测试期间，典型值 1419 和 2859 取得了良好效果。使用 "strace -e trace=write" 找到最佳值。HAProxy 将在检测到空闲流后自动切换到此设置（请参见上面的 tune.idletimer）。另请参见 tune.ssl.hard-maxrecord。

将用于存储生成证书的缓存大小设置为 <number> 个条目。这是一个 LRU 缓存。因为动态生成 SSL 证书的开销很大，所以它们被缓存起来。默认缓存大小设置为 1000 个条目。

设置连接或请求可以通过 "tcp-request" 或 "http-request" 规则中的 "track-sc*" 操作同时跟踪的粘性计数器（stick-counters）的数量。默认值在构建时由宏 MAX_SESS_STK_CTR 设置，默认为 3。使用此设置可以更改该值并忽略构建时传递的值。在将复杂配置移植到 HAProxy 时可能需要增加此值，但请用户注意其成本：每个条目每个连接占用 16 字节，每个请求占用 16 字节，所有这些都需要为所有请求分配和清零，即使未使用。因此，值为 10 将使每个请求的内存消耗增加 320 字节，并导致该内存在每个请求时都被擦除，这确实会对 CPU 产生可测量的影响。相反，当不使用 "track-sc" 规则时，可以降低该值（0 是有效的，可以完全禁用粘性计数器）。

这五个调优有助于管理变量系统使用的最大内存量。"global" 限制所有范围可用的总内存量。"proc" 限制进程范围的内存，"sess" 限制会话范围的内存，"txn" 限制事务范围的内存，"reqres" 限制每个请求或响应处理的内存。内存核算具有层次结构，意味着更粗粒度的限制包括更细粒度的限制："proc" 包括 "sess"，"sess" 包括 "txn"，"txn" 包括 "reqres"。例如，当 "tune.vars.sess-max-size" 限制为 100 时，"tune.vars.txn-max-size" 和 "tune.vars.reqres-max-size" 也不能超过 100。如果我们创建一个包含 100 字节的变量 "txn.var"，则所有可用空间都被消耗。请注意，运行时超出限制不会导致错误消息，但值可能会被截断或损坏。因此，请确保准确规划存储所有变量所需的空间量。

为每个流设置 zlib 初始化中的 memLevel 参数。它定义了应为内部压缩状态分配多少内存。值为 1 使用最少的内存，但速度慢并降低压缩率；值为 9 使用最大的内存以获得最佳速度。可以是 1 到 9 之间的值。默认值为 8。

为每个流设置窗口大小（历史缓冲区的大小）作为 zlib 初始化的参数。此参数的较大值会导致更好的压缩，但代价是内存使用量增加。可以是 8 到 15 之间的值。默认值为 15。

这将全局匿名化密钥设置为 <密钥>，它必须是一个介于 0 和 4294967295 之间的 32 位数字。这是启用匿名模式时 CLI 命令默认使用的密钥。此密钥也可以在运行时通过 CLI 命令“set anon global-key”设置。另请参阅管理手册中的命令行参数“-dC”。

此命令将配置解析器暂停 <timeout> 毫秒。这对于开发或测试 init 脚本的超时非常有用，特别是用于模拟非常长的重载。它需要设置 expose-experimental-directives。<timeout> 是默认以毫秒为单位指定的超时值，但如果数字后跟单位后缀，也可以是任何其他单位，如本文档开头所述。

global expose-experimental-directives force-cfg-parser-pause 10s

这通过跳过释放内存对象和侦听器来加快重载时旧进程的退出，因为所有这些都将在进程死亡时由操作系统回收。收益只是微不足道的（对于巨大的配置，最多也就几百毫秒）。实际上，主要目标用途是当在 deinit() 代码中发现错误时，因为它允许绕过它。除非开发人员指示，否则最好不要使用此选项。

启动期间不显示任何消息。它等同于命令行参数 "-q"。

这允许调整一个延迟，在此延迟之后，阻塞流量的卡住任务将触发在标准错误输出上发出警告。延迟以毫秒为单位表示，默认为 100 毫秒。允许的值必须在 1 毫秒到 1000 毫秒（包括）之间。较低的值会频繁触发警告，较高的值会很少触发。无论如何，看门狗都会杀死一个在一秒钟内两次未能响应的失控任务，因此 1000 毫秒的警告延迟通常不会触发任何警告。建议保持在 10 到 100 毫秒之间的值，以检测可能降低用户体验、导致响应时间过长或交互式会话卡顿的配置异常。例如，一个设计不佳的 Lua 样本获取函数进行繁重计算，或者一个非常大的 map_reg 或 map_regm map 文件具有非常高的评估成本，都可能导致此类问题。相比之下，TLS 握手可能需要一到两毫秒，压缩 16kB HTTP 响应缓冲区大约需要一毫秒。输出包含一个违规任务的线程转储，其中包含回溯和一些上下文，有助于找出时间花在哪里。

设置此选项后，如果在处理和应用配置时发出任何警告，HAProxy 将拒绝启动。这意味着有关参数组合不佳的警告、有关无法设置的非常高限制的警告等等，都会使进程在启动期间因错误而退出。此选项无法捕获一些较晚的启动警告，例如在“daemon”或“master-worker”模式下更改组 ID 时未能丢弃补充组，或者在 fork() 后未能将进程标记为可转储。此选项不捕获运行时发出的警告。强烈建议在不经常更改的配置上设置此选项，因为它有助于检测细微的错误并保持配置的整洁和向前兼容。请注意，“haproxy -c”在这种情况下也会报告错误。此选项等同于命令行参数“-dW”。

出于调试目的，可以激活 HAProxy 子系统的跟踪。这将转储有关特定子系统的调试消息。这是一个诊断问题的强大工具。跟踪可以通过 CLI 动态配置。也可以在配置文件中预定义一些设置，在专门的 "traces" 部分中。有关跟踪的更多详细信息，请参阅管理指南。它仍然是开发人员在复杂调试会话期间使用的工具。它非常详细且有成本，因此请谨慎使用。而且由于它是一个开发人员工具，因此不保证此部分的向后兼容性。

开始一个新的跟踪部分。可以使用一个或多个“traces”部分。所有指令都按照声明顺序进行评估，最后的指令将覆盖之前的指令。

配置 "trace" 子系统。这些配置项在管理手册中有详细说明，且语法完全相同。任何 "trace" 命令产生的输出将在该部分的解析阶段输出。通常情况下，这些输出是错误和警告，但某些不完整的命令可能会列出允许的选项。此命令并非用于常规使用，通常只会在复杂的调试会话中由开发人员建议使用。请注意，根据跟踪级别和详细程度，启用跟踪可能会严重降低全局性能。请参阅管理手册了解语句语法。

ring buf1 size 10485760 # 10MB format timed backing-file /tmp/h1.traces ring buf2 size 10485760 # 10MB format timed backing-file /tmp/h2.traces traces trace h1 sink buf1 level developer verbosity complete start now trace h2 sink buf1 level developer verbosity complete start now

可以通过仅允许经过身份验证和授权的用户来控制对前端/后端/侦听部分或 http 统计信息的访问。为此，需要创建至少一个用户列表并定义用户。

创建名为 <listname> 的新用户列表。可以使用许多独立的用户列表来存储独立客户的身份验证和授权数据。

将组 <groupname> 添加到当前用户列表。也可以通过使用逗号分隔的名称列表（前面有 "users" 关键字）将用户附加到此组。

将用户 <username> 添加到当前用户列表。可以使用安全（加密）和不安全（未加密）密码。加密密码使用 crypt(3) 函数进行评估，因此根据系统的功能，支持不同的算法。例如，基于现代 Glibc 的 Linux 系统支持 MD5、SHA-256、SHA-512，当然还有经典的基于 DES 的密码加密方法。注意：请注意，使用加密密码可能会显着增加 CPU 使用率，具体取决于请求数和所使用的算法。对于任何散列变体，每个请求的密码都必须经过所选算法的处理，然后才能将其与配置文件中指定的值进行比较。大多数当前算法被故意设计为计算成本高昂，以实现抵抗暴力攻击。它们不只是对明文密码进行一次加盐/散列，而是成千上万次。这很快就会成为 HAProxy 整体 CPU 消耗的一个主要因素，甚至可能导致应用程序崩溃！为了解决哈希函数的高 CPU 使用率，一种方法是减少哈希函数的轮数（SHA 系列算法），或者如果算法支持，则降低函数的“成本”。顺便说一句，已知 musl（例如 Alpine Linux）实现在计算哈希时比其 glibc 对应项慢，因此您可能也想考虑这一方面。所有密码都被视为常规参数，因此受制于常规 第 2.2 节 引用和转义。因此建议对密码使用单引号。

userlist L1 group G1 users tiger,scott group G2 users xdb,scott user tiger password $6$k6y3o.eP$JlKBx9za9667qe4(...)xHSwRv6J.C0/D7cV91 user scott insecure-password 'elgato' user xdb insecure-password 'hello' userlist L2 group G1 group G2 user tiger password $6$k6y3o.eP$JlKBx(...)xHSwRv6J.C0/D7cV91 groups G1 user scott insecure-password 'elgato' groups G1,G2 user xdb insecure-password 'hello' groups G2

请注意，这两个列表在功能上是相同的。

可以将任何数据类型在 stick-tables 中的条目通过 TCP 连接在多个 HAProxy 实例之间以多主方式传播。每个实例将其本地更新和插入推送到远程对等体。推送的值会覆盖远程值，而无需聚合。作为例外，数据类型 "conn_cur" 永远不会从对等体学习，因为它应该反映本地值。早期版本曾同步它，并在 active-active 设置中导致负值，并在重新加载或 active-passive 切换时导致值不断增长，因为本地值会反映比本地存在的连接更多的连接。然而，此信息被推送，以便监控系统可以监视它。中断的交换会自动检测并从最后一个已知点恢复。此外，在软重启期间，旧进程使用这样的 TCP 连接连接到新进程，以在新进程尝试连接到其他对等体之前推送其所有条目。这确保了在重新加载期间非常快速的复制，即使对于大型表，通常也只需一小部分时间。请注意，服务器 ID 用于远程识别服务器，因此重要的是所有参与者上的配置看起来相似，或者至少在每个服务器上强制使用相同的 ID。

创建名为 <peersect> 的新对等节点列表。它是一个独立的部分，由一个或多个粘性表引用。

定义此“peers”部分中本地对等节点的绑定参数。在同一个“peers”部分中，此类行不支持与“peer”行同时使用。

禁用一个对等节点部分。它会禁用与此部分相关的侦听和任何同步。这用于禁用粘性表的同步，而无需注释掉所有 "peers" 引用。

定义本地对等节点的绑定参数，但不包括其地址。

更改“peers”部分中服务器的默认选项。

<param*> 是此服务器的参数列表。关键字 "default-server
This keyword is available in sections :
Peers
Alphabetically sorted keywords reference" 接受大量选项，并有一个完整的专用部分。在对等体部分中，支持 "default-server
This keyword is available in sections :
Peers
Alphabetically sorted keywords reference" 行的传输参数。请参阅 第 5 节 了解更多详细信息，并参阅本节中下面的 "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" 关键字了解一些限制。

此选项重新启用一个先前通过“disabled
此关键字在以下部分可用：
对等节点
按字母排序的关键字参考
服务器和默认服务器选项”关键字禁用的 peers 部分。

"peers" 部分支持与代理相同的 "log
This keyword is available in sections :
Process management and security
Log forwarding
Peers
Alphabetically sorted keywords reference" 关键字，用于记录有关 "peers" 监听器的信息。有关代理的更多详细信息，请参阅 "log
This keyword is available in sections :
Process management and security
Log forwarding
Peers
Alphabetically sorted keywords reference" 选项。

在 peers 部分中定义一个对等体。如果 <peername> 设置为本地对等体名称（默认为主机名，或使用 "-L" 命令行选项或 "localpeer" 全局配置设置强制设置），HAProxy 将监听在提供的地址上的传入远程对等体连接。否则，地址定义了连接到何处以加入远程对等体，<peername> 用于协议级别以在服务器端识别和验证远程对等体。在软重启期间，本地对等体地址被旧实例用于连接新实例并启动完整的复制（教学过程）。强烈建议在所有对等体上使用完全相同的 peers 声明，并且仅依赖 "-L" 命令行参数或 "localpeer" 全局配置设置来更改本地对等体名称。这使得跨所有对等体维护一致的配置文件更加容易。您可能希望在地址参数中引用一些环境变量，请参阅 第 2.3 节 有关环境变量的内容。注意：关键字 "peer" 可以透明地替换为关键字 "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference"（请参阅下面的 "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" 关键字解释）。

如前所述，关键字 "peer" 可以替换为关键字 "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference"，并支持 第 5.2 段 中与传输设置相关的所有 "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" 参数。如果底层对等体是本地的，则地址参数不得存在；它必须在 "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" 行上提供（请参阅此 "peers" 部分的 "bind
This keyword is available in sections :
Log forwarding
Peers
Alphabetically sorted keywords reference" 关键字）。许多 "server
This keyword is available in sections :
Peers
Rings
Alphabetically sorted keywords reference" 参数与 "peers" 部分无关。对等体本质上不支持动态主机名解析，也不支持健康检查，因此不支持 "init_addr"、"resolvers
This keyword is available in sections :
Server and default-server options
The resolvers section"、"check"、"agent-check" 或 "track" 等参数。同样，没有负载均衡或粘性，因此 "weight" 或 "cookie
This keyword is available in sections :
Alphabetically sorted keywords reference
Server and default-server options
Fetching HTTP samples (Layer 7)" 等参数无效。