.. _envoy_v3_api_file_envoy/config/core/v3/protocol.proto: Protocol options ================ .. _envoy_v3_api_msg_config.core.v3.UpstreamHttpProtocolOptions: config.core.v3.UpstreamHttpProtocolOptions ------------------------------------------ `[config.core.v3.UpstreamHttpProtocolOptions proto] `_ .. code-block:: json { "auto_sni": "...", "auto_san_validation": "..." } .. _envoy_v3_api_field_config.core.v3.UpstreamHttpProtocolOptions.auto_sni: auto_sni (`bool `_) Set transport socket `SNI `_ for new upstream connections based on the downstream HTTP host/authority header, as seen by the :ref:`router filter `. .. _envoy_v3_api_field_config.core.v3.UpstreamHttpProtocolOptions.auto_san_validation: auto_san_validation (`bool `_) Automatic validate upstream presented certificate for new upstream connections based on the downstream HTTP host/authority header, as seen by the :ref:`router filter `. This field is intended to set with `auto_sni` field. .. _envoy_v3_api_msg_config.core.v3.HttpProtocolOptions: config.core.v3.HttpProtocolOptions ---------------------------------- `[config.core.v3.HttpProtocolOptions proto] `_ .. code-block:: json { "idle_timeout": "{...}", "max_connection_duration": "{...}", "max_headers_count": "{...}", "max_stream_duration": "{...}", "headers_with_underscores_action": "..." } .. _envoy_v3_api_field_config.core.v3.HttpProtocolOptions.idle_timeout: idle_timeout (`Duration `_) The idle timeout for connections. The idle timeout is defined as the period in which there are no active requests. When the idle timeout is reached the connection will be closed. If the connection is an HTTP/2 downstream connection a drain sequence will occur prior to closing the connection, see :ref:`drain_timeout `. Note that request based timeouts mean that HTTP/2 PINGs will not keep the connection alive. If not specified, this defaults to 1 hour. To disable idle timeouts explicitly set this to 0. .. warning:: Disabling this timeout has a highly likelihood of yielding connection leaks due to lost TCP FIN packets, etc. If the :ref:`overload action ` "envoy.overload_actions.reduce_timeouts" is configured, this timeout is scaled for downstream connections according to the value for :ref:`HTTP_DOWNSTREAM_CONNECTION_IDLE `. .. _envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_connection_duration: max_connection_duration (`Duration `_) The maximum duration of a connection. The duration is defined as a period since a connection was established. If not set, there is no max duration. When max_connection_duration is reached the connection will be closed. Drain sequence will occur prior to closing the connection if if's applicable. See :ref:`drain_timeout `. Note: not implemented for upstream connections. .. _envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_headers_count: max_headers_count (`UInt32Value `_) The maximum number of headers. If unconfigured, the default maximum number of request headers allowed is 100. Requests that exceed this limit will receive a 431 response for HTTP/1.x and cause a stream reset for HTTP/2. .. _envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_stream_duration: max_stream_duration (`Duration `_) Total duration to keep alive an HTTP request/response stream. If the time limit is reached the stream will be reset independent of any other timeouts. If not specified, this value is not set. .. _envoy_v3_api_field_config.core.v3.HttpProtocolOptions.headers_with_underscores_action: headers_with_underscores_action (:ref:`config.core.v3.HttpProtocolOptions.HeadersWithUnderscoresAction `) Action to take when a client request with a header name containing underscore characters is received. If this setting is not specified, the value defaults to ALLOW. Note: upstream responses are not affected by this setting. .. _envoy_v3_api_enum_config.core.v3.HttpProtocolOptions.HeadersWithUnderscoresAction: Enum config.core.v3.HttpProtocolOptions.HeadersWithUnderscoresAction -------------------------------------------------------------------- `[config.core.v3.HttpProtocolOptions.HeadersWithUnderscoresAction proto] `_ Action to take when Envoy receives client request with header names containing underscore characters. Underscore character is allowed in header names by the RFC-7230 and this behavior is implemented as a security measure due to systems that treat '_' and '-' as interchangeable. Envoy by default allows client request headers with underscore characters. .. _envoy_v3_api_enum_value_config.core.v3.HttpProtocolOptions.HeadersWithUnderscoresAction.ALLOW: ALLOW *(DEFAULT)* ⁣Allow headers with underscores. This is the default behavior. .. _envoy_v3_api_enum_value_config.core.v3.HttpProtocolOptions.HeadersWithUnderscoresAction.REJECT_REQUEST: REJECT_REQUEST ⁣Reject client request. HTTP/1 requests are rejected with the 400 status. HTTP/2 requests end with the stream reset. The "httpN.requests_rejected_with_underscores_in_headers" counter is incremented for each rejected request. .. _envoy_v3_api_enum_value_config.core.v3.HttpProtocolOptions.HeadersWithUnderscoresAction.DROP_HEADER: DROP_HEADER ⁣Drop the header with name containing underscores. The header is dropped before the filter chain is invoked and as such filters will not see dropped headers. The "httpN.dropped_headers_with_underscores" is incremented for each dropped header. .. _envoy_v3_api_msg_config.core.v3.Http1ProtocolOptions: config.core.v3.Http1ProtocolOptions ----------------------------------- `[config.core.v3.Http1ProtocolOptions proto] `_ .. code-block:: json { "allow_absolute_url": "{...}", "accept_http_10": "...", "default_host_for_http_10": "...", "header_key_format": "{...}", "enable_trailers": "...", "allow_chunked_length": "...", "override_stream_error_on_invalid_http_message": "{...}" } .. _envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.allow_absolute_url: allow_absolute_url (`BoolValue `_) Handle HTTP requests with absolute URLs in the requests. These requests are generally sent by clients to forward/explicit proxies. This allows clients to configure envoy as their HTTP proxy. In Unix, for example, this is typically done by setting the *http_proxy* environment variable. .. _envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.accept_http_10: accept_http_10 (`bool `_) Handle incoming HTTP/1.0 and HTTP 0.9 requests. This is off by default, and not fully standards compliant. There is support for pre-HTTP/1.1 style connect logic, dechunking, and handling lack of client host iff *default_host_for_http_10* is configured. .. _envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.default_host_for_http_10: default_host_for_http_10 (`string `_) A default host for HTTP/1.0 requests. This is highly suggested if *accept_http_10* is true as Envoy does not otherwise support HTTP/1.0 without a Host header. This is a no-op if *accept_http_10* is not true. .. _envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.header_key_format: header_key_format (:ref:`config.core.v3.Http1ProtocolOptions.HeaderKeyFormat `) Describes how the keys for response headers should be formatted. By default, all header keys are lower cased. .. _envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.enable_trailers: enable_trailers (`bool `_) Enables trailers for HTTP/1. By default the HTTP/1 codec drops proxied trailers. .. attention:: Note that this only happens when Envoy is chunk encoding which occurs when: - The request is HTTP/1.1. - Is neither a HEAD only request nor a HTTP Upgrade. - Not a response to a HEAD request. - The content length header is not present. .. _envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.allow_chunked_length: allow_chunked_length (`bool `_) Allows Envoy to process requests/responses with both `Content-Length` and `Transfer-Encoding` headers set. By default such messages are rejected, but if option is enabled - Envoy will remove Content-Length header and process message. See `RFC7230, sec. 3.3.3 ` for details. .. attention:: Enabling this option might lead to request smuggling vulnerability, especially if traffic is proxied via multiple layers of proxies. .. _envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.override_stream_error_on_invalid_http_message: override_stream_error_on_invalid_http_message (`BoolValue `_) Allows invalid HTTP messaging. When this option is false, then Envoy will terminate HTTP/1.1 connections upon receiving an invalid HTTP message. However, when this option is true, then Envoy will leave the HTTP/1.1 connection open where possible. If set, this overrides any HCM :ref:`stream_error_on_invalid_http_messaging `. .. _envoy_v3_api_msg_config.core.v3.Http1ProtocolOptions.HeaderKeyFormat: config.core.v3.Http1ProtocolOptions.HeaderKeyFormat --------------------------------------------------- `[config.core.v3.Http1ProtocolOptions.HeaderKeyFormat proto] `_ .. code-block:: json { "proper_case_words": "{...}" } .. _envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.HeaderKeyFormat.proper_case_words: proper_case_words (:ref:`config.core.v3.Http1ProtocolOptions.HeaderKeyFormat.ProperCaseWords `, *REQUIRED*) Formats the header by proper casing words: the first character and any character following a special character will be capitalized if it's an alpha character. For example, "content-type" becomes "Content-Type", and "foo$b#$are" becomes "Foo$B#$Are". Note that while this results in most headers following conventional casing, certain headers are not covered. For example, the "TE" header will be formatted as "Te". .. _envoy_v3_api_msg_config.core.v3.Http1ProtocolOptions.HeaderKeyFormat.ProperCaseWords: config.core.v3.Http1ProtocolOptions.HeaderKeyFormat.ProperCaseWords ------------------------------------------------------------------- `[config.core.v3.Http1ProtocolOptions.HeaderKeyFormat.ProperCaseWords proto] `_ .. code-block:: json {} .. _envoy_v3_api_msg_config.core.v3.KeepaliveSettings: config.core.v3.KeepaliveSettings -------------------------------- `[config.core.v3.KeepaliveSettings proto] `_ .. code-block:: json { "interval": "{...}", "timeout": "{...}", "interval_jitter": "{...}" } .. _envoy_v3_api_field_config.core.v3.KeepaliveSettings.interval: interval (`Duration `_, *REQUIRED*) Send HTTP/2 PING frames at this period, in order to test that the connection is still alive. .. _envoy_v3_api_field_config.core.v3.KeepaliveSettings.timeout: timeout (`Duration `_, *REQUIRED*) How long to wait for a response to a keepalive PING. If a response is not received within this time period, the connection will be aborted. .. _envoy_v3_api_field_config.core.v3.KeepaliveSettings.interval_jitter: interval_jitter (:ref:`type.v3.Percent `) A random jitter amount as a percentage of interval that will be added to each interval. A value of zero means there will be no jitter. The default value is 15%. .. _envoy_v3_api_msg_config.core.v3.Http2ProtocolOptions: config.core.v3.Http2ProtocolOptions ----------------------------------- `[config.core.v3.Http2ProtocolOptions proto] `_ .. code-block:: json { "hpack_table_size": "{...}", "max_concurrent_streams": "{...}", "initial_stream_window_size": "{...}", "initial_connection_window_size": "{...}", "allow_connect": "...", "max_outbound_frames": "{...}", "max_outbound_control_frames": "{...}", "max_consecutive_inbound_frames_with_empty_payload": "{...}", "max_inbound_priority_frames_per_stream": "{...}", "max_inbound_window_update_frames_per_data_frame_sent": "{...}", "stream_error_on_invalid_http_messaging": "...", "override_stream_error_on_invalid_http_message": "{...}", "connection_keepalive": "{...}" } .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.hpack_table_size: hpack_table_size (`UInt32Value `_) `Maximum table size `_ (in octets) that the encoder is permitted to use for the dynamic HPACK table. Valid values range from 0 to 4294967295 (2^32 - 1) and defaults to 4096. 0 effectively disables header compression. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.max_concurrent_streams: max_concurrent_streams (`UInt32Value `_) `Maximum concurrent streams `_ allowed for peer on one HTTP/2 connection. Valid values range from 1 to 2147483647 (2^31 - 1) and defaults to 2147483647. For upstream connections, this also limits how many streams Envoy will initiate concurrently on a single connection. If the limit is reached, Envoy may queue requests or establish additional connections (as allowed per circuit breaker limits). .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.initial_stream_window_size: initial_stream_window_size (`UInt32Value `_) `Initial stream-level flow-control window `_ size. Valid values range from 65535 (2^16 - 1, HTTP/2 default) to 2147483647 (2^31 - 1, HTTP/2 maximum) and defaults to 268435456 (256 * 1024 * 1024). NOTE: 65535 is the initial window size from HTTP/2 spec. We only support increasing the default window size now, so it's also the minimum. This field also acts as a soft limit on the number of bytes Envoy will buffer per-stream in the HTTP/2 codec buffers. Once the buffer reaches this pointer, watermark callbacks will fire to stop the flow of data to the codec buffers. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.initial_connection_window_size: initial_connection_window_size (`UInt32Value `_) Similar to *initial_stream_window_size*, but for connection-level flow-control window. Currently, this has the same minimum/maximum/default as *initial_stream_window_size*. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.allow_connect: allow_connect (`bool `_) Allows proxying Websocket and other upgrades over H2 connect. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.max_outbound_frames: max_outbound_frames (`UInt32Value `_) Limit the number of pending outbound downstream frames of all types (frames that are waiting to be written into the socket). Exceeding this limit triggers flood mitigation and connection is terminated. The ``http2.outbound_flood`` stat tracks the number of terminated connections due to flood mitigation. The default limit is 10000. NOTE: flood and abuse mitigation for upstream connections is presently enabled by the `envoy.reloadable_features.upstream_http2_flood_checks` flag. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.max_outbound_control_frames: max_outbound_control_frames (`UInt32Value `_) Limit the number of pending outbound downstream frames of types PING, SETTINGS and RST_STREAM, preventing high memory utilization when receiving continuous stream of these frames. Exceeding this limit triggers flood mitigation and connection is terminated. The ``http2.outbound_control_flood`` stat tracks the number of terminated connections due to flood mitigation. The default limit is 1000. NOTE: flood and abuse mitigation for upstream connections is presently enabled by the `envoy.reloadable_features.upstream_http2_flood_checks` flag. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.max_consecutive_inbound_frames_with_empty_payload: max_consecutive_inbound_frames_with_empty_payload (`UInt32Value `_) Limit the number of consecutive inbound frames of types HEADERS, CONTINUATION and DATA with an empty payload and no end stream flag. Those frames have no legitimate use and are abusive, but might be a result of a broken HTTP/2 implementation. The `http2.inbound_empty_frames_flood`` stat tracks the number of connections terminated due to flood mitigation. Setting this to 0 will terminate connection upon receiving first frame with an empty payload and no end stream flag. The default limit is 1. NOTE: flood and abuse mitigation for upstream connections is presently enabled by the `envoy.reloadable_features.upstream_http2_flood_checks` flag. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.max_inbound_priority_frames_per_stream: max_inbound_priority_frames_per_stream (`UInt32Value `_) Limit the number of inbound PRIORITY frames allowed per each opened stream. If the number of PRIORITY frames received over the lifetime of connection exceeds the value calculated using this formula:: max_inbound_priority_frames_per_stream * (1 + inbound_streams) the connection is terminated. The ``http2.inbound_priority_frames_flood`` stat tracks the number of connections terminated due to flood mitigation. The default limit is 100. NOTE: flood and abuse mitigation for upstream connections is presently enabled by the `envoy.reloadable_features.upstream_http2_flood_checks` flag. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.max_inbound_window_update_frames_per_data_frame_sent: max_inbound_window_update_frames_per_data_frame_sent (`UInt32Value `_) Limit the number of inbound WINDOW_UPDATE frames allowed per DATA frame sent. If the number of WINDOW_UPDATE frames received over the lifetime of connection exceeds the value calculated using this formula:: 1 + 2 * (inbound_streams + max_inbound_window_update_frames_per_data_frame_sent * outbound_data_frames) the connection is terminated. The ``http2.inbound_priority_frames_flood`` stat tracks the number of connections terminated due to flood mitigation. The default limit is 10. Setting this to 1 should be enough to support HTTP/2 implementations with basic flow control, but more complex implementations that try to estimate available bandwidth require at least 2. NOTE: flood and abuse mitigation for upstream connections is presently enabled by the `envoy.reloadable_features.upstream_http2_flood_checks` flag. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.stream_error_on_invalid_http_messaging: stream_error_on_invalid_http_messaging (`bool `_) Allows invalid HTTP messaging and headers. When this option is disabled (default), then the whole HTTP/2 connection is terminated upon receiving invalid HEADERS frame. However, when this option is enabled, only the offending stream is terminated. This is overridden by HCM :ref:`stream_error_on_invalid_http_messaging ` iff present. This is deprecated in favor of :ref:`override_stream_error_on_invalid_http_message ` See `RFC7540, sec. 8.1 `_ for details. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.override_stream_error_on_invalid_http_message: override_stream_error_on_invalid_http_message (`BoolValue `_) Allows invalid HTTP messaging and headers. When this option is disabled (default), then the whole HTTP/2 connection is terminated upon receiving invalid HEADERS frame. However, when this option is enabled, only the offending stream is terminated. This overrides any HCM :ref:`stream_error_on_invalid_http_messaging ` See `RFC7540, sec. 8.1 `_ for details. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.connection_keepalive: connection_keepalive (:ref:`config.core.v3.KeepaliveSettings `) Send HTTP/2 PING frames to verify that the connection is still healthy. If the remote peer does not respond within the configured timeout, the connection will be aborted. .. _envoy_v3_api_msg_config.core.v3.Http2ProtocolOptions.SettingsParameter: config.core.v3.Http2ProtocolOptions.SettingsParameter ----------------------------------------------------- `[config.core.v3.Http2ProtocolOptions.SettingsParameter proto] `_ Defines a parameter to be sent in the SETTINGS frame. See `RFC7540, sec. 6.5.1 `_ for details. .. code-block:: json { "identifier": "{...}", "value": "{...}" } .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.SettingsParameter.identifier: identifier (`UInt32Value `_, *REQUIRED*) The 16 bit parameter identifier. .. _envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.SettingsParameter.value: value (`UInt32Value `_, *REQUIRED*) The 32 bit parameter value.