katacontainers启动分析

最新推荐文章于 2024-05-21 09:36:08 发布
最新推荐文章于 2024-05-21 09:36:08 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： katacontainers 文章标签： kata katacontainers
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010827484/article/details/117488374
版权

程序入口

文章目录


程序启动命令示例： 

/usr/bin/containerd-shim-kata-v2 -namespace k8s.io -address /run/containerd/containerd.sock -publish-binary /usr/bin/containerd -id 19639196b889a15b8dcd5d718371de7af5afccfbdf5d7fdc314685e40ba55b09

检测kata输入参数

func main() {

	if len(os.Args) == 2 && os.Args[1] == "--version" {
		fmt.Printf("%s containerd shim: id: %q, version: %s, commit: %v\n", project, types.DefaultKataRuntimeName, version, commit)
		os.Exit(0)
	}

	shim.Run(types.DefaultKataRuntimeName, containerdshim.New, shimConfig)
}

containerdshim.New：获取service实例

shimConfig：初始化shim配置

初始化环境

shim.Run是进入主要逻辑入口，首先解析输入的参数，初始化运行时环境，设置child_subreaper（subreaper，只针对linux环境），这样它就能接收以他为父节点的进程树下所有的孤儿进程，比如containerd中父进程拉起子进程后父进程退出，子进程会被设置了child_subreaper的父进程接管，这里设置相当于用containerd-shim管理容器内的子进程，是否启动subreaper由shimConfig函数初始化变量确定

func run(id string, initFunc Init, config Config) error {
	parseFlags()
	setRuntime()

	signals, err := setupSignals(config)
	if err != nil {
		return err
	}
	if !config.NoSubreaper {
		if err := subreaper(); err != nil {
			return err
		}
	}
	......
	......
	......

初始化事件通知器

初始化事件通知实例，addressFlag和containerdBinaryFlag string根据parseFlags解析输入参数获取，config.NoReaper根据shimConfig获取

	publisher := &remoteEventsPublisher{
		address:              addressFlag,
		containerdBinaryPath: containerdBinaryFlag,
		noReaper:             config.NoReaper,
	}

初始化命名空间

初始化命名空间，namespaceFlag从parseFlags解析到的输入参数获取，并在上下文空间传递BundlePath和Debug两个参数，同时把ctx的log加上“runtime”字段

	ctx := namespaces.WithNamespace(context.Background(), namespaceFlag)
	ctx = context.WithValue(ctx, OptsKey{}, Opts{BundlePath: bundlePath, Debug: debugFlag})
	ctx = log.WithLogger(ctx, log.G(ctx).WithField("runtime", id))

初始化service实例

initFunc是函数指针，指向containerdshim.New函数，相当于调用containerdshim.New方法，主要作用是实例化service对象

	service, err := initFunc(ctx, idFlag, publisher)
	if err != nil {
		return err
	}

containerdshim.New，首先初始化vci、katautils日志，包括日志的等级、字段，然后初始化service实例

	s := &service{
		id:         id,
		pid:        uint32(os.Getpid()),
		ctx:        ctx,
		containers: make(map[string]*container),
		events:     make(chan interface{}, chSize),
		ec:         make(chan exit, bufferSize),
		cancel:     cancel,
	}

启动service事件处理协程

使用goroutine启动service的processExits方法，使用for轮回service.ec信道信息，然后使用service.sendL方法发送出去，sendL把需要发送的事件发给events信道，以上两个信道都是service实例的信道

func (s *service) processExits() {
	for e := range s.ec {
		s.checkProcesses(e)
	}
}
func (s *service) checkProcesses(e exit) {
	s.mu.Lock()
	defer s.mu.Unlock()

	id := e.execid
	if id == "" {
		id = e.id
	}

	s.sendL(&eventstypes.TaskExit{
		ContainerID: e.id,
		ID:          id,
		Pid:         e.pid,
		ExitStatus:  uint32(e.status),
		ExitedAt:    e.timestamp,
	})
}
func (s *service) sendL(evt interface{}) {
	s.eventSendMu.Lock()
	if s.events != nil {
		s.events <- evt
	}
	s.eventSendMu.Unlock()
}

使用gorouteine启动service的forward方法，publisher是remoteEventsPublisher实例对象，forward轮询service的events信道，相当于在接收service.ev信道信息

func (s *service) forward(publisher events.Publisher) {
	for e := range s.events {
		ctx, cancel := context.WithTimeout(s.ctx, timeOut)
		err := publisher.Publish(ctx, getTopic(e), e)
		cancel()
		if err != nil {
			shimLog.WithError(err).Error("post event")
		}
	}
}

Publish对消息经过预处理后开始组织命令，然后执行命令等待返回值，这里就是调用containerd的地方

l.containerdBinaryPath是启动程序传入的参数containerdBinaryFlag（publish-binary），默认为containerd

l.address是启动程序传入的参数addressFlag（address），默认为空

ns是启动程序传入的参数namespaceFlag（namespace），默认为空

topic是事件类型

file:src\runtime\vendor\github.com\containerd\containerd\runtime\v2\shim\shim_unix.go
func (l *remoteEventsPublisher) Publish(ctx context.Context, topic string, event events.Event) error {
	ns, _ := namespaces.Namespace(ctx)
	encoded, err := typeurl.MarshalAny(event)
	if err != nil {
		return err
	}
	data, err := encoded.Marshal()
	if err != nil {
		return err
	}
	cmd := exec.CommandContext(ctx, l.containerdBinaryPath, "--address", l.address, "publish", "--topic", topic, "--namespace", ns)
	cmd.Stdin = bytes.NewReader(data)
	if l.noReaper {
		if err := cmd.Start(); err != nil {
			return err
		}
		if err := cmd.Wait(); err != nil {
			return errors.Wrap(err, "failed to publish event")
		}
		return nil
	}
	c, err := Default.Start(cmd)
	if err != nil {
		return err
	}
	status, err := Default.Wait(cmd, c)
	if err != nil {
		return err
	}
	if status != 0 {
		return errors.New("failed to publish event")
	}
	return nil
}

topic事件类型

func getTopic(e interface{}) string {
	switch e.(type) {
	case *eventstypes.TaskCreate:
		return cdruntime.TaskCreateEventTopic
	case *eventstypes.TaskStart:
		return cdruntime.TaskStartEventTopic
	case *eventstypes.TaskOOM:
		return cdruntime.TaskOOMEventTopic
	case *eventstypes.TaskExit:
		return cdruntime.TaskExitEventTopic
	case *eventstypes.TaskDelete:
		return cdruntime.TaskDeleteEventTopic
	case *eventstypes.TaskExecAdded:
		return cdruntime.TaskExecAddedEventTopic
	case *eventstypes.TaskExecStarted:
		return cdruntime.TaskExecStartedEventTopic
	case *eventstypes.TaskPaused:
		return cdruntime.TaskPausedEventTopic
	case *eventstypes.TaskResumed:
		return cdruntime.TaskResumedEventTopic
	case *eventstypes.TaskCheckpointed:
		return cdruntime.TaskCheckpointedEventTopic
	default:
		shimLog.WithField("event-type", e).Warn("no topic for event type")
	}
	return cdruntime.TaskUnknownTopic
}

处理事件

action = flag.Arg(0)，flag.arg处理没有被解析的参数，如果没有未被解析的参数action则为空

	switch action {
	case "delete":
		logger := logrus.WithFields(logrus.Fields{
			"pid":       os.Getpid(),
			"namespace": namespaceFlag,
		})
		go handleSignals(logger, signals)
		response, err := service.Cleanup(ctx)
		if err != nil {
			return err
		}
		data, err := proto.Marshal(response)
		if err != nil {
			return err
		}
		if _, err := os.Stdout.Write(data); err != nil {
			return err
		}
		return nil
	case "start":
		address, err := service.StartShim(ctx, idFlag, containerdBinaryFlag, addressFlag)
		if err != nil {
			return err
		}
		if _, err := os.Stdout.WriteString(address); err != nil {
			return err
		}
		return nil
	default:
		if err := setLogger(ctx, idFlag); err != nil {
			return err
		}
		client := NewShimClient(ctx, service, signals)
		return client.Serve()
	}

default

NewShimClient获取Client实例，svc是service实例

// NewShimClient creates a new shim server client
func NewShimClient(ctx context.Context, svc shimapi.TaskService, signals chan os.Signal) *Client {
	s := &Client{
		service: svc,
		context: ctx,
		signals: signals,
	}
	return s
}

client.Serve()中会初始化信号捕获函数、日志，启动serve

// Serve the shim server
func (s *Client) Serve() error {
	dump := make(chan os.Signal, 32)
	setupDumpStacks(dump)

	path, err := os.Getwd()
	if err != nil {
		return err
	}
	server, err := newServer()
	if err != nil {
		return errors.Wrap(err, "failed creating server")
	}

	logrus.Debug("registering ttrpc server")
	shimapi.RegisterTaskService(server, s.service)

	if err := serve(s.context, server, socketFlag); err != nil {
		return err
	}
	logger := logrus.WithFields(logrus.Fields{
		"pid":       os.Getpid(),
		"path":      path,
		"namespace": namespaceFlag,
	})
	go func() {
		for range dump {
			dumpStacks(logger)
		}
	}()
	return handleSignals(logger, s.signals)
}

newServer会初始化ttrpc服务

file:src\runtime\vendor\github.com\containerd\containerd\runtime\v2\shim\shim_linux.go
func newServer() (*ttrpc.Server, error) {
	return ttrpc.NewServer(ttrpc.WithServerHandshaker(ttrpc.UnixSocketRequireSameUser()))
}

shimapi.RegisterTaskService(server, s.service)，把service实例注册到ttrpc服务器

func RegisterTaskService(srv *ttrpc.Server, svc TaskService) {
	srv.Register("containerd.task.v2.Task", map[string]ttrpc.Method{
		"State": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req StateRequest
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.State(ctx, &req)
		},
		"Create": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req CreateTaskRequest
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.Create(ctx, &req)
		},
		"Start": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req StartRequest
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.Start(ctx, &req)
		},
		"Delete": func(ctx context.Context, unmarshal func(interface{}) error) (interface{}, error) {
			var req DeleteRequest
			if err := unmarshal(&req); err != nil {
				return nil, err
			}
			return svc.Delete(ctx, &req)
		},
		......
		......

ttrpc注册的方法如“Create”方法被调用后会被执行到service的Create方法，然后调用create方法，最后把创建结果使用service的send方法通过信道发送给service的events信道，然后被service的forward协程处理发送给containerd

file:src\runtime\containerd-shim-v2\service.go
// Create a new sandbox or container with the underlying OCI runtime
func (s *service) Create(ctx context.Context, r *taskAPI.CreateTaskRequest) (_ *taskAPI.CreateTaskResponse, err error) {
	start := time.Now()
	defer func() {
		err = toGRPC(err)
		rpcDurationsHistogram.WithLabelValues("create").Observe(float64(time.Since(start).Nanoseconds() / int64(time.Millisecond)))
	}()

	s.mu.Lock()
	defer s.mu.Unlock()

	var c *container

	c, err = create(ctx, s, r)
	if err != nil {
		return nil, err
	}

	c.status = task.StatusCreated

	s.containers[r.ID] = c

	s.send(&eventstypes.TaskCreate{
		ContainerID: r.ID,
		Bundle:      r.Bundle,
		Rootfs:      r.Rootfs,
		IO: &eventstypes.TaskIO{
			Stdin:    r.Stdin,
			Stdout:   r.Stdout,
			Stderr:   r.Stderr,
			Terminal: r.Terminal,
		},
		Checkpoint: r.Checkpoint,
		Pid:        s.pid,
	})

	return &taskAPI.CreateTaskResponse{
		Pid: s.pid,
	}, nil
}
func (s *service) send(evt interface{}) {
	// for unit test, it will not initialize s.events
	if s.events != nil {
		s.events <- evt
	}
}
service goroutine
call
call
call
call
chan
chan
chan
chan
start
loop event
public
syscall containerd
ttrpc service
process event
create
create_backend
Start
Start_backend
State
State_backend
...
...
send event

create方法分为两种创建方式PodSandbox和PodContainerg

file:src\runtime\containerd-shim-v2\create.go
func create(ctx context.Context, s *service, r *taskAPI.CreateTaskRequest) (*container, error) {
	rootFs := vc.RootFs{}
	if len(r.Rootfs) == 1 {
		m := r.Rootfs[0]
		rootFs.Source = m.Source
		rootFs.Type = m.Type
		rootFs.Options = m.Options
	}

	detach := !r.Terminal
	ociSpec, bundlePath, err := loadSpec(r)
	if err != nil {
		return nil, err
	}

	containerType, err := oci.ContainerType(*ociSpec)
	if err != nil {
		return nil, err
	}

	disableOutput := noNeedForOutput(detach, ociSpec.Process.Terminal)
	rootfs := filepath.Join(r.Bundle, "rootfs")

	switch containerType {
	case vc.PodSandbox:
		if s.sandbox != nil {
			return nil, fmt.Errorf("cannot create another sandbox in sandbox: %s", s.sandbox.ID())
		}

		_, err := loadRuntimeConfig(s, r, ociSpec.Annotations)
		if err != nil {
			return nil, err
		}

		if rootFs.Mounted, err = checkAndMount(s, r); err != nil {
			return nil, err
		}

		defer func() {
			if err != nil && rootFs.Mounted {
				if err2 := mount.UnmountAll(rootfs, 0); err2 != nil {
					shimLog.WithField("container-type", containerType).WithError(err2).Warn("failed to cleanup rootfs mount")
				}
			}
		}()

		katautils.HandleFactory(ctx, vci, s.config)

		// Pass service's context instead of local ctx to CreateSandbox(), since local
		// ctx will be canceled after this rpc service call, but the sandbox will live
		// across multiple rpc service calls.
		//
		sandbox, _, err := katautils.CreateSandbox(s.ctx, vci, *ociSpec, *s.config, rootFs, r.ID, bundlePath, "", disableOutput, false)
		if err != nil {
			return nil, err
		}
		s.sandbox = sandbox
		go s.startManagementServer(ctx, ociSpec)

	case vc.PodContainer:
		if s.sandbox == nil {
			return nil, fmt.Errorf("BUG: Cannot start the container, since the sandbox hasn't been created")
		}

		if rootFs.Mounted, err = checkAndMount(s, r); err != nil {
			return nil, err
		}

		defer func() {
			if err != nil && rootFs.Mounted {
				if err2 := mount.UnmountAll(rootfs, 0); err2 != nil {
					shimLog.WithField("container-type", containerType).WithError(err2).Warn("failed to cleanup rootfs mount")
				}
			}
		}()

		_, err = katautils.CreateContainer(ctx, s.sandbox, *ociSpec, rootFs, r.ID, bundlePath, "", disableOutput)
		if err != nil {
			return nil, err
		}
	}

	container, err := newContainer(s, r, containerType, ociSpec, rootFs.Mounted)
	if err != nil {
		return nil, err
	}

	return container, nil
}

初始化sandbox

kata创建过程会进入vc.PodSandbox分支，首先加载配置文件中的配置和rpc调用过来的配置

		s.config, err = loadRuntimeConfig(s, r, ociSpec.Annotations)
		if err != nil {
			return nil, err
		}

创建tracer

		// create tracer
		// This is the earliest location we can create the tracer because we must wait
		// until the runtime config is loaded
		_, err = katautils.CreateTracer("kata", s.config)
		if err != nil {
			return nil, err
		}

		// create root span
		var rootSpan otelTrace.Span
		rootSpan, s.rootCtx = trace(s.ctx, "root span")
		defer rootSpan.End()

		// create span
		var span otelTrace.Span
		span, s.ctx = trace(s.rootCtx, "create")
		defer span.End()

检查挂载

		if rootFs.Mounted, err = checkAndMount(s, r); err != nil {
			return nil, err
		}

初始化sandbox配置，kata采用模板方式初始化sandbox，katautils.HandleFactory根据初始配置创建sandbox模板，配置通过vci返回，这个步骤从配置文件同步配置到vci，后续再从vci同步到SandboxConfig

		katautils.HandleFactory(ctx, vci, s.config)

创建sandbox入口

		sandbox, _, err := katautils.CreateSandbox(s.ctx, vci, *ociSpec, *s.config, rootFs, r.ID, bundlePath, "", disableOutput, false)
		if err != nil {
			return nil, err
		}

1、初始化virtcontainers的sandbox配置结构体SandboxConfig

2、检测系统是否开启FIPS功能（在 FIPS 模式下，只能使用 FIPS 140-2 批准的加密算法）

3、指定container文件系统路径

4、创建网络命名空间

5、进入网络命名空间执行precontainer hook函数

6、创建sandbox，实现方法：src\runtime\virtcontainers\implementation.go

// CreateSandbox create a sandbox container
func CreateSandbox(ctx context.Context, vci vc.VC, ociSpec specs.Spec, runtimeConfig oci.RuntimeConfig, rootFs vc.RootFs,
	containerID, bundlePath, console string, disableOutput, systemdCgroup bool) (_ vc.VCSandbox, _ vc.Process, err error) {
	span, ctx := Trace(ctx, "createSandbox")
	defer span.End()

	sandboxConfig, err := oci.SandboxConfig(ociSpec, runtimeConfig, bundlePath, containerID, console, disableOutput, systemdCgroup)
	if err != nil {
		return nil, vc.Process{}, err
	}

	if err := checkForFIPS(&sandboxConfig); err != nil {
		return nil, vc.Process{}, err
	}

	if !rootFs.Mounted && len(sandboxConfig.Containers) == 1 {
		if rootFs.Source != "" {
			realPath, err := ResolvePath(rootFs.Source)
			if err != nil {
				return nil, vc.Process{}, err
			}
			rootFs.Source = realPath
		}
		sandboxConfig.Containers[0].RootFs = rootFs
	}

	// Important to create the network namespace before the sandbox is
	// created, because it is not responsible for the creation of the
	// netns if it does not exist.
	if err := SetupNetworkNamespace(&sandboxConfig.NetworkConfig); err != nil {
		return nil, vc.Process{}, err
	}

	defer func() {
		// cleanup netns if kata creates it
		ns := sandboxConfig.NetworkConfig
		if err != nil && ns.NetNsCreated {
			if ex := cleanupNetNS(ns.NetNSPath); ex != nil {
				kataUtilsLogger.WithField("path", ns.NetNSPath).WithError(ex).Warn("failed to cleanup netns")
			}
		}
	}()

	// Run pre-start OCI hooks.
	err = EnterNetNS(sandboxConfig.NetworkConfig.NetNSPath, func() error {
		return PreStartHooks(ctx, ociSpec, containerID, bundlePath)
	})
	if err != nil {
		return nil, vc.Process{}, err
	}

	sandbox, err := vci.CreateSandbox(ctx, sandboxConfig)
	if err != nil {
		return nil, vc.Process{}, err
	}

	sid := sandbox.ID()
	kataUtilsLogger = kataUtilsLogger.WithField("sandbox", sid)
	span.SetAttributes(label.Key("sandbox").String(sid))

	containers := sandbox.GetAllContainers()
	if len(containers) != 1 {
		return nil, vc.Process{}, fmt.Errorf("BUG: Container list from sandbox is wrong, expecting only one container, found %d containers", len(containers))
	}

	return sandbox, containers[0].Process(), nil
}

vci.CreateSandbox(ctx, sandboxConfig)流程：

file：src\runtime\pkg\katautils\create.go vci.CreateSandbox

file：src\runtime\virtcontainers\implementation.go CreateSandbox

file：src\runtime\virtcontainers\api.go CreateSandbox createSandboxFromConfig

file：src\runtime\virtcontainers\sandbox.go createSandbox

sandbox.go
api.go
implementation.go
create.go
createSandbox
CreateSandbox
createSandboxFromConfig
CreateSandbox
vci.CreateSandbox

createSandbox回到sandbox包：src\runtime\virtcontainers\sandbox.go

getNewAgentFunc：创建运行在sandbox中agent的实例，kataAgent对象

newHypervisor：创建hypervisor实例，sandbox的虚拟化平台，根据配置返回不同的虚拟化平台实例，默认是qemu：src\runtime\virtcontainers\qemu.go

s.hypervisor.createSandbox：根据sandbox配置如处理器、内存、虚拟设备等初始化虚拟机配置（qemu：src\runtime\virtcontainers\qemu.go：createSandbox）

s.agent.init：初始化kata-agent，初始化trace功能和基础配置（src\runtime\virtcontainers\kata_agent.go）

file：src\runtime\virtcontainers\sandbox.go


func newSandbox(ctx context.Context, sandboxConfig SandboxConfig, factory Factory) (sb *Sandbox, retErr error) {
	span, ctx := trace(ctx, "newSandbox")
	defer span.End()

	if !sandboxConfig.valid() {
		return nil, fmt.Errorf("Invalid sandbox configuration")
	}

	// create agent instance
	agent := getNewAgentFunc(ctx)()

	hypervisor, err := newHypervisor(sandboxConfig.HypervisorType)
	if err != nil {
		return nil, err
	}

	s := &Sandbox{
		id:              sandboxConfig.ID,
		factory:         factory,
		hypervisor:      hypervisor,
		agent:           agent,
		config:          &sandboxConfig,
		volumes:         sandboxConfig.Volumes,
		containers:      map[string]*Container{},
		state:           types.SandboxState{BlockIndexMap: make(map[int]struct{})},
		annotationsLock: &sync.RWMutex{},
		wg:              &sync.WaitGroup{},
		shmSize:         sandboxConfig.ShmSize,
		sharePidNs:      sandboxConfig.SharePidNs,
		networkNS:       NetworkNamespace{NetNsPath: sandboxConfig.NetworkConfig.NetNSPath},
		ctx:             ctx,
	}

	hypervisor.setSandbox(s)

	if s.store, err = persist.GetDriver(); err != nil || s.store == nil {
		return nil, fmt.Errorf("failed to get fs persist driver: %v", err)
	}

	defer func() {
		if retErr != nil {
			s.Logger().WithError(retErr).Error("Create new sandbox failed")
			s.store.Destroy(s.id)
		}
	}()

	spec := s.GetPatchedOCISpec()
	if spec != nil && spec.Process.SelinuxLabel != "" {
		sandboxConfig.HypervisorConfig.SELinuxProcessLabel = spec.Process.SelinuxLabel
	}

	s.devManager = deviceManager.NewDeviceManager(sandboxConfig.HypervisorConfig.BlockDeviceDriver,
		sandboxConfig.HypervisorConfig.EnableVhostUserStore,
		sandboxConfig.HypervisorConfig.VhostUserStorePath, nil)

	// Ignore the error. Restore can fail for a new sandbox
	if err := s.Restore(); err != nil {
		s.Logger().WithError(err).Debug("restore sandbox failed")
	}

	// store doesn't require hypervisor to be stored immediately
	if err = s.hypervisor.createSandbox(ctx, s.id, s.networkNS, &sandboxConfig.HypervisorConfig); err != nil {
		return nil, err
	}

	if s.disableVMShutdown, err = s.agent.init(ctx, s, sandboxConfig.AgentConfig); err != nil {
		return nil, err
	}

	return s, nil
}

启动sandbox

file：src\runtime\virtcontainers\api.go

func createSandboxFromConfig(ctx context.Context, sandboxConfig SandboxConfig, factory Factory) (_ *Sandbox, err error) {
	span, ctx := trace(ctx, "createSandboxFromConfig")
	defer span.End()

	// Create the sandbox.
	s, err := createSandbox(ctx, sandboxConfig, factory)
	if err != nil {
		return nil, err
	}

	// cleanup sandbox resources in case of any failure
	defer func() {
		if err != nil {
			s.Delete(ctx)
		}
	}()

	// Create the sandbox network
	if err = s.createNetwork(ctx); err != nil {
		return nil, err
	}

	// network rollback
	defer func() {
		if err != nil {
			s.removeNetwork(ctx)
		}
	}()

	// Move runtime to sandbox cgroup so all process are created there.
	if s.config.SandboxCgroupOnly {
		if err := s.createCgroupManager(); err != nil {
			return nil, err
		}

		if err := s.setupSandboxCgroup(); err != nil {
			return nil, err
		}
	}

	// Start the VM
	if err = s.startVM(ctx); err != nil {
		return nil, err
	}

	// rollback to stop VM if error occurs
	defer func() {
		if err != nil {
			s.stopVM(ctx)
		}
	}()

	s.postCreatedNetwork(ctx)

	if err = s.getAndStoreGuestDetails(ctx); err != nil {
		return nil, err
	}

	// Create Containers
	if err = s.createContainers(ctx); err != nil {
		return nil, err
	}

	// The sandbox is completely created now, we can store it.
	if err = s.storeSandbox(ctx); err != nil {
		return nil, err
	}

	return s, nil
}

s.createNetwork：创建网络

s.startVM：启动虚拟机，最后会根据hypervisor配置拉起虚拟机，还有很多流程。。。

s.postCreatedNetwork(ctx)：创建网络命名空间

s.getAndStoreGuestDetails(ctx)：获取guest资源信息

s.createContainers(ctx)：在guest环境中创建container，container配置在SandboxConfig结构体

s.storeSandbox(ctx)：写入kata环境在配置文件，包括版本、状态、虚拟化平台、kata-agent等信息

启动service等待kata-agent连接

todo：service分析，还有很多流程。。。

		s.sandbox = sandbox
		pid, err := s.sandbox.GetHypervisorPid()
		if err != nil {
			return nil, err
		}
		s.hpid = uint32(pid)

		go s.startManagementServer(ctx, ociSpec)

start

start分支主要用于拉起containerd-shim-kata-v2命令

可能containerd-shim-kata-v2由start分支发起，start分支再退出，具体实现需要分析containerd源码

func (s *service) StartShim(ctx context.Context, id, containerdBinary, containerdAddress string) (string, error) {
	bundlePath, err := os.Getwd()
	if err != nil {
		return "", err
	}

	address, err := getAddress(ctx, bundlePath, id)
	if err != nil {
		return "", err
	}
	if address != "" {
		if err := cdshim.WriteAddress("address", address); err != nil {
			return "", err
		}
		return address, nil
	}

	cmd, err := newCommand(ctx, containerdBinary, id, containerdAddress)
	if err != nil {
		return "", err
	}

	address, err = cdshim.SocketAddress(ctx, id)
	if err != nil {
		return "", err
	}

	socket, err := cdshim.NewSocket(address)
	if err != nil {
		return "", err
	}
	defer socket.Close()
	f, err := socket.File()
	if err != nil {
		return "", err
	}
	defer f.Close()

	cmd.ExtraFiles = append(cmd.ExtraFiles, f)

	if err := cmd.Start(); err != nil {
		return "", err
	}
	defer func() {
		if err != nil {
			cmd.Process.Kill()
		}
	}()

	// make sure to wait after start
	go cmd.Wait()
	if err = cdshim.WritePidFile("shim.pid", cmd.Process.Pid); err != nil {
		return "", err
	}
	if err = cdshim.WriteAddress("address", address); err != nil {
		return "", err
	}
	return address, nil
}
迷失0
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kata容器：Kata Containers版本2.x存储库。 Kata Containers是一个开源项目和社区，致力于构建轻量级虚拟机（VM）的标准实现，这些虚拟机的感觉和性能类似于容器，但提供了工作负载隔离和VM的安全优势。 https：katacontainers.io
02-02
该存储库是2.0及更高版本的Kata Containers代码的所在地。 如果您想了解Kata Containers，请访问主要的。 有关较旧（第一代）Kata Containers 1.x版本的详细信息，请参阅“ 部分。 介绍 Kata Containers是一个...
ttrpc:适用于低内存环境的GRPC
05-05
ttrpc 适用于低内存环境的GRPC。 现有的grpc-go项目在导入包和运行时需要大量内存开销。 尽管这对于具有低密度要求的许多服务非常有用，但是在单台计算机上或在具有少量内存的计算机上运行大量服务时，这可能是个问题。 使用相同的GRPC定义，该项目减少了二进制文件的大小和所需的协议开销。 通过net/http2 grpc所使用的net/http ， net/http2和grpc软件包来实现此目的，将其替换为轻量级的框架协议。 结果是较小的二进制文件使用了较少的驻留内存，并且具有与GRPC相同的易用性。 请注意，尽管该项目支持生成协议的任一端，但是生成的服务定义将与常规GRPC服务不兼容，因为它们使用的协议不同。 用法 创建一个gogo虚荣二进制文件（有关启用了ttrpc插件的示例，请参阅 建议使用来为此项目构建protobuf，但是如果需要，可以直接与一起使用。 与GRPC
Kata Containers容器平台技术最新概述.pptx
10-11
Kata Containers容器平台技术最新概述.pptx
Kata Containers
summer_fish的专栏
07-31 499
综上所述，Kata Containers 提供了一种虚拟化容器的解决方案，可以提供更高的安全性和隔离性，同时保持与容器生态系统的兼容性。它适用于需要更强安全隔离或对性能有一定要求的场景。但也需要权衡资源消耗和启动时间等因素。
推荐文章：轻量级gRPC框架——ttrpc
最新发布
gitblog_00068的博客
05-21 289
推荐文章：轻量级gRPC框架——ttrpc 项目地址:https://gitcode.com/containerd/ttrpc 在低内存环境的开发中，传统gRPC库可能会带来较大的内存开销，这对于资源有限的设备或者高密度服务部署来说是一项挑战。现在，让我们一起来了解一个专为此场景设计的开源项目——ttrpc。 1、项目介绍 ttrpc(Tiny Tightrope RPC) 是一个针对低内存环境优...
【kubernetes/k8s源码分析】kata container agent create container 源码分析
zhonglinzhang
09-23 4009
1. CreateContainer 函数 接收到 GRPC 消息为 CreateContainerRequest 请求 func (a *agentGRPC) CreateContainer(ctx context.Context, req *pb.CreateContainerRequest) (resp *gpb.Empty, err error) { ...
kata-container初探
热门推荐
hdu_hanwei的专栏
09-04 2万+
概览 kata containers是由OpenStack基金会管理，但独立于OpenStack项目之外的容器项目。kata containers整合了Intel的 Clear Containers 和 Hyper.sh 的 runV，能够支持不同平台的硬件 （x86-64，arm等），并符合OCI(Open Container Initiative)规范，同时还可以兼容k8s的 CRI（Cont...
【云原生】安全容器 Kata Containers
include的博客
10-24 2380
出于对传统容器安全性的担忧，Intel 在 2015 年启动了它们以虚拟机为基础的容器技术：Clear Container。Clear Container 依赖 Intel VT 的硬件虚拟化技术以及高度定制的 QEMU-KVM（qemu-lite）来提供高性能的基于虚拟机的容器。在 2017 年，Clear container 项目加入了 Hyper RunV，这是一个基于 hypervisor 的 OCI 运行时，从而启动了 Kata 容器项目。
基于OpenShift的Kata Containers容器技术应用.pptx
10-11
2. **快速启动**：尽管使用了虚拟机，但Kata的启动时间仍然接近传统容器，这得益于其轻量级的虚拟化实现。 3. **性能接近原生**：虽然引入了虚拟化层，但Kata设计的目标是尽可能减少性能损失，使其对某些工作负载来...
Kata containers性能调优探索与实践.pptx
10-17
Kata Containers 性能调优探索与实践 在本文中，我们将探索 Kata Containers 的性能调优探索与实践，讨论其架构、网络模型、性能优化思路等方面的技术要点。 一、Kata Containers 概述 Kata Containers 是一个轻...
Kata Container是什么？
m0_37574389的博客
12-25 2337
KataContainer首页的几个大字写的是容器的速度，虚拟机的安全性。与Docker一样，都是容器，但相对与docker，Kata更安全、更好的性能 在2019年12月份，开源中国发布了一篇：以Docker为代表的传统容器到了生死存亡之际 在AWS的官方博客中描述了docker的安全隐患： 由于操作系统内核漏洞，docker 组件设计缺陷，以及不当的配置都会导致 dock......
Kata Containers用例
开源云中文社区
07-30 434
Kata Containers是OpenInfra基金会支持的开源容器运行时项目。来自AMD、蚂蚁集团、苹果、IBM和华为的Kata Containers社区成员分享他们如何运行Kata。...
kata container的基本使用示例
学亮编程手记
03-16 545
以上是一个简单的Kata Container使用示例。Kata Container还支持更多高级用法，如同时运行多个Kata容器、使用镜像等。您可以参考Kata Container官方文档，了解更多用法和功能。这将在Kata容器中运行ls命令，并显示文件列表。，安装最新版本的Kata Container。安装Kata Container。创建一个Kata容器。
干货｜认识kata-containers
中兴开发者社区
01-05 1万+
点击上方“中兴开发者社区”，关注我们每天读一篇一线开发者原创好文认识kata-containers 1、kata-containers是什么 2、在容器生态系统中的位置 3、包含的组件及其功能介绍 4、现状以及后续的计划 5、在Docker中的使用 本文主要让大家认识什么是kata-containers，它在容器生态系统中的位置，如何跟现有容 器系统进行集成。最后介绍如何在Docker中使用kat
3分钟，让你了解 OpenStack Kata Containers 项目
开源云中文社区
04-04 905
打造开源云计算中国第一互动社区内容专注于Linux、Kubernetes、OpenStack、容器、Ceph、Cloud Foundry......导读Linux 容器模型飞速发展，因为容器轻巧，快速且易于集成到许多不同的应用程序工作流程中。任何有关 Linux 容器的讨论总是会涉及容器技术和虚拟化之间的差异。现在，由OpenStack Foundation 管理的开源 Kata Containe
Kata Containers 高效的 Direct Block Volume 方案及 CSI | 技术解读
金融级分布式架构
03-05 127
背景介绍文件系统卷通常通过virtio-fs共享到虚拟机中。在典型的工作流程中，CSI Controller会确保后端存储（通常是块设备）已连接到节点。然后，CSI Node Driver会创建文件系统并将其挂载。如图所示：Virtio-fs Sharing但在虚拟化场景中，比较理想的操作是虚拟机应该直接使用块设备本身，而不是共享文件系统卷。并且直接使用块设备还能大大简化宿主机上的卷管理，并能获得...
OpenStack基金会支持的Kata Containers发布最新版本
开源云中文社区
12-14 487
这两天，Kata Containers社区聚集在KubeCon / CloudNativeCon 2018上，刚刚推出的最新版本标志着该项目成立一周年。Kata Cont...
docker study --- containerd
Max_Cong的博客
02-01 1013
containerd is a binary , it will run background when docker service starts. containerd -l unix:///var/run/docker/libcontainerd/docker-containerd.sock --shim containerd-shim --metrics-interval=0 --s
Kata Containers与gVisor：性能对比与技术解析
Kata Containers 的核心理念是在容器和主机操作系统之间添加一个虚拟化层，以提供更强的隔离性，同时保持容器的快速启动和轻量级特性。它支持 OCI（开放容器倡议）运行时规范，这意味着可以与 Docker、Kubernetes...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值