แฒจแแแแจแแแ. แแแ แแแแ: แกแขแแขแแแก แแแขแแ แ - แแ แแแ แแ แแแ, แแแแแแแ แ SAP-แแแ - แแแแแ แแแก แแแแแก แแแแแแแก แแฃแแแแก แคแฃแแฅแชแแแแแ แแแแก แแแฅแแแแแแแแแก แจแแกแแฎแแ. kubectl exec, แแกแ แแแชแแแแแ แงแแแแแกแแแแก, แแแแช แแฃแจแแแแก Kubernetes-แแแ. แแก แแแแ แแแแแ แแแแก แแฎแแแแก Kubernetes-แแก แฌแงแแ แแก แแแแแก (แแ แแแกแแแ แแแแแแจแแ แแแฃแแ แแ แแแฅแขแแแแก) แฉแแแแแแแแแแก, แ แแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแ แแแแ แ แแช แจแแแซแแแแ แฆแ แแแ.
แแ แ แแแ แแกแแแแก, แแแแแแ แแแแแแฎแแแแแ แแ แแแแแฎแ, แ แแแแ แจแแแแกแ แฃแแแแแแ แแ แซแแแแแ แแแแจแ . แแแ แแฃแแแกแฃแฎแ แแ แฃแชแแ แแแแฎแแแ, แ แแ แแฃแจแแแแแก แแแฅแแแแแแแก แจแแกแแฎแแ แแ แแคแแ แ แแแชแแแ kubectl exec. แแแแฎ, แแ แแฅแแแแ แแแ แแแแฃแแ แแแแแแ แแแก แแแฌแงแแแแแแแแแ, แแแแ แแ แแ แแ แแแงแแแ 100% แแแ แฌแแฃแแแแฃแแ แแแ แกแแกแฌแแ แแจแ แแ แแแแขแแ แแแแแแฌแงแแแขแ แแ แกแแแแแฎแแก แแแแแแ แแแ. แแแแแแแแก, แแแแฃแแแแขแแชแแแกแ แแ แฌแงแแ แแก แแแแแก แจแแกแฌแแแแแก แจแแแแแ, แแแแ แ แ แแ แแแกแฌแแแแ แแ แแ แกแขแแขแแแจแ แแแแแ แแแแแแแแ แแ แฉแแแ แแฆแแแฉแแแแแ แแ แแแแแแ. แแฃ แ แแแ แแ แแกแฌแแ แแ, แแแฎแแแ แแแแแแแแจแแ แแแ แแแแแ แแ .
แกแแกแฌแแแแ
MacBook-แแ แแแแกแขแแ แแก แจแแกแแฅแแแแแแ, แแ แแแแแแ แแแ แแแแแฎแแแแ . แจแแแแแ แแแแแกแฌแแ แ แแแแแซแแแแก IP แแแกแแแแ แแแแ kubelet'a แแแแคแแแฃแ แแชแแแจแ, แ แแแแแ แแแแฃแแแกแฎแแแแ แแแ แแแแขแ แแแ แแ แแซแแแแแ แกแแจแฃแแแแแแก. kubectl exec. แแแแก แแแแแแ แ แแแแแแแก แจแแกแแฎแแ แแแขแ แจแแแแซแแแแ แฌแแแแแแฎแแ .
- แแแแแกแแแแ แ แแแแฅแแแ = แฉแแแ MacBook
- แซแแ แแแแแ แแแแแซแ IP = 192.168.205.10
- IP แแฃแจแ แแแแแซแ = 192.168.205.11
- API แกแแ แแแ แแก แแแ แขแ = 6443
แแแแแแแแแขแแแ
- kubectl exec แแ แแชแแกแ: แ แแแแกแแช แแแแแแแแ "kubectl exec..." แแ แแชแแกแ แแฌแงแแแ. แแแแก แแแแแแแแ แจแแแแซแแแแ แแแแแกแแแแ แแแแฅแแแแแ K8s API แกแแ แแแ แแ แฌแแแแแแ. แฒจแแแแจแแแ. แแแ แแแแแ: แแแ แแ แแแแกแ, แแแแกแแแแก แฉแแแแแแแแแแจแ, แแแขแแ แ แแงแแแแแก แแแแแแขแแ แก "แแแแแกแแแแ แ แแแแฅแแแ", แ แแช แแฃแแแกแฎแแแแก, แ แแ แจแแแแแแ แแ แซแแแแแแแ แจแแแซแแแแ แจแแกแ แฃแแแแก แแแแแกแแแแ แแกแแ แแแแ แแขแแ, แ แแแแแกแแช แแฅแแก แฌแแแแแ Kubernetes-แแ.
- : แแแแแแแแแขแ แแแแแแ แแแแแซแแ, แ แแแแแแช แฃแแ แฃแแแแแงแแคแก แฌแแแแแแก Kubernetes API-แแ. แแก แแ แแก แกแแแแแขแ แแแ แแแแแแคแ แแแแแแก แฌแแแ แแแแ แแฃแแแ แแแขแแกแจแ.
- : แแแแแขแ, แ แแแแแแช แแฃแจแแแแก แแแแกแขแแ แแก แงแแแแ แแแแแซแแ. แแก แฃแแ แฃแแแแแงแแคแก แแแแขแแแแแ แแแแก แแฃแจแแแแแก แแแแจแ.
- (แแแแขแแแแแ แแก แแแจแแแแแก แแ แ): แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ, แ แแแแแแช แแแกแฃแฎแแกแแแแแแแแ แแแแขแแแแแ แแแแก แแแจแแแแแแ. แแแแแแแแแแ: Docker, CRI-O, แแแแขแแแแแ แโฆ
- kernel: OS แแแ แแแ แแฃแจแ แแแแแซแแ; แแแกแฃแฎแแกแแแแแแแแ แแ แแชแแกแแก แแแ แแแแแ.
- แกแแแแแแ (แกแแแแแแ) แแแแขแแแแแ แ: แแแแขแแแแแ แ, แ แแแแแแช แแ แแก pod-แแก แแแฌแแแ แแ แแฃแจแแแแก แแ แ-แแ แ แแฃแจแ แแแแแซแแ.
แ แ แแฆแแแแแฉแแแ
1. แแฅแขแแแแแ แแแแแแขแแก แแฎแแ แแก
แจแแฅแแแแแ แแแแ แกแแฎแแแแ แกแแแ แชแแจแ default:
// any machine
$ kubectl run exec-test-nginx --image=nginxแจแแแแแ แฉแแแ แแแกแ แฃแแแแ exec แแ แซแแแแแแก แแ แแแแแแแแแ 5000 แฌแแแก แจแแแแแแแ แแแแแแ แแแแแกแแแแก:
// any machine
$ kubectl exec -it exec-test-nginx-6558988d5-fgxgg -- sh
# sleep 5000แฉแแแแแ kubectl แแ แแชแแกแ (แฉแแแแก แจแแแแฎแแแแแจแ pid=8507):
// any machine
$ ps -ef |grep kubectl
501 8507 8409 0 7:19PM ttys000 0:00.13 kubectl exec -it exec-test-nginx-6558988d5-fgxgg -- shแแฃ แจแแแแแแฌแแแแ แแ แแชแแกแแก แฅแกแแแฃแ แแฅแขแแแแแแก, แแฆแแแแแฉแแแ, แ แแ แแแก แแฅแแก แแแแจแแ แแแ api-แกแแ แแแ แแแ (192.168.205.10.6443):
// any machine
$ netstat -atnv |grep 8507
tcp4 0 0 192.168.205.1.51673 192.168.205.10.6443 ESTABLISHED 131072 131768 8507 0 0x0102 0x00000020
tcp4 0 0 192.168.205.1.51672 192.168.205.10.6443 ESTABLISHED 131072 131768 8507 0 0x0102 0x00000028แแแแแ แจแแแฎแแแแ แแแแก. Kubectl แฅแแแแก POST แแแแฎแแแแแก exec แฅแแแ แแกแฃแ แกแแ แแ แแแแแแแแก REST แแแแฎแแแแแก:
req := restClient.Post().
Resource("pods").
Name(pod.Name).
Namespace(pod.Namespace).
SubResource("exec")
req.VersionedParams(&corev1.PodExecOptions{
Container: containerName,
Command: p.Command,
Stdin: p.Stdin,
Stdout: p.Out != nil,
Stderr: p.ErrOut != nil,
TTY: t.Raw,
}, scheme.ParameterCodec)
return p.Executor.Execute("POST", req.URL(), p.Config, p.In, p.Out, p.ErrOut, t.Raw, sizeQueue)()
2. แแฅแขแแแแแ แกแแแแแแกแขแ แ แแแแแซแแก แแฎแแ แแก
แฉแแแ แแกแแแ แจแแแแแซแแแ แแแแแแแแ แแแ แแแแฎแแแแแก api-แกแแ แแแ แแก แแฎแแ แแก:
handler.go:143] kube-apiserver: POST "/api/v1/namespaces/default/pods/exec-test-nginx-6558988d5-fgxgg/exec" satisfied by gorestful with webservice /api/v1
upgradeaware.go:261] Connecting to backend proxy (intercepting redirects) https://192.168.205.11:10250/exec/default/exec-test-nginx-6558988d5-fgxgg/exec-test-nginx?command=sh&input=1&output=1&tty=1
Headers: map[Connection:[Upgrade] Content-Length:[0] Upgrade:[SPDY/3.1] User-Agent:[kubectl/v1.12.10 (darwin/amd64) kubernetes/e3c1340] X-Forwarded-For:[192.168.205.1] X-Stream-Protocol-Version:[v4.channel.k8s.io v3.channel.k8s.io v2.channel.k8s.io channel.k8s.io]]แแแแแแแแแกแฌแแแแ, แ แแ HTTP แแแแฎแแแแ แจแแแชแแแก แแ แแขแแแแแแก แชแแแแแแแแก แแแแฎแแแแแก. แกแแจแฃแแแแแแก แแซแแแแก stdin/stdout/stderr/spdy-error-แแก แชแแแแแฃแแ "แแแแแแแแแก" แแฃแแขแแแแแฅแกแแ แแแแก แแ แ TCP แแแแจแแ แแ.
API แกแแ แแแ แ แแฆแแแก แแแแฎแแแแแก แแ แแแ แแแฅแแแแก แแแก PodExecOptions:
// PodExecOptions is the query options to a Pod's remote exec call
type PodExecOptions struct {
metav1.TypeMeta
// Stdin if true indicates that stdin is to be redirected for the exec call
Stdin bool
// Stdout if true indicates that stdout is to be redirected for the exec call
Stdout bool
// Stderr if true indicates that stderr is to be redirected for the exec call
Stderr bool
// TTY if true indicates that a tty will be allocated for the exec call
TTY bool
// Container in which to execute the command.
Container string
// Command is the remote command to execute; argv array; not executed within a shell.
Command []string
}()
แกแแญแแ แ แแแฅแแแแแแแแแก แจแแกแแกแ แฃแแแแแแ, api-แกแแ แแแ แแ แฃแแแ แแชแแแแก แ แแแแ แแแแก แฃแแแ แแแฃแแแแจแแ แแแก:
// ExecLocation returns the exec URL for a pod container. If opts.Container is blank
// and only one container is present in the pod, that container is used.
func ExecLocation(
getter ResourceGetter,
connInfo client.ConnectionInfoGetter,
ctx context.Context,
name string,
opts *api.PodExecOptions,
) (*url.URL, http.RoundTripper, error) {
return streamLocation(getter, connInfo, ctx, name, opts, opts.Container, "exec")
}()
แ แ แแฅแแ แฃแแแ, แกแแแแแแ แฌแแ แขแแแแก แจแแกแแฎแแ แแแแแชแแแแแ แแฆแแแฃแแแ แแแแแซแแก แจแแกแแฎแแ แแแคแแ แแแชแแแกแแแ:
nodeName := types.NodeName(pod.Spec.NodeName)
if len(nodeName) == 0 {
// If pod has not been assigned a host, return an empty location
return nil, nil, errors.NewBadRequest(fmt.Sprintf("pod %s does not have a host assigned", name))
}
nodeInfo, err := connInfo.GetConnectionInfo(ctx, nodeName)()
แฐแแ! แแฃแแแแแขแก แแฎแแ แแฅแแก แแแ แขแ (node.Status.DaemonEndpoints.KubeletEndpoint.Port) แ แแแแแแแแแช API แกแแ แแแ แก แจแแฃแซแแแ แแแแแแจแแ แแแ:
// GetConnectionInfo retrieves connection info from the status of a Node API object.
func (k *NodeConnectionInfoGetter) GetConnectionInfo(ctx context.Context, nodeName types.NodeName) (*ConnectionInfo, error) {
node, err := k.nodes.Get(ctx, string(nodeName), metav1.GetOptions{})
if err != nil {
return nil, err
}
// Find a kubelet-reported address, using preferred address type
host, err := nodeutil.GetPreferredNodeAddress(node, k.preferredAddressTypes)
if err != nil {
return nil, err
}
// Use the kubelet-reported port, if present
port := int(node.Status.DaemonEndpoints.KubeletEndpoint.Port)
if port <= 0 {
port = k.defaultPort
}
return &ConnectionInfo{
Scheme: k.scheme,
Hostname: host,
Port: strconv.Itoa(port),
Transport: k.transport,
}, nil
}()
แแแแฃแแแแขแแชแแแแแ :
แแก แแแแจแแ แแแ แฌแงแแแแ kubelet-แแก HTTPS แแแแ แฌแแ แขแแแจแ. แแแแฃแแแกแฎแแแแแ, apiserver แแ แแแแฌแแแแก kubelet-แแก แกแแ แแแคแแแแขแก, แ แแช แแแแจแแ แก แแแฃแชแแแแก แฎแแแก "แแแแแแแแแก แจแฃแแแฃแแจแ แจแแขแแแแแแก" (MITM) แแ แกแแฎแแคแแแ แแ แแกแแแแ แแ/แแ แกแแฏแแ แ แฅแกแแแแแจแ แแฃแจแแแแ.
แแฎแแ API แกแแ แแแ แแ แแชแแก แกแแแแแแ แฌแแ แขแแแ แแ แแแงแแ แแแก แแแแจแแ แก:
// Connect returns a handler for the pod exec proxy
func (r *ExecREST) Connect(ctx context.Context, name string, opts runtime.Object, responder rest.Responder) (http.Handler, error) {
execOpts, ok := opts.(*api.PodExecOptions)
if !ok {
return nil, fmt.Errorf("invalid options object: %#v", opts)
}
location, transport, err := pod.ExecLocation(r.Store, r.KubeletConn, ctx, name, execOpts)
if err != nil {
return nil, err
}
return newThrottledUpgradeAwareProxyHandler(location, transport, false, true, true, responder), nil
}()
แแแแฎแแ, แ แ แฎแแแแ แแแแแแ แแแแแซแแ.
แแแ แแแแ, แแแแ แแแแแ แกแแแฃแจแแ แแแแแซแแก IP. แฉแแแแก แจแแแแฎแแแแแจแ, แแก แแ แแก 192.168.205.11:
// any machine
$ kubectl get nodes k8s-node-1 -o wide
NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-IP OS-IMAGE KERNEL-VERSION CONTAINER-RUNTIME
k8s-node-1 Ready <none> 9h v1.15.3 192.168.205.11 <none> Ubuntu 16.04.6 LTS 4.4.0-159-generic docker://17.3.3แจแแแแแ แแแแงแแแแ แแฃแแแแแขแแก แแแ แขแ (แฉแแแแก แจแแแแฎแแแแแจแ 10250):
// any machine
$ kubectl get nodes k8s-node-1 -o jsonpath='{.status.daemonEndpoints.kubeletEndpoint}'
map[Port:10250]
แแฎแแ แแ แแ แจแแแแแฌแแแ แฅแกแแแ. แแ แแก แแฃ แแ แ แแแแจแแ แ แแฃแจแ แแแแแซแแแ (192.168.205.11)? แฒแก แแ แแก! แแฃ โแแแแแแโ แแ แแชแแกแก exec, แแแฅแ แแแ, แแแแขแแ แแแชแ, แ แแ แแแแจแแ แ แแแแงแแ แแ api-แกแแ แแแ แแก แแแแ แจแแกแ แฃแแแแฃแแ exec แแ แซแแแแแแก แจแแแแแแ.
// master node
$ netstat -atn |grep 192.168.205.11
tcp 0 0 192.168.205.10:37870 192.168.205.11:10250 ESTABLISHED
โฆ
แแแแจแแ แ kubectl-แกแ แแ api-แกแแ แแแ แก แจแแ แแก แฏแแ แแแแแ แฆแแแ. แแแ แแ แแแแกแ, แแ แกแแแแแก แแแแแ แแ แแ แแแแจแแ แ, แ แแแแแแช แแแแแจแแ แแแก api-แกแแ แแแ แกแ แแ แแฃแแแแแขแก.
3. แแฅแขแแแแแ แแฃแจแ แแแแแซแแ
แแฎแแ แแแแแ แแแแฃแแแแจแแ แแแ แแฃแจแ แแแแแซแก แแ แแแแฎแแ แ แ แฎแแแแ แแแกแแ.
แฃแแแ แแแแแก แงแแแแแกแ, แแฎแแแแแ, แ แแ แแแกแแแ แแแแจแแ แแช แแงแแ แแแแ (แแแแ แ แฎแแแ); 192.168.205.10 แแ แแก แแแแแแ แ แแแแแซแแก IP:
// worker node
$ netstat -atn |grep 10250
tcp6 0 0 :::10250 :::* LISTEN
tcp6 0 0 192.168.205.11:10250 192.168.205.10:37870 ESTABLISHED
แ แแช แจแแแฎแแแ แฉแแแแก แแฃแแแก sleep? แฐแแ แ, แแกแแช แแฅ แแ แแก!
// worker node
$ ps -afx
...
31463 ? Sl 0:00 _ docker-containerd-shim 7d974065bbb3107074ce31c51f5ef40aea8dcd535ae11a7b8f2dd180b8ed583a /var/run/docker/libcontainerd/7d974065bbb3107074ce31c51
31478 pts/0 Ss 0:00 _ sh
31485 pts/0 S+ 0:00 _ sleep 5000
โฆแแแแ แแ แแแแชแแแแ, แ แแแแ แแแแฎแแ แฎแ แแฃแแแแแขแแ แแก? Kubelet-แก แแฅแแก แแแแแแ, แ แแแแแแช แฎแกแแแก แฌแแแแแแก API-แแ แแแ แขแแก แแแจแแแแแแ api-แกแแ แแแ แแก แแแแฎแแแแแแแกแแแแก:
// Server is the library interface to serve the stream requests.
type Server interface {
http.Handler
// Get the serving URL for the requests.
// Requests must not be nil. Responses may be nil iff an error is returned.
GetExec(*runtimeapi.ExecRequest) (*runtimeapi.ExecResponse, error)
GetAttach(req *runtimeapi.AttachRequest) (*runtimeapi.AttachResponse, error)
GetPortForward(*runtimeapi.PortForwardRequest) (*runtimeapi.PortForwardResponse, error)
// Start the server.
// addr is the address to serve on (address:port) stayUp indicates whether the server should
// listen until Stop() is called, or automatically stop after all expected connections are
// closed. Calling Get{Exec,Attach,PortForward} increments the expected connection count.
// Function does not return until the server is stopped.
Start(stayUp bool) error
// Stop the server, and terminate any open connections.
Stop() error
}()
Kubelet แแแแแแก แแแกแฃแฎแแก แกแแแแแแ แฌแแ แขแแแก exec แแแแฎแแแแแแแกแแแแก:
func (s *server) GetExec(req *runtimeapi.ExecRequest) (*runtimeapi.ExecResponse, error) {
if err := validateExecRequest(req); err != nil {
return nil, err
}
token, err := s.cache.Insert(req)
if err != nil {
return nil, err
}
return &runtimeapi.ExecResponse{
Url: s.buildURL("exec", token),
}, nil
}()
แแฃ แแแแแแ. แแก แแ แแแ แฃแแแแก แแ แซแแแแแแก แจแแแแแก, แแ แแแแ แแแแจแแ แแก แแแแ แฌแแ แขแแแก:
type ExecResponse struct {
// Fully qualified URL of the exec streaming server.
Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_sizecache int32 `json:"-"`
}()
Kubelet แแฎแแ แชแแแแแแก แแแขแแ แคแแแกแก RuntimeServiceClient, แ แแแแแแช Container Runtime Interface-แแก แแแฌแแแแ (แแแแแ แแแขแ แแแแฌแแ แแ, แแแแแแแแแ, - แแแแฎแ. แแแ แแแแแ.):
แแ แซแแแ แกแแ cri-api-แแแ kubernetes/kubernetes-แจแ
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RuntimeServiceClient interface {
// Version returns the runtime name, runtime version, and runtime API version.
Version(ctx context.Context, in *VersionRequest, opts ...grpc.CallOption) (*VersionResponse, error)
// RunPodSandbox creates and starts a pod-level sandbox. Runtimes must ensure
// the sandbox is in the ready state on success.
RunPodSandbox(ctx context.Context, in *RunPodSandboxRequest, opts ...grpc.CallOption) (*RunPodSandboxResponse, error)
// StopPodSandbox stops any running process that is part of the sandbox and
// reclaims network resources (e.g., IP addresses) allocated to the sandbox.
// If there are any running containers in the sandbox, they must be forcibly
// terminated.
// This call is idempotent, and must not return an error if all relevant
// resources have already been reclaimed. kubelet will call StopPodSandbox
// at least once before calling RemovePodSandbox. It will also attempt to
// reclaim resources eagerly, as soon as a sandbox is not needed. Hence,
// multiple StopPodSandbox calls are expected.
StopPodSandbox(ctx context.Context, in *StopPodSandboxRequest, opts ...grpc.CallOption) (*StopPodSandboxResponse, error)
// RemovePodSandbox removes the sandbox. If there are any running containers
// in the sandbox, they must be forcibly terminated and removed.
// This call is idempotent, and must not return an error if the sandbox has
// already been removed.
RemovePodSandbox(ctx context.Context, in *RemovePodSandboxRequest, opts ...grpc.CallOption) (*RemovePodSandboxResponse, error)
// PodSandboxStatus returns the status of the PodSandbox. If the PodSandbox is not
// present, returns an error.
PodSandboxStatus(ctx context.Context, in *PodSandboxStatusRequest, opts ...grpc.CallOption) (*PodSandboxStatusResponse, error)
// ListPodSandbox returns a list of PodSandboxes.
ListPodSandbox(ctx context.Context, in *ListPodSandboxRequest, opts ...grpc.CallOption) (*ListPodSandboxResponse, error)
// CreateContainer creates a new container in specified PodSandbox
CreateContainer(ctx context.Context, in *CreateContainerRequest, opts ...grpc.CallOption) (*CreateContainerResponse, error)
// StartContainer starts the container.
StartContainer(ctx context.Context, in *StartContainerRequest, opts ...grpc.CallOption) (*StartContainerResponse, error)
// StopContainer stops a running container with a grace period (i.e., timeout).
// This call is idempotent, and must not return an error if the container has
// already been stopped.
// TODO: what must the runtime do after the grace period is reached?
StopContainer(ctx context.Context, in *StopContainerRequest, opts ...grpc.CallOption) (*StopContainerResponse, error)
// RemoveContainer removes the container. If the container is running, the
// container must be forcibly removed.
// This call is idempotent, and must not return an error if the container has
// already been removed.
RemoveContainer(ctx context.Context, in *RemoveContainerRequest, opts ...grpc.CallOption) (*RemoveContainerResponse, error)
// ListContainers lists all containers by filters.
ListContainers(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (*ListContainersResponse, error)
// ContainerStatus returns status of the container. If the container is not
// present, returns an error.
ContainerStatus(ctx context.Context, in *ContainerStatusRequest, opts ...grpc.CallOption) (*ContainerStatusResponse, error)
// UpdateContainerResources updates ContainerConfig of the container.
UpdateContainerResources(ctx context.Context, in *UpdateContainerResourcesRequest, opts ...grpc.CallOption) (*UpdateContainerResourcesResponse, error)
// ReopenContainerLog asks runtime to reopen the stdout/stderr log file
// for the container. This is often called after the log file has been
// rotated. If the container is not running, container runtime can choose
// to either create a new log file and return nil, or return an error.
// Once it returns error, new container log file MUST NOT be created.
ReopenContainerLog(ctx context.Context, in *ReopenContainerLogRequest, opts ...grpc.CallOption) (*ReopenContainerLogResponse, error)
// ExecSync runs a command in a container synchronously.
ExecSync(ctx context.Context, in *ExecSyncRequest, opts ...grpc.CallOption) (*ExecSyncResponse, error)
// Exec prepares a streaming endpoint to execute a command in the container.
Exec(ctx context.Context, in *ExecRequest, opts ...grpc.CallOption) (*ExecResponse, error)
// Attach prepares a streaming endpoint to attach to a running container.
Attach(ctx context.Context, in *AttachRequest, opts ...grpc.CallOption) (*AttachResponse, error)
// PortForward prepares a streaming endpoint to forward ports from a PodSandbox.
PortForward(ctx context.Context, in *PortForwardRequest, opts ...grpc.CallOption) (*PortForwardResponse, error)
// ContainerStats returns stats of the container. If the container does not
// exist, the call returns an error.
ContainerStats(ctx context.Context, in *ContainerStatsRequest, opts ...grpc.CallOption) (*ContainerStatsResponse, error)
// ListContainerStats returns stats of all running containers.
ListContainerStats(ctx context.Context, in *ListContainerStatsRequest, opts ...grpc.CallOption) (*ListContainerStatsResponse, error)
// UpdateRuntimeConfig updates the runtime configuration based on the given request.
UpdateRuntimeConfig(ctx context.Context, in *UpdateRuntimeConfigRequest, opts ...grpc.CallOption) (*UpdateRuntimeConfigResponse, error)
// Status returns the status of the runtime.
Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error)
}
()
แแก แฃแแ แแแแ แแงแแแแแก gRPC แแแแแแแก แแแแแกแแซแแฎแแแแแ Container Runtime Interface-แแก แแแจแแแแแแ:
type runtimeServiceClient struct {
cc *grpc.ClientConn
}()
func (c *runtimeServiceClient) Exec(ctx context.Context, in *ExecRequest, opts ...grpc.CallOption) (*ExecResponse, error) {
out := new(ExecResponse)
err := c.cc.Invoke(ctx, "/runtime.v1alpha2.RuntimeService/Exec", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}()
Container Runtime แแแกแฃแฎแแกแแแแแแแแ แแแแฎแแ แชแแแแแแแแ RuntimeServiceServer:
แแ แซแแแ แกแแ cri-api-แแแ kubernetes/kubernetes-แจแ
// RuntimeServiceServer is the server API for RuntimeService service.
type RuntimeServiceServer interface {
// Version returns the runtime name, runtime version, and runtime API version.
Version(context.Context, *VersionRequest) (*VersionResponse, error)
// RunPodSandbox creates and starts a pod-level sandbox. Runtimes must ensure
// the sandbox is in the ready state on success.
RunPodSandbox(context.Context, *RunPodSandboxRequest) (*RunPodSandboxResponse, error)
// StopPodSandbox stops any running process that is part of the sandbox and
// reclaims network resources (e.g., IP addresses) allocated to the sandbox.
// If there are any running containers in the sandbox, they must be forcibly
// terminated.
// This call is idempotent, and must not return an error if all relevant
// resources have already been reclaimed. kubelet will call StopPodSandbox
// at least once before calling RemovePodSandbox. It will also attempt to
// reclaim resources eagerly, as soon as a sandbox is not needed. Hence,
// multiple StopPodSandbox calls are expected.
StopPodSandbox(context.Context, *StopPodSandboxRequest) (*StopPodSandboxResponse, error)
// RemovePodSandbox removes the sandbox. If there are any running containers
// in the sandbox, they must be forcibly terminated and removed.
// This call is idempotent, and must not return an error if the sandbox has
// already been removed.
RemovePodSandbox(context.Context, *RemovePodSandboxRequest) (*RemovePodSandboxResponse, error)
// PodSandboxStatus returns the status of the PodSandbox. If the PodSandbox is not
// present, returns an error.
PodSandboxStatus(context.Context, *PodSandboxStatusRequest) (*PodSandboxStatusResponse, error)
// ListPodSandbox returns a list of PodSandboxes.
ListPodSandbox(context.Context, *ListPodSandboxRequest) (*ListPodSandboxResponse, error)
// CreateContainer creates a new container in specified PodSandbox
CreateContainer(context.Context, *CreateContainerRequest) (*CreateContainerResponse, error)
// StartContainer starts the container.
StartContainer(context.Context, *StartContainerRequest) (*StartContainerResponse, error)
// StopContainer stops a running container with a grace period (i.e., timeout).
// This call is idempotent, and must not return an error if the container has
// already been stopped.
// TODO: what must the runtime do after the grace period is reached?
StopContainer(context.Context, *StopContainerRequest) (*StopContainerResponse, error)
// RemoveContainer removes the container. If the container is running, the
// container must be forcibly removed.
// This call is idempotent, and must not return an error if the container has
// already been removed.
RemoveContainer(context.Context, *RemoveContainerRequest) (*RemoveContainerResponse, error)
// ListContainers lists all containers by filters.
ListContainers(context.Context, *ListContainersRequest) (*ListContainersResponse, error)
// ContainerStatus returns status of the container. If the container is not
// present, returns an error.
ContainerStatus(context.Context, *ContainerStatusRequest) (*ContainerStatusResponse, error)
// UpdateContainerResources updates ContainerConfig of the container.
UpdateContainerResources(context.Context, *UpdateContainerResourcesRequest) (*UpdateContainerResourcesResponse, error)
// ReopenContainerLog asks runtime to reopen the stdout/stderr log file
// for the container. This is often called after the log file has been
// rotated. If the container is not running, container runtime can choose
// to either create a new log file and return nil, or return an error.
// Once it returns error, new container log file MUST NOT be created.
ReopenContainerLog(context.Context, *ReopenContainerLogRequest) (*ReopenContainerLogResponse, error)
// ExecSync runs a command in a container synchronously.
ExecSync(context.Context, *ExecSyncRequest) (*ExecSyncResponse, error)
// Exec prepares a streaming endpoint to execute a command in the container.
Exec(context.Context, *ExecRequest) (*ExecResponse, error)
// Attach prepares a streaming endpoint to attach to a running container.
Attach(context.Context, *AttachRequest) (*AttachResponse, error)
// PortForward prepares a streaming endpoint to forward ports from a PodSandbox.
PortForward(context.Context, *PortForwardRequest) (*PortForwardResponse, error)
// ContainerStats returns stats of the container. If the container does not
// exist, the call returns an error.
ContainerStats(context.Context, *ContainerStatsRequest) (*ContainerStatsResponse, error)
// ListContainerStats returns stats of all running containers.
ListContainerStats(context.Context, *ListContainerStatsRequest) (*ListContainerStatsResponse, error)
// UpdateRuntimeConfig updates the runtime configuration based on the given request.
UpdateRuntimeConfig(context.Context, *UpdateRuntimeConfigRequest) (*UpdateRuntimeConfigResponse, error)
// Status returns the status of the runtime.
Status(context.Context, *StatusRequest) (*StatusResponse, error)
}
()
แแฃ แแกแแ, แฉแแแ แฃแแแ แแแแแแแฎแแ แแแแจแแ แ แแฃแแแแแขแกแ แแ แแแแขแแแแแ แแก แแแจแแแแแก แจแแ แแก, แแ แ? แจแแแแแแฌแแแ.
แแแฃแจแแแ แแก แแ แซแแแแแ exec แแ แซแแแแแแก แฌแแ แแ แจแแแแแ แแ แแแฎแแ แแแแกแฎแแแแแแ. แฉแแแก แจแแแแฎแแแแแจแ แแแแกแฎแแแแแแแ:
// worker node
$ ss -a -p |grep kubelet
...
u_str ESTAB 0 0 * 157937 * 157387 users:(("kubelet",pid=5714,fd=33))
...แฐแ... แแฎแแแ unix แกแแแแขแแก แแแแจแแ แ แแฃแแแแแขแก (pid=5714) แแ แ แแฆแแช แฃแชแแแแก แจแแ แแก. แ แ แจแแแซแแแแ แแงแแก? แแแ แแแแแ, แแก แแ แแก Docker (pid=1186)!
// worker node
$ ss -a -p |grep 157387
...
u_str ESTAB 0 0 * 157937 * 157387 users:(("kubelet",pid=5714,fd=33))
u_str ESTAB 0 0 /var/run/docker.sock 157387 * 157937 users:(("dockerd",pid=1186,fd=14))
...แ แแแแ แช แแแฎแกแแแ, แแก แแ แแก แแแแแ แแก แแแแแแแก แแ แแชแแกแ (pid=1186), แ แแแแแแช แแกแ แฃแแแแก แฉแแแแก แแ แซแแแแแแก:
// worker node
$ ps -afx
...
1186 ? Ssl 0:55 /usr/bin/dockerd -H fd://
17784 ? Sl 0:00 _ docker-containerd-shim 53a0a08547b2f95986402d7f3b3e78702516244df049ba6c5aa012e81264aa3c /var/run/docker/libcontainerd/53a0a08547b2f95986402d7f3
17801 pts/2 Ss 0:00 _ sh
17827 pts/2 S+ 0:00 _ sleep 5000
...4. แแฅแขแแแแแ แแแแขแแแแแ แแก แแฃแจแแแแแก แแ แแก
แแแแแ แจแแแแแแฌแแแ CRI-O แฌแงแแ แแก แแแแ, แ แแแ แแแแแแแ แ แ แฎแแแแ. แแแแแ แจแ แแแแแแ แแกแแแแกแแ.
แแ แกแแแแแก แกแแ แแแ แ, แ แแแแแแช แแแกแฃแฎแแกแแแแแแแแ แแแแฎแแ แชแแแแแแแแ RuntimeServiceServer:
// Server implements the RuntimeService and ImageService
type Server struct {
config libconfig.Config
seccompProfile *seccomp.Seccomp
stream StreamService
netPlugin ocicni.CNIPlugin
hostportManager hostport.HostPortManager
appArmorProfile string
hostIP string
bindAddress string
*lib.ContainerServer
monitorsChan chan struct{}
defaultIDMappings *idtools.IDMappings
systemContext *types.SystemContext // Never nil
updateLock sync.RWMutex
seccompEnabled bool
appArmorEnabled bool
}()
// Exec prepares a streaming endpoint to execute a command in the container.
func (s *Server) Exec(ctx context.Context, req *pb.ExecRequest) (resp *pb.ExecResponse, err error) {
const operation = "exec"
defer func() {
recordOperation(operation, time.Now())
recordError(operation, err)
}()
resp, err = s.getExec(req)
if err != nil {
return nil, fmt.Errorf("unable to prepare exec endpoint: %v", err)
}
return resp, nil
}()
แฏแแญแแแก แแแแแก, แแแแขแแแแแ แแก แแแจแแแแแก แแ แ แแกแ แฃแแแแก แแ แซแแแแแแก แแฃแจแ แแแแแซแแ:
// ExecContainer prepares a streaming endpoint to execute a command in the container.
func (r *runtimeOCI) ExecContainer(c *Container, cmd []string, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize) error {
processFile, err := prepareProcessExec(c, cmd, tty)
if err != nil {
return err
}
defer os.RemoveAll(processFile.Name())
args := []string{rootFlag, r.root, "exec"}
args = append(args, "--process", processFile.Name(), c.ID())
execCmd := exec.Command(r.path, args...)
if v, found := os.LookupEnv("XDG_RUNTIME_DIR"); found {
execCmd.Env = append(execCmd.Env, fmt.Sprintf("XDG_RUNTIME_DIR=%s", v))
}
var cmdErr, copyError error
if tty {
cmdErr = ttyCmd(execCmd, stdin, stdout, resize)
} else {
if stdin != nil {
// Use an os.Pipe here as it returns true *os.File objects.
// This way, if you run 'kubectl exec <pod> -i bash' (no tty) and type 'exit',
// the call below to execCmd.Run() can unblock because its Stdin is the read half
// of the pipe.
r, w, err := os.Pipe()
if err != nil {
return err
}
go func() { _, copyError = pools.Copy(w, stdin) }()
execCmd.Stdin = r
}
if stdout != nil {
execCmd.Stdout = stdout
}
if stderr != nil {
execCmd.Stderr = stderr
}
cmdErr = execCmd.Run()
}
if copyError != nil {
return copyError
}
if exitErr, ok := cmdErr.(*exec.ExitError); ok {
return &utilexec.ExitErrorWrapper{ExitError: exitErr}
}
return cmdErr
}()
แกแแแแแแแ, แแแ แแแ แแกแ แฃแแแแก แแ แซแแแแแแแก:
แจแแฎแกแแแแแแแ
- API แกแแ แแแ แก แแกแแแ แจแแฃแซแแแ แแฃแแแแแขแแแ แแแแจแแ แแก แแแแชแแแแแแแชแแ.
- แจแแแแแแ แแแแจแแ แแแ แจแแแแ แฉแฃแแแแฃแแแ แแแขแแ แแฅแขแแฃแแ exec แกแแกแแแก แแแกแ แฃแแแแแแแ:
- kubectl-แกแ แแ api-แกแแ แแแ แก แจแแ แแก;
- api-แกแแ แแแ แกแ แแ kubectl-แก แจแแ แแก;
- แแฃแแแแแขแกแ แแ แแแแขแแแแแ แแก แแแจแแแแแก แจแแ แแก.
- Kubectl แแ api-แกแแ แแแ แ แแแ แแคแแ แก แฃแจแแแแก แแฃแจแ แแแแแซแแแแ. Kubelet-แก แจแแฃแซแแแ แแฌแแ แแแแก, แแแแ แแ แแก แแกแแแ แฃแ แแแแ แแฅแแแแแแก แแแแขแแแแแ แแก แแฃแจแแแแแก แแ แแก แแ แแแฅแแแแแแแแแกแแแแก.
แ แแกแฃแ แกแแแ
- แแแกแแฃแกแแ"ยป kubernetes-dev-แจแ;
- แกแขแแขแแ "";
- แแแกแแฃแกแแ"ยป แกแแ แแแ แแก แแแฃแแแ แแแแแแแ.
PS แแแแ แแแแแแแกแแแ
แแกแแแ แฌแแแแแแฎแแ แฉแแแแก แแแแแแ:
- "แ แ แฎแแแแ Kubernetes-แจแ, แ แแชแ แแฌแแ แแแแ kubectl run?" ะธ ;
- ยซ";
- ยซ";
- ยซ".
แฌแงแแ แ: www.habr.com