You are browsing unreleased documentation. See the latest documentation here.

HostnameGenerator

A HostnameGenerator provides

a template to generate hostnames from properties of MeshServices, MeshMultiZoneService, and MeshExternalServices
a selector that defines for which MeshServices, MeshMultiZoneService, and MeshExternalServices this generator runs

Defaults

Kong Mesh ships with default HostnameGenerators depending on the control plane mode and storage type.

Local MeshService in Universal zone

The following policy is automatically created on a zone control plane running in the Universal mode. It creates a hostname for each MeshService created in a zone. For example, MeshService of name redis would obtain redis.svc.mesh.local hostname.

type: HostnameGenerator
name: local-universal-mesh-service
spec:
  selector:
    meshService:
      matchLabels:
        kuma.io/origin: zone
  template: "{{ .DisplayName }}.svc.mesh.local"

Local MeshExternalService

The following policy is automatically created on a zone control plane. It creates a hostname for each MeshExternalService created in a zone. For example, MeshExternalService of name aurora would obtain aurora.extsvc.mesh.local hostname.

        
          Kubernetes
        
      

        
          Universal
        
      

        
          Terraform
        
      

    
      apiVersion: kuma.io/v1alpha1
kind: HostnameGenerator
metadata:
  name: local-mesh-external-service
  namespace: kong-mesh-system
spec:
  selector:
    meshExternalService:
      matchLabels:
        kuma.io/origin: zone
  template: "{{ .DisplayName }}.extsvc.mesh.local"

    
      type: HostnameGenerator
name: local-mesh-external-service
spec:
  selector:
    meshExternalService:
      matchLabels:
        kuma.io/origin: zone
  template: "{{ .DisplayName }}.extsvc.mesh.local"

    
      
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_hostname_generator" "local_mesh_external_service" {
  provider = konnect-beta
  type = "HostnameGenerator"
  name = "local-mesh-external-service"
  spec = {
    selector = {
      mesh_external_service = {
        match_labels = {
          kuma.io/origin = "zone"
        }
      }
    }
    template = "{{ .DisplayName }}.extsvc.mesh.local"
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}


    
  

Synced MeshService from Kubernetes zone

The following policies are automatically created on a global control plane and synced to all zones.

The first creates a hostname for each MeshService synced from another Kubernetes zone. For example, MeshService of name redis and namespace redis-system from zone east would obtain redis.redis-system.svc.east.mesh.local

        
          Kubernetes
        
      

        
          Universal
        
      

        
          Terraform
        
      

    
      apiVersion: kuma.io/v1alpha1
kind: HostnameGenerator
metadata:
  name: synced-kube-mesh-service
  namespace: kong-mesh-system
spec:
  selector:
    meshService:
      matchLabels:
        kuma.io/origin: global
        k8s.kuma.io/is-headless-service: false
        kuma.io/env: kubernetes
  template: "{{ .DisplayName }}.{{ .Namespace }}.svc.{{ .Zone }}.mesh.local"

    
      type: HostnameGenerator
name: synced-kube-mesh-service
spec:
  selector:
    meshService:
      matchLabels:
        kuma.io/origin: global
        k8s.kuma.io/is-headless-service: false
        kuma.io/env: kubernetes
  template: "{{ .DisplayName }}.{{ .Namespace }}.svc.{{ .Zone }}.mesh.local"

    
      
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_hostname_generator" "synced_kube_mesh_service" {
  provider = konnect-beta
  type = "HostnameGenerator"
  name = "synced-kube-mesh-service"
  spec = {
    selector = {
      mesh_service = {
        match_labels = {
          kuma.io/origin = "global"
          k8s.kuma.io/is-headless-service = "false"
          kuma.io/env = "kubernetes"
        }
      }
    }
    template = "{{ .DisplayName }}.{{ .Namespace }}.svc.{{ .Zone }}.mesh.local"
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}


    
  

The second creates a hostname for each MeshService synced from another Kubernetes zone that were created from a headless Service. For example, instance redis-0 of MeshService of name redis and namespace redis-system from zone east would obtain redis-0.redis.redis-system.svc.east.mesh.local

        
          Kubernetes
        
      

        
          Universal
        
      

        
          Terraform
        
      

    
      apiVersion: kuma.io/v1alpha1
kind: HostnameGenerator
metadata:
  name: synced-headless-kube-mesh-service
  namespace: kong-mesh-system
spec:
  selector:
    meshService:
      matchLabels:
        kuma.io/origin: global
        k8s.kuma.io/is-headless-service: true
        kuma.io/env: kubernetes
  template: "{{ label 'statefulset.kubernetes.io/pod-name' }}.{{ label 'k8s.kuma.io/service-name'
    }}.{{ .Namespace }}.svc.{{ .Zone }}.mesh.local"

    
      type: HostnameGenerator
name: synced-headless-kube-mesh-service
spec:
  selector:
    meshService:
      matchLabels:
        kuma.io/origin: global
        k8s.kuma.io/is-headless-service: true
        kuma.io/env: kubernetes
  template: "{{ label 'statefulset.kubernetes.io/pod-name' }}.{{ label 'k8s.kuma.io/service-name'
    }}.{{ .Namespace }}.svc.{{ .Zone }}.mesh.local"

    
      
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_hostname_generator" "synced_headless_kube_mesh_service" {
  provider = konnect-beta
  type = "HostnameGenerator"
  name = "synced-headless-kube-mesh-service"
  spec = {
    selector = {
      mesh_service = {
        match_labels = {
          kuma.io/origin = "global"
          k8s.kuma.io/is-headless-service = "true"
          kuma.io/env = "kubernetes"
        }
      }
    }
    template = "{{ label 'statefulset.kubernetes.io/pod-name' }}.{{ label 'k8s.kuma.io/service-name' }}.{{ .Namespace }}.svc.{{ .Zone }}.mesh.local"
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}


    
  

Synced MeshService from Universal zone

The following policy is automatically created on a global control plane and synced to all zones. It creates a hostname for each MeshService synced from another Universal zone. For example, MeshService of name redis from zone west would obtain redis.svc.west.mesh.local

        
          Kubernetes
        
      

        
          Universal
        
      

        
          Terraform
        
      

    
      apiVersion: kuma.io/v1alpha1
kind: HostnameGenerator
metadata:
  name: synced-universal-mesh-service
  namespace: kong-mesh-system
spec:
  selector:
    meshService:
      matchLabels:
        kuma.io/origin: global
        kuma.io/env: universal
  template: "{{ .DisplayName }}.svc.{{ .Zone }}.mesh.local"

    
      type: HostnameGenerator
name: synced-universal-mesh-service
spec:
  selector:
    meshService:
      matchLabels:
        kuma.io/origin: global
        kuma.io/env: universal
  template: "{{ .DisplayName }}.svc.{{ .Zone }}.mesh.local"

    
      
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_hostname_generator" "synced_universal_mesh_service" {
  provider = konnect-beta
  type = "HostnameGenerator"
  name = "synced-universal-mesh-service"
  spec = {
    selector = {
      mesh_service = {
        match_labels = {
          kuma.io/origin = "global"
          kuma.io/env = "universal"
        }
      }
    }
    template = "{{ .DisplayName }}.svc.{{ .Zone }}.mesh.local"
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}


    
  

Synced MeshMultiZoneService from a global control plane

The following policy is automatically created on a global control plane and synced to all zones. It creates a hostname for each MeshMultiZoneService synced from a global control plane. For example, MeshMultiZoneService of name redis would obtain redis.mzsvc.mesh.local

        
          Kubernetes
        
      

        
          Universal
        
      

        
          Terraform
        
      

    
      apiVersion: kuma.io/v1alpha1
kind: HostnameGenerator
metadata:
  name: synced-mesh-multi-zone-service
  namespace: kong-mesh-system
spec:
  selector:
    meshMultiZoneService:
      matchLabels:
        kuma.io/origin: global
  template: "{{ .DisplayName }}.mzsvc.mesh.local"

    
      type: HostnameGenerator
name: synced-mesh-multi-zone-service
spec:
  selector:
    meshMultiZoneService:
      matchLabels:
        kuma.io/origin: global
  template: "{{ .DisplayName }}.mzsvc.mesh.local"

    
      
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_hostname_generator" "synced_mesh_multi_zone_service" {
  provider = konnect-beta
  type = "HostnameGenerator"
  name = "synced-mesh-multi-zone-service"
  spec = {
    selector = {
      mesh_multi_zone_service = {
        match_labels = {
          kuma.io/origin = "global"
        }
      }
    }
    template = "{{ .DisplayName }}.mzsvc.mesh.local"
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}


    
  

Synced MeshExternalService from a global control plane

The following policy is automatically created on a global control plane and synced to all zones. It creates a hostname for each MeshExternalService synced from a global control plane. For example, MeshExternalService of name aurora would obtain aurora.extsvc.mesh.local

        
          Kubernetes
        
      

        
          Universal
        
      

        
          Terraform
        
      

    
      apiVersion: kuma.io/v1alpha1
kind: HostnameGenerator
metadata:
  name: synced-mesh-external-service
  namespace: kong-mesh-system
spec:
  selector:
    meshExternalService:
      matchLabels:
        kuma.io/origin: global
  template: "{{ .DisplayName }}.extsvc.mesh.local"

    
      type: HostnameGenerator
name: synced-mesh-external-service
spec:
  selector:
    meshExternalService:
      matchLabels:
        kuma.io/origin: global
  template: "{{ .DisplayName }}.extsvc.mesh.local"

    
      
Please adjust konnect_mesh_control_plane.my_meshcontrolplane.id and konnect_mesh.my_mesh.name according to your current configuration
resource "konnect_hostname_generator" "synced_mesh_external_service" {
  provider = konnect-beta
  type = "HostnameGenerator"
  name = "synced-mesh-external-service"
  spec = {
    selector = {
      mesh_external_service = {
        match_labels = {
          kuma.io/origin = "global"
        }
      }
    }
    template = "{{ .DisplayName }}.extsvc.mesh.local"
  }
  labels   = {
    "kuma.io/mesh" = konnect_mesh.my_mesh.name
  }
  cp_id    = konnect_mesh_control_plane.my_meshcontrolplane.id
  mesh     = konnect_mesh.my_mesh.name
}


    
  

Template

A template is a golang text template. It is run with the function label to retrieve labels of the MeshService, MeshMultiZoneService or MeshExternalService as well as the following attributes:

.DisplayName: the name of the resource in its original zone
.Namespace: the namespace of the resource in its original zone, if kubernetes
.Zone: the zone of the resource
.Mesh: the mesh of the resource

For example, given:

kind: MeshService
metadata:
  name: redis
  namespace: kuma-demo
  labels:
    kuma.io/mesh: products
    team: backend
    k8s.kuma.io/service-name: redis
    k8s.kuma.io/namespace: kuma-demo

and

template: "{{ .DisplayName }}.{{ .Namespace }}.{{ .Mesh }}.{{ label "team" }}.mesh.local"

the generated hostname would be:

redis.kuma-demo.products.backend.mesh.local

The generated hostname points to the first VIP known for the MeshService.

Status

Every generated hostname is recorded on the MeshService status in addresses:

status:
  addresses:
    - hostname: redis.kuma-demo.svc.east.mesh.local
      origin: HostnameGenerator
      hostnameGeneratorRef:
        coreName: synced-kube-mesh-service