remove runtimetype

Signed-off-by: Shelley-BaoYue <baoyue2@huawei.com>

16 files changed, 37 insertions, 271 deletions

diff --git a/edge/pkg/edgehub/upgrade/upgrade.go b/edge/pkg/edgehub/upgrade/upgrade.go
index 3a7ecfcd2..e26cd50ca 100644
--- a/edge/pkg/edgehub/upgrade/upgrade.go
+++ b/edge/pkg/edgehub/upgrade/upgrade.go
@@ -112,7 +112,10 @@ func (*keadmUpgrade) Upgrade(upgradeReq *commontypes.NodeUpgradeJobRequest) erro
 
 	// install the requested installer keadm from docker image
 	klog.Infof("Begin to download version %s keadm", upgradeReq.Version)
-	container, err := util.NewContainerRuntime(config.Modules.Edged.ContainerRuntime, config.Modules.Edged.RemoteRuntimeEndpoint, config.Modules.Edged.TailoredKubeletConfig.CgroupDriver)
+	if config.Modules.Edged.TailoredKubeletConfig.ContainerRuntimeEndpoint == "" {
+		config.Modules.Edged.TailoredKubeletConfig.ContainerRuntimeEndpoint = config.Modules.Edged.RemoteRuntimeEndpoint
+	}
+	container, err := util.NewContainerRuntime(config.Modules.Edged.TailoredKubeletConfig.ContainerRuntimeEndpoint, config.Modules.Edged.TailoredKubeletConfig.CgroupDriver)
 	if err != nil {
 		return fmt.Errorf("failed to new container runtime: %v", err)
 	}
diff --git a/keadm/cmd/keadm/app/cmd/common/constant.go b/keadm/cmd/keadm/app/cmd/common/constant.go
index 581d0ff6b..2593ba645 100644
--- a/keadm/cmd/keadm/app/cmd/common/constant.go
+++ b/keadm/cmd/keadm/app/cmd/common/constant.go
@@ -44,11 +44,8 @@ const (
 	// DefaultK8SMinimumVersion is the minimum version of K8S
 	DefaultK8SMinimumVersion = 11
 
-	// RuntimeType is default runtime type
-	RuntimeType = "runtimetype"
-
 	// DefaultKubeEdgeVersion is the default KubeEdge version, it must have no prefix 'v'
-	DefaultKubeEdgeVersion = "1.14.0"
+	DefaultKubeEdgeVersion = "1.15.1"
 
 	// Token sets the token used when edge applying for the certificate
 	Token = "token"
diff --git a/keadm/cmd/keadm/app/cmd/common/types.go b/keadm/cmd/keadm/app/cmd/common/types.go
index e48627d4e..71c7efb74 100644
--- a/keadm/cmd/keadm/app/cmd/common/types.go
+++ b/keadm/cmd/keadm/app/cmd/common/types.go
@@ -51,7 +51,6 @@ type JoinOptions struct {
 	CertPath              string
 	CloudCoreIPPort       string
 	EdgeNodeName          string
-	RuntimeType           string
 	RemoteRuntimeEndpoint string
 	Token                 string
 	CertPort              string
@@ -66,7 +65,6 @@ type CheckOptions struct {
 	Domain         string
 	DNSIP          string
 	IP             string
-	Runtime        string
 	Timeout        int
 	CloudHubServer string
 	EdgecoreServer string
@@ -88,10 +86,9 @@ type CollectOptions struct {
 }
 
 type ResetOptions struct {
-	Kubeconfig  string
-	Force       bool
-	RuntimeType string
-	Endpoint    string
+	Kubeconfig string
+	Force      bool
+	Endpoint   string
 }
 
 type GettokenOptions struct {
diff --git a/keadm/cmd/keadm/app/cmd/config.go b/keadm/cmd/keadm/app/cmd/config.go
index 0d6eb3681..f70c5cd32 100644
--- a/keadm/cmd/keadm/app/cmd/config.go
+++ b/keadm/cmd/keadm/app/cmd/config.go
@@ -22,7 +22,6 @@ import (
 
 	"github.com/spf13/cobra"
 
-	"github.com/kubeedge/kubeedge/common/constants"
 	cmdcommon "github.com/kubeedge/kubeedge/keadm/cmd/keadm/app/cmd/common"
 	"github.com/kubeedge/kubeedge/keadm/cmd/keadm/app/cmd/util"
 	"github.com/kubeedge/kubeedge/pkg/image"
@@ -37,7 +36,6 @@ type Configuration struct {
 	// eg. cloud/edge
 	Part string
 
-	RuntimeType           string
 	RemoteRuntimeEndpoint string
 }
 
@@ -45,7 +43,6 @@ func newDefaultConfiguration() *Configuration {
 	return &Configuration{
 		ImageRepository: "kubeedge",
 		Part:            "",
-		RuntimeType:     constants.DefaultRuntimeType,
 	}
 }
 
@@ -120,7 +117,7 @@ func newCmdConfigImagesPull() *cobra.Command {
 			cfg.KubeEdgeVersion = ver
 
 			images := GetKubeEdgeImages(cfg)
-			return pullImages(cfg.RuntimeType, cfg.RemoteRuntimeEndpoint, "", images)
+			return pullImages(cfg.RemoteRuntimeEndpoint, "", images)
 		},
 		Args: cobra.NoArgs,
 	}
@@ -129,8 +126,8 @@ func newCmdConfigImagesPull() *cobra.Command {
 	return cmd
 }
 
-func pullImages(runtimeType, endpoint, cgroupDriver string, images []string) error {
-	runtime, err := util.NewContainerRuntime(runtimeType, endpoint, cgroupDriver)
+func pullImages(endpoint, cgroupDriver string, images []string) error {
+	runtime, err := util.NewContainerRuntime(endpoint, cgroupDriver)
 	if err != nil {
 		return err
 	}
@@ -149,9 +146,6 @@ func AddImagesCommonConfigFlags(cmd *cobra.Command, cfg *Configuration) {
 	cmd.Flags().StringVar(&cfg.Part, "part", cfg.Part,
 		"Use this key to set which part keadm will install: cloud part or edge part. If not set, keadm will list/pull all images used by both cloud part and edge part.")
 
-	cmd.Flags().StringVar(&cfg.RuntimeType, cmdcommon.RuntimeType, cfg.RuntimeType,
-		"Container runtime type, default is remote")
-
 	cmd.Flags().StringVar(&cfg.RemoteRuntimeEndpoint, cmdcommon.RemoteRuntimeEndpoint, cfg.RemoteRuntimeEndpoint,
 		"The endpoint of remote runtime service in edge node")
 }
diff --git a/keadm/cmd/keadm/app/cmd/debug/check.go b/keadm/cmd/keadm/app/cmd/debug/check.go
index ba7c56910..44081d612 100644
--- a/keadm/cmd/keadm/app/cmd/debug/check.go
+++ b/keadm/cmd/keadm/app/cmd/debug/check.go
@@ -16,7 +16,6 @@ import (
 	"github.com/shirou/gopsutil/mem"
 	"github.com/spf13/cobra"
 
-	"github.com/kubeedge/kubeedge/common/constants"
 	"github.com/kubeedge/kubeedge/keadm/cmd/keadm/app/cmd/common"
 	"github.com/kubeedge/kubeedge/keadm/cmd/keadm/app/cmd/util"
 )
@@ -84,7 +83,6 @@ func NewSubEdgeCheck(object CheckObject) *cobra.Command {
 		cmd.Flags().StringVarP(&co.Domain, "domain", "d", co.Domain, "specify test domain")
 		cmd.Flags().StringVarP(&co.IP, "ip", "i", co.IP, "specify test ip")
 		cmd.Flags().StringVarP(&co.CloudHubServer, "cloud-hub-server", "s", co.CloudHubServer, "specify cloudhub server")
-		cmd.Flags().StringVarP(&co.Runtime, "runtime", "r", co.Runtime, "specify test runtime")
 		cmd.Flags().StringVarP(&co.DNSIP, "dns-ip", "D", co.DNSIP, "specify test dns ip")
 		cmd.Flags().StringVarP(&co.Config, common.EdgecoreConfig, "c", co.Config,
 			fmt.Sprintf("Specify configuration file, default is %s", common.EdgecoreConfigPath))
@@ -96,8 +94,6 @@ func NewSubEdgeCheck(object CheckObject) *cobra.Command {
 		cmd.Flags().StringVarP(&co.CloudHubServer, "cloud-hub-server", "s", co.CloudHubServer, "specify cloudhub server")
 		cmd.Flags().StringVarP(&co.Config, common.EdgecoreConfig, "c", co.Config,
 			fmt.Sprintf("Specify configuration file, default is %s", common.EdgecoreConfigPath))
-	case common.ArgCheckRuntime:
-		cmd.Flags().StringVarP(&co.Runtime, "runtime", "r", co.Runtime, "specify test runtime")
 	}
 
 	return cmd
@@ -106,7 +102,6 @@ func NewSubEdgeCheck(object CheckObject) *cobra.Command {
 // NewCheckOptions returns check options
 func NewCheckOptions() *common.CheckOptions {
 	co := &common.CheckOptions{}
-	co.Runtime = constants.DefaultRuntimeType
 	co.Domain = "www.github.com"
 	co.Timeout = 1
 	return co
@@ -134,7 +129,7 @@ func (co *CheckObject) ExecuteCheck(use string, ob *common.CheckOptions) {
 	case common.ArgCheckNetwork:
 		err = CheckNetWork(ob.IP, ob.Timeout, ob.CloudHubServer, ob.EdgecoreServer, ob.Config)
 	case common.ArgCheckRuntime:
-		err = CheckRuntime(ob.Runtime)
+		err = CheckRuntime()
 	case common.ArgCheckPID:
 		err = CheckPid()
 	}
@@ -178,7 +173,7 @@ func CheckAll(ob *common.CheckOptions) error {
 		return err
 	}
 
-	err = CheckRuntime(ob.Runtime)
+	err = CheckRuntime()
 	if err != nil {
 		return err
 	}
@@ -346,20 +341,9 @@ func CheckHTTP(url string) error {
 	return nil
 }
 
-func CheckRuntime(runtime string) error {
-	if runtime == constants.DefaultRuntimeType {
-		result, err := util.ExecShellFilter(common.CmdGetStatusDocker)
-		if err != nil {
-			return err
-		}
-		if result != "active" {
-			return fmt.Errorf("docker is not running: %s", result)
-		}
-		fmt.Printf("docker is running\n")
-		return nil
-	}
-	return fmt.Errorf("now only support docker: %s", runtime)
-	// TODO
+func CheckRuntime() error {
+	// TODO: check runtime status
+	return nil
 }
 
 func CheckPid() error {
diff --git a/keadm/cmd/keadm/app/cmd/debug/diagnose.go b/keadm/cmd/keadm/app/cmd/debug/diagnose.go
index 769caf188..ce5cf2e56 100644
--- a/keadm/cmd/keadm/app/cmd/debug/diagnose.go
+++ b/keadm/cmd/keadm/app/cmd/debug/diagnose.go
@@ -7,7 +7,6 @@ import (
 	"github.com/spf13/cobra"
 	v1 "k8s.io/api/core/v1"
 
-	"github.com/kubeedge/kubeedge/common/constants"
 	"github.com/kubeedge/kubeedge/common/types"
 	"github.com/kubeedge/kubeedge/edge/pkg/metamanager/dao"
 	"github.com/kubeedge/kubeedge/keadm/cmd/keadm/app/cmd/common"
@@ -71,7 +70,6 @@ func NewSubDiagnose(object Diagnose) *cobra.Command {
 		cmd.Flags().StringVarP(&do.CheckOptions.Domain, "domain", "d", do.CheckOptions.Domain, "specify test domain")
 		cmd.Flags().StringVarP(&do.CheckOptions.IP, "ip", "i", do.CheckOptions.IP, "specify test ip")
 		cmd.Flags().StringVarP(&do.CheckOptions.CloudHubServer, "cloud-hub-server", "s", do.CheckOptions.CloudHubServer, "specify cloudhub server")
-		cmd.Flags().StringVarP(&do.CheckOptions.Runtime, "runtime", "r", do.CheckOptions.Runtime, "specify the runtime")
 	}
 	return cmd
 }
@@ -84,7 +82,6 @@ func NewDiagnoseOptions() *common.DiagnoseOptions {
 	do.CheckOptions = &common.CheckOptions{
 		IP:      "",
 		Timeout: 3,
-		Runtime: constants.DefaultRuntimeType,
 	}
 	return do
 }
@@ -139,11 +136,6 @@ func DiagnoseNode(ops *common.DiagnoseOptions) error {
 		return fmt.Errorf("parse Edgecore config failed")
 	}
 
-	err = CheckRuntime(edgeconfig.Modules.Edged.ContainerRuntime)
-	if err != nil {
-		return err
-	}
-
 	// check datebase
 	dataSource := v1alpha2.DataBaseDataSource
 	if edgeconfig.DataBase.DataSource != "" {
@@ -303,10 +295,5 @@ func DiagnoseInstall(ob *common.CheckOptions) error {
 		return err
 	}
 
-	err = CheckRuntime(ob.Runtime)
-	if err != nil {
-		return err
-	}
-
 	return nil
 }
diff --git a/keadm/cmd/keadm/app/cmd/deprecated/join.go b/keadm/cmd/keadm/app/cmd/deprecated/join.go
index 452d8284a..cf63f208e 100644
--- a/keadm/cmd/keadm/app/cmd/deprecated/join.go
+++ b/keadm/cmd/keadm/app/cmd/deprecated/join.go
@@ -123,7 +123,6 @@ func Add2EdgeToolsList(toolList map[string]types.ToolsInstaller, flagData map[st
 		},
 		CloudCoreIP:           joinOptions.CloudCoreIPPort,
 		EdgeNodeName:          joinOptions.EdgeNodeName,
-		RuntimeType:           joinOptions.RuntimeType,
 		CertPath:              joinOptions.CertPath,
 		RemoteRuntimeEndpoint: joinOptions.RemoteRuntimeEndpoint,
 		Token:                 joinOptions.Token,
diff --git a/keadm/cmd/keadm/app/cmd/edge/image.go b/keadm/cmd/keadm/app/cmd/edge/image.go
index 83a640fa2..8ed7ec69e 100644
--- a/keadm/cmd/keadm/app/cmd/edge/image.go
+++ b/keadm/cmd/keadm/app/cmd/edge/image.go
@@ -30,7 +30,7 @@ func request(opt *common.JoinOptions, step *common.Step) error {
 	imageSet := image.EdgeSet(opt)
 	images := imageSet.List()
 
-	runtime, err := util.NewContainerRuntime(opt.RuntimeType, opt.RemoteRuntimeEndpoint, opt.CGroupDriver)
+	runtime, err := util.NewContainerRuntime(opt.RemoteRuntimeEndpoint, opt.CGroupDriver)
 	if err != nil {
 		return err
 	}
diff --git a/keadm/cmd/keadm/app/cmd/edge/join.go b/keadm/cmd/keadm/app/cmd/edge/join.go
index 93710dc70..b0a880504 100644
--- a/keadm/cmd/keadm/app/cmd/edge/join.go
+++ b/keadm/cmd/keadm/app/cmd/edge/join.go
@@ -108,7 +108,6 @@ func newOption() *common.JoinOptions {
 	joinOptions.WithMQTT = true
 	joinOptions.CGroupDriver = v1alpha2.CGroupDriverCGroupFS
 	joinOptions.CertPath = common.DefaultCertPath
-	joinOptions.RuntimeType = constants.DefaultRuntimeType
 	joinOptions.RemoteRuntimeEndpoint = constants.DefaultRemoteRuntimeEndpoint
 	joinOptions.HubProtocol = api.ProtocolTypeWS
 	return joinOptions
diff --git a/keadm/cmd/keadm/app/cmd/edge/join_others.go b/keadm/cmd/keadm/app/cmd/edge/join_others.go
index 48343bdf2..6fc674690 100644
--- a/keadm/cmd/keadm/app/cmd/edge/join_others.go
+++ b/keadm/cmd/keadm/app/cmd/edge/join_others.go
@@ -27,7 +27,6 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/blang/semver"
 	"github.com/spf13/cobra"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/klog/v2"
@@ -60,9 +59,6 @@ func AddJoinOtherFlags(cmd *cobra.Command, joinOptions *common.JoinOptions) {
 		fmt.Printf("mark flag required failed with error: %v\n", err)
 	}
 
-	cmd.Flags().StringVarP(&joinOptions.RuntimeType, common.RuntimeType, "r", joinOptions.RuntimeType,
-		"Container runtime type. Note it will be removed in 1.16 as the only valid value is 'remote'")
-
 	cmd.Flags().StringVarP(&joinOptions.EdgeNodeName, common.EdgeNodeName, "i", joinOptions.EdgeNodeName,
 		"KubeEdge Node unique identification string, if flag not used then the command will generate a unique id on its own")
 
@@ -93,18 +89,8 @@ func AddJoinOtherFlags(cmd *cobra.Command, joinOptions *common.JoinOptions) {
 }
 
 func createEdgeConfigFiles(opt *common.JoinOptions) error {
-	// Determines whether the kubeEdgeVersion is earlier than v1.12.0
-	// If so, we need to create edgeconfig with v1alpha1 version
-	v, err := semver.ParseTolerant(opt.KubeEdgeVersion)
-	if err != nil {
-		return fmt.Errorf("parse kubeedge version failed, %v", err)
-	}
-	if v.Major >= 1 && v.Minor >= 14 && opt.RuntimeType != constants.DefaultRuntimeType {
-		return fmt.Errorf("since KubeEdge v1.14, runtime type only supports `remote`")
-	}
-
 	configFilePath := filepath.Join(util.KubeEdgePath, "config/edgecore.yaml")
-	_, err = os.Stat(configFilePath)
+	_, err := os.Stat(configFilePath)
 	if err == nil || os.IsExist(err) {
 		klog.Infoln("Read existing configuration file")
 		b, err := os.ReadFile(configFilePath)
@@ -129,9 +115,6 @@ func createEdgeConfigFiles(opt *common.JoinOptions) error {
 	if opt.EdgeNodeName != "" {
 		edgeCoreConfig.Modules.Edged.HostnameOverride = opt.EdgeNodeName
 	}
-	if opt.RuntimeType != "" {
-		edgeCoreConfig.Modules.Edged.ContainerRuntime = opt.RuntimeType
-	}
 
 	switch opt.CGroupDriver {
 	case v1alpha2.CGroupDriverSystemd:
diff --git a/keadm/cmd/keadm/app/cmd/edge/join_windows.go b/keadm/cmd/keadm/app/cmd/edge/join_windows.go
index 08ec544ba..a17fed841 100644
--- a/keadm/cmd/keadm/app/cmd/edge/join_windows.go
+++ b/keadm/cmd/keadm/app/cmd/edge/join_windows.go
@@ -79,8 +79,6 @@ func AddJoinOtherFlags(cmd *cobra.Command, joinOptions *common.JoinOptions) {
 }
 
 func createEdgeConfigFiles(opt *common.JoinOptions) error {
-	// Determines whether the kubeEdgeVersion is earlier than v1.12.0
-	// If so, we need to create edgeconfig with v1alpha1 version
 	v, err := semver.ParseTolerant(opt.KubeEdgeVersion)
 	if err != nil {
 		return fmt.Errorf("parse kubeedge version failed, %v", err)
@@ -115,9 +113,6 @@ func createEdgeConfigFiles(opt *common.JoinOptions) error {
 	if opt.EdgeNodeName != "" {
 		edgeCoreConfig.Modules.Edged.HostnameOverride = opt.EdgeNodeName
 	}
-	if opt.RuntimeType != "" {
-		edgeCoreConfig.Modules.Edged.ContainerRuntime = opt.RuntimeType
-	}
 
 	if opt.RemoteRuntimeEndpoint != "" {
 		edgeCoreConfig.Modules.Edged.TailoredKubeletConfig.ContainerRuntimeEndpoint = opt.RemoteRuntimeEndpoint
diff --git a/keadm/cmd/keadm/app/cmd/edge/upgrade.go b/keadm/cmd/keadm/app/cmd/edge/upgrade.go
index df1898870..001323679 100644
--- a/keadm/cmd/keadm/app/cmd/edge/upgrade.go
+++ b/keadm/cmd/keadm/app/cmd/edge/upgrade.go
@@ -179,7 +179,10 @@ func (up *Upgrade) PreProcess() error {
 	// download the request version edgecore
 	klog.Infof("Begin to download version %s edgecore", up.ToVersion)
 	upgradePath := filepath.Join(util.KubeEdgeUpgradePath, up.ToVersion)
-	container, err := util.NewContainerRuntime(up.EdgeCoreConfig.Modules.Edged.ContainerRuntime, up.EdgeCoreConfig.Modules.Edged.RemoteRuntimeEndpoint,
+	if up.EdgeCoreConfig.Modules.Edged.TailoredKubeletConfig.ContainerRuntimeEndpoint == "" {
+		up.EdgeCoreConfig.Modules.Edged.TailoredKubeletConfig.ContainerRuntimeEndpoint = up.EdgeCoreConfig.Modules.Edged.RemoteRuntimeEndpoint
+	}
+	container, err := util.NewContainerRuntime(up.EdgeCoreConfig.Modules.Edged.RemoteRuntimeEndpoint,
 		up.EdgeCoreConfig.Modules.Edged.TailoredKubeletConfig.CgroupDriver)
 	if err != nil {
 		return fmt.Errorf("failed to new container runtime: %v", err)
diff --git a/keadm/cmd/keadm/app/cmd/reset_others.go b/keadm/cmd/keadm/app/cmd/reset_others.go
index 8abc30624..3fd2b96e7 100644
--- a/keadm/cmd/keadm/app/cmd/reset_others.go
+++ b/keadm/cmd/keadm/app/cmd/reset_others.go
@@ -30,7 +30,6 @@ import (
 	utilruntime "k8s.io/kubernetes/cmd/kubeadm/app/util/runtime"
 	utilsexec "k8s.io/utils/exec"
 
-	"github.com/kubeedge/kubeedge/common/constants"
 	"github.com/kubeedge/kubeedge/keadm/cmd/keadm/app/cmd/common"
 	"github.com/kubeedge/kubeedge/keadm/cmd/keadm/app/cmd/helm"
 	"github.com/kubeedge/kubeedge/keadm/cmd/keadm/app/cmd/util"
@@ -54,7 +53,6 @@ keadm reset
 func newResetOptions() *common.ResetOptions {
 	opts := &common.ResetOptions{}
 	opts.Kubeconfig = common.DefaultKubeConfig
-	opts.RuntimeType = constants.DefaultRuntimeType
 	return opts
 }
 
@@ -128,7 +126,7 @@ func NewKubeEdgeReset() *cobra.Command {
 			}
 
 			// cleanup mqtt container
-			if err := RemoveMqttContainer(reset.RuntimeType, reset.Endpoint, ""); err != nil {
+			if err := RemoveMqttContainer(reset.Endpoint, ""); err != nil {
 				fmt.Printf("Failed to remove MQTT container: %v\n", err)
 			}
 			//4. TODO: clean status information
@@ -141,8 +139,8 @@ func NewKubeEdgeReset() *cobra.Command {
 	return cmd
 }
 
-func RemoveMqttContainer(runtimeType, endpoint, cgroupDriver string) error {
-	runtime, err := util.NewContainerRuntime(runtimeType, endpoint, cgroupDriver)
+func RemoveMqttContainer(endpoint, cgroupDriver string) error {
+	runtime, err := util.NewContainerRuntime(endpoint, cgroupDriver)
 	if err != nil {
 		return fmt.Errorf("failed to new container runtime: %v", err)
 	}
@@ -220,8 +218,6 @@ func addResetFlags(cmd *cobra.Command, resetOpts *common.ResetOptions) {
 		"Use this key to set kube-config path, eg: $HOME/.kube/config")
 	cmd.Flags().BoolVar(&resetOpts.Force, "force", resetOpts.Force,
 		"Reset the node without prompting for confirmation")
-	cmd.Flags().StringVar(&resetOpts.RuntimeType, common.RuntimeType, resetOpts.RuntimeType,
-		"Use this key to set container runtime")
 	cmd.Flags().StringVar(&resetOpts.Endpoint, common.RemoteRuntimeEndpoint, resetOpts.Endpoint,
 		"Use this key to set container runtime endpoint")
 }
diff --git a/keadm/cmd/keadm/app/cmd/reset_windows.go b/keadm/cmd/keadm/app/cmd/reset_windows.go
index 0f3e85b70..d8e4b5a33 100644
--- a/keadm/cmd/keadm/app/cmd/reset_windows.go
+++ b/keadm/cmd/keadm/app/cmd/reset_windows.go
@@ -24,7 +24,6 @@ import (
 	"os"
 	"strings"
 
-	"github.com/kubeedge/kubeedge/common/constants"
 	"github.com/spf13/cobra"
 	phases "k8s.io/kubernetes/cmd/kubeadm/app/cmd/phases/reset"
 	utilruntime "k8s.io/kubernetes/cmd/kubeadm/app/util/runtime"
@@ -47,7 +46,6 @@ keadm reset
 func newResetOptions() *common.ResetOptions {
 	opts := &common.ResetOptions{}
 	opts.Kubeconfig = common.DefaultKubeConfig
-	opts.RuntimeType = constants.DefaultRuntimeType
 	return opts
 }
 
diff --git a/keadm/cmd/keadm/app/cmd/util/edgecoreinstaller.go b/keadm/cmd/keadm/app/cmd/util/edgecoreinstaller.go
index 5eb00ccac..842cda521 100755
--- a/keadm/cmd/keadm/app/cmd/util/edgecoreinstaller.go
+++ b/keadm/cmd/keadm/app/cmd/util/edgecoreinstaller.go
@@ -39,7 +39,6 @@ type KubeEdgeInstTool struct {
 	CertPath              string
 	CloudCoreIP           string
 	EdgeNodeName          string
-	RuntimeType           string
 	RemoteRuntimeEndpoint string
 	Token                 string
 	CertPort              string
@@ -97,9 +96,6 @@ func (ku *KubeEdgeInstTool) createEdgeConfigFiles() error {
 	if ku.EdgeNodeName != "" {
 		edgeCoreConfig.Modules.Edged.HostnameOverride = ku.EdgeNodeName
 	}
-	if ku.RuntimeType != "" {
-		edgeCoreConfig.Modules.Edged.ContainerRuntime = ku.RuntimeType
-	}
 	if ku.CGroupDriver != "" {
 		switch ku.CGroupDriver {
 		case v1alpha2.CGroupDriverSystemd:
diff --git a/keadm/cmd/keadm/app/cmd/util/image.go b/keadm/cmd/keadm/app/cmd/util/image.go
index 7ffbd6056..b92ed0799 100644
--- a/keadm/cmd/keadm/app/cmd/util/image.go
+++ b/keadm/cmd/keadm/app/cmd/util/image.go
@@ -19,16 +19,10 @@ package util
 import (
 	"context"
 	"fmt"
-	"io"
 	"path/filepath"
 	"strings"
 	"time"
 
-	dockertypes "github.com/docker/docker/api/types"
-	dockercontainer "github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/filters"
-	dockerclient "github.com/docker/docker/client"
-	"github.com/docker/go-connections/nat"
 	oteltrace "go.opentelemetry.io/otel/trace"
 	internalapi "k8s.io/cri-api/pkg/apis"
 	runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1"
@@ -51,184 +45,25 @@ type ContainerRuntime interface {
 	RemoveMQTT() error
 }
 
-func NewContainerRuntime(runtimeType, endpoint, cgroupDriver string) (ContainerRuntime, error) {
+func NewContainerRuntime(endpoint, cgroupDriver string) (ContainerRuntime, error) {
 	var runtime ContainerRuntime
-	switch runtimeType {
-	case constants.DockerContainerRuntime:
-		cli, err := dockerclient.NewClientWithOpts(dockerclient.FromEnv)
-		if err != nil {
-			return runtime, fmt.Errorf("init docker client failed: %v", err)
-		}
-
-		ctx := context.Background()
-		cli.NegotiateAPIVersion(ctx)
-
-		runtime = &DockerRuntime{
-			Client: cli,
-			ctx:    ctx,
-		}
-	case constants.RemoteContainerRuntime:
-		imageService, err := remote.NewRemoteImageService(endpoint, time.Second*10, oteltrace.NewNoopTracerProvider())
-		if err != nil {
-			return runtime, err
-		}
-		runtimeService, err := remote.NewRemoteRuntimeService(endpoint, time.Second*10, oteltrace.NewNoopTracerProvider())
-		if err != nil {
-			return runtime, err
-		}
-		runtime = &CRIRuntime{
-			endpoint:            endpoint,
-			cgroupDriver:        cgroupDriver,
-			ImageManagerService: imageService,
-			RuntimeService:      runtimeService,
-			ctx:                 context.Background(),
-		}
-	default:
-		return runtime, fmt.Errorf("unsupport CRI runtime: %s", runtimeType)
-	}
-
-	return runtime, nil
-}
-
-type DockerRuntime struct {
-	Client *dockerclient.Client
-	ctx    context.Context
-}
-
-func (runtime *DockerRuntime) PullImages(images []string) error {
-	for _, image := range images {
-		fmt.Printf("Pulling %s ...\n", image)
-		args := filters.NewArgs()
-		args.Add("reference", image)
-		list, err := runtime.Client.ImageList(runtime.ctx, dockertypes.ImageListOptions{Filters: args})
-		if err != nil {
-			return err
-		}
-		if len(list) > 0 {
-			continue
-		}
-
-		rc, err := runtime.Client.ImagePull(runtime.ctx, image, dockertypes.ImagePullOptions{})
-		if err != nil {
-			return err
-		}
-
-		if _, err := io.Copy(io.Discard, rc); err != nil {
-			return err
-		}
-		if err := rc.Close(); err != nil {
-			return err
-		}
-		fmt.Printf("Successfully pulled %s\n", image)
-	}
-
-	return nil
-}
-
-func (runtime *DockerRuntime) RunMQTT(mqttImage string) error {
-	_, portMap, err := nat.ParsePortSpecs([]string{
-		"1883:1883",
-		"9001:9001",
-	})
+	imageService, err := remote.NewRemoteImageService(endpoint, time.Second*10, oteltrace.NewNoopTracerProvider())
 	if err != nil {
-		return err
+		return runtime, err
 	}
-
-	hostConfig := &dockercontainer.HostConfig{
-		PortBindings: portMap,
-		RestartPolicy: dockercontainer.RestartPolicy{
-			Name: "unless-stopped",
-		},
-		Binds: []string{
-			filepath.Join(KubeEdgeSocketPath, image.EdgeMQTT) + ":/mosquitto",
-		},
-	}
-	config := &dockercontainer.Config{Image: mqttImage}
-
-	container, err := runtime.Client.ContainerCreate(runtime.ctx, config, hostConfig, nil, nil, image.EdgeMQTT)
+	runtimeService, err := remote.NewRemoteRuntimeService(endpoint, time.Second*10, oteltrace.NewNoopTracerProvider())
 	if err != nil {
-		return err
-	}
-	return runtime.Client.ContainerStart(runtime.ctx, container.ID, dockertypes.ContainerStartOptions{})
-}
-
-func (runtime *DockerRuntime) RemoveMQTT() error {
-	options := dockertypes.ContainerListOptions{
-		All: true,
-	}
-	options.Filters = filters.NewArgs()
-	options.Filters.Add("name", image.EdgeMQTT)
-
-	mqttContainers, err := runtime.Client.ContainerList(runtime.ctx, options)
-	if err != nil {
-		fmt.Printf("List MQTT containers failed: %v\n", err)
-		return err
-	}
-
-	for _, c := range mqttContainers {
-		err = runtime.Client.ContainerRemove(runtime.ctx, c.ID, dockertypes.ContainerRemoveOptions{RemoveVolumes: true, Force: true})
-		if err != nil {
-			fmt.Printf("failed to remove MQTT container: %v\n", err)
-		}
+		return runtime, err
 	}
-
-	return nil
-}
-
-// CopyResources copies binary and configuration file from the image to the host.
-// dirs/files map: key is container file path, value is host file path
-// The command it executes are as follows:
-//
-// docker run -v /usr/local/bin:/tmp/usr/local/bin <IMAGE-NAME> \
-// bash -c cp /usr/local/bin/edgecore:/tmp/usr/local/bin/edgecore
-// TODO: support copy dirs, so that users can copy customized files in dir /etc/kubeedge of image kubeedge/installation-package
-func (runtime *DockerRuntime) CopyResources(image string, files map[string]string) error {
-	if len(files) == 0 {
-		return fmt.Errorf("no resources need copying")
+	runtime = &CRIRuntime{
+		endpoint:            endpoint,
+		cgroupDriver:        cgroupDriver,
+		ImageManagerService: imageService,
+		RuntimeService:      runtimeService,
+		ctx:                 context.Background(),
 	}
 
-	copyCmd := copyResourcesCmd(files)
-
-	config := &dockercontainer.Config{
-		Image: image,
-		Cmd: []string{
-			"/bin/sh",
-			"-c",
-			copyCmd,
-		},
-	}
-
-	var binds []string
-	for _, hostPath := range files {
-		binds = append(binds, filepath.Dir(hostPath)+":"+filepath.Join("/tmp", filepath.Dir(hostPath)))
-	}
-
-	hostConfig := &dockercontainer.HostConfig{
-		Binds: binds,
-	}
-
-	// Randomly generate container names to prevent duplicate names.
-	container, err := runtime.Client.ContainerCreate(runtime.ctx, config, hostConfig, nil, nil, "")
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if err := runtime.Client.ContainerRemove(runtime.ctx, container.ID, dockertypes.ContainerRemoveOptions{}); err != nil {
-			klog.V(3).ErrorS(err, "Remove container failed", "containerID", container.ID)
-		}
-	}()
-
-	if err := runtime.Client.ContainerStart(runtime.ctx, container.ID, dockertypes.ContainerStartOptions{}); err != nil {
-		return fmt.Errorf("container start failed: %v", err)
-	}
-
-	statusCh, errCh := runtime.Client.ContainerWait(runtime.ctx, container.ID, "")
-	select {
-	case err := <-errCh:
-		klog.Errorf("container wait error %v", err)
-	case <-statusCh:
-	}
-	return nil
+	return runtime, nil
 }
 
 type CRIRuntime struct {