Traffic Route

must select the data plane proxies to route the connection between them.

Kuma also supports locality aware load balancing.

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

  1. type: TrafficRoute
  2. name: route-all-default
  3. mesh: default
  4. sources:
  5.   - match:
  6.       kuma.io/service: '*'
  7. destinations:
  8.   - match:
  9.       kuma.io/service: '*'
  10. conf:
  11.   loadBalancer:
  12.     roundRobin: {}
  13.   split:
  14.     - weight: 100
  15.       destination:

By default when a service makes a request to another service, Kuma will round robin the request across every data plane proxy belogning to the destination service. It is possible to change this behavior by using this policy, for example:

  1. apiVersion: kuma.io/v1alpha1
  2. kind: TrafficRoute
  3. mesh: default
  4. metadata:
  5.   name: route-example
  7.   sources:
  8.     - match:
  9.         kuma.io/service: backend_default_svc_80
  10.   destinations:
  11.     - match:
  12.         kuma.io/service: redis_default_svc_6379
  13.   conf:
  14.     split:
  15.       - weight: 90
  16.         destination:
  17.           kuma.io/service: redis_default_svc_6379
  18.           version: '1.0'
  19.         destination:
  20.           kuma.io/service: redis_default_svc_6379
  21.           version: '2.0'

We will apply the configuration with kubectl apply -f [..].

We will apply the configuration with kumactl apply -f [..] or via the .

Note that routing can be applied not just on the automatically provisioned service Kuma tag, but on any other tag that we may want to add to our data plane proxies (like version in the example above).

Kuma utilizes positive weights in the TrafficRoute policy and not percentages, therefore Kuma 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.

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:

    1. loadBalancer:
    2.   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.

    1. loadBalancer:
    2.   leastRequest:
    3.     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:

  • random selects a random available host.

    Example:

    1. loadBalancer:
    2.   random: {}

  • maglev implements consistent hashing to upstream hosts

    Example:

    1.   maglev: {}