mirror of
https://github.com/k3s-io/kubernetes.git
synced 2025-07-24 04:06:03 +00:00
215 lines
7.8 KiB
Go
215 lines
7.8 KiB
Go
/*
|
|
Copyright 2015 The Kubernetes Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package kubemark
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"go.opentelemetry.io/otel/trace"
|
|
v1 "k8s.io/api/core/v1"
|
|
"k8s.io/klog/v2"
|
|
"k8s.io/mount-utils"
|
|
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
clientset "k8s.io/client-go/kubernetes"
|
|
"k8s.io/client-go/tools/record"
|
|
internalapi "k8s.io/cri-api/pkg/apis"
|
|
kubeletapp "k8s.io/kubernetes/cmd/kubelet/app"
|
|
"k8s.io/kubernetes/cmd/kubelet/app/options"
|
|
"k8s.io/kubernetes/pkg/kubelet"
|
|
kubeletconfig "k8s.io/kubernetes/pkg/kubelet/apis/config"
|
|
"k8s.io/kubernetes/pkg/kubelet/cadvisor"
|
|
"k8s.io/kubernetes/pkg/kubelet/cm"
|
|
containertest "k8s.io/kubernetes/pkg/kubelet/container/testing"
|
|
probetest "k8s.io/kubernetes/pkg/kubelet/prober/testing"
|
|
kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
|
|
kubeletutil "k8s.io/kubernetes/pkg/kubelet/util"
|
|
"k8s.io/kubernetes/pkg/util/oom"
|
|
"k8s.io/kubernetes/pkg/volume"
|
|
"k8s.io/kubernetes/pkg/volume/cephfs"
|
|
"k8s.io/kubernetes/pkg/volume/configmap"
|
|
"k8s.io/kubernetes/pkg/volume/csi"
|
|
"k8s.io/kubernetes/pkg/volume/downwardapi"
|
|
"k8s.io/kubernetes/pkg/volume/emptydir"
|
|
"k8s.io/kubernetes/pkg/volume/fc"
|
|
"k8s.io/kubernetes/pkg/volume/git_repo"
|
|
"k8s.io/kubernetes/pkg/volume/hostpath"
|
|
"k8s.io/kubernetes/pkg/volume/iscsi"
|
|
"k8s.io/kubernetes/pkg/volume/local"
|
|
"k8s.io/kubernetes/pkg/volume/nfs"
|
|
"k8s.io/kubernetes/pkg/volume/portworx"
|
|
"k8s.io/kubernetes/pkg/volume/projected"
|
|
"k8s.io/kubernetes/pkg/volume/rbd"
|
|
"k8s.io/kubernetes/pkg/volume/secret"
|
|
"k8s.io/kubernetes/pkg/volume/util/hostutil"
|
|
"k8s.io/kubernetes/pkg/volume/util/subpath"
|
|
"k8s.io/kubernetes/test/utils"
|
|
)
|
|
|
|
type HollowKubelet struct {
|
|
KubeletFlags *options.KubeletFlags
|
|
KubeletConfiguration *kubeletconfig.KubeletConfiguration
|
|
KubeletDeps *kubelet.Dependencies
|
|
}
|
|
|
|
func volumePlugins() []volume.VolumePlugin {
|
|
allPlugins := []volume.VolumePlugin{}
|
|
allPlugins = append(allPlugins, emptydir.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, git_repo.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, hostpath.FakeProbeVolumePlugins(volume.VolumeConfig{})...)
|
|
allPlugins = append(allPlugins, nfs.ProbeVolumePlugins(volume.VolumeConfig{})...)
|
|
allPlugins = append(allPlugins, secret.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, iscsi.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, rbd.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, cephfs.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, downwardapi.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, fc.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, configmap.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, projected.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, portworx.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, local.ProbeVolumePlugins()...)
|
|
allPlugins = append(allPlugins, csi.ProbeVolumePlugins()...)
|
|
return allPlugins
|
|
}
|
|
|
|
func NewHollowKubelet(
|
|
flags *options.KubeletFlags,
|
|
config *kubeletconfig.KubeletConfiguration,
|
|
client *clientset.Clientset,
|
|
heartbeatClient *clientset.Clientset,
|
|
cadvisorInterface cadvisor.Interface,
|
|
imageService internalapi.ImageManagerService,
|
|
runtimeService internalapi.RuntimeService,
|
|
containerManager cm.ContainerManager) *HollowKubelet {
|
|
d := &kubelet.Dependencies{
|
|
KubeClient: client,
|
|
HeartbeatClient: heartbeatClient,
|
|
ProbeManager: probetest.FakeManager{},
|
|
RemoteRuntimeService: runtimeService,
|
|
RemoteImageService: imageService,
|
|
CAdvisorInterface: cadvisorInterface,
|
|
Cloud: nil,
|
|
OSInterface: &containertest.FakeOS{},
|
|
ContainerManager: containerManager,
|
|
VolumePlugins: volumePlugins(),
|
|
TLSOptions: nil,
|
|
OOMAdjuster: oom.NewFakeOOMAdjuster(),
|
|
Mounter: &mount.FakeMounter{},
|
|
Subpather: &subpath.FakeSubpath{},
|
|
HostUtil: hostutil.NewFakeHostUtil(nil),
|
|
PodStartupLatencyTracker: kubeletutil.NewPodStartupLatencyTracker(),
|
|
TracerProvider: trace.NewNoopTracerProvider(),
|
|
Recorder: &record.FakeRecorder{}, // With real recorder we attempt to read /dev/kmsg.
|
|
}
|
|
|
|
return &HollowKubelet{
|
|
KubeletFlags: flags,
|
|
KubeletConfiguration: config,
|
|
KubeletDeps: d,
|
|
}
|
|
}
|
|
|
|
// Starts this HollowKubelet and blocks.
|
|
func (hk *HollowKubelet) Run() {
|
|
if err := kubeletapp.RunKubelet(&options.KubeletServer{
|
|
KubeletFlags: *hk.KubeletFlags,
|
|
KubeletConfiguration: *hk.KubeletConfiguration,
|
|
}, hk.KubeletDeps, false); err != nil {
|
|
klog.Fatalf("Failed to run HollowKubelet: %v. Exiting.", err)
|
|
}
|
|
select {}
|
|
}
|
|
|
|
// HollowKubeletOptions contains settable parameters for hollow kubelet.
|
|
type HollowKubeletOptions struct {
|
|
NodeName string
|
|
KubeletPort int
|
|
KubeletReadOnlyPort int
|
|
MaxPods int
|
|
PodsPerCore int
|
|
NodeLabels map[string]string
|
|
RegisterWithTaints []v1.Taint
|
|
}
|
|
|
|
// Builds a KubeletConfiguration for the HollowKubelet, ensuring that the
|
|
// usual defaults are applied for fields we do not override.
|
|
func GetHollowKubeletConfig(opt *HollowKubeletOptions) (*options.KubeletFlags, *kubeletconfig.KubeletConfiguration) {
|
|
testRootDir := utils.MakeTempDirOrDie("hollow-kubelet.", "")
|
|
podFilePath := utils.MakeTempDirOrDie("static-pods", testRootDir)
|
|
klog.Infof("Using %s as root dir for hollow-kubelet", testRootDir)
|
|
|
|
// Flags struct
|
|
f := options.NewKubeletFlags()
|
|
f.RootDirectory = testRootDir
|
|
f.HostnameOverride = opt.NodeName
|
|
f.MinimumGCAge = metav1.Duration{Duration: 1 * time.Minute}
|
|
f.MaxContainerCount = 100
|
|
f.MaxPerPodContainerCount = 2
|
|
f.NodeLabels = opt.NodeLabels
|
|
f.RegisterSchedulable = true
|
|
|
|
// Config struct
|
|
c, err := options.NewKubeletConfiguration()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
c.ImageServiceEndpoint = "unix:///run/containerd/containerd.sock"
|
|
c.StaticPodURL = ""
|
|
c.EnableServer = true
|
|
c.Address = "0.0.0.0" /* bind address */
|
|
c.Port = int32(opt.KubeletPort)
|
|
c.ReadOnlyPort = int32(opt.KubeletReadOnlyPort)
|
|
c.StaticPodPath = podFilePath
|
|
c.FileCheckFrequency.Duration = 20 * time.Second
|
|
c.HTTPCheckFrequency.Duration = 20 * time.Second
|
|
c.NodeStatusUpdateFrequency.Duration = 10 * time.Second
|
|
c.NodeStatusReportFrequency.Duration = 5 * time.Minute
|
|
c.SyncFrequency.Duration = 10 * time.Second
|
|
c.EvictionPressureTransitionPeriod.Duration = 5 * time.Minute
|
|
c.MaxPods = int32(opt.MaxPods)
|
|
c.PodsPerCore = int32(opt.PodsPerCore)
|
|
c.ClusterDNS = []string{}
|
|
c.ImageGCHighThresholdPercent = 90
|
|
c.ImageGCLowThresholdPercent = 80
|
|
c.ProviderID = fmt.Sprintf("kubemark://%v", opt.NodeName)
|
|
c.VolumeStatsAggPeriod.Duration = time.Minute
|
|
c.CgroupRoot = ""
|
|
c.CPUCFSQuota = true
|
|
c.EnableControllerAttachDetach = false
|
|
c.EnableDebuggingHandlers = true
|
|
c.CgroupsPerQOS = false
|
|
// hairpin-veth is used to allow hairpin packets. Note that this deviates from
|
|
// what the "real" kubelet currently does, because there's no way to
|
|
// set promiscuous mode on docker0.
|
|
c.HairpinMode = kubeletconfig.HairpinVeth
|
|
c.MaxOpenFiles = 1024
|
|
c.RegistryBurst = 10
|
|
c.RegistryPullQPS = 5.0
|
|
c.ResolverConfig = kubetypes.ResolvConfDefault
|
|
c.KubeletCgroups = "/kubelet"
|
|
c.SerializeImagePulls = true
|
|
c.SystemCgroups = ""
|
|
c.ProtectKernelDefaults = false
|
|
c.RegisterWithTaints = opt.RegisterWithTaints
|
|
c.RegisterNode = true
|
|
c.LocalStorageCapacityIsolation = true
|
|
|
|
return f, c
|
|
}
|