旧バージョンのドキュメントを参照しています。最新のドキュメントはこちらをご参照ください。

Traffic Route

Traffic Route is an outbound policy. Dataplanes whose configuration is modified are in the sources matcher.

This policy lets you configure routing rules for the traffic in the mesh. It supports weighted routing and can be used to implement versioning across services or to support deployment strategies such as blue/green or canary.

Note the following:

The configuration must specify the data plane proxies for the routing rules.
The spec.destinations field supports only kuma.io/service.
All available tags are supported for spec.conf.
This is an outbound connection policy. Make sure that your data plane proxy configuration includes the appropriate tags.

Kong Mesh also supports locality aware load balancing.

Default TrafficRoute

The control plane creates a default TrafficRoute every time a new Mesh is created. The default TrafficRoute enables the traffic between all the services in the mesh.

Kubernetes

Universal

apiVersion: kuma.io/v1alpha1
kind: TrafficRoute
mesh: default
metadata:
  name: route-all-default
spec:
  sources:
    - match:
        kuma.io/service: '*'
  destinations:
    - match:
        kuma.io/service: '*'
  conf:
    loadBalancer:
      roundRobin: {}
    destination:
      kuma.io/service: '*'

type: TrafficRoute
name: route-all-default
mesh: default
sources:
  - match:
      kuma.io/service: '*'
destinations:
  - match:
      kuma.io/service: '*'
conf:
  loadBalancer:
    roundRobin: {}
  destination:
    kuma.io/service: '*'

Usage

Here is a full example of TrafficRoute policy

Kubernetes

Universal

apiVersion: kuma.io/v1alpha1
kind: TrafficRoute
mesh: default
metadata:
  name: full-example
spec:
  sources:
    - match:
        kuma.io/service: backend_default_svc_80
  destinations:
    - match:
        kuma.io/service: redis_default_svc_6379
  conf:
    http:
    - match:
        method: # one of either "prefix", "exact" or "regex" is allowed
          exact: GET
          regex: "^POST|PUT$"
        path: # one of either "prefix", "exact" or "regex" is allowed
          prefix: /users
          exact: /users/user-1
          regex: "^users$"
        headers:
          some-header: # one of either "prefix", "exact" or "regex" will be allowed
            exact: some-value
            prefix: some-
            regex: "^users$"
      modify: # optional section
        path: # one of "rewritePrefix" or "regex" is allowed
          rewritePrefix: /not-users # rewrites previously matched prefix
          regex: # (example to change the path from "/service/foo/v1/api" to "/v1/api/instance/foo")
            pattern: "^/service/([^/]+)(/.*)$"
            substitution: '\2/instance/\1'
        host: # one of "value" or "fromPath" is allowed
          value: "XYZ"
          fromPath: # (example to extract "envoyproxy.io" host header from "/envoyproxy.io/some/path" path)
            pattern: "^/(.+)/.+$"
            substitution: '\1'
        requestHeaders:
          add:
            - name: x-custom-header
              value: xyz
              append: true # if true then if there is x-custom-header already, it will append xyz to the value 
          remove:
            - name: x-something
        responseHeaders:
          add:
            - name: x-custom-header
              value: xyz
              append: true
          remove:
            - name: x-something
      destination: # one of "destination", "split" is allowed
        kuma.io/service: redis_default_svc_6379
      split:
        - weight: 100
          destination:
            kuma.io/service: redis_default_svc_6379
    destination: # one of "destination", "split" is allowed
      kuma.io/service: redis_default_svc_6379
    split:
      - weight: 100
        destination:
          kuma.io/service: redis_default_svc_6379
    loadBalancer: # one of "roundRobin", "leastRequest", "ringHash", "random", "maglev" is allowed    
      roundRobin: {}
      leastRequest:
        choiceCount: 8
      ringHash:
        hashFunction: "MURMUR_HASH_2"
        minRingSize: 64
        maxRingSize: 1024
      random: {}
      maglev: {}

type: TrafficRoute
name: full-example
mesh: default
sources:
  - match:
      kuma.io/service: backend
destinations:
  - match:
      kuma.io/service: redis
conf:
  http:
    - match:
        method: # one of either "prefix", "exact" or "regex" is allowed
          exact: GET
          regex: "^POST|PUT$"
        path: # one of either "prefix", "exact" or "regex" is allowed
          prefix: /users
          exact: /users/user-1
          regex: "^users$"
        headers:
          some-header: # one of either "prefix", "exact" or "regex" will be allowed
            exact: some-value
            prefix: some-
            regex: "^users$"
      modify: # optional section
        path: # one of "rewritePrefix" or "regex" is allowed
          rewritePrefix: /not-users # rewrites previously matched prefix
          regex: # (example to change the path from "/service/foo/v1/api" to "/v1/api/instance/foo")
            pattern: "^/service/([^/]+)(/.*)$"
            substitution: '\2/instance/\1'
        host: # one of "value" or "fromPath" is allowed
          value: "XYZ"
          fromPath: # (example to extract "envoyproxy.io" host header from "/envoyproxy.io/some/path" path)
            pattern: "^/(.+)/.+$"
            substitution: '\1'
        requestHeaders:
          add:
            - name: x-custom-header
              value: xyz
              append: true # if true then if there is x-custom-header already, it will append xyz to the value 
          remove:
            - name: x-something
        responseHeaders:
          add:
            - name: x-custom-header
              value: xyz
              append: true
          remove:
            - name: x-something
      destination: # one of "destination", "split" is allowed
        kuma.io/service: redis
      split:
        - weight: 100
          destination:
            kuma.io/service: redis
  destination: # one of "destination", "split" is allowed
    kuma.io/service: redis
  split:
    - weight: 100
      destination:
        kuma.io/service: redis
  loadBalancer: # one of "roundRobin", "leastRequest", "ringHash", "random", "maglev" is allowed    
    roundRobin: {}
    leastRequest:
      choiceCount: 8
    ringHash:
      hashFunction: "MURMUR_HASH_2"
      minRingSize: 64
      maxRingSize: 1024
    random: {}
    maglev: {}

Kong Mesh utilizes positive weights in the TrafficRoute policy and not percentages, therefore Kong Mesh does not check if the total adds up to 100. If we want to stop sending traffic to a destination service we change the weight for that service to 0.

L4 Traffic Split

We can use TrafficRoute to split a TCP traffic between services with different tags implementing A/B testing or canary deployments.

Here is an example of a TrafficRoute that splits the traffic over the two different versions of the application. 90% of the connections from backend_default_svc_80 service will be initiated to redis_default_svc_6379 with tag version: 1.0 and 10% of the connections will be initiated to version: 2.0

Kubernetes

Universal

apiVersion: kuma.io/v1alpha1
kind: TrafficRoute
mesh: default
metadata:
  name: split-traffic
spec:
  sources:
    - match:
        kuma.io/service: backend_default_svc_80
  destinations:
    - match:
        kuma.io/service: redis_default_svc_6379
  conf:
    split:
      - weight: 90
        destination:
          kuma.io/service: redis_default_svc_6379
          version: '1.0'
      - weight: 10
        destination:
          kuma.io/service: redis_default_svc_6379
          version: '2.0'

type: TrafficRoute
name: split-traffic
mesh: default
sources:
  - match:
      kuma.io/service: backend
destinations:
  - match:
      kuma.io/service: redis
conf:
  split:
    - weight: 90
      destination:
        kuma.io/service: redis
        version: '1.0'
    - weight: 10
      destination:
        kuma.io/service: redis
        version: '2.0'

L4 Traffic Rerouting

We can use TrafficRoute to fully reroute a TCP traffic to different version of a service or even completely different service.

Here is an example of a TrafficRoute that redirects the traffic to another-redis_default_svc_6379 when backend_default_svc_80 is trying to consume redis_default_svc_6379.

Kubernetes

Universal

apiVersion: kuma.io/v1alpha1
kind: TrafficRoute
mesh: default
metadata:
  name: reroute-traffic
spec:
  sources:
    - match:
        kuma.io/service: backend_default_svc_80
  destinations:
    - match:
        kuma.io/service: redis_default_svc_6379
  conf:
    destination:
      kuma.io/service: another-redis_default_svc_6379

type: TrafficRoute
name: reroute-traffic
mesh: default
sources:
  - match:
      kuma.io/service: backend_default_svc_80
destinations:
  - match:
      kuma.io/service: redis_default_svc_6379
conf:
  destination:
    kuma.io/service: another-redis_default_svc_6379

L7 Traffic Split

We can use TrafficRoute to split an HTTP traffic between services with different tags implementing A/B testing or canary deployments.

Here is an example of a TrafficRoute that splits the traffic from frontend_default_svc_80 to backend_default_svc_80 between versions, but only on endpoints starting with /api. All other endpoints will go to version: 1.0

Kubernetes

Universal

apiVersion: kuma.io/v1alpha1
kind: TrafficRoute
mesh: default
metadata:
  name: api-split
spec:
  sources:
    - match:
        kuma.io/service: frontend_default_svc_80
  destinations:
    - match:
        kuma.io/service: backend_default_svc_80
  conf:
    http:
    - match:
        path:
          prefix: "/api"
      split:
      - weight: 90
        destination:
          kuma.io/service: backend_default_svc_80
          version: '1.0'
      - weight: 10
        destination:
          kuma.io/service: backend_default_svc_80
          version: '2.0'
    destination: # default rule is applied when endpoint does not match any rules in http section
      kuma.io/service: backend_default_svc_80
      version: '1.0'

type: TrafficRoute
name: api-split
mesh: default
sources:
  - match:
      kuma.io/service: frontend_default_svc_80
destinations:
  - match:
      kuma.io/service: backend_default_svc_80
conf:
  http:
    - match:
        path:
          prefix: "/api"
      split:
        - weight: 90
          destination:
            kuma.io/service: backend_default_svc_80
            version: '1.0'
        - weight: 10
          destination:
            kuma.io/service: backend_default_svc_80
            version: '2.0'
  destination: # default rule is applied when endpoint does not match any rules in http section
    kuma.io/service: backend_default_svc_80
    version: '1.0'

In order to use L7 Traffic Split, we need to mark the destination service with kuma.io/protocol: http.

L7 Traffic Modification

We can use TrafficRoute to modify outgoing requests, by setting new path or changing request and response headers.

Here is an example of a TrafficRoute that adds x-custom-header with value xyz when frontend_default_svc_80 tries to consume backend_default_svc_80.

Kubernetes

Universal

apiVersion: kuma.io/v1alpha1
kind: TrafficRoute
mesh: default
metadata:
  name: add-header
spec:
  sources:
    - match:
        kuma.io/service: frontend_default_svc_80
  destinations:
    - match:
        kuma.io/service: backend_default_svc_80
  conf:
    http:
    - match:
        path:
          prefix: "/"
      modify:
        requestHeader:
          add:
            - name: x-custom-header
              value: xyz
      destination:
        kuma.io/service: backend_default_svc_80
    destination:
      kuma.io/service: backend_default_svc_80

type: TrafficRoute
name: add-header
mesh: default
sources:
  - match:
      kuma.io/service: frontend_default_svc_80
destinations:
  - match:
      kuma.io/service: backend_default_svc_80
conf:
  http:
    - match:
        path:
          prefix: "/"
      modify:
        requestHeader:
          add:
            - name: x-custom-header
              value: xyz
      destination:
        kuma.io/service: backend_default_svc_80
  destination:
    kuma.io/service: backend_default_svc_80

In order to use L7 Traffic Modification, we need to mark the destination service with kuma.io/protocol: http.

L7 Traffic Rerouting

We can use TrafficRoute to modify outgoing requests, by setting new path or changing request and response headers.

Here is an example of a TrafficRoute that redirect traffic to offers_default_svc_80 when frontend_default_svc_80 is trying to consume backend_default_svc_80 on /offers endpoint.

Kubernetes

Universal

apiVersion: kuma.io/v1alpha1
kind: TrafficRoute
mesh: default
metadata:
  name: http-reroute
spec:
  sources:
    - match:
        kuma.io/service: frontend_default_svc_80
  destinations:
    - match:
        kuma.io/service: backend_default_svc_80
  conf:
    http:
    - match:
        path:
          prefix: "/offers"
      destination:
        kuma.io/service: offers_default_svc_80
    destination:
      kuma.io/service: backend_default_svc_80

type: TrafficRoute
name: http-reroute
mesh: default
sources:
  - match:
      kuma.io/service: frontend_default_svc_80
destinations:
  - match:
      kuma.io/service: backend_default_svc_80
conf:
  http:
    - match:
        path:
          prefix: "/offers"
      destination:
        kuma.io/service: offers_default_svc_80
  destination:
    kuma.io/service: backend_default_svc_80

In order to use L7 Traffic Rerouting, we need to mark the destination service with kuma.io/protocol: http.

Load balancer types

There are different load balancing algorithms that can be used to determine how traffic is routed to the destinations. By default TrafficRoute uses the roundRobin load balancer, but more options are available:

roundRobin is a simple algorithm in which each available upstream host is selected in round robin order.

Example:
```
loadBalancer:
  roundRobin: {}
```
leastRequest uses different algorithms depending on whether the hosts have the same or different weights. It has a single configuration field choiceCount, which denotes the number of random healthy hosts from which the host with the fewer active requests will be chosen.

Example:
```
loadBalancer:
  leastRequest:
    choiceCount: 8
```
ringHash implements consistent hashing to the upstream hosts. It has the following fields:
- hashFunction the hash function used to hash the hosts onto the ketama ring. Can be XX_HASH or MURMUR_HASH_2.
- minRingSize minimum hash ring size.
- maxRingSize maximum hash ring size.
Example:
```
loadBalancer:
  ringHash:
    hashFunction: "MURMUR_HASH_2"
    minRingSize: 64
    maxRingSize: 1024
```
random selects a random available host.

Example:
```
loadBalancer:
  random: {}
```
maglev implements consistent hashing to upstream hosts

Example:
```
loadBalancer:
  maglev: {}
```

All options

$schema: http://json-schema.org/draft-04/schema#

$ref: #/definitions/TrafficRoute

definitions

TrafficRoute

## Traffic Route
TrafficRoute defines routing rules for the traffic in the mesh.
Type: object
This schema accepts additional properties.
Properties
- sources
  - List of selectors to match data plane proxies that are sources of traffic.
  - Type: array
    - Items
    - $ref: #/definitions/kuma.mesh.v1alpha1.Selector
- destinations
  - List of selectors to match services that are destinations of traffic. Notice the difference between sources and destinations. While the source of traffic is always a data plane proxy within a mesh, the destination is a service that could be either within or outside of a mesh.
  - Type: array
    - Items
    - $ref: #/definitions/kuma.mesh.v1alpha1.Selector
- conf
  - Configuration for the route.
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Conf
  - This schema accepts additional properties.
  - Properties kuma.mesh.v1alpha1.Selector
## Selector
Selector defines structure for selecting tags for given dataplane
Type: object
This schema accepts additional properties.
Properties
- match
  - Tags to match, can be used for both source and destinations
  - Type: object
  - This schema accepts additional properties.
  - Properties kuma.mesh.v1alpha1.TrafficRoute.Conf
## Conf
Conf defines the destination configuration.
Type: object
This schema accepts additional properties.
Properties
- split
  - List of destinations with weights assigned to them. When used, "destination" is not allowed.
  - Type: array
    - Items
    - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Split
- load_balancer
  - Load balancer configuration for given "split" or "destination"
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer
  - This schema accepts additional properties.
  - Properties
- destination
  - One destination that the traffic will be redirected to. When used, "split" is not allowed.
  - Type: object
  - This schema accepts additional properties.
  - Properties
- http
  - Configuration of HTTP traffic. Traffic is matched one by one with the order defined in the list. If the request does not match any criteria then "split" or "destination" outside of "http" section is executed.
  - Type: array
    - Items
    - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http kuma.mesh.v1alpha1.TrafficRoute.Http
## Http
Http defines configuration for HTTP traffic.
Type: object
This schema accepts additional properties.
Properties
- match
  - If request matches against defined criteria then "split" or "destination" is executed.
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Match
  - This schema accepts additional properties.
  - Properties
- modify
  - Modifications to the traffic matched by the match section.
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Modify
  - This schema accepts additional properties.
  - Properties
- split
  - List of destinations with weights assigned to them. When used, "destination" is not allowed.
  - Type: array
    - Items
    - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Split
- destination
  - One destination that the traffic will be redirected to. When used, "split" is not allowed.
  - Type: object
  - This schema accepts additional properties.
  - Properties kuma.mesh.v1alpha1.TrafficRoute.Http.Match
## Match
Match defines a series of matching criteria to apply modification and reroute the traffic.
Type: object
This schema accepts additional properties.
Properties
- method
  - Method matches method of HTTP request.
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Match.StringMatcher
  - This schema accepts additional properties.
  - Properties
- path
  - Path matches HTTP path.
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Match.StringMatcher
  - This schema accepts additional properties.
  - Properties
- headers
  - Headers match HTTP request headers.
  - Type: object
  - This schema accepts additional properties.
  - Properties kuma.mesh.v1alpha1.TrafficRoute.Http.Match.StringMatcher
## String Matcher
StringMatcher matches the string value.
Type: object
This schema accepts additional properties.
Properties
- prefix
  - Prefix matches the string against defined prefix.
  - Type: string
- exact
  - Exact checks that strings are equal to each other.
  - Type: string
- regex
  - Regex checks the string using RE2 syntax. https://github.com/google/re2/wiki/Syntax
  - Type: string kuma.mesh.v1alpha1.TrafficRoute.Http.Modify
## Modify
Modify defines modifications of matched HTTP messages.
Type: object
This schema accepts additional properties.
Properties
- path
  - Path modifications.
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.Path
  - This schema accepts additional properties.
  - Properties
- host
  - Host modifications.
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.Host
  - This schema accepts additional properties.
  - Properties
- requestHeaders
  - Request headers modifications.
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.Headers
  - This schema accepts additional properties.
  - Properties
- responseHeaders
  - Response headers modifications.
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.Headers
  - This schema accepts additional properties.
  - Properties kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.Headers
## Headers
Headers defines modification of HTTP headers.
Type: object
This schema accepts additional properties.
Properties
- add
  - List of add header operations.
  - Type: array
    - Items
    - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.Headers.Add
- remove
  - List of remove header operations.
  - Type: array
    - Items
    - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.Headers.Remove kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.Headers.Add
## Add
Add defines operation of adding new HTTP header.
Type: object
This schema accepts additional properties.
Properties
- name
  - Name of the header.
  - Type: string
- value
  - Value of the header.
  - Type: string
- append
  - If true, it appends the value if there is already a value. Otherwise, value of existing header will be replaced.
  - Type: boolean kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.Headers.Remove
## Remove
Remove defines operation of removing an HTTP header.
Type: object
This schema accepts additional properties.
Properties
- name
  - Name of the header to remove.
  - Type: string kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.Host
## Host
Host defines modification of the HTTP Host header
Type: object
This schema accepts additional properties.
Properties
- value
  - Value replaces the host header with given value.
  - Type: string
- fromPath
  - FromPath replaces the host header from path using regex.
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.RegexReplace
  - This schema accepts additional properties.
  - Properties kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.Path
## Path
Path defines modification of path of the HTTP request.
Type: object
This schema accepts additional properties.
Properties
- rewritePrefix
  - RewritePrefix rewrites previously matched prefix in match section.
  - Type: string
- regex
  - Regex rewrites prefix using regex with substitution.
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.RegexReplace
  - This schema accepts additional properties.
  - Properties kuma.mesh.v1alpha1.TrafficRoute.Http.Modify.RegexReplace
## Regex Replace
RegexReplace defines a way to match string using regex and build a new one using substitution section.
Type: object
This schema accepts additional properties.
Properties
- pattern
  - Pattern of the regex using RE2 syntax. https://github.com/google/re2/wiki/Syntax
  - Type: string
- substitution
  - Substitution using regex groups. E.g. use \1 as a first matched group.
  - Type: string kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer
## Load Balancer
LoadBalancer defines the load balancing policy and configuration.
Type: object
This schema accepts additional properties.
Properties
- round_robin
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer.RoundRobin
  - This schema accepts additional properties.
  - Properties
- least_request
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer.LeastRequest
  - This schema accepts additional properties.
  - Properties
- ring_hash
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer.RingHash
  - This schema accepts additional properties.
  - Properties
- random
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer.Random
  - This schema accepts additional properties.
  - Properties
- maglev
  - Type: object
  - $ref: #/definitions/kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer.Maglev
  - This schema accepts additional properties.
  - Properties kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer.LeastRequest
## Least Request
LeastRequest uses different algorithms depending on whether hosts have the same or different weights.
Type: object
This schema accepts additional properties.
Properties
- choice_count
  - The number of random healthy hosts from which the host with the fewest active requests will be chosen. Defaults to 2 so that we perform two-choice selection if the field is not set.
  - Type: integer kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer.Maglev
## Maglev
Maglev implements consistent hashing to upstream hosts.
Type: object
This schema accepts additional properties.
Properties kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer.Random
## Random
Random selects a random available host.
Type: object
This schema accepts additional properties.
Properties kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer.RingHash
## Ring Hash
RingHash implements consistent hashing to upstream hosts.
Type: object
This schema accepts additional properties.
Properties
- hash_function
  - The hash function used to hash hosts onto the ketama ring. The value defaults to 'XX_HASH'.
  - Type: string
- minringsize
  - Minimum hash ring size.
  - Type: string
- maxringsize
  - Maximum hash ring size.
  - Type: string kuma.mesh.v1alpha1.TrafficRoute.LoadBalancer.RoundRobin
## Round Robin
RoundRobin is a simple policy in which each available upstream host is selected in round robin order.
Type: object
This schema accepts additional properties.
Properties kuma.mesh.v1alpha1.TrafficRoute.Split
## Split
Split defines a destination with a weight assigned to it.
Type: object
This schema accepts additional properties.
Properties
- weight
  - Weight assigned to that destination. Weights are not percentages. For example two destinations with weights the same weight "1" will receive both same amount of the traffic. 0 means that the destination will be ignored.
  - Type: integer
- destination
  - Selector to match individual endpoints that comprise that destination. Notice that an endpoint can be either inside or outside the mesh. In the former case an endpoint corresponds to a data plane proxy, in the latter case an endpoint is an External Service.
  - Type: object
  - This schema accepts additional properties.
  - Properties

Generated with json-schema-md-doc Fri May 09 2025 22:13:19 GMT+0000 (Coordinated Universal Time)