2024-12-06 周记 0x004

k8s.io/kubernetes/pkg/kubelet/network/dns/dns.go:303
 
// IsHostNetworkPod returns whether the host networking requested for the given Pod.
// Pod must not be nil.
func IsHostNetworkPod(pod *v1.Pod) bool {
      return pod.Spec.HostNetwork
}
 
func getPodDNSType(pod *v1.Pod) (podDNSType, error) {
      dnsPolicy := pod.Spec.DNSPolicy
      switch dnsPolicy {
      case v1.DNSNone:
            return podDNSNone, nil
      case v1.DNSClusterFirstWithHostNet:
            return podDNSCluster, nil
      case v1.DNSClusterFirst:
            if !kubecontainer.IsHostNetworkPod(pod) {
                  return podDNSCluster, nil
            }
            // Fallback to DNSDefault for pod on hostnetwork.
            fallthrough
      case v1.DNSDefault:
            return podDNSHost, nil
      }
      // This should not happen as kube-apiserver should have rejected
      // invalid dnsPolicy.
      return podDNSCluster, fmt.Errorf("invalid DNSPolicy=%v", dnsPolicy)
}
 
 
// GetPodDNS returns DNS settings for the pod.
func (c *Configurer) GetPodDNS(pod *v1.Pod) (*runtimeapi.DNSConfig, error) {
      dnsConfig, err := c.getHostDNSConfig(c.ResolverConfig)
      if err != nil {
            return nil, err
      }
 
      dnsType, err := getPodDNSType(pod)
      if err != nil {
            klog.ErrorS(err, "Failed to get DNS type for pod. Falling back to DNSClusterFirst policy.", "pod", klog.KObj(pod))
            dnsType = podDNSCluster
      }
      switch dnsType {
      case podDNSNone:
            // DNSNone should use empty DNS settings as the base.
            dnsConfig = &runtimeapi.DNSConfig{}
      case podDNSCluster:
            if len(c.clusterDNS) != 0 {
                  // For a pod with DNSClusterFirst policy, the cluster DNS server is
                  // the only nameserver configured for the pod. The cluster DNS server
                  // itself will forward queries to other nameservers that is configured
                  // to use, in case the cluster DNS server cannot resolve the DNS query
                  // itself.
                  dnsConfig.Servers = []string{}
                  for _, ip := range c.clusterDNS {
                        dnsConfig.Servers = append(dnsConfig.Servers, ip.String())
                  }
                  dnsConfig.Searches = c.generateSearchesForDNSClusterFirst(dnsConfig.Searches, pod)
                  dnsConfig.Options = defaultDNSOptions
                  break
            }
            // clusterDNS is not known. Pod with ClusterDNSFirst Policy cannot be created.
            nodeErrorMsg := fmt.Sprintf("kubelet does not have ClusterDNS IP configured and cannot create Pod using %q policy. Falling back to %q policy.", v1.DNSClusterFirst, v1.DNSDefault)
            c.recorder.Eventf(c.nodeRef, v1.EventTypeWarning, "MissingClusterDNS", nodeErrorMsg)
            c.recorder.Eventf(pod, v1.EventTypeWarning, "MissingClusterDNS", "pod: %q. %s", format.Pod(pod), nodeErrorMsg)
            // Fallback to DNSDefault.
            fallthrough
      case podDNSHost:
            // When the kubelet --resolv-conf flag is set to the empty string, use
            // DNS settings that override the docker default (which is to use
            // /etc/resolv.conf) and effectively disable DNS lookups. According to
            // the bind documentation, the behavior of the DNS client library when
            // "nameservers" are not specified is to "use the nameserver on the
            // local machine". A nameserver setting of localhost is equivalent to
            // this documented behavior.
            if c.ResolverConfig == "" {
                  for _, nodeIP := range c.nodeIPs {
                        if utilnet.IsIPv6(nodeIP) {
                              dnsConfig.Servers = append(dnsConfig.Servers, "::1")
                        } else {
                              dnsConfig.Servers = append(dnsConfig.Servers, "127.0.0.1")
                        }
                  }
                  if len(dnsConfig.Servers) == 0 {
                        dnsConfig.Servers = append(dnsConfig.Servers, "127.0.0.1")
                  }
                  dnsConfig.Searches = []string{"."}
            }
      }
 
      if pod.Spec.DNSConfig != nil {
            dnsConfig = appendDNSConfig(dnsConfig, pod.Spec.DNSConfig)
      }
      return c.formDNSConfigFitsLimits(dnsConfig, pod), nil
}