Skip to content
Kong Docs are moving soon! Our docs are migrating to a new home. You'll be automatically redirected to the new site in the future. In the meantime, view this page on the new site!
Kong Logo | Kong Docs Logo
  • Docs
    • Explore the API Specs
      View all API Specs View all API Specs View all API Specs arrow image
    • Documentation
      API Specs
      Kong Gateway
      Lightweight, fast, and flexible cloud-native API gateway
      Kong Konnect
      Single platform for SaaS end-to-end connectivity
      Kong AI Gateway
      Multi-LLM AI Gateway for GenAI infrastructure
      Kong Mesh
      Enterprise service mesh based on Kuma and Envoy
      decK
      Helps manage Kong’s configuration in a declarative fashion
      Kong Ingress Controller
      Works inside a Kubernetes cluster and configures Kong to proxy traffic
      Kong Gateway Operator
      Manage your Kong deployments on Kubernetes using YAML Manifests
      Insomnia
      Collaborative API development platform
  • Plugin Hub
    • Explore the Plugin Hub
      View all plugins View all plugins View all plugins arrow image
    • Functionality View all View all arrow image
      View all plugins
      AI's icon
      AI
      Govern, secure, and control AI traffic with multi-LLM AI Gateway plugins
      Authentication's icon
      Authentication
      Protect your services with an authentication layer
      Security's icon
      Security
      Protect your services with additional security layer
      Traffic Control's icon
      Traffic Control
      Manage, throttle and restrict inbound and outbound API traffic
      Serverless's icon
      Serverless
      Invoke serverless functions in combination with other plugins
      Analytics & Monitoring's icon
      Analytics & Monitoring
      Visualize, inspect and monitor APIs and microservices traffic
      Transformations's icon
      Transformations
      Transform request and responses on the fly on Kong
      Logging's icon
      Logging
      Log request and response data using the best transport for your infrastructure
  • Support
  • Community
  • Kong Academy
Get a Demo Start Free Trial
Kong Mesh
dev
  • Home icon
  • Kong Mesh
  • Policies
  • Mesh Timeout
github-edit-pageEdit this page
report-issueReport an issue
  • Kong Gateway
  • Kong Konnect
  • Kong Mesh
  • Kong AI Gateway
  • Plugin Hub
  • decK
  • Kong Ingress Controller
  • Kong Gateway Operator
  • Insomnia
  • Kuma

  • Docs contribution guidelines
  • dev
  • 2.10.x (latest)
  • 2.9.x
  • 2.8.x
  • 2.7.x (LTS)
  • 2.6.x
  • 2.5.x
  • 2.4.x
  • 2.3.x
  • 2.2.x
  • Introduction
    • About service meshes
    • Overview of Kong Mesh
    • How Kong Mesh works
    • Architecture
    • Install
    • Concepts
    • Stages of software availability
    • Version support policy
    • Software Bill of Materials
    • Vulnerability patching process
    • Mesh requirements
    • Release notes
  • Quickstart
    • Deploy Kong Mesh on Kubernetes
    • Deploy Kong Mesh on Universal
  • Kong Mesh in Production
    • Overview
    • Deployment topologies
      • Overview
      • Single-zone deployment
      • Multi-zone deployment
    • Use Kong Mesh
    • Control plane deployment
      • Kong Mesh license
      • Deploy a single-zone control plane
      • Deploy a multi-zone global control plane
      • Zone Ingress
      • Zone Egress
      • Configure zone proxy authentication
      • Control plane configuration reference
      • Systemd
      • Kubernetes
      • kumactl
      • Deploy Kong Mesh in Production with Helm
    • Configuring your Mesh and multi-tenancy
    • Data plane configuration
      • Data plane proxy
      • Configure the data plane on Kubernetes
      • Configure the data plane on Universal
      • Configure the Kong Mesh CNI
      • Configure transparent proxying
      • IPv6 support
    • Secure your deployment
      • Manage secrets
      • Authentication with the API server
      • Authentication with the data plane proxy
      • Configure data plane proxy membership
      • Secure access across services
      • Kong Mesh RBAC
      • FIPS support
    • Kong Mesh user interface
    • Inspect API
      • Matched policies
      • Affected data plane proxies
      • Envoy proxy configuration
    • Upgrades and tuning
      • Upgrade Kong Mesh
      • Performance fine-tuning
      • Version specific upgrade notes
    • Control Plane Configuration
      • Modifying the configuration
      • Inspecting the configuration
      • Store
  • Using Kong Mesh
    • Zero Trust & Application Security
      • Mutual TLS
      • External Service
    • Resiliency & Failover
      • Dataplane Health
      • Service Health Probes
    • Managing incoming traffic with gateways
      • How ingress works in Kuma
      • Delegated gateways
      • Built-in gateways
      • Running built-in gateway pods on Kubernetes
      • Configuring built-in listeners
      • Configuring built-in routes
      • Using the Kubernetes Gateway API
    • Observability
      • Demo setup
      • Control plane metrics
      • Configuring Prometheus
      • Configuring Grafana
      • Configuring Datadog
      • Observability in multi-zone
    • Route & Traffic shaping
      • Protocol support in Kong Mesh
    • Service Discovery & Networking
      • Service Discovery
      • MeshService
      • MeshMultiZoneService
      • HostnameGenerator
      • DNS
      • Non-mesh traffic
      • MeshExternalService
      • Transparent Proxying
  • Policies
    • Introduction
      • What is a policy?
      • What do policies look like?
      • Writing a targetRef
      • Merging configuration
      • Using policies with MeshService
      • Examples
      • Applying policies in shadow mode
    • MeshAccessLog
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshCircuitBreaker
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshFaultInjection
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshHealthCheck
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshHTTPRoute
      • TargetRef support matrix
      • Configuration
      • Examples
      • Merging
    • MeshLoadBalancingStrategy
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshMetric
      • TargetRef support matrix
      • Configuration
      • Prometheus
      • OpenTelemetry
      • Examples
    • MeshPassthrough
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshProxyPatch
      • TargetRef support matrix
      • Configuration
      • Examples
      • Merging
    • MeshRateLimit
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshRetry
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshTCPRoute
      • TargetRef support matrix
      • Configuration
      • Examples
      • Route policies with different types targeting the same destination
    • MeshTimeout
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshTLS
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshTrace
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshTrafficPermission
      • TargetRef support matrix
      • Configuration
      • Examples
    • MeshOPA
    • MeshGlobalRateLimit (beta)
    • Previous Policies
      • General notes about Kong Mesh policies
      • How Kong Mesh chooses the right policy to apply
      • Traffic Permissions
      • Traffic Route
      • Traffic Metrics
      • Traffic Trace
      • Traffic Log
      • Locality-aware Load Balancing
      • Fault Injection
      • Health Check
      • Circuit Breaker
      • Retry
      • Timeout
      • Rate Limit
      • Virtual Outbound
      • MeshGatewayRoute
      • OPA policy
  • Guides
    • Federate zone control plane
    • Add a builtin Gateway
    • Add Kong as a delegated Gateway
    • Kubernetes Gateway API
    • Collect Metrics with OpenTelemetry
    • Migration to the new policies
    • Progressively rolling in strict mTLS
    • Producer and consumer policies
    • Configuring inbound traffic with Rules API
    • Upgrading Transparent Proxy
  • Enterprise Features
    • Overview
    • HashiCorp Vault CA
    • Amazon ACM Private CA
    • cert-manager Private CA
    • OPA policy support
    • MeshOPA
    • Multi-zone authentication
    • FIPS support
    • Certificate Authority rotation
    • Role-Based Access Control
    • Red Hat
      • UBI Images
      • Red Hat OpenShift Quickstart
    • Windows Support
    • ECS Support
    • Auditing
    • MeshGlobalRateLimit (beta)
    • Verify signatures for signed Kong Mesh images
    • Build provenance
      • Verify build provenance for signed Kong Mesh images
      • Verify build provenance for signed Kong Mesh binaries
  • Reference
    • HTTP API
    • Kubernetes annotations and labels
    • Kuma data collection
    • Control plane configuration reference
    • Envoy proxy template
  • Community
    • Contribute to Kuma
enterprise-switcher-icon Switch to OSS
On this pageOn this page
  • TargetRef support matrix
  • Configuration
    • Timeouts explained
    • Examples
    • Defaults
  • All policy options
You are browsing unreleased documentation. See the latest documentation here.

Mesh Timeout

This policy uses new policy matching algorithm. Do not combine with Timeout policy.

TargetRef support matrix

Sidecar
Builtin Gateway
Delegated Gateway
targetRef Allowed kinds
targetRef.kind Mesh, Dataplane, MeshHTTPRoute, MeshSubset(deprecated)
to[].targetRef.kind Mesh, MeshService, MeshExternalService
targetRef Allowed kinds
targetRef.kind Mesh, MeshGateway, MeshGateway with listener tags
to[].targetRef.kind Mesh
targetRef Allowed kinds
targetRef.kind Mesh, MeshSubset, MeshHTTPRoute
to[].targetRef.kind Mesh, MeshService, MeshExternalService

To learn more about the information in this table, see the matching docs.

Configuration

This policy enables Kong Mesh to set timeouts on the inbound and outbound connections depending on the protocol. Using this policy you can configure TCP and HTTP timeouts. Timeout configuration is split into two sections: common configuration and HTTP configuration. Common config is applied to both HTTP and TCP communication. HTTP timeout are only applied when service is marked as http. More on this in protocol support section.

MeshTimeout policy lets you configure multiple timeouts:

  • connectionTimeout
  • idleTimeout
  • http.requestTimeout
  • http.streamIdleTimeout
  • http.maxStreamDuration
  • http.maxConnectionDuration
  • http.requestHeadersTimeout

Timeouts explained

Connection timeout

Connection timeout specifies the amount of time DP will wait for a TCP connection to be established.

Idle timeout

For TCP connections idle timeout is the amount of time that the DP will allow a connection to exist with no inbound or outbound activity. On the other hand when connection in HTTP time at which an inbound or outbound connection will be terminated if there are no active streams

HTTP request timeout

Request timeout lets you configure how long the data plane proxy should wait for the full response. In details, it spans between the point at which the entire request has been processed by DP and when the response has been completely processed by DP.

HTTP stream idle timeout

Stream idle timeout is the amount of time that the data plane proxy will allow an HTTP/2 stream to exist with no inbound or outbound activity. This timeout is strongly recommended for all requests (not just streaming requests/responses) as it additionally defends against a peer that does not open the stream window once an entire response has been buffered to be sent to a downstream client.

Stream timeouts apply even when you are only using HTTP/1.1 in you services. This is because every connection between data plane proxies is upgraded to HTTP/2.

HTTP max stream duration

Max stream duration is the maximum time that a stream’s lifetime will span. You can use this functionality when you want to reset HTTP request/response streams periodically.

HTTP max connection duration

Max connection duration is the time after which an inbound or outbound connection will be drained and/or closed, starting from when it was first established. If there are no active streams, the connection will be closed. If there are any active streams, the drain sequence will kick-in, and the connection will be force-closed after 5 seconds.

HTTP request headers timeout

The amount of time that proxy will wait for the request headers to be received. The timer is activated when the first byte of the headers is received, and is disarmed when the last byte of the headers has been received.

Examples

Simple outbound HTTP configuration

This configuration will be applied to all data plane proxies inside of Mesh.

Kubernetes
Universal
Terraform
apiVersion: kuma.io/v1alpha1
kind: MeshTimeout
metadata:
  name: timeout-global
  namespace: kuma-demo
  labels:
    kuma.io/mesh: default
spec:
  to:
  - targetRef:
      kind: Mesh
    default:
      idleTimeout: 20s
      connectionTimeout: 2s
      http:
        requestTimeout: 2s
type: MeshTimeout
name: timeout-global
mesh: default
spec:
  to:
  - targetRef:
      kind: Mesh
    default:
      idleTimeout: 20s
      connectionTimeout: 2s
      http:
        requestTimeout: 2s
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_mesh_timeout" "timeout_global" {
  provider = konnect-beta
  type = "MeshTimeout"
  name = "timeout-global"
  spec = {
    to = [
      {
        target_ref = {
          kind = "Mesh"
        }
        default = {
          idle_timeout = "20s"
          connection_timeout = "2s"
          http = {
            request_timeout = "2s"
          }
        }
      }
    ]
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}

Simple TCP configuration

Kubernetes
Universal
Terraform
apiVersion: kuma.io/v1alpha1
kind: MeshTimeout
metadata:
  name: tcp-timeout
  namespace: kuma-demo
  labels:
    kuma.io/mesh: default
spec:
  to:
  - targetRef:
      kind: Mesh
    default:
      idleTimeout: 20s
      connectionTimeout: 2s
type: MeshTimeout
name: tcp-timeout
mesh: default
spec:
  to:
  - targetRef:
      kind: Mesh
    default:
      idleTimeout: 20s
      connectionTimeout: 2s
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_mesh_timeout" "tcp_timeout" {
  provider = konnect-beta
  type = "MeshTimeout"
  name = "tcp-timeout"
  spec = {
    to = [
      {
        target_ref = {
          kind = "Mesh"
        }
        default = {
          idle_timeout = "20s"
          connection_timeout = "2s"
        }
      }
    ]
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}

Simple configuration for inbound applied to specific service

This configuration will be applied to backend service inbound.

Kubernetes
Universal
Terraform
apiVersion: kuma.io/v1alpha1
kind: MeshTimeout
metadata:
  name: inbound-timeout
  namespace: kuma-demo
  labels:
    kuma.io/mesh: default
spec:
  targetRef:
    kind: Dataplane
    labels:
      app: backend
  rules:
  - default:
      idleTimeout: 60s
      connectionTimeout: 2s
      http:
        requestTimeout: 10s
        streamIdleTimeout: 1h
        maxStreamDuration: 30m
        maxConnectionDuration: 30m
type: MeshTimeout
name: inbound-timeout
mesh: default
spec:
  targetRef:
    kind: Dataplane
    labels:
      app: backend
  rules:
  - default:
      idleTimeout: 60s
      connectionTimeout: 2s
      http:
        requestTimeout: 10s
        streamIdleTimeout: 1h
        maxStreamDuration: 30m
        maxConnectionDuration: 30m
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_mesh_timeout" "inbound_timeout" {
  provider = konnect-beta
  type = "MeshTimeout"
  name = "inbound-timeout"
  spec = {
    target_ref = {
      kind = "Dataplane"
      labels = {
        app = "backend"
      }
    }
    rules = [
      {
        default = {
          idle_timeout = "60s"
          connection_timeout = "2s"
          http = {
            request_timeout = "10s"
            stream_idle_timeout = "1h"
            max_stream_duration = "30m"
            max_connection_duration = "30m"
          }
        }
      }
    ]
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}

Configuration for a single inbound port named tcp-port

Kubernetes
Universal
Terraform
apiVersion: kuma.io/v1alpha1
kind: MeshTimeout
metadata:
  name: inbound-timeout
  namespace: kuma-demo
  labels:
    kuma.io/mesh: default
spec:
  targetRef:
    kind: Dataplane
    labels:
      app: backend
    sectionName: tcp-port
  rules:
  - default:
      idleTimeout: 1h
      connectionTimeout: 10s
type: MeshTimeout
name: inbound-timeout
mesh: default
spec:
  targetRef:
    kind: Dataplane
    labels:
      app: backend
    sectionName: tcp-port
  rules:
  - default:
      idleTimeout: 1h
      connectionTimeout: 10s
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_mesh_timeout" "inbound_timeout" {
  provider = konnect-beta
  type = "MeshTimeout"
  name = "inbound-timeout"
  spec = {
    target_ref = {
      kind = "Dataplane"
      labels = {
        app = "backend"
      }
      section_name = "tcp-port"
    }
    rules = [
      {
        default = {
          idle_timeout = "1h"
          connection_timeout = "10s"
        }
      }
    ]
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}

Target MeshHTTPRoute

Timeouts like http.requestTimeout and http.streamIdleTimeout are configurable per route. If a MeshHTTPRoute creates routes on the outbound listener of the service then MeshTimeout policy can configure timeouts on these routes.

In the following example the MeshHTTPRoute policy route-to-backend-v2 redirects all requests to /v2* to backend instances with version: v2 tag. MeshTimeout backend-v2 configures timeouts only for requests that are going through route-to-backend-v2 route.

Kubernetes
Universal
Terraform
apiVersion: kuma.io/v1alpha1
kind: MeshHTTPRoute
metadata:
  name: route-to-backend-v2
  namespace: kuma-demo
  labels:
    kuma.io/mesh: default
spec:
  targetRef:
    kind: Dataplane
    labels:
      app: frontend
  to:
  - targetRef:
      kind: MeshService
      name: backend_kuma-demo_svc_3001
    rules:
    - matches:
      - path:
          type: PathPrefix
          value: "/v2"
      default:
        backendRefs:
        - kind: MeshService
          name: backend-v2_kuma-demo_svc_3001
apiVersion: kuma.io/v1alpha1
kind: MeshHTTPRoute
metadata:
  name: route-to-backend-v2
  namespace: kuma-demo
  labels:
    kuma.io/mesh: default
spec:
  targetRef:
    kind: Dataplane
    labels:
      app: frontend
  to:
  - targetRef:
      kind: MeshService
      name: backend
      namespace: kuma-demo
      sectionName: http
    rules:
    - matches:
      - path:
          type: PathPrefix
          value: "/v2"
      default:
        backendRefs:
        - kind: MeshService
          name: backend-v2
          namespace: kuma-demo
          port: 3001
type: MeshHTTPRoute
name: route-to-backend-v2
mesh: default
spec:
  targetRef:
    kind: Dataplane
    labels:
      app: frontend
  to:
  - targetRef:
      kind: MeshService
      name: backend
    rules:
    - matches:
      - path:
          type: PathPrefix
          value: "/v2"
      default:
        backendRefs:
        - kind: MeshService
          name: backend-v2
type: MeshHTTPRoute
name: route-to-backend-v2
mesh: default
spec:
  targetRef:
    kind: Dataplane
    labels:
      app: frontend
  to:
  - targetRef:
      kind: MeshService
      name: backend
      sectionName: http
    rules:
    - matches:
      - path:
          type: PathPrefix
          value: "/v2"
      default:
        backendRefs:
        - kind: MeshService
          name: backend-v2
          port: 3001
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_mesh_http_route" "route_to_backend_v2" {
  provider = konnect-beta
  type = "MeshHTTPRoute"
  name = "route-to-backend-v2"
  spec = {
    target_ref = {
      kind = "Dataplane"
      labels = {
        app = "frontend"
      }
    }
    to = [
      {
        target_ref = {
          kind = "MeshService"
          name = "backend"
          section_name = "http"
        }
        rules = [
          {
            matches = [
              {
                path = {
                  type = "PathPrefix"
                  value = "/v2"
                }
              }
            ]
            default = {
              backend_refs = [
                {
                  kind = "MeshService"
                  name = "backend-v2"
                  port = "3001"
                }
              ]
            }
          }
        ]
      }
    ]
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}

You can see in the following route that the top level targetRef matches the previously defined MeshHTTPRoute.

Kubernetes
Universal
Terraform
apiVersion: kuma.io/v1alpha1
kind: MeshTimeout
metadata:
  name: backend-v2
  namespace: kuma-demo
  labels:
    kuma.io/mesh: default
spec:
  targetRef:
    kind: MeshHTTPRoute
    name: route-to-backend-v2
  to:
  - targetRef:
      kind: Mesh
    default:
      http:
        requestTimeout: 5s
        streamIdleTimeout: 1h
type: MeshTimeout
name: backend-v2
mesh: default
spec:
  targetRef:
    kind: MeshHTTPRoute
    name: route-to-backend-v2
  to:
  - targetRef:
      kind: Mesh
    default:
      http:
        requestTimeout: 5s
        streamIdleTimeout: 1h
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_mesh_timeout" "backend_v2" {
  provider = konnect-beta
  type = "MeshTimeout"
  name = "backend-v2"
  spec = {
    target_ref = {
      kind = "MeshHTTPRoute"
      name = "route-to-backend-v2"
    }
    to = [
      {
        target_ref = {
          kind = "Mesh"
        }
        default = {
          http = {
            request_timeout = "5s"
            stream_idle_timeout = "1h"
          }
        }
      }
    ]
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}

Default configuration for all gateways in the Mesh

This configuration will be applied on inbounds and outbounds of all gateways.

Kubernetes
Universal
Terraform
apiVersion: kuma.io/v1alpha1
kind: MeshTimeout
metadata:
  name: mesh-gateways-timeout-all-default
  namespace: kong-mesh-system
  labels:
    kuma.io/mesh: default
spec:
  targetRef:
    kind: Mesh
    proxyTypes:
    - Gateway
  from:
  - targetRef:
      kind: Mesh
    default:
      idleTimeout: 5m
      http:
        streamIdleTimeout: 5s
        requestHeadersTimeout: 500ms
  to:
  - targetRef:
      kind: Mesh
    default:
      idleTimeout: 1h
      http:
        streamIdleTimeout: 5s
type: MeshTimeout
name: mesh-gateways-timeout-all-default
mesh: default
spec:
  targetRef:
    kind: Mesh
    proxyTypes:
    - Gateway
  from:
  - targetRef:
      kind: Mesh
    default:
      idleTimeout: 5m
      http:
        streamIdleTimeout: 5s
        requestHeadersTimeout: 500ms
  to:
  - targetRef:
      kind: Mesh
    default:
      idleTimeout: 1h
      http:
        streamIdleTimeout: 5s
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_mesh_timeout" "mesh_gateways_timeout_all_default" {
  provider = konnect-beta
  type = "MeshTimeout"
  name = "mesh-gateways-timeout-all-default"
  spec = {
    target_ref = {
      kind = "Mesh"
      proxy_types = [
         = "Gateway"
      ]
    }
    from = [
      {
        target_ref = {
          kind = "Mesh"
        }
        default = {
          idle_timeout = "5m"
          http = {
            stream_idle_timeout = "5s"
            request_headers_timeout = "500ms"
          }
        }
      }
    ]
    to = [
      {
        target_ref = {
          kind = "Mesh"
        }
        default = {
          idle_timeout = "1h"
          http = {
            stream_idle_timeout = "5s"
          }
        }
      }
    ]
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}

Defaults

Property default
idleTimeout 1h
connectionTimeout 5s
http.requestTimeout 15s
http.streamIdleTimeout 30m
http.maxStreamDuration 0s
http.maxConnectionDuration 0s
http.requestHeadersTimeout 0s

All policy options

Spec is the specification of the Kuma MeshTimeout resource.

Type: object

Properties

  • from
    • From list makes a match between clients and corresponding configurations
    • Type: array
      • Items
      • Type: object
      • Properties
        • default
          • Default is a configuration specific to the group of clients referenced in'targetRef'
          • Type: object
          • Properties
            • connectionTimeout
              • ConnectionTimeout specifies the amount of time proxy will wait for an TCP connection to be established.Default value is 5 seconds. Cannot be set to 0.
              • Type: string
            • http
              • Http provides configuration for HTTP specific timeouts
              • Type: object
              • Properties
                • maxConnectionDuration
                  • MaxConnectionDuration is the time after which a connection will be drained and/or closed,starting from when it was first established. Setting this timeout to 0 will disable it.Disabled by default.
                  • Type: string
                • maxStreamDuration
                  • MaxStreamDuration is the maximum time that a stream’s lifetime will span.Setting this timeout to 0 will disable it. Disabled by default.
                  • Type: string
                • requestHeadersTimeout
                  • RequestHeadersTimeout The amount of time that proxy will wait for the request headers to be received. The timer isactivated when the first byte of the headers is received, and is disarmed when the last byte ofthe headers has been received. If not specified or set to 0, this timeout is disabled.Disabled by default.
                  • Type: string
                • requestTimeout
                  • RequestTimeout The amount of time that proxy will wait for the entire request to be received.The timer is activated when the request is initiated, and is disarmed when the last byte of the request is sent,OR when the response is initiated. Setting this timeout to 0 will disable it.Default is 15s.
                  • Type: string
                • streamIdleTimeout
                  • StreamIdleTimeout is the amount of time that proxy will allow a stream to exist with no activity.Setting this timeout to 0 will disable it. Default is 30m
                  • Type: string
            • idleTimeout
              • IdleTimeout is defined as the period in which there are no bytes sent or received on connectionSetting this timeout to 0 will disable it. Be cautious when disabling it becauseit can lead to connection leaking. Default value is 1h.
              • Type: string
        • targetRef required
          • TargetRef is a reference to the resource that represents a group ofclients.
          • Type: object
          • Properties
            • kind required
              • Kind of the referenced resource
              • Type: string
              • The value is restricted to the following:
                1. "Mesh"
                2. "MeshSubset"
                3. "MeshGateway"
                4. "MeshService"
                5. "MeshExternalService"
                6. "MeshMultiZoneService"
                7. "MeshServiceSubset"
                8. "MeshHTTPRoute"
                9. "Dataplane"
            • labels
              • Labels are used to select group of MeshServices that match labels. Either Labels orName and Namespace can be used.
              • Type: object
              • This schema accepts additional properties.
              • Properties
            • mesh
              • Mesh is reserved for future use to identify cross mesh resources.
              • Type: string
            • name
              • Name of the referenced resource. Can only be used with kinds: MeshService,MeshServiceSubset and MeshGatewayRoute
              • Type: string
            • namespace
              • Namespace specifies the namespace of target resource. If empty only resources in policy namespacewill be targeted.
              • Type: string
            • proxyTypes
              • ProxyTypes specifies the data plane types that are subject to the policy. When not specified,all data plane types are targeted by the policy.
              • Type: array
                • Items
                • Type: string
                • The value is restricted to the following:
                  1. "Sidecar"
                  2. "Gateway"
            • sectionName
              • SectionName is used to target specific section of resource.For example, you can target port from MeshService.ports[] by its name. Only traffic to this port will be affected.
              • Type: string
            • tags
              • Tags used to select a subset of proxies by tags. Can only be used with kindsMeshSubset and MeshServiceSubset
              • Type: object
              • This schema accepts additional properties.
              • Properties
  • rules
    • Rules defines inbound timeout configurations. Currently limited to exactly one rule containingdefault timeouts that apply to all inbound traffic, as L7 matching is not yet implemented.
    • Type: array
      • Items
      • Type: object
      • Properties
        • default
          • Default contains configuration of the inbound timeouts
          • Type: object
          • Properties
            • connectionTimeout
              • ConnectionTimeout specifies the amount of time proxy will wait for an TCP connection to be established.Default value is 5 seconds. Cannot be set to 0.
              • Type: string
            • http
              • Http provides configuration for HTTP specific timeouts
              • Type: object
              • Properties
                • maxConnectionDuration
                  • MaxConnectionDuration is the time after which a connection will be drained and/or closed,starting from when it was first established. Setting this timeout to 0 will disable it.Disabled by default.
                  • Type: string
                • maxStreamDuration
                  • MaxStreamDuration is the maximum time that a stream’s lifetime will span.Setting this timeout to 0 will disable it. Disabled by default.
                  • Type: string
                • requestHeadersTimeout
                  • RequestHeadersTimeout The amount of time that proxy will wait for the request headers to be received. The timer isactivated when the first byte of the headers is received, and is disarmed when the last byte ofthe headers has been received. If not specified or set to 0, this timeout is disabled.Disabled by default.
                  • Type: string
                • requestTimeout
                  • RequestTimeout The amount of time that proxy will wait for the entire request to be received.The timer is activated when the request is initiated, and is disarmed when the last byte of the request is sent,OR when the response is initiated. Setting this timeout to 0 will disable it.Default is 15s.
                  • Type: string
                • streamIdleTimeout
                  • StreamIdleTimeout is the amount of time that proxy will allow a stream to exist with no activity.Setting this timeout to 0 will disable it. Default is 30m
                  • Type: string
            • idleTimeout
              • IdleTimeout is defined as the period in which there are no bytes sent or received on connectionSetting this timeout to 0 will disable it. Be cautious when disabling it becauseit can lead to connection leaking. Default value is 1h.
              • Type: string
  • targetRef
    • TargetRef is a reference to the resource the policy takes an effect on.The resource could be either a real store object or virtual resourcedefined inplace.
    • Type: object
    • Properties
      • kind required
        • Kind of the referenced resource
        • Type: string
        • The value is restricted to the following:
          1. "Mesh"
          2. "MeshSubset"
          3. "MeshGateway"
          4. "MeshService"
          5. "MeshExternalService"
          6. "MeshMultiZoneService"
          7. "MeshServiceSubset"
          8. "MeshHTTPRoute"
          9. "Dataplane"
      • labels
        • Labels are used to select group of MeshServices that match labels. Either Labels orName and Namespace can be used.
        • Type: object
        • This schema accepts additional properties.
        • Properties
      • mesh
        • Mesh is reserved for future use to identify cross mesh resources.
        • Type: string
      • name
        • Name of the referenced resource. Can only be used with kinds: MeshService,MeshServiceSubset and MeshGatewayRoute
        • Type: string
      • namespace
        • Namespace specifies the namespace of target resource. If empty only resources in policy namespacewill be targeted.
        • Type: string
      • proxyTypes
        • ProxyTypes specifies the data plane types that are subject to the policy. When not specified,all data plane types are targeted by the policy.
        • Type: array
          • Items
          • Type: string
          • The value is restricted to the following:
            1. "Sidecar"
            2. "Gateway"
      • sectionName
        • SectionName is used to target specific section of resource.For example, you can target port from MeshService.ports[] by its name. Only traffic to this port will be affected.
        • Type: string
      • tags
        • Tags used to select a subset of proxies by tags. Can only be used with kindsMeshSubset and MeshServiceSubset
        • Type: object
        • This schema accepts additional properties.
        • Properties
  • to
    • To list makes a match between the consumed services and corresponding configurations
    • Type: array
      • Items
      • Type: object
      • Properties
        • default
          • Default is a configuration specific to the group of destinations referenced in'targetRef'
          • Type: object
          • Properties
            • connectionTimeout
              • ConnectionTimeout specifies the amount of time proxy will wait for an TCP connection to be established.Default value is 5 seconds. Cannot be set to 0.
              • Type: string
            • http
              • Http provides configuration for HTTP specific timeouts
              • Type: object
              • Properties
                • maxConnectionDuration
                  • MaxConnectionDuration is the time after which a connection will be drained and/or closed,starting from when it was first established. Setting this timeout to 0 will disable it.Disabled by default.
                  • Type: string
                • maxStreamDuration
                  • MaxStreamDuration is the maximum time that a stream’s lifetime will span.Setting this timeout to 0 will disable it. Disabled by default.
                  • Type: string
                • requestHeadersTimeout
                  • RequestHeadersTimeout The amount of time that proxy will wait for the request headers to be received. The timer isactivated when the first byte of the headers is received, and is disarmed when the last byte ofthe headers has been received. If not specified or set to 0, this timeout is disabled.Disabled by default.
                  • Type: string
                • requestTimeout
                  • RequestTimeout The amount of time that proxy will wait for the entire request to be received.The timer is activated when the request is initiated, and is disarmed when the last byte of the request is sent,OR when the response is initiated. Setting this timeout to 0 will disable it.Default is 15s.
                  • Type: string
                • streamIdleTimeout
                  • StreamIdleTimeout is the amount of time that proxy will allow a stream to exist with no activity.Setting this timeout to 0 will disable it. Default is 30m
                  • Type: string
            • idleTimeout
              • IdleTimeout is defined as the period in which there are no bytes sent or received on connectionSetting this timeout to 0 will disable it. Be cautious when disabling it becauseit can lead to connection leaking. Default value is 1h.
              • Type: string
        • targetRef required
          • TargetRef is a reference to the resource that represents a group ofdestinations.
          • Type: object
          • Properties
            • kind required
              • Kind of the referenced resource
              • Type: string
              • The value is restricted to the following:
                1. "Mesh"
                2. "MeshSubset"
                3. "MeshGateway"
                4. "MeshService"
                5. "MeshExternalService"
                6. "MeshMultiZoneService"
                7. "MeshServiceSubset"
                8. "MeshHTTPRoute"
                9. "Dataplane"
            • labels
              • Labels are used to select group of MeshServices that match labels. Either Labels orName and Namespace can be used.
              • Type: object
              • This schema accepts additional properties.
              • Properties
            • mesh
              • Mesh is reserved for future use to identify cross mesh resources.
              • Type: string
            • name
              • Name of the referenced resource. Can only be used with kinds: MeshService,MeshServiceSubset and MeshGatewayRoute
              • Type: string
            • namespace
              • Namespace specifies the namespace of target resource. If empty only resources in policy namespacewill be targeted.
              • Type: string
            • proxyTypes
              • ProxyTypes specifies the data plane types that are subject to the policy. When not specified,all data plane types are targeted by the policy.
              • Type: array
                • Items
                • Type: string
                • The value is restricted to the following:
                  1. "Sidecar"
                  2. "Gateway"
            • sectionName
              • SectionName is used to target specific section of resource.For example, you can target port from MeshService.ports[] by its name. Only traffic to this port will be affected.
              • Type: string
            • tags
              • Tags used to select a subset of proxies by tags. Can only be used with kindsMeshSubset and MeshServiceSubset
              • Type: object
              • This schema accepts additional properties.
              • Properties

Generated with json-schema-md-doc Tue May 20 2025 04:17:33 GMT+0000 (Coordinated Universal Time)

Thank you for your feedback.
Was this page useful?
Too much on your plate? close cta icon
More features, less infrastructure with Kong Konnect. 1M requests per month for free.
Try it for Free
  • Kong
    Powering the API world

    Increase developer productivity, security, and performance at scale with the unified platform for API management, service mesh, and ingress controller.

    • Products
      • Kong Konnect
      • Kong Gateway Enterprise
      • Kong Gateway
      • Kong Mesh
      • Kong Ingress Controller
      • Kong Insomnia
      • Product Updates
      • Get Started
    • Documentation
      • Kong Konnect Docs
      • Kong Gateway Docs
      • Kong Mesh Docs
      • Kong Insomnia Docs
      • Kong Konnect Plugin Hub
    • Open Source
      • Kong Gateway
      • Kuma
      • Insomnia
      • Kong Community
    • Company
      • About Kong
      • Customers
      • Careers
      • Press
      • Events
      • Contact
  • Terms• Privacy• Trust and Compliance
© Kong Inc. 2025