在Kubernetes上如何基于自定义指标实现应用的自动缩放

img{512x368}

如何在Kubernetes上实现应用缩放?

使用静态配置将应用程序部署到生产环境并不是最佳选择。

流量模式可能会快速变化,应用程序应该能够实现自适应:

  • 当需求增加时,应用程序应扩大规模(增加副本数)以保持响应速度。
  • 当需求减少时,应用程序应缩小规模(减少副本数量),以免浪费资源。

Kubernetes以Horizontal Pod Autoscaler的形式为自动缩放应用程序提供了出色的支持。

下面我们将学习如何使用它。

不同类型的自动缩放

首先,为了消除任何误解,让我们澄清一下Kubernetes中的术语“自动缩放”的不同用法。

在Kubernetes中,有几件事可被称为“自动缩放”,包括:

  • 水平Pod自动缩放器:调整应用程序的副本数
  • Vertical Pod Autoscaler:调整容器的资源请求(request)和限制(limit)
  • 集群自动缩放器:调整集群的节点数

尽管这些组件都可以“自动缩放”某些东西,但是它们彼此之间完全不相关。

它们都针对非常不同的用例,并使用不同的概念和机制。

它们是在单独的项目中开发的,可以彼此独立使用。

本文介绍的是水平Pod自动缩放器。

什么是水平Pod自动缩放器?

水平Pod自动配置器是Kubernetes内置的功能,允许基于一个或多个被监测的指标水平缩放应用规模。

水平缩放意味着增加和减少副本数量。垂直缩放意味着增加和减少单个副本的计算资源。

从技术上讲,Horizontal Pod Autoscaler是Kubernetes控制器管理器(controller manager)中的控制器(controller),它是由HorizontalPodAutoscaler资源对象配置的。

Horizontal Pod Autoscaler可以监视有关应用程序的指标,并不断调整副本数以最佳地满足当前需求。

Horizontal Pod Autoscaler可缩放的资源包括Deployment,StatefulSet,ReplicaSet和ReplicationController。

为了自动缩放应用程序,Horizontal Pod自动缩放器会执行一个永久控制循环:

img{512x368}

此控制循环的步骤为:

  • 查询缩放指标
  • 计算所需的副本数
  • 将应用程序缩放到所需数量的副本

控制循环的默认周期为15秒

所需副本数的计算基于缩放度量和该度量的用户提供的目标值。

目的是计算一个副本计数,该副本计数将使度量值尽可能接近目标值。

例如,假设缩放指标是每个副本的每秒请求速率:

  • 如果目标值为10 req / sec,而当前值为20 req / sec,则Horizontal Pod Autoscaler将按比例放大应用程序(即增加副本数),以使度量标准减小并更接近目标值。
  • 如果目标值为10 req / sec,当前值为2 req / sec,则Horizontal Pod Autoscaler将按比例缩小应用程序(即减少副本数),以使度量标准增加并更接近目标值。

用于计算所需副本数的算法基于以下公式:

X = N * (c/t)

其中X是所需的副本数,N是当前副本数,c是度量的当前值,t是目标值。

您可以在文档中找到有关算法的详细信息。

这就是Horizontal Pod Autoscaler的工作方式,但是如何使用它呢?

如何配置水平pod自动缩放器?

通过创建HorizontalPodAutoscaler资源,可以将Horizontal Pod Autoscaler配置为自动缩放应用程序。

此资源使您可以指定以下参数:

  • 可扩展的资源(例如,部署)
  • 最小和最大副本数
  • 缩放指标
  • 缩放指标的目标值

创建此资源后,Horizontal Pod Autoscaler将使用提供的参数开始对您的应用执行上述控制循环。

具体的HorizontalPodAutoscaler资源如下所示:

//hpa.yaml

apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: myhpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: Pods
      pods:
        metric:
          name: myapp_requests_per_second
        target:
          type: AverageValue
          averageValue: 2

存在清单文件结构不同的HorizontalPodAutoscaler资源的不同版本。上面的示例使用version v2beta2,它是撰写本文时的最新版本。

此资源myapp根据myapp_requests_per_second一个目标值为2 的指标指定一个名为Deployment的部署,该部署将在1到10个副本之间自动缩放。

您可以想象到,该myapp_requests_per_second指标代表此部署中各个Pod的请求率-因此,本规范的目的是自动调整Deployment的目标,以使每个Pod保持每秒2个请求的请求率。

到目前为止,这听起来不错,但有一个问题。

指标来自哪里?

什么是指标注册表?

整个自动缩放机制均基于代表应用程序当前负载的指标。

定义HorizontalPodAutoscaler资源时,您必须指定此类指标。

但是Horizontal Pod Autoscaler如何知道如何获取这些指标?

事实证明,还有另一个组件在起作用-指标注册表。

Horizontal Pod Autoscaler从指标注册表查询指标:

img{512x368}

度量标准注册表是集群中的中心位置,度量标准(任何类型)向客户端(任何类型)公开。

Horizontal Pod Autoscaler是这些客户端之一。

度量标准注册表的目的是为客户端提供从中查询度量标准的标准接口。

指标注册表的接口包含三个单独的API:

img{512x368}

这些API旨在提供不同类型的指标:

  • 资源度量标准API: Pod和节点的预定义资源使用度量标准(CPU和内存)
  • 自定义指标API:与Kubernetes对象关联的自定义指标
  • 外部指标API:与Kubernetes对象不关联的自定义指标

所有这些度量标准API都是扩展API

这意味着它们是核心Kubernetes API的扩展,可通过Kubernetes API服务器进行访问。

如果要自动缩放应用程序,这对您意味着什么?

您想要用作缩放指标的任何指标都必须通过这三个指标API之一公开。

因为只有这样,Horizontal Pod Autoscaler才能访问它们。

因此,要自动缩放应用程序,您的任务不仅是配置Horizontal Pod自动缩放器…

您还必须通过度量标准注册表公开所需的缩放度量标准。

如何通过度量标准API公开度量标准?

通过在集群中安装和配置其他组件。

对于每个度量标准API,您需要一个相应的度量标准API服务器,并且需要对其进行配置以通过度量标准API公开特定的度量标准。

默认情况下,Kubernetes中未安装任何度量标准API服务器,这意味着默认情况下未启用度量标准API 。

此外,您需要一个指标收集器,该指标收集器从源(例如,从目标应用的Pod)收集所需的指标,并将其提供给指标API服务器。

img{512x368}

对于不同的度量标准API,度量标准API服务器和度量标准收集器有不同的选择。

资源指标API:

  • 指标收集器是cAdvisor,它在每个工作程序节点上作为kubelet的一部分运行(因此默认情况下已安装)
  • 资源指标API的官方指标API服务器是metrics-server

自定义指标API和外部指标API:

  • 指标收集器的一个流行选择是Prometheus。但是,也可以使用其他指标系统(例如Datadog或Google Stackdriver)代替
  • prometheus适配器是与普罗米修斯集成为度量收集的度量标准API服务器-但是,其他度量收集器有自己的度量标准API服务器

因此,要通过一种度量标准API公开度量标准,您必须执行以下步骤:

  • 安装指标收集器(例如Prometheus)并将其配置为收集所需指标(例如从您的应用程序的Pod中收集)
  • 安装度量标准API服务器(例如Prometheus适配器)并将其配置为通过相应的度量标准API从度量标准收集器暴露度量数据

请注意,这专门适用于提供自定义指标的自定义指标API和外部指标API。Resource Metrics API仅提供默认指标,而不能配置为提供自定义指标。

以上信息很多,让我们把它们放在一起再完整过一遍。

放在一起

让我们来看一个完整的示例,该示例将应用配置为由Horizontal Pod Autoscaler自动缩放。

想象一下,您想基于副本的平均每秒请求速率来自动缩放Web应用程序。

另外,假设您要使用基于Prometheus的设置来通过Custom Metrics API公开请求率指标。

请求速率是与Kubernetes对象(Pods)关联的自定义指标,因此必须通过Custom Metrics API公开。

以下是达到目标的一系列步骤:

  • 设置您的应用程序,以将接收到的请求总数作为Prometheus指标公开
  • 安装Prometheus并将其配置为从应用程序的所有Pod中收集此指标
  • 安装Prometheus适配器并将其配置为将度量标准从Prometheus转换为每秒请求速率(使用PromQL)并且作为myapp_requests_per_second指标通过Custom Metrics API 公开
  • 创建一个HorizontalPodAutoscaler资源(如上所示),指定myapp_requests_per_second为缩放指标和适当的目标值

一旦创建HorizontalPodAutoscaler资源,Horizontal Pod Autoscaler就会启动,并开始根据您的配置自动缩放您的应用程序。

现在,您可以观察您的应用程序适应流量的情况。

本文为基于自定义指标自动缩放应用程序设置了理论框架。

在以后的文章中,您将把这些知识付诸实践,并在自己的集群上使用自己的应用程序执行上述步骤。

本文翻译自《How to autoscale apps on Kubernetes with custom metrics》


我的网课“Kubernetes实战:高可用集群搭建、配置、运维与应用”在慕课网上线了,感谢小伙伴们学习支持!

我爱发短信:企业级短信平台定制开发专家 https://tonybai.com/
smspush : 可部署在企业内部的定制化短信平台,三网覆盖,不惧大并发接入,可定制扩展; 短信内容你来定,不再受约束, 接口丰富,支持长短信,签名可选。

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

我的联系方式:

微博:https://weibo.com/bigwhite20xx
微信公众号:iamtonybai
博客:tonybai.com
github: https://github.com/bigwhite

微信赞赏:
img{512x368}

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

如何在Go语言中使用Websockets:最佳工具与行动指南

如今,在不刷新页面的情况下发送消息并获得即时响应在我们看来是理所当然的事情。但是曾几何时,启用实时功能对开发人员来说是一个真正的挑战。开发社区在HTTP长轮询(http long polling)和AJAX上走了很长一段路,但终于还是找到了一种构建真正的实时应用程序的解决方案。

该解决方案以WebSockets的形式出现,这使得在用户浏览器和服务器之间开启一个交互式会话成为可能。WebSocket支持浏览器将消息发送到服务器并接收事件驱动的响应,而不必使用长轮询服务器的方式去获取响应。

就目前而言,WebSockets是构建实时应用程序的首选解决方案,包括在线游戏,即时通讯程序,跟踪应用程序等均在使用这一方案。本文将说明WebSockets的操作方式,并说明我们如何使用Go语言构建WebSocket应用程序。我们还将比较最受欢迎的WebSocket库,以便您可以根据选择出最适合您的那个。

网络套接字(network socket)与WebSocket

在Go中使用WebSockets之前,让我们在网络套接字和WebSockets之间划清一条界限。

网络套接字

网络套接字(或简称为套接字)充当内部端点,用于在同一计算机或同一网络上的不同计算机上运行的应用程序之间交换数据。

套接字是Unix和Windows操作系统的关键部分,它们使开发人员更容易创建支持网络的软件。应用程序开发人员不可以直接在程序中包含套接字,而不是从头开始构建网络连接。由于网络套接字可用于许多不同的网络协议(如HTTP,FTP等),因此可以同时使用多个套接字。

套接字是通过一组函数调用创建和使用的,这些函数调用有时称为套接字的应用程序编程接口(API)。正是由于这些函数调用,套接字可以像常规文件一样被打开。

网络套接字有如下几种类型:

  • 数据报套接字(SOCK_DGRAM),也称为无连接套接字,使用用户数据报协议(UDP)。数据报套接字支持双向消息流并保留记录边界。

  • 流套接字(SOCK_STREAM),也称为面向连接的套接字,使用传输控制协议(TCP),流控制传输协议(SCTP)或数据报拥塞控制协议(DCCP)。这些套接字提供了没有记录边界的双向,可靠,有序且无重复的数据流。

  • 原始套接字(或原始IP套接字)通常在路由器和其他网络设备中可用。这些套接字通常是面向数据报的,尽管它们的确切特性取决于协议提供的接口。大多数应用程序不使用原始套接字。提供它们是为了支持新的通信协议的开发,并提供对现有协议更深层设施的访问。

套接字通信

首先,让我们弄清楚如何确保每个套接字都是唯一的。否则,您将无法建立可靠的沟通通道(channel)。

为每个进程(process)提供唯一的PID有助于解决本地问题。但是,这种方法不适用于网络。要创建唯一的套接字,我们建议使用TCP / IP协议。使用TCP / IP,网络层的IP地址在给定网络内是唯一的,并且协议和端口在主机应用程序之间是唯一的。

TCP和UDP是用于主机之间通信的两个主要协议。让我们看看您的应用程序如何连接到TCP和UDP套接字。

  • 连接到TCP套接字

为了建立TCP连接,Go客户端使用net程序包中的DialTCP函数。DialTCP返回一个TCPConn对象。建立连接后,客户端和服务器开始交换数据:客户端通过TCPConn向服务器发送请求,服务器解析请求并发送响应,TCPConn从服务器接收响应。

img{512x368}
图:TCP Socket

该连接将持续保持有效,直到客户端或服务器将其关闭。创建连接的函数如下:

客户端:

// init
   tcpAddr, err := net.ResolveTCPAddr(resolver, serverAddr)
   if err != nil {
        // handle error
   }
   conn, err := net.DialTCP(network, nil, tcpAddr)
   if err != nil {
           // handle error
   }

   // send message
    _, err = conn.Write({message})
   if err != nil {
        // handle error
   }

   // receive message
   var buf [{buffSize}]byte
   _, err := conn.Read(buf[0:])
   if err != nil {
        // handle error
   }

服务端:

// init
   tcpAddr, err := net.ResolveTCPAddr(resolver, serverAddr)
       if err != nil {
           // handle error
       }

       listener, err := net.ListenTCP("tcp", tcpAddr)
    if err != nil {
        // handle error
    }

    // listen for an incoming connection
    conn, err := listener.Accept()
    if err != nil {
        // handle error
    }

    // send message
    if _, err := conn.Write({message}); err != nil {
        // handle error
    }
    // receive message
    buf := make([]byte, 512)
    n, err := conn.Read(buf[0:])
    if err != nil {
        // handle error
    }

  • 连接到UDP套接字

与TCP套接字相反,使用UDP套接字,客户端只是向服务器发送数据报。没有Accept函数,因为服务器不需要接受连接,而只是等待数据报到达。

img{512x368}
图:UDP Socket

其他TCP函数都具有UDP对应的函数;只需在上述函数中将TCP替换为UDP。

客户端:

// init
    raddr, err := net.ResolveUDPAddr("udp", address)
    if err != nil {
        // handle error
    }

    conn, err := net.DialUDP("udp", nil, raddr)
    if err != nil {
        // handle error
    }
        .......
    // send message
    buffer := make([]byte, maxBufferSize)
    n, addr, err := conn.ReadFrom(buffer)
    if err != nil {
        // handle error
    }
         .......
    // receive message
    buffer := make([]byte, maxBufferSize)
    n, err = conn.WriteTo(buffer[:n], addr)
    if err != nil {
        // handle error
    }

服务端:

// init
    udpAddr, err := net.ResolveUDPAddr(resolver, serverAddr)
    if err != nil {
        // handle error
    }

    conn, err := net.ListenUDP("udp", udpAddr)
    if err != nil {
        // handle error
    }
        .......
    // send message
    buffer := make([]byte, maxBufferSize)
    n, addr, err := conn.ReadFromUDP(buffer)
    if err != nil {
        // handle error
    }
         .......
    // receive message
    buffer := make([]byte, maxBufferSize)
    n, err = conn.WriteToUDP(buffer[:n], addr)
    if err != nil {
        // handle error
    }

什么是WebSocket

WebSocket通信协议通过单个TCP连接提供全双工通信通道。与HTTP相比,WebSocket不需要您发送请求即可获得响应。它们允许双向数据流,因此您只需等待服务器响应即可。可用时,它将向您发送一条消息。

对于需要连续数据交换的服务(例如即时通讯程序,在线游戏和实时交易系统),WebSockets是一个很好的解决方案。您可以在RFC 6455规范中找到有关WebSocket协议的完整信息。

WebSocket连接由浏览器请求发起,并由服务器响应,之后连接就建立起来了。此过程通常称为握手。WebSockets中的特殊标头仅需要浏览器与服务器之间的一次握手即可建立连接,该连接将在其整个生命周期内保持活动状态。

WebSockets解决了许多实时Web开发的难题,与传统的HTTP相比,它具有许多优点:

  • 轻量级报头减少了数据传输开销。
  • 单个Web客户端仅需要一个TCP连接。
  • WebSocket服务器可以将数据推送到Web客户端。

img{512x368}
图:WebSocket

WebSocket协议实现起来相对简单。它使用HTTP协议进行初始握手。成功握手后,连接就建立起来了,并且WebSocket实质上使用原始TCP(raw tcp)来读取/写入数据。

客户端请求如下所示:

GET /chat HTTP/1.1
    Host: server.example.com
    Upgrade: websocket
    Connection: Upgrade
    Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
    Sec-WebSocket-Protocol: chat, superchat
    Sec-WebSocket-Version: 13
    Origin: http://example.com

这是服务器响应:

HTTP/1.1 101 Switching Protocols
    Upgrade: websocket
    Connection: Upgrade
    Sec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=
    Sec-WebSocket-Protocol: chat

如何在Go中创建WebSocket应用

要基于该net/http 库编写简单的WebSocket echo服务器,您需要:

  • 发起握手
  • 从客户端接收数据帧
  • 发送数据帧给客户端
  • 关闭握手

首先,让我们创建一个带有WebSocket端点的HTTP处理程序:

// HTTP server with WebSocket endpoint
func Server() {
        http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
            ws, err := NewHandler(w, r)
            if err != nil {
                 // handle error
            }
            if err = ws.Handshake(); err != nil {
                // handle error
            }
        …

然后初始化WebSocket结构。

初始握手请求始终来自客户端。服务器确定了WebSocket请求后,需要使用握手响应进行回复。

请记住,您无法使用http.ResponseWriter编写响应,因为一旦开始发送响应,它将关闭基础TCP连接。

因此,您需要使用HTTP劫持(hijack)。通过劫持,您可以接管基础的TCP连接处理程序和bufio.Writer。这使您可以在不关闭TCP连接的情况下读取和写入数据。

// NewHandler initializes a new handler
func NewHandler(w http.ResponseWriter, req *http.Request) (*WS, error) {
        hj, ok := w.(http.Hijacker)
        if !ok {
            // handle error
        }                  .....
}

要完成握手,服务器必须使用适当的头进行响应。

// Handshake creates a handshake header
    func (ws *WS) Handshake() error {

        hash := func(key string) string {
            h := sha1.New()
            h.Write([]byte(key))
            h.Write([]byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11"))

        return base64.StdEncoding.EncodeToString(h.Sum(nil))
        }(ws.header.Get("Sec-WebSocket-Key"))
      .....
}

“Sec-WebSocket-key”是随机生成的,并且是Base64编码的。接受请求后,服务器需要将此密钥附加到固定字符串。假设您有x3JJHMbDL1EzLkh9GBhXDw== 钥匙。在这个例子中,可以使用SHA-1计算二进制值,并使用Base64对其进行编码。假设你得到HSmrc0sMlYUkAGmm5OPpG2HaGWk=。使,用它作为Sec-WebSocket-Accept 响应头的值。

传输数据帧

握手成功完成后,您的应用程序可以从客户端读取数据或向客户端写入数据。WebSocket规范定义了的一个客户机和服务器之间使用的特定帧格式。这是框架的位模式:

img{512x368}
图:传输数据帧的位模式

使用以下代码对客户端有效负载进行解码:

// Recv receives data and returns a Frame
    func (ws *WS) Recv() (frame Frame, _ error) {
        frame = Frame{}
        head, err := ws.read(2)
        if err != nil {
            // handle error
        }

反过来,这些代码行允许对数据进行编码:

// Send sends a Frame
    func (ws *WS) Send(fr Frame) error {
        // make a slice of bytes of length 2
        data := make([]byte, 2)

        // Save fragmentation & opcode information in the first byte
        data[0] = 0x80 | fr.Opcode
        if fr.IsFragment {
            data[0] &= 0x7F
        }
        .....

关闭握手

当各方之一发送状态为关闭的关闭帧作为有效负载时,握手将关闭。可选地,发送关闭帧的一方可以在有效载荷中发送关闭原因。如果关闭是由客户端发起的,则服务器应发送相应的关闭帧作为响应。

// Close sends a close frame and closes the TCP connection
func (ws *Ws) Close() error {
    f := Frame{}
    f.Opcode = 8
    f.Length = 2
    f.Payload = make([]byte, 2)
    binary.BigEndian.PutUint16(f.Payload, ws.status)
    if err := ws.Send(f); err != nil {
        return err
    }
    return ws.conn.Close()
}

WebSocket库列表

有几个第三方库可简化开发人员的开发工作,并极大地促进使用WebSockets。

  • STDLIB(golang.org/x/net/websocket)

此WebSocket库是标准库的一部分。如RFC 6455规范中所述,它为WebSocket协议实现了客户端和服务器。它不需要安装并且有很好的官方文档。但是,另一方面,它仍然缺少其他WebSocket库中可以找到的某些功能。/x/net/websocket软件包中的Golang WebSocket实现不允许用户以明确的方式重用连接之间的I/O缓冲区。

让我们检查一下STDLIB软件包的工作方式。这是用于执行基本功能(如创建连接以及发送和接收消息)的代码示例。

首先,要安装和使用此库,应将以下代码行添加到您的:

import "golang.org/x/net/websocket"

客户端:

    // create connection
    // schema can be ws:// or wss://
    // host, port – WebSocket server
    conn, err := websocket.Dial("{schema}://{host}:{port}", "", op.Origin)
    if err != nil {
        // handle error
    }
    defer conn.Close()
             .......
      // send message
        if err = websocket.JSON.Send(conn, {message}); err != nil {
         // handle error
    }
              .......
        // receive message
    // messageType initializes some type of message
    message := messageType{}
    if err := websocket.JSON.Receive(conn, &message); err != nil {
          // handle error
    }
        .......

服务器端:

    // Initialize WebSocket handler + server
    mux := http.NewServeMux()
        mux.Handle("/", websocket.Handler(func(conn *websocket.Conn) {
            func() {
                for {

                    // do something, receive, send, etc.
                }
            }
            .......
        // receive message
    // messageType initializes some type of message
    message := messageType{}
    if err := websocket.JSON.Receive(conn, &message); err != nil {
        // handle error
    }
        .......
    // send message
    if err := websocket.JSON.Send(conn, message); err != nil {
        // handle error
    }
        ........
  • GORILLA

Gorilla Web工具包中的WebSocket软件包拥有WebSocket协议的完整且经过测试的实现以及稳定的软件包API。WebSocket软件包文档齐全,易于使用。您可以在Gorilla官方网站上找到文档。

安装

go get github.com/gorilla/websocket
Examples of code
Client side:
 // init
    // schema – can be ws:// or wss://
    // host, port – WebSocket server
    u := url.URL{
        Scheme: {schema},
        Host:   {host}:{port},
        Path:   "/",
    }
    c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        // handle error
    }
        .......
    // send message
    err := c.WriteMessage(websocket.TextMessage, {message})
    if err != nil {
        // handle error
    }
        .......
    // receive message
    _, message, err := c.ReadMessage()
    if err != nil {
        // handle error
    }
        .......

服务器端:

  // init
    u := websocket.Upgrader{}
    c, err := u.Upgrade(w, r, nil)
    if err != nil {
        // handle error
    }
        .......
    // receive message
    messageType, message, err := c.ReadMessage()
    if err != nil {
        // handle error
    }
        .......
    // send message
    err = c.WriteMessage(messageType, {message})
    if err != nil {
        // handle error
    }
        .......
  • GOBWAS

这个微小的WebSocket封装具有强大的功能列表,例如零拷贝升级(zero-copy upgrade)和允许构建自定义数据包处理逻辑的低级API。GOBWAS在I/O期间不需要中间做额外分配操作。它还在wsutil软件包中提供了围绕API的高级包装API和帮助API,使开发人员可以快速使用,而无需深入研究协议的内部。该库具有灵活的API,但这是以可用性和清晰度为代价的。

可在GoDoc网站上找到文档。您可以通过下面代码行来安装它:

go get github.com/gobwas/ws

客户端:

    // init
    // schema – can be ws or wss
    // host, port – ws server
    conn, _, _, err := ws.DefaultDialer.Dial(ctx, {schema}://{host}:{port})
    if err != nil {
        // handle error
    }
        .......
    // send message
    err = wsutil.WriteClientMessage(conn, ws.OpText, {message})
    if err != nil {
        // handle error
    }

        .......
    // receive message
    msg, _, err := wsutil.ReadServerData(conn)
    if err != nil {
        // handle error
    }
        .......

服务器端:

   // init
    listener, err := net.Listen("tcp", op.Port)
    if err != nil {
        // handle error
    }
    conn, err := listener.Accept()
    if err != nil {
        // handle error
    }
    upgrader := ws.Upgrader{}
    if _, err = upgrader.Upgrade(conn); err != nil {
        // handle error
    }
        .......
    // receive message
    for {
         reader := wsutil.NewReader(conn, ws.StateServerSide)
         _, err := reader.NextFrame()
         if err != nil {
             // handle error
         }
         data, err := ioutil.ReadAll(reader)
         if err != nil {
             // handle error
         }
            .......
    }
        .......
    // send message
    msg := "new server message"
    if err := wsutil.WriteServerText(conn, {message}); err != nil {
        // handle error
    }
        .......
  • GOWebsockets

该工具提供了广泛的易于使用的功能。它允许并发控制,数据压缩和设置请求标头。GoWebsockets支持代理和子协议,用于发送和接收文本和二进制数据。开发人员还可以启用或禁用SSL验证。

您可以在GoDoc网站和项目的GitHub页面上找到有关如何使用GOWebsockets的文档和示例。通过添加以下代码行来安装软件包:

go get github.com/sacOO7/gowebsocket

客户端:

    // init
    // schema – can be ws or wss
    // host, port – ws server
    socket := gowebsocket.New({schema}://{host}:{port})
    socket.Connect()
        .......
    // send message
    socket.SendText({message})
    or
    socket.SendBinary({message})
        .......
    // receive message
    socket.OnTextMessage = func(message string, socket gowebsocket.Socket) {
        // hande received message
    };
    or
    socket.OnBinaryMessage = func(data [] byte, socket gowebsocket.Socket) {
        // hande received message
    };
        .......

服务器端:

    // init
    // schema – can be ws or wss
    // host, port – ws server
    conn, _, _, err := ws.DefaultDialer.Dial(ctx, {schema}://{host}:{port})
    if err != nil {
        // handle error
    }
        .......
    // send message
    err = wsutil.WriteClientMessage(conn, ws.OpText, {message})
    if err != nil {
        // handle error
    }
        .......
    // receive message
    msg, _, err := wsutil.ReadServerData(conn)
    if err != nil {
        // handle error
    }

比较现有解决方案

我们已经描述了Go中使用最广泛的四个WebSocket库。下表包含这些工具的详细比较。

img{512x368}
图 Websocket库比较

为了更好地分析其性能,我们还进行了一些基准测试。结果如下:

img{512x368}

  • 如您所见,GOBWAS与其他库相比具有明显的优势。每个操作分配的内存更少,每个分配使用的内存和时间更少。另外,它的I/O分配为零。此外,GOBWAS还具有创建WebSocket客户端与服务器的交互并接收消息片段所需的所有方法。您也可以使用它轻松地使用TCP套接字。

  • 如果您真的不喜欢GOBWAS,则可以使用Gorilla。它非常简单,几乎具有所有相同的功能。您也可以使用STDLIB,但由于它缺少许多必要的功能,并且在生产中表现不佳,而且正如您在基准测试中所看到的那样,它的性能较弱。GOWebsocket与STDLIB大致相同。但是,如果您需要快速构建原型或MVP,则它可能是一个合理的选择。

除了这些工具之外,还有几种替代实现可让您构建强大的流处理解决方案。其中有:

流技术的不断发展以及WebSockets等文档较好的可用工具的存在,使开发人员可以轻松创建真正的实时应用程序。 如果您需要使用WebSockets创建实时应用程序的建议或帮助,请给我们写信。希望本教程对您有所帮助。

本文翻译自《How to Use Websockets in Golang : Best Tools and Step-by-Step Guide》


我的网课“Kubernetes实战:高可用集群搭建、配置、运维与应用”在慕课网上线了,感谢小伙伴们学习支持!

我爱发短信:企业级短信平台定制开发专家 https://tonybai.com/
smspush : 可部署在企业内部的定制化短信平台,三网覆盖,不惧大并发接入,可定制扩展; 短信内容你来定,不再受约束, 接口丰富,支持长短信,签名可选。

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

我的联系方式:

微博:https://weibo.com/bigwhite20xx
微信公众号:iamtonybai
博客:tonybai.com
github: https://github.com/bigwhite

微信赞赏:
img{512x368}

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 Go语言编程指南
商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats