2020-09-11 11:16:45 +02:00
|
|
|
package kubernetes
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
2021-03-11 15:41:09 +01:00
|
|
|
"io"
|
2020-09-11 11:16:45 +02:00
|
|
|
"strconv"
|
|
|
|
|
|
|
|
"github.com/VictoriaMetrics/VictoriaMetrics/lib/promscrape/discoveryutils"
|
|
|
|
)
|
|
|
|
|
2021-04-02 13:45:08 +02:00
|
|
|
func (eps *EndpointSlice) key() string {
|
|
|
|
return eps.Metadata.key()
|
2021-02-26 15:54:03 +01:00
|
|
|
}
|
|
|
|
|
2021-03-11 15:41:09 +01:00
|
|
|
func parseEndpointSliceList(r io.Reader) (map[string]object, ListMeta, error) {
|
2021-02-26 15:54:03 +01:00
|
|
|
var epsl EndpointSliceList
|
2021-03-11 15:41:09 +01:00
|
|
|
d := json.NewDecoder(r)
|
|
|
|
if err := d.Decode(&epsl); err != nil {
|
|
|
|
return nil, epsl.Metadata, fmt.Errorf("cannot unmarshal EndpointSliceList: %w", err)
|
2021-02-26 15:54:03 +01:00
|
|
|
}
|
2021-04-02 13:45:08 +02:00
|
|
|
objectsByKey := make(map[string]object)
|
2021-02-26 15:54:03 +01:00
|
|
|
for _, eps := range epsl.Items {
|
2021-04-02 13:45:08 +02:00
|
|
|
objectsByKey[eps.key()] = eps
|
2021-02-26 15:54:03 +01:00
|
|
|
}
|
2021-04-02 13:45:08 +02:00
|
|
|
return objectsByKey, epsl.Metadata, nil
|
2021-02-26 15:54:03 +01:00
|
|
|
}
|
2020-09-11 11:16:45 +02:00
|
|
|
|
2021-02-26 15:54:03 +01:00
|
|
|
func parseEndpointSlice(data []byte) (object, error) {
|
|
|
|
var eps EndpointSlice
|
|
|
|
if err := json.Unmarshal(data, &eps); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &eps, nil
|
2020-09-11 11:16:45 +02:00
|
|
|
}
|
|
|
|
|
2021-02-26 19:21:27 +01:00
|
|
|
// getTargetLabels returns labels for eps.
|
|
|
|
//
|
|
|
|
// See https://prometheus.io/docs/prometheus/latest/configuration/configuration/#endpointslices
|
2021-03-14 20:10:35 +01:00
|
|
|
func (eps *EndpointSlice) getTargetLabels(gw *groupWatcher) []map[string]string {
|
2021-02-26 15:46:13 +01:00
|
|
|
var svc *Service
|
2021-04-29 09:14:24 +02:00
|
|
|
if o := gw.getObjectByRoleLocked("service", eps.Metadata.Namespace, eps.Metadata.Name); o != nil {
|
2021-02-26 15:54:03 +01:00
|
|
|
svc = o.(*Service)
|
2021-02-26 15:46:13 +01:00
|
|
|
}
|
2020-09-11 11:16:45 +02:00
|
|
|
podPortsSeen := make(map[*Pod][]int)
|
2021-02-26 19:21:27 +01:00
|
|
|
var ms []map[string]string
|
2020-09-11 11:16:45 +02:00
|
|
|
for _, ess := range eps.Endpoints {
|
2021-02-26 15:54:03 +01:00
|
|
|
var p *Pod
|
2021-04-29 09:14:24 +02:00
|
|
|
if o := gw.getObjectByRoleLocked("pod", ess.TargetRef.Namespace, ess.TargetRef.Name); o != nil {
|
2021-02-26 15:54:03 +01:00
|
|
|
p = o.(*Pod)
|
2021-02-26 15:46:13 +01:00
|
|
|
}
|
2020-09-11 11:16:45 +02:00
|
|
|
for _, epp := range eps.Ports {
|
|
|
|
for _, addr := range ess.Addresses {
|
2022-04-22 18:39:34 +02:00
|
|
|
m := getEndpointSliceLabelsForAddressAndPort(gw, podPortsSeen, addr, eps, ess, epp, p, svc)
|
|
|
|
if m != nil {
|
|
|
|
ms = append(ms, m)
|
|
|
|
}
|
2020-09-11 11:16:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Append labels for skipped ports on seen pods.
|
|
|
|
portSeen := func(port int, ports []int) bool {
|
|
|
|
for _, p := range ports {
|
|
|
|
if p == port {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
for p, ports := range podPortsSeen {
|
|
|
|
for _, c := range p.Spec.Containers {
|
|
|
|
for _, cp := range c.Ports {
|
|
|
|
if portSeen(cp.ContainerPort, ports) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
addr := discoveryutils.JoinHostPort(p.Status.PodIP, cp.ContainerPort)
|
|
|
|
m := map[string]string{
|
|
|
|
"__address__": addr,
|
|
|
|
}
|
2022-04-22 18:39:34 +02:00
|
|
|
if !p.appendCommonLabels(m, gw) {
|
|
|
|
// The corresponding node is filtered out with label or field selectors.
|
|
|
|
// Do not generate endpointslice labels in this case.
|
|
|
|
continue
|
|
|
|
}
|
2020-09-11 11:16:45 +02:00
|
|
|
p.appendContainerLabels(m, c, &cp)
|
2020-12-24 10:26:14 +01:00
|
|
|
if svc != nil {
|
|
|
|
svc.appendCommonLabels(m)
|
|
|
|
}
|
2020-09-11 11:16:45 +02:00
|
|
|
ms = append(ms, m)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ms
|
|
|
|
}
|
|
|
|
|
|
|
|
// getEndpointSliceLabelsForAddressAndPort gets labels for endpointSlice
|
|
|
|
// from address, Endpoint and EndpointPort
|
|
|
|
// enriches labels with TargetRef
|
2021-02-26 15:54:03 +01:00
|
|
|
// p appended to seen Ports
|
2020-09-11 11:16:45 +02:00
|
|
|
// if TargetRef matches
|
2022-04-22 18:39:34 +02:00
|
|
|
func getEndpointSliceLabelsForAddressAndPort(gw *groupWatcher, podPortsSeen map[*Pod][]int, addr string, eps *EndpointSlice, ea Endpoint, epp EndpointPort,
|
|
|
|
p *Pod, svc *Service) map[string]string {
|
2020-09-11 11:16:45 +02:00
|
|
|
m := getEndpointSliceLabels(eps, addr, ea, epp)
|
|
|
|
if svc != nil {
|
|
|
|
svc.appendCommonLabels(m)
|
|
|
|
}
|
2022-02-11 13:54:47 +01:00
|
|
|
// See https://github.com/prometheus/prometheus/issues/10284
|
|
|
|
eps.Metadata.registerLabelsAndAnnotations("__meta_kubernetes_endpointslice", m)
|
2020-09-11 11:16:45 +02:00
|
|
|
if ea.TargetRef.Kind != "Pod" || p == nil {
|
|
|
|
return m
|
|
|
|
}
|
2022-02-11 12:34:22 +01:00
|
|
|
// always add pod targetRef, even if epp port doesn't match container port.
|
|
|
|
// See https://github.com/VictoriaMetrics/VictoriaMetrics/issues/2134
|
|
|
|
if _, ok := podPortsSeen[p]; !ok {
|
|
|
|
podPortsSeen[p] = []int{}
|
|
|
|
}
|
2022-04-22 18:39:34 +02:00
|
|
|
if !p.appendCommonLabels(m, gw) {
|
|
|
|
// The corresponding node is filtered out with label or field selectors.
|
|
|
|
// Do not generate endpointslice labels in this case.
|
|
|
|
return nil
|
|
|
|
}
|
2020-09-11 11:16:45 +02:00
|
|
|
for _, c := range p.Spec.Containers {
|
|
|
|
for _, cp := range c.Ports {
|
|
|
|
if cp.ContainerPort == epp.Port {
|
|
|
|
podPortsSeen[p] = append(podPortsSeen[p], cp.ContainerPort)
|
2022-02-11 12:34:22 +01:00
|
|
|
p.appendContainerLabels(m, c, &cp)
|
2020-09-11 11:16:45 +02:00
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
|
|
|
// //getEndpointSliceLabels builds labels for given EndpointSlice
|
|
|
|
func getEndpointSliceLabels(eps *EndpointSlice, addr string, ea Endpoint, epp EndpointPort) map[string]string {
|
|
|
|
addr = discoveryutils.JoinHostPort(addr, epp.Port)
|
|
|
|
m := map[string]string{
|
|
|
|
"__address__": addr,
|
|
|
|
"__meta_kubernetes_namespace": eps.Metadata.Namespace,
|
|
|
|
"__meta_kubernetes_endpointslice_name": eps.Metadata.Name,
|
|
|
|
"__meta_kubernetes_endpointslice_address_type": eps.AddressType,
|
|
|
|
"__meta_kubernetes_endpointslice_endpoint_conditions_ready": strconv.FormatBool(ea.Conditions.Ready),
|
|
|
|
"__meta_kubernetes_endpointslice_port_name": epp.Name,
|
|
|
|
"__meta_kubernetes_endpointslice_port_protocol": epp.Protocol,
|
2020-09-11 20:34:13 +02:00
|
|
|
"__meta_kubernetes_endpointslice_port": strconv.Itoa(epp.Port),
|
2020-09-11 11:16:45 +02:00
|
|
|
}
|
|
|
|
if epp.AppProtocol != "" {
|
|
|
|
m["__meta_kubernetes_endpointslice_port_app_protocol"] = epp.AppProtocol
|
|
|
|
}
|
|
|
|
if ea.TargetRef.Kind != "" {
|
|
|
|
m["__meta_kubernetes_endpointslice_address_target_kind"] = ea.TargetRef.Kind
|
|
|
|
m["__meta_kubernetes_endpointslice_address_target_name"] = ea.TargetRef.Name
|
|
|
|
}
|
|
|
|
if ea.Hostname != "" {
|
|
|
|
m["__meta_kubernetes_endpointslice_endpoint_hostname"] = ea.Hostname
|
|
|
|
}
|
|
|
|
for k, v := range ea.Topology {
|
|
|
|
m["__meta_kubernetes_endpointslice_endpoint_topology_"+discoveryutils.SanitizeLabelName(k)] = v
|
|
|
|
m["__meta_kubernetes_endpointslice_endpoint_topology_present_"+discoveryutils.SanitizeLabelName(k)] = "true"
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
2021-08-29 10:16:40 +02:00
|
|
|
// EndpointSliceList - implements kubernetes endpoint slice list object, that groups service endpoints slices.
|
|
|
|
//
|
|
|
|
// See https://v1-21.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.21/#endpointslicelist-v1-discovery-k8s-io
|
2020-09-11 11:16:45 +02:00
|
|
|
type EndpointSliceList struct {
|
2021-02-26 15:54:03 +01:00
|
|
|
Metadata ListMeta
|
|
|
|
Items []*EndpointSlice
|
2020-09-11 11:16:45 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// EndpointSlice - implements kubernetes endpoint slice.
|
2021-08-29 10:16:40 +02:00
|
|
|
//
|
|
|
|
// See https://v1-21.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.21/#endpointslice-v1-discovery-k8s-io
|
2020-09-11 11:16:45 +02:00
|
|
|
type EndpointSlice struct {
|
|
|
|
Metadata ObjectMeta
|
|
|
|
Endpoints []Endpoint
|
|
|
|
AddressType string
|
|
|
|
Ports []EndpointPort
|
|
|
|
}
|
|
|
|
|
|
|
|
// Endpoint implements kubernetes object endpoint for endpoint slice.
|
2021-08-29 10:16:40 +02:00
|
|
|
//
|
|
|
|
// See https://v1-21.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.21/#endpoint-v1-discovery-k8s-io
|
2020-09-11 11:16:45 +02:00
|
|
|
type Endpoint struct {
|
|
|
|
Addresses []string
|
|
|
|
Conditions EndpointConditions
|
|
|
|
Hostname string
|
|
|
|
TargetRef ObjectReference
|
|
|
|
Topology map[string]string
|
|
|
|
}
|
|
|
|
|
|
|
|
// EndpointConditions implements kubernetes endpoint condition.
|
2021-08-29 10:16:40 +02:00
|
|
|
//
|
|
|
|
// See https://v1-21.docs.kubernetes.io/docs/reference/generated/kubernetes-api/v1.21/#endpointconditions-v1-discovery-k8s-io
|
2020-09-11 11:16:45 +02:00
|
|
|
type EndpointConditions struct {
|
|
|
|
Ready bool
|
|
|
|
}
|