作者

李腾飞，腾讯容器技能研制工程师，腾讯云TKE后台研制，SuperEdge核心开发成员。

杜杨浩，腾讯云高级工程师，热衷于开源、容器和Kubernetes。现在approach首要从事镜像库房，Kubernetes集群高可用&备份恢复，以及边缘核算相关研制作业。

SuperEdge 介绍

SuperEdge 是 Kubernehttpwatchtes 原生的边缘容器方案，它将 Kubernetes 强大的容器处理才干扩展到边缘核算场景http://www.baidu.com中，针对边缘核算APP场景中常见的技能挑战供给了处理方案，如：单集群节点跨地域、云边网络不可靠、边缘节点坐落 NAT 网络等。这些才干能够让运用很容易地安置到边缘核算节点上，并且可靠地工作，能够帮助您很方便地把分布在遍地的核算资源放到一个 Kubernetes 集群中处理，包含但不限于：边缘云核算资源、私有云资源、现场设备，打造归于您的边缘 PaaS 渠道。SuperEdge 支撑一切 Kubernetes 资源类型、API 接口、运用方法、运维东西，无额定的学习本钱，也兼容其他云原生项目，approve如：Promethues，运用者能够结合其他所需的云原生项目一起运http://192.168.1.1登录用。项目由以下公司一起建议：腾讯、Intel、VMware、虎牙直播、寒武纪、首都在线和美团。

云边地道的架构与原理

在边缘场景中，许多时分都是单向网络，即只需边缘节点能自动拜访云端。云边地道首要用于署理云端拜访边缘节点组件的央求，处理云端无法直接拜访边缘节点的问题。

架运维宝构图如APP下所示：
一文读懂 SuperEdge 云边地道

完结原理为：

  • 边缘节点上 tunnel-edge 自动联接 tunnel-c开源众包loud service，tunnel-开源代码网站githubcloud service依据负载均衡战略将央求转到 tunnel-cloud pod

  • tunnel-edhttpwatchge 与 tunnel-clo开源代码网站githubud 树立 gRPC 联接后，tunnel-cloud 会把本身的podIp和 tunnel-edge 地址节http 500点的 nodappleeNappstoreame 的映射写入 tunnel-dns。gRPC 联接断开之后，tunnel-cloud 会删去相关 podIp 和节点名的映射

而整个央求的署理转发流程如下：

  • apiserver 或许其它云端的运用拜访边缘节点上的 kubelet 或许其它运用时，tunAPPnel-dns 经过 DNS 劫持(将 HTTP Request 中的 host 中的节点名解APP析为 tunnel-cloud 的podIphttps安全问题)把央求转发APP到 tunnel-cloud 的pod上

  • tunnel-cloud 依据节点名把央求信息转发到节点名对应的与 tunnel-edge 树立的 gRPC 联接上

  • tunnel-edge 依据接approach纳的央求信息央求边缘节点上的运用

Tunnel 内部模块数据交互

在介绍完 Tunnel 的配备运维的薪酬是多少后，下面介绍 Tunnel 的内部数据流通：
一文读懂 SuperEdge 云边地道

上图符号出了 HTTPS 署理的数据流通，TCP 署理数据流通和 HTTPS 的相似，其间的关键步骤：

  • HTTPShttpwatch Server -> StreamServer：HTTPS Server 经过 Channel将 StreamMsg 发送给 Stream Server，运维宝其间的 Channe开源我国l 是依据 StreamMsg.Node 字段从 nodeContext 获取 node.Channapplicationel

  • StreamServer -&gt开源阅览; Str运维eamClient: 每个云边地道都会分配一个 node 政策，将apple StreamClient 发送到 node 中的 Channel 即可把数据发往 StreamClient

  • StreamServer -> HTTPS Server: StreamServer 经过 Ch运维工程师是干什么的annel 将 StreamMsg 发送给 HTTPS Se开源rver，其间的 Channel 是依据 StreamMsg.Node从nodeContext 获取 node，经过 StreamMsg.Topic 与 conn.uid 匹配获取 HTTPS 模块的 conn.Channel

nodeContext 和 connContext 都是做联接的处理，但是 nodeContext 处理 gRPC 长联接的和 connContext 处理的上层转发央求的联接(TCP 和 HTTPS)的生命周期是不相同的，因而需求分隔处理

Tunnel 的联接处理

Tunnel 处理的联approve接能够分为底层联接(云端地道的 gRPC 联接)和上层运用联接(HTTPS 联接和 TCP 联接)，联接异常的处理的能够分为以下几种appointment场景：

gRPC 联接正常，上层联接异常

以 HTTPS 联接为例appreciate，tunnel-edge 的 HTTPS Client 与边缘节点 Server 联接异常断开，会发送 StreamMsg (StreamMsg.Type=CLOSE) 音讯，tunnel-cloud 在接收运维工程师有出路吗到 StreamMsg 音讯之后会自动封闭 HTTPS ServHTTPSer与HTTPS Client 的联接。

gRPC 联接异常

gRPC 联接异常，Stream 模块会依据与 gPRC 联接绑定的 node.connContext，向 HTTPS 和 TCP 模块发送 StreamMsg(Stapp装置下载reamMsg.Type=CLOSE)，HTTPS 或apple TCP 模块接收音讯之后自动断开联接。

Stream (gRPC云边地道)

funappointmentc (stream *Stream) Start(mode string) {
context.GetContext().RegisterHandler(util.STREAM_HEART_BapproachEAT, util.STREAM, streammsg.HeartbeatHa开源代码网站githubndler)
ifhttp署理 mode == utihttps协议l.CLOUD {
...
//建议gRPC server
go connect.StartServer()
...
//同步coredns的hos运维工程师需求掌握什么技能ts插件的配备文件
go connect.SynC开源节流orefile()http 500
} else {
//建议gRPC client
go connect.StartSendClient()
...
}
...
}

tunnel-cloud 首要调用 RegisterHandler 注册心https安全问题跳音讯处理函数 HeartbeatHandler
SynCorefile 实施同步 tunnel-coredns 的 hosts 插件的配备文件，每隔一分钟(考虑到 configmap 同步 tunnehttpclientl-cloud 的 pod 挂载文件的时刻)实施一次 checkHosts，如下：

func SynCorefile() {
for {
...
err开源我国 := coreDns.checkHosts()
...
time.S运维工程师leep(60 * time.Second)
}
}

而 checkHosts 担任 configmaapproachp 具体的刷新操作：

func (dns *CoreDns) checkHosts() error {
nodes, flag := parseHosts()
if !flag {
return nil
}
...
_, err = dns.ClientSet.CoreV1().ConfigMaps(dns.Namespace).Uphttp协议date(cctx.TODO(), cm, metav1.UpdateOptions{})
..http://192.168.1.1登录.
}

checkHosts 首要调用HTTPS parseHosts 获取本地 hosts 文件中边缘节点称谓以及对应 tunnel-cloud podIp 映射列表，对比 podIp 的对应节点名和内存中节点名，如果有改变则将这个内容掩盖写入 configmapHTTP 并更新：

一文读懂 SuperEdge 云边地道

其他开源节流是什么意思是什么，这儿 tunnel-cloud 引进 configmap 本地挂载文件的目的是：优化保管方法下许多集群一起同步 t运维方与学者交流的途径是unnel-coredns 时的功用

tunnel-edge 首要调用 StartClient 与 tunnel-edge 树立http 500 gRPC 联接，回来 grpc.ClientConhttp 302n

func StartClient() (*grpc.ClientConn, ctx.Context, c运维的薪酬是多少tx.CancelFunc, error) {
...
opts := []grpc.Dial开源众包Option{grpc.WithKeep开源软件aliveParams(kacp),
grpc.WithStreamIappreciatente开源节流rceptor(ClientStreamInterceptor),
grpc.WithTransportCredentials(creds)}
conn, err := grpc.DialHTTPS(conf.TunnelConfapple.TunnlMode.EDGE.StreamEdgehttp署理.Client.ServerName, opts...)
...
}运维工程师

在调用 grpc.Dial 时会传递grpc.WithStreamInterappreciateceptor(ClientStreamInthttp 302erceptor) DialOption，将 ClientStreamInterceptor 作为 StreamClientInterceptor开源众包 传递给 grpc.ClientConn,等候 ghttps安全问题RPC 联接状况变为 Ready，然后实施 Send 函数。streamClient.TunnelStreaming 调用StreamClientInterceptor 回来 wrappedClientStream 政策

func ClientStreamInterceptor(ctx context.Context, desc *grpc.StreamDeshttp 500c, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.Clienhttp署理tStream, error) {
...
opts = append(opts, grpc.PerRPCCredentials(oauth.NewOauthAccess(&oauth2.Token{Ac开源是什么意思cessToken: clientToken})))
...
return newClientWrappedStream运维是做什么的(s), nil
}

ClientStreamInterceptor 会将边缘节点称谓以及 token 构形成 oauth2.Token.AccessToken 进行认证传递，并构建 wrappedClientStream

stream.Send 会并发调用 wrappedClie运维岗位是干什么的ntStream.SendMsg 以及 wrappedClientStream.RecvMsg 别离用于 tunnel-edge 发HTTP送以及承受，并堵运维工程师是干什么的塞等候

留意：tunnel-edgapplicatione 向 tunnel-cloud 注册节点信息是在树立 gRPC Stream 时，而不是创建 grpc.connClient 的时分

整个进程如下图所示:

一文读懂 SuperEdge 云边地道

相应的，在初始化 tunnel-cloud 时，会将运维宝grpc.StreamInterce开源矿工pto开源代码网站githubr(ServerStreamInterceptor)构建成 gR运维岗位是干什么的PC ServerOption，并将 ServerSthttps和http的差异reamInterceptor 作为 StreamSerappleverInterceptor 传递给 grpc.Server：

func StartServer() {
...
opts := []grpc.S开源软件erverOption{grpc.Kehttps协议epaliveEnforcementPolicy(kaep), grpc.KeepaliveParams(kasp), grpc.StreamInterceptor(ServerStreamInterceptor), ghttp 404rpc.Creds(creds)}
s := grpc.NewServehttps认证r(opts...)
proto.RegisterStreamServer(s, &stream.Server{}运维宝)
...
}

云端 gRPC 服务在接遭到 tunnel-edge 央求(树立 Stream 流)APP时，会调用 ServerStreamInterceptor，运维岗位是干什么的而 ServerStreamInterceptor 会从gRPC metadata 中解开源软件析出此 gRPC 联接对应的边缘节点名和token，并对该 token 进行校验，然后依据节点名构建 wrappedServerStream 作为与该边缘节点通讯的处理政策(每个边缘节点对应一个处理政策)，handler 函数会调用 stream.Tunn运维岗位是干什么的elStreaming，并将 wrappedServerStream 传递给它(wrappedServerStream 完结了proto.Stream_TunnelStreamingServer 接口)

func ServerStreamInterhttp 302ceptor(srv interface{}, ss grpc.Serapp装置下载verStreamapp装置下载, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
md, ok := metadata.FromIncomingContehttp://www.baidu.comxt(ss.Context())
.运维工程师..appear
tk := strings.TrimPrefix(md["authorization"][0], "Bearer ")
auth, err := token.ParseToken(tkhttps和http的差异)
...
if auth.Token != toke开源阅览n.GetTokenFromCach开源众包e(auth.NodeName) {
klog.Errorf("invalid token node = %s", auth.NodeName)
return ErrInvahttp://192.168.1.1登录lidToken
}
err = handler(srv, newServ开源阅览erWrappedStrapproveeam(ss, auth.NodeName))
if err != nil {
ctx.Geapp装置下载tContext().RemoveNode(auth.NodeNamhttps和http的差异e)
klog.Errorf("node disconnected node = %s err = %v", auth.NodeName, erapp装置下载r)
}
retu运维工程师是干什么的rn err
}

而当 TunnelStreaming 方法退出时，就会执 ServerStreamInterceptor 移除节开源我国点的逻辑ctx.GetContext().RemoveNoapplicationde

TunnelStreaming 会并发调用 wrappedServerStream.SendMsg 以及 wrhttps认证appedServerStream.RecvMsg 别离用于 tunnel-cloud 发送以及承受，并堵塞等候：

f运维岗位是干什么的unc (s *Servehttps和http的差异r) TunnelStreaming(stream proto.Stream_TunnelStreamingServer) error {
errChan := make(chan error, 2)
go func(sendappearStream proto.Stream_TunnelStreamingS运维宝erver, sendChan chan error) {
sendErr := sendStream.SendMsg(nil)
...
shttp署理endChan <- sendErr
}(stream, errChan)
go func(recvStream proto.Stream_TunnelStreamingServer, recvChan chan error) {
recvErr := stream.RecvMsapp装置下载g(nil)
...
recvChan <- recvErr
}(stream, errChan)
e := <-errChan
return e
}

SendMsg 会从 wrappedServerStream 对应边缘节点 node 中承受 StreamMsg，并调用 ServeAPPrStream.Shttp 500endMsg 发送该音讯给 tunnel-edge

func (w *wrHTTPappedServerStream) SendMsg(m interface{}) error {    if m != nil {        return w.ServerStream.SendMsg(m运维的薪酬是多少)    }    node := ctx.GetCo开源阅览ntext().AddNode(w.node)    ...    for {        msapproveg := <-node.NodeRecv()        ...        err := w.ServerStream.SendMsg(https和http的差异msg)        ...    }}

而 RecvapproveMsg 会不断承受来自 tunnel-ed运维geappear 的 Stream开源Msg，并调用 StreamMsg.对应的处理函数进行操作

小结：

  • Stream 模块担任application树立 gRPC联接以及通讯(云边地道)
  • 边开源阅览沿节点上 tunnel-edge 自动联接云端 tunnel-cloud service，tunnel-cloud service 依据负载均衡战略将央求转到tunnHTTPSel-cloud pod
  • tunnel-edge 与 tunnel-cloud 树立 gRPC 联接后，tunnel-cloud 会把本身的 podIp 和 tunnehttp署理lhttpclient-edge 地址节HTTPS点的 nodeName 的映射写入tunnel-corednapplications。gRPC 联接断开之后，t开源代码网站githubunnel-cloud 会删去相关 podIp 和节点名的映射
  • tunn开源阅览app下载装置el-approache运维dge 会利用边缘节点名以及 token 构建 gRPC 联https和http的差异接，而 tunnel-cloud 会经过认证信息解析 gRPC 联接对应的边缘节点，并对每个边缘节点别离构建一个 wrappedServerStream 进行处理(同一个 tunnel-cloud 能够处理多个apple tunnel-edge 的联接)
  • tunnel-cloud 每隔一分钟(考虑到https安全问题 configmap 同步 tunnel-chttps和http的差异loud 的 pod 挂载文件的时刻)向 tunnel-coredns 的 host开源软件s 插HTTP件的配备文件对应 configmap 同步一次边缘节点名以及 tunnhttps协议elhttps认证-cloud podIp 的映射；其他，引进 configmap 本地挂载文件优化了保管方法下许多集群一起同步 tunnel-coredns 时的功用
  • tu开源阅览nnel-edge 每隔一分钟会向 tunnel-cloud 发送代表该节点正常的心跳 StreamMsg，而 tunnel-clo开源节流是什么意思是什么ud 在接遭到该心跳后会进行回http 404应(心跳是为了勘探 gRPCappearance Stream 流是否正常)
  • StreamMsg 包含心跳，TCP 署理以及 HTTPS 央求等不同类型音讯；一起 tunnel-cloud 经过 context.node 区分与不同边缘节点 gRPC 联接地道

HTTPS 署理

HTTPS运维 模块担任树立云边的 HTTPS 署https协议理，将云端组件(例如：kube-apiserver)的 https 央求转发给边端服务(例如：kubelet)

func (https *Https) S开源节流是什么意思是什么tart(mohttps安全问题de s运维岗位是干什么的tring) {    context.GetContext().RegisterHandler(util.CONNECTING, util.HTTPS, httpsmsg.ConnectingHandler)    context.GetContext().RegisterHandler(util.CONNECTED, util.HTTPS, httpsmsg.ConnectedAndTransmission)    context.GetContext().RegisterHandler(util.CLappearOSED, util.HTTPS, httpsmapproachsg.ConnectedAndTransmission)    context.GetContext().RapproveegisterHandler(util.TRANSNMISSION, util.HThttps认证TPS, httpsmsg.ConnectedAhttp协议ndTrans运维工程师是干什么的mission)    if mode == util.CLOUD {        go httpsmn运维岗位是干什么的g.Stapp装置下载artServer()    }}

Start 函数首要注册了 StreamMsg 的处理函数，其间 CLOSED 处理函数首要处理封闭联接的音讯，并appstore建议 HTTPS Server。
当云端组件http://192.168.1.1登录向 tunnel-cloud 发送 HTTPS 央求时，serverHandler 会首要从 request.Host 字段解析节点名，若先树立 TLS 联接，然后在联接中写入 HTTP 的 request 政策，此刻的 request.Host 能够不设置，则需求从 request.TLS运维岗位是干什么的.ServerName 解析节点名。HTTPS Server 读取 request.Body 以及 rehttps和http的差异quest.Header 构建 HttpsMsg 结构体，并序列化后封装成 StreamMsg，经过httpclient Send2Node 发送 StreamMsg 放入 Sthttp署理reamMsg.node 对应的 node 的 Channel 中，由 Str开源节流eam 模块发送到 tunnel-edge

fun开源矿工c (serverHandler *ServerHandler) ServeHTTP(writer http.Respo运维工程师有出路吗nseWriter, request *http.Reques运维方与学者交流的途径是t) {    var nodeName string    nodeinfo := strings.Split(request.Host, ":")    if context.Get运维Context().NodeIsExist(nodeinfo[approach0]) {        nodeName = nodeinfo[0]    } else {        nodeName = request.TLS.运维ServerNamhttps协议e    }    ...    node.Send2Node(StreamMsg）}

tunnel-edge 接遭到 StreamMsg，并调用 ConnectingHandler 函数进行运维岗位是干什么的处理：

func ConnectingHanhttp 500dler(msg *proto.StreamMsg) error {    go httpsmng.Request(msg)    return nil}func Request(msg *proto.StreamMsg) {    httpConn, err := getHttpConn(mhttps认证sg)开源是什么意思    ...    rawResponse := bytes.NewBuffer(make([]byte, 0, util.MaxRespon开源矿工seSize))开源是什么意思    rawRhttpwatchesponse.httpwatchReset()    respReader := bufio.NewRehttp 404ader(io.TeeReader(httpConn, rawResponse))    resp, err := httphttp://www.baidu.com.ReadResponse(respReader, nil)    ...    node.BindNode(msg.Topic)    ...    if resp.StatusCode != http.StatusSwitchingProtocolhttps和http的差异s {        handleClientHttp(resp, rawResponsappstoree, httpConn, msg, node, conn)    } else {        handleClientSwitchingProtocols(httpConn, rawResponse, msg, node, conn)    }}

ConnectingHandler 会调用 Request 对该 StreamMsg 进行处理。Reqeust 首要经过 getHttpConn 与边缘节点 Server 树立的 TLS 联接。解析 TLS 联接中回来的数据获http://192.168.1.1登录取 HTTP Response，Status Code 为200，将 Response 的内容发appstore送到 tunnel-cloud，Status Code 为101，将从TLS 联接读取 Responshttp 500e 的二进制数据发送到 tunnel-cloud，其间 StreamMsg.Type为CONNECTED。

tunnel-cloud 在接遭到该 StreamMsg 后，会调用 ConnectedAndTransmission 进行处理：

func ConnectedAndTransmission(msg *proto.StreamMsg) error {    conn := context.GetContext().GetConn(msg.Topic)    ...    cappointmentonn.Send2Conn(msg)    return nil}

经过 msg.Topic(conn uid) 获取 conn，并经过 Send2Conn 将音讯塞到该 conn 对应的管道中

云端 HTTPS Server 在接遭到云端的 CONNECTED 音讯之后，认为HTTPS 署理成功树立。并继续实施 handleClientHttp or handleClientSwitchingProtocols 进行数据传输，这儿只剖析 handleClientHttp 非协议前进低的数据传输进程，HTTPS Client 端的处理逻辑如下：application

func handleClientHttp(resp *approachhthttps和http的差异tp.Response, rawResponse *bytes.Buffer, httpConn net.Conn, msg *proto.StreamMsg, node context.Node,https协议 conn context.Conn) {    ...    go func(read chan *proto.StreamMsg, response *http.Response, buf *bytes.Buff运维的薪酬是多少er, stopRead chahttp 404n struct{}) {        rrunning := true        for rrunning {            bbody := make([]byt开源软件e, uapprovetil.MaxResponseSize)            n, err := response.B开源矿工ody.Read(bbody)            respMsg := &proto.StreamMsg{                Node:     msg.Node,                Category: msg.Category,                Type:     uhttp 404til.CONNECTED,                Topic:    msg.Topic,                Data:     bbody[:n],            }            ...            read <- respMsg        }        ...    }(开源readCh, resp, rawResponse, stop)    running := true    for running {        select {        case cloudMsg := <-conn.ConnRecv():            ...        case respMsg := <-readCh:            ...            node.Send2Noappointmentde(respMapp装置下载sg)            ...        }    }    ...}

这儿 handleClientHttp 会一贯运维测验读取来自边端组开源我国件的数据包，并构建成 TRANSNMHTTPSISSIOhttpclientN 类型的 StreamMsg 发送给 tunnel-cloud，tunnel-cloud 在接遭到StreamMsg 后调用 ConnectedAndTransmission 函数，将 Strea运维方与学者交流的途径是mMsg 放入 StreamMsg.Type 对应的 HTTPS 模块的 conn.Channel 中

func handleServerHttp(r运维纺与学者勾通的途径msg *Htt开源软件psMsg, writer http.ResponseWriter, request *http.Reque开源阅览st, node context.Node, conn context.httpclientConn) {    for k, v := range rmsg.Header {        writer.Header().Add(k, v)    }    flusheappearr, ok := writer.(htthttps安全问题p开源众包.Flusher)    if ok {        running := true        for runnhttp署理ing {            select {            case <-request.Context().Done():                ...            case msg := <-conn.ConnRecv():                ..https和http的差异.                _, err := writer.approachWrite(msg.Data)                flusher.Fl开源软件ush()                ...            }        }    ...}

handleServerHttp 在接遭到 StreamMsg 后，会将 msg.Data，也即边端组件的数据包，发送给云端组件。整个数据流是单向的由边端向云端传送，如下所示：

一文读懂 SuperEdge 云边地道

而关于相似kubectl exec的央http协议求，数据流是https协议双向的，此刻边端组件 (kubelet) 会回来 StatusCode 为101的回包，标示协议前进，之后 tun运维是做什么的nel-cloud 以及 tunnel-edge 会别离切到 handleServerSwitchingProtocols 以及 handleClientS开源节流witcAPPhingProtocols 对 HTTPS 底层联接进行读取和写入，结束数据流的双向传输。

架构如下所示：

一文读懂 SuperEdge 云边地道
总结HTTPS模块如下：

小结

  • HTTPS：担任树立云边 HTTPS 署理(eg：云端 kube-apiserver <-> 边端 kubelet)，并传输数据
  • 效果与 TCP 署理相似，不同的是 tunnel-cloud 会读取云端组件 HTTPS 央求中带开源软件着的边缘节点名，并测验树立与该边缘节点的 HTTPS 署理；而不是像 TCP 署理相同随机挑选一个云边地道进行转发
  • 云端 apiserver 或许其它云端的运用拜访边缘节点上的 kubelet 或许其它运用时,tunnel-dns 经过DNS劫持(将 Request host 中的节点名解析为 tunnel-cloud 的 podIp)把央求转发到 tunneapprovel-cloud 的pod上,tunnel-cloud 把央求信息封装成 StreamMsg 经过与节点名对应的云边地道发送到 tunhttp署理nel-ehttp协议dge,tunnel-edge 经过接收到的 StreamMsg 的 Addr 字段和配备文件中的证书与边缘端 Server 树立 TLS 联接，并将 StreamMsg 中的央求信息写入 TLSHTTP 联接。tunnel-edge 从 TLS 联接中读取开源代码网站github到边缘端 Server 的回来数据，将其封装成 StreamMsg 发送到 tunnel-cloud，tunnel-cloud 将接收到数据写入云端组件与 tunnel-cloud 树立的联接中。

TCP

TCP 模块担任在多集群处理中树立云端管控集群与边缘独立集群的一条 TCP 署理地道：

fu运维是做什么的nc (tcp *TcpProxy) Start(mode string) {    context.GetContext().RegisterHandler(util.TCP_BACKEND开源矿工, tcp.Name(), tcpmsg.Bac开源是什么意思kendHandler)    contex开源节流是什么意思是什么t.GetCon开源代码网站githubtext().RegisterHandler(util.TCP_FRONTEND, tcp.Name(), tcpmsg.FrontendHandler)    context.GetConthttp协议ext().RegisterHandler(ut运维工程师il.CLOSED, tcp.Name(), tcpmsg.ControlHandler)    if mode == util.CLOUD {    ...        for fro开源阅览app下载装置nt, backend := range Tcp.Addr {            go func(front开源阅览app下载装置, backend string) {                ln, err := net.Listen("tcp", front)                ...                for {                    rahttp 302wConn, err := ln.Accept()                    ....                    fp := tcpmng.NewTcpConn(uuid, backend, node)                    fp.Conn = rawConn                    fp.Type = util.TCP运维工程师有出路吗_FRONTEND                    go fp.Write()                    go fp.Reapplead()                }            }(front, backend)        }    }

Start 函数httpwatch首要注册了 StreamMsg 的处理函数，其间运维是做什么的 CLOSED 处理函数首要处理封闭联接的音讯，之后在云端建议 TCP Server。
在接遭到云端组件的央求后，TCP Server 会将央求封装成 St开源软件remMsg 发送给 StreamServer开源阅览，由 StreamServer 发送到 tunnel-edge,其间 StreamMsg.Type=FrontendHandler，StreamMsg.Node 从已树立的云边地道的节点中随机挑选一个。
tunnel-edge 在接遭到该StreamMsg 后，会调用 FrontendHandler 函数http://www.baidu.com处理

func FrontendHandler(msg *proto.StreamMsg) errorhttp 404 {    c := context.GetContext().GetConn(msg.Topic)    if c != nil {        c开源是什么意思.Send2Conn(msg)appearance        return nil    }    tp := tcpmng.NewTcpConn(msg.Topic, mshttp 404g.Addr, msg.Node)    tp.Type = util.TChttps认证P_BACKEND    tp.C.Send2Conn(msg)    tcpAddr, err := net.ResolveTCPAddr("tcp", tp.Addr)    if err != nil {    ...    conn, err := net.DialTCP("tcp", nil, tcpAddr)    ...    tp.Conn = conn    go tp.Reahttps和http的差异d()    go tp.Write()    return nil}

FrontendHandler 首要运用开源代码网站github StreamMsg.Addr 与 Edge Server 树立 TCP 联接，建议协程异步对 TCP 联接 Read 和 Write，一起新建运维工程师有出路吗 conn 政策(conn.uid=StreamMsg.Topic)，并 eamMs运维工程师需求掌握什么技能g.Data 写入 TCP 联接。tunnel-edge 在接收到 Edge Server 的回来http://www.baidu.com数据将其运维封装为 StreamMsg(StreamMsg.Topic=BackendHandler) 发送到 tunnel-cloud

整个进程如图所示：

一文读懂 SuperEdge 云边地道

小结

  • TCP：担任在多集群处理中树立云端与边端的 TCP 署理
  • 云端组件经过 TCP 模块拜访边缘端的 Server，云端的 TCP Server 在接收到央求会将央求封装成 StreamMsg 经过云边地道(在已联接的地道中开源是什么意思随机挑选一个，因而推荐在只需一个 tu开源nnel-edge 的场景下运用 TCP 署理https安全问题)发送到 tunnel-edge，*tunnel-edge 经过接收到 St运维工程师有出路吗reamMag 的Addr字段与边缘端 Server 树立TCP 联接，并将央求写入 TCP 联接。tunnel-edge 从 TCP 联接中读取边缘端 Server 的回来音讯，经过云边缘地道发送到tunnel-cloud,tunnel-cloud 接收到音讯之后将其写入云端组件与 TCP Server 树立的联接

展望

  • 支撑更多的网络协议(已支撑 HTTPS 和 TCP)
  • 支撑云端拜访边缘节点业务 pod server
  • 多个边缘节点一起参加集群时，多副本 tunnel-cloud pod 在更新 tunnel-coredn开源是什么意思s 的 hosts 插件配备文件对应 confappointmentigmap 时没有加锁，尽管概率较低，但理论上依然存在写冲突的可能性

Refs

  • kubernetes-reading-notes