如何在 Kubernetes 中实现容器原地升级

pkg/kubelet/kubelet.go:1870
func (kl *Kubelet) syncLoopIteration(configCh <-chan kubetypes.PodUpdate, handler SyncHandler,    syncCh <-chan time.Time, housekeepingCh <-chan time.Time, plegCh <-chan *pleg.PodLifecycleEvent) bool {    select {    case u, open := <-configCh:        ...        switch u.Op {        ...        case kubetypes.UPDATE:            glog.V(2).Infof("SyncLoop (UPDATE, %q): %q", u.Source, format.PodsWithDeletionTimestamps(u.Pods))            handler.HandlePodUpdates(u.Pods)        ...    ...    }...}

pkg/kubelet/kuberuntime/kuberuntime_manager.go:451
// computePodActions checks whether the pod spec has changed and returns the changes if true.func (m *kubeGenericRuntimeManager) computePodActions(pod *v1.Pod, podStatus *kubecontainer.PodStatus) podActions {    glog.V(5).Infof("Syncing Pod %q: %+v", format.Pod(pod), pod)
    createPodSandbox, attempt, sandboxID := m.podSandboxChanged(pod, podStatus)    changes := podActions{        KillPod:           createPodSandbox,        CreateSandbox:     createPodSandbox,        SandboxID:         sandboxID,        Attempt:           attempt,        ContainersToStart: []int{},        ContainersToKill:  make(map[kubecontainer.ContainerID]containerToKillInfo),    }
    // If we need to (re-)create the pod sandbox, everything will need to be    // killed and recreated, and init containers should be purged.    if createPodSandbox {        if !shouldRestartOnFailure(pod) && attempt != 0 {            // Should not restart the pod, just return.            return changes        }        if len(pod.Spec.InitContainers) != 0 {            // Pod has init containers, return the first one.            changes.NextInitContainerToStart = &pod.Spec.InitContainers[0]            return changes        }        // Start all containers by default but exclude the ones that succeeded if        // RestartPolicy is OnFailure.        for idx, c := range pod.Spec.Containers {            if containerSucceeded(&c, podStatus) && pod.Spec.RestartPolicy == v1.RestartPolicyOnFailure {                continue            }            changes.ContainersToStart = append(changes.ContainersToStart, idx)        }        return changes    }    // Check initialization progress.    initLastStatus, next, done := findNextInitContainerToRun(pod, podStatus)    if !done {        if next != nil {            initFailed := initLastStatus != nil && isContainerFailed(initLastStatus)            if initFailed && !shouldRestartOnFailure(pod) {                changes.KillPod = true            } else {                changes.NextInitContainerToStart = next            }        }        // Initialization failed or still in progress. Skip inspecting non-init        // containers.        return changes    }
    // Number of running containers to keep.    keepCount := 0    // check the status of containers.    for idx, container := range pod.Spec.Containers {        containerStatus := podStatus.FindContainerStatusByName(container.Name)
        // Call internal container post-stop lifecycle hook for any non-running container so that any        // allocated cpus are released immediately. If the container is restarted, cpus will be re-allocated        // to it.        if containerStatus != nil && containerStatus.State != kubecontainer.ContainerStateRunning {            if err := m.internalLifecycle.PostStopContainer(containerStatus.ID.ID); err != nil {                glog.Errorf("internal container post-stop lifecycle hook failed for container %v in pod %v with error %v",                    container.Name, pod.Name, err)            }        }        // If container does not exist, or is not running, check whether we        // need to restart it.        if containerStatus == nil || containerStatus.State != kubecontainer.ContainerStateRunning {            if kubecontainer.ShouldContainerBeRestarted(&container, pod, podStatus) {                message := fmt.Sprintf("Container %+v is dead, but RestartPolicy says that we should restart it.", container)                glog.V(3).Infof(message)                changes.ContainersToStart = append(changes.ContainersToStart, idx)            }            continue        }        // The container is running, but kill the container if any of the following condition is met.        reason := ""        restart := shouldRestartOnFailure(pod)        if expectedHash, actualHash, changed := containerChanged(&container, containerStatus); changed {            reason = fmt.Sprintf("Container spec hash changed (%d vs %d).", actualHash, expectedHash)            // Restart regardless of the restart policy because the container            // spec changed.            restart = true        } else if liveness, found := m.livenessManager.Get(containerStatus.ID); found && liveness == proberesults.Failure {            // If the container failed the liveness probe, we should kill it.            reason = "Container failed liveness probe."        } else {            // Keep the container.            keepCount += 1            continue        }        // We need to kill the container, but if we also want to restart the        // container afterwards, make the intent clear in the message. Also do        // not kill the entire pod since we expect container to be running eventually.        message := reason        if restart {            message = fmt.Sprintf("%s. Container will be killed and recreated.", message)            changes.ContainersToStart = append(changes.ContainersToStart, idx)        }        changes.ContainersToKill[containerStatus.ID] = containerToKillInfo{            name:      containerStatus.Name,            container: &pod.Spec.Containers[idx],            message:   message,        }        glog.V(2).Infof("Container %q (%q) of pod %s: %s", container.Name, containerStatus.ID, format.Pod(pod), message)    }    if keepCount == 0 && len(changes.ContainersToStart) == 0 {        changes.KillPod = true    }    return changes}

pkg/kubelet/kuberuntime/kuberuntime_manager.go:369
// podActions keeps information what to do for a pod.type podActions struct {    // Stop all running (regular and init) containers and the sandbox for the pod.    KillPod bool    // Whether need to create a new sandbox. If needed to kill pod and create a    // a new pod sandbox, all init containers need to be purged (i.e., removed).    CreateSandbox bool    // The id of existing sandbox. It is used for starting containers in ContainersToStart.    SandboxID string    // The attempt number of creating sandboxes for the pod.    Attempt uint32
    // The next init container to start.    NextInitContainerToStart *v1.Container    // ContainersToStart keeps a list of indexes for the containers to start,    // where the index is the index of the specific container in the pod spec (    // pod.Spec.Containers.    ContainersToStart []int    // ContainersToKill keeps a map of containers that need to be killed, note that    // the key is the container ID of the container, while    // the value contains necessary information to kill a container.    ContainersToKill map[kubecontainer.ContainerID]containerToKillInfo}

func (m *kubeGenericRuntimeManager) SyncPod(pod *v1.Pod, _ v1.PodStatus, podStatus *kubecontainer.PodStatus, pullSecrets []v1.Secret, backOff *flowcontrol.Backoff) (result kubecontainer.PodSyncResult) {    // Step 1: Compute sandbox and container changes.    podContainerChanges := m.computePodActions(pod, podStatus)    ...    // Step 2: Kill the pod if the sandbox has changed.    if podContainerChanges.KillPod {        ...    } else {        // Step 3: kill any running containers in this pod which are not to keep.        for containerID, containerInfo := range podContainerChanges.ContainersToKill {            glog.V(3).Infof("Killing unwanted container %q(id=%q) for pod %q", containerInfo.name, containerID, format.Pod(pod))            killContainerResult := kubecontainer.NewSyncResult(kubecontainer.KillContainer, containerInfo.name)            result.AddSyncResult(killContainerResult)            if err := m.killContainer(pod, containerID, containerInfo.name, containerInfo.message, nil); err != nil {                killContainerResult.Fail(kubecontainer.ErrKillContainer, err.Error())                glog.Errorf("killContainer %q(id=%q) for pod %q failed: %v", containerInfo.name, containerID, format.Pod(pod), err)                return            }        }    }    ...    // Step 4: Create a sandbox for the pod if necessary.    podSandboxID := podContainerChanges.SandboxID    if podContainerChanges.CreateSandbox {        ...    }    ...    // Step 5: start the init container.    if container := podContainerChanges.NextInitContainerToStart; container != nil {    ...            }    // Step 6: start containers in podContainerChanges.ContainersToStart.    for _, idx := range podContainerChanges.ContainersToStart {        container := &pod.Spec.Containers[idx]        startContainerResult := kubecontainer.NewSyncResult(kubecontainer.StartContainer, container.Name)        result.AddSyncResult(startContainerResult)        isInBackOff, msg, err := m.doBackOff(pod, container, podStatus, backOff)        if isInBackOff {            startContainerResult.Fail(err, msg)            glog.V(4).Infof("Backing Off restarting container %+v in pod %v", container, format.Pod(pod))            continue        }        glog.V(4).Infof("Creating container %+v in pod %v", container, format.Pod(pod))        if msg, err := m.startContainer(podSandboxID, podSandboxConfig, container, pod, podStatus, pullSecrets, podIP, kubecontainer.ContainerTypeRegular); err != nil {            startContainerResult.Fail(err, msg)            // known errors that are logged in other places are logged at higher levels here to avoid            // repetitive log spam            switch {            case err == images.ErrImagePullBackOff:                glog.V(3).Infof("container start failed: %v: %s", err, msg)            default:                utilruntime.HandleError(fmt.Errorf("container start failed: %v: %s", err, msg))            }            continue        }    }    return}

  kubelet[1121]: I0412 16:34:28.356083    1121 kubelet.go:1868] SyncLoop (UPDATE, "api"): "web-2_default(2813f459-59cc-11e9-a1f7-525400e7b58a)"  kubelet[1121]: I0412 16:34:28.657836    1121 kuberuntime_manager.go:549] Container "nginx" ({"docker" "8d16517eb4b7b5b84755434eb25c7ab83667bca44318cbbcd89cf8abd232973f"}) of pod web-2_default(2813f459-59cc-11e9-a1f7-525400e7b58a): Container spec hash changed (3176550502 vs 1676109989).. Container will be killed and recreated.  kubelet[1121]: I0412 16:34:28.658529    1121 kuberuntime_container.go:548] Killing container "docker://8d16517eb4b7b5b84755434eb25c7ab83667bca44318cbbcd89cf8abd232973f" with 10 second grace period  kubelet[1121]: I0412 16:34:28.814944    1121 kuberuntime_manager.go:757] checking backoff for container "nginx" in pod "web-2_default(2813f459-59cc-11e9-a1f7-525400e7b58a)"  kubelet[1121]: I0412 16:34:29.179953    1121 kubelet.go:1906] SyncLoop (PLEG): "web-2_default(2813f459-59cc-11e9-a1f7-525400e7b58a)", event: &pleg.PodLifecycleEvent{ID:"2813f459-59cc-11e9-a1f7-525400e7b58a", Type:"ContainerDied", Data:"8d16517eb4b7b5b84755434eb25c7ab83667bca44318cbbcd89cf8abd232973f"}  kubelet[1121]: I0412 16:34:29.182257    1121 kubelet.go:1906] SyncLoop (PLEG): "web-2_default(2813f459-59cc-11e9-a1f7-525400e7b58a)", event: &pleg.PodLifecycleEvent{ID:"2813f459-59cc-11e9-a1f7-525400e7b58a", Type:"ContainerStarted", Data:"52e30b1aa621a20ae2eae5accf98c451c1be3aed781609d5635a79e48eb98222"}