2023年一月月 发布的文章

聊聊Go与TLS 1.3

本文永久链接 – https://tonybai.com/2023/01/13/go-and-tls13

除了一些综述类文章和译文,我的文章选题多来源于实际工作和学习中遇到的问题。这次我们来聊聊近期遇到一个问题:如何加快基于TLS安全通信的海量连接的建连速度?

TLS(Transport Layer Security)传输安全层的下面是TCP层,我们首先可能会想到的是优化内核有关TCP握手的相关参数来快速建立TCP连接,比如:

  • net.ipv4.tcp_max_syn_backlog
  • net.ipv4.tcp_syncookies
  • net.ipv4.tcp_synack_retries
  • net.ipv4.tcp_abort_on_overflow
  • net.core.somaxconn
  • … …

关于Linux内核参数调优,大家可以参考一下极客时间专栏《系统性能调优必知必会》

此外为了加速海量连接的建连速度,提高应用从内核accept连接队列获取连接的速度,我们还可以采用多线程/多goroutine并发Listen同一个端口并并发Accept的机制,如果你使用的是Go语言,可以看看go-reuseport这个包。

说完TCP层,那么TLS层是否有可优化的、对建连速度有影响的地方呢?有的,那就是使用TLS 1.3版本来加速握手过程,从而加快建连速度。TLS 1.3是2018年发布的新TLS标准,近2-3年才开始得到主流语言、浏览器和web服务器的支持。那么它与之前的TLS 1.2有何不同呢?Go对TLS 1.3版本的支持程度如何?如何用Go编写使用TLS 1.3的安全通信代码?TLS 1.3建连速度究竟比TLS 1.2快多少呢?

带着这些问题,我们进入本篇正文部分!我们先来简要看看TLS 1.3与TLS 1.2版本的差异。

1. TLS 1.3与TLS 1.2的差异

TLS是由互联网工程任务组(Internet Engineering Task Force, IETF)制定和发布的、用于替代SSL的、基于加解密和签名算法的安全连接协议标准,其演进过程如下图:

其中TLS 1.0和1.1版本因不再安全,于2020年被作废,目前主流的版本,也是应用最为广泛的是2008年发布的TLS 1.2版本(使用占比如下图统计),而最新版本则是2018年正式发布的TLS 1.3,而TLS 1.3版本的发布也意味着TLS 1.2版本进入“作废期”,虽然实际中TLS 1.2的“下线”还需要很长时间:

TLS 1.3与TLS 1.2并不不兼容,在TLS 1.3协议规范中,我们能看到列出的TLS 1.3相对于TLS 1.2的一些主要改动:

  • 去除了原先对称加密算法列表中的非AEAD(Authenticated Encryption with Associated Data)算法,包括3DES、RC4、AES-CBC等,只支持更安全的加密算法。

注:常见的AEAD算法包括:AES-128-GCM、AES-256-GCM、ChaCha20-IETF-Poly1305等。在具备AES加速的CPU(桌面,服务器)上,建议使用AES-XXX-GCM系列,移动设备建议使用ChaCha20-IETF-Poly1305系列。

  • 静态RSA和Diffie-Hellman密码套件(cipher suites)已被删除;所有基于公钥的密钥交换机制现在都提供前向安全性。

注:前向安全(Forward Secrecy)是指的是长期使用的主密钥泄漏不会导致过去的会话密钥泄漏。前向安全能够保护过去进行的通讯不受密码或密钥在未来暴露的威胁。如果系统具有前向安全性,就可以保证在主密钥泄露时历史通讯的安全,即使系统遭到主动攻击也是如此。

  • TLS 1.2版本的协商机制已被废弃,引入了一个更快的新的密钥协商机制:PSK(Pre-Shared Key),简化了握手流程(下图是TLS 1.2与TLS 1.3握手流程的对比)。同时在ServerHello之后的所有握手信息现在都被加密了,以前在ServerHello中以明文方式发送的各种扩展信息现在也可以享受加密保护。

  • 增加了一个零往返时间(0-RTT)模式,在恢复连接建立时为一些应用数据节省了一个往返时间。但代价是丧失了某些安全属性。

注:当客户端(例如浏览器)首次成功完成与服务器的TLS 1.3握手后,客户端和服务器都可在本地存储预共享的加密密钥,这称为恢复主密钥。如果客户端稍后再次与服务器建立连接,则可以使用此恢复密钥将其第一条消息中的加密应用程序数据发送到服务器,而无需第二次执行握手。0-RTT模式有一个安全弱点。通过恢复模式发送数据不需要服务器的任何交互,这意味着攻击者(一般是中间人(middle-man))可以捕获加密的0-RTT数据,然后将其重新发送到服务器,或重放(Replay)它们。解决此问题的方法是确保所有0-RTT请求都是幂等的。

在这些主要变化中,与初次建连速度有关的显然是TLS 1.3握手机制的变化:从2-RTT缩短到1-RTT(如上图所示)。下面我们就用Go作为示例来看看TLS 1.3相对于TLS 1.2在建连速度方面究竟有怎样的提升。

2. Go对TLS 1.3的支持

  • Go语言从Go 1.12版本开始提供对TLS 1.3的可选支持。在Go 1.12版本下,你通过设置GODEBUG=tls13=1并且不显式设置tls Config的MaxVersion的情况下,便会开启TLS 1.3。这个版本实现中暂不支持TLS 1.3的0-RTT的特性。

  • Go 1.13版本默认情况下开启TLS 1.3,你可以使用GODEBUG=tls13=0关闭对TLS 1.3的支持。

  • 等到了Go 1.14版本,TLS 1.3成为默认TLS版本选项且无法再用GODEBUG=tls13=0关闭了!不过,通过Config.MaxVersion可以配置要使用的TLS版本。

  • Go 1.16版本中,在服务端或客户端不支持AES硬件加速的情况下,server端会优先选择其他AEAD的密码套件(cipher suite),比如ChaCha20Poly1305,而不会选择AES-GCM密码套件。

  • Go 1.18版本中,client端的Config.MinVersion将默认为TLS 1.2, 以替代原先的默认值TLS 1.0/TLS 1.1。不过你可以通过显式设置客户端的Config.MinVersion来改变这个设置。不过这个改动不影响server端。

了解了这些后,我们来看一个简单的使用Go和TLS 1.3版本的客户端与服务端示例。

3. Go TLS 1.3客户端与服务端通信示例

这次我们不去参考Go标准库crypto/tls包的样例,我们玩把时髦儿的:通过AI辅助生成一套基于TLS的client与server端的通信代码示例。ChatGPT不对大陆开放,我这里用的是AI编程助手(AICodeHelper),下面是生成过程的截图:

AICodeHelper为我们生成了大部分代码,但是server端代码有两个问题:只能处理一个client端连接和没有生成传入server证书和私钥的代码段,我们基于上面的框架代码做一下修改,得到我们的server和client端代码:

server端代码:

// https://github.com/bigwhite/experiments/blob/master/go-and-tls13/server.go
package main

import (
    "bufio"
    "crypto/tls"
    "fmt"
    "net"
)

func main() {
    cer, err := tls.LoadX509KeyPair("server.crt", "server.key")
    if err != nil {
        fmt.Println(err)
        return
    }

    config := &tls.Config{Certificates: []tls.Certificate{cer}}
    ln, err := tls.Listen("tcp", "localhost:8443", config)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer ln.Close()

    for {
        conn, err := ln.Accept()
        if err != nil {
            fmt.Println(err)
            continue
        }
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()
    r := bufio.NewReader(conn)
    for {
        msg, err := r.ReadString('\n')
        if err != nil {
            fmt.Println(err)
            return
        }

        println(msg)

        n, err := conn.Write([]byte("hello, world from server\n"))
        if err != nil {
            fmt.Println(n, err)
            return
        }
    }
}
// https://github.com/bigwhite/experiments/blob/master/go-and-tls13/client.go

package main

import (
    "crypto/tls"
    "log"
)

func main() {
    conf := &tls.Config{
        InsecureSkipVerify: true,
    }

    conn, err := tls.Dial("tcp", "localhost:8443", conf)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()

    n, err := conn.Write([]byte("hello, world from client\n"))
    if err != nil {
        log.Println(n, err)
        return
    }

    buf := make([]byte, 100)
    n, err = conn.Read(buf)
    if err != nil {
        log.Println(n, err)
        return
    }

    println(string(buf[:n]))
}

为了方便期间,这里使用自签名证书,并且客户端不对服务端的公钥数字证书进行验签(我们无需生成创建CA的相关key和证书),我们只需要使用下面命令生成一对server.key和server.crt:

$openssl genrsa -out server.key 2048
Generating RSA private key, 2048 bit long modulus
..........................+++
................................+++
e is 65537 (0x10001)

$openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) []:
State or Province Name (full name) []:
Locality Name (eg, city) []:
Organization Name (eg, company) []:
Organizational Unit Name (eg, section) []:
Common Name (eg, fully qualified host name) []:localhost
Email Address []:

关于非对称加密和数字证书方面的详细内容,可以参见我的《Go语言精进之路》一书的第51条“使用net/http包实现安全通信”

运行Server和Client,这里我使用的是Go 1.19版本编译器:

$go run server.go
hello, world from client

EOF

$go run client.go
hello, world from server

我们的示例已经可以正常运行了!那么如何证明示例中的client与server间使用的是1.3版本的TLS连接呢?或者如何查看client与server间使用的是哪个TLS版本呢?

有小伙伴可能会说:用wireshark抓包看,这个可行,但是用wireshark抓tls包,尤其是1.3建连包比较费劲。我们有更简单的方式,我们在开发环境可以通过修改标准库来实现。我们继续往下看。

4. server和client端的TLS版本的选择

TLS握手过程由client端发起,从client的视角,当client收到serverHello的响应后便可得到决策后要使用的TLS版本。因此这里我们改造一下crypto/tls/handshake_client.go的clientHandshake方法,在其实现中利用fmt.Printf输出TLS连接相关的信息即可(见下面代码中”====”开头的输出内容):

// $GOROOT/src/crypto/tls/handshake_client.go

func (c *Conn) clientHandshake(ctx context.Context) (err error) {
    ... ...
    hello, ecdheParams, err := c.makeClientHello()
    if err != nil {
        return err
    }
    c.serverName = hello.serverName

    fmt.Printf("====client: supportedVersions: %x, cipherSuites: %x\n", hello.supportedVersions, hello.cipherSuites)

    ... ...

    msg, err := c.readHandshake()
    if err != nil {
        return err
    }

    serverHello, ok := msg.(*serverHelloMsg)
    if !ok {
        c.sendAlert(alertUnexpectedMessage)
        return unexpectedMessageError(serverHello, msg)
    }

    if err := c.pickTLSVersion(serverHello); err != nil {
        return err
    }

    ... ...

    if c.vers == VersionTLS13 {
        fmt.Printf("====client: choose tls 1.3, server use ciphersuite: [0x%x]\n", serverHello.cipherSuite)
        ... ...
        // In TLS 1.3, session tickets are delivered after the handshake.
        return hs.handshake()
    }
    fmt.Printf("====client: choose tls 1.2, server use ciphersuite: [0x%x]\n", serverHello.cipherSuite)

    hs := &clientHandshakeState{
        ... ...
    }

    if err := hs.handshake(); err != nil {
        return err
    }
    ... ...
}

修改完标准库后,我们再来重新运行一下上面的client.go:

$go run client.go
====client: supportedVersions: [304 303], cipherSuites: [c02b c02f c02c c030 cca9 cca8 c009 c013 c00a c014 9c 9d 2f 35 c012 a 1301 1302 1303]
====client: choose tls 1.3, server use ciphersuite: [0x1301]
hello, world from server

这里我们看一下第一行输出的内容,这里输出的是client端构建clientHello握手包中的内容,展示的是client端支持的TLS版本以及密码套件(cipher suites),我们看到客户端支持0×304、0×303两个TLS版本,这两个数字与下面代码中的常量分别对应:

// $GOROOT/src/crypto/tls/common.go
const (
    VersionTLS10 = 0x0301
    VersionTLS11 = 0x0302
    VersionTLS12 = 0x0303
    VersionTLS13 = 0x0304

    // Deprecated: SSLv3 is cryptographically broken, and is no longer
    // supported by this package. See golang.org/issue/32716.
    VersionSSL30 = 0x0300
)

而输出的cipherSuites中包含的那些十六进制数则来自下面常量:

// $GOROOT/src/crypto/tls/cipher_suites.go
const (
    // TLS 1.0 - 1.2 cipher suites.
    TLS_RSA_WITH_RC4_128_SHA                      uint16 = 0x0005
    TLS_RSA_WITH_3DES_EDE_CBC_SHA                 uint16 = 0x000a
    TLS_RSA_WITH_AES_128_CBC_SHA                  uint16 = 0x002f
    TLS_RSA_WITH_AES_256_CBC_SHA                  uint16 = 0x0035
    TLS_RSA_WITH_AES_128_CBC_SHA256               uint16 = 0x003c
    TLS_RSA_WITH_AES_128_GCM_SHA256               uint16 = 0x009c
    TLS_RSA_WITH_AES_256_GCM_SHA384               uint16 = 0x009d
    TLS_ECDHE_ECDSA_WITH_RC4_128_SHA              uint16 = 0xc007
    TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA          uint16 = 0xc009
    TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA          uint16 = 0xc00a
    TLS_ECDHE_RSA_WITH_RC4_128_SHA                uint16 = 0xc011
    TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA           uint16 = 0xc012
    TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA            uint16 = 0xc013
    TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA            uint16 = 0xc014
    TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256       uint16 = 0xc023
    TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256         uint16 = 0xc027
    TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256         uint16 = 0xc02f
    TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256       uint16 = 0xc02b
    TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384         uint16 = 0xc030
    TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384       uint16 = 0xc02c
    TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256   uint16 = 0xcca8
    TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xcca9

    // TLS 1.3 cipher suites.
    TLS_AES_128_GCM_SHA256       uint16 = 0x1301
    TLS_AES_256_GCM_SHA384       uint16 = 0x1302
    TLS_CHACHA20_POLY1305_SHA256 uint16 = 0x1303
    ... ...
}

而从client.go运行结果中的第二行输出可以看出:这次建连,双方最终选择了TLS 1.3版本和TLS_AES_128_GCM_SHA256这个cipher suite。这与前面我们在回顾Go语言对TLS 1.3的支持历史中的描述一致,TLS 1.3是建连版本的默认选择。

那么我们是否可以选择建连时使用的版本呢?当然可以,我们既可以在server端配置,也可以在客户端配置。我们先来看看在Server端如何配置:

// https://github.com/bigwhite/experiments/blob/master/go-and-tls13/server_tls12.go

func main() {
    cer, err := tls.LoadX509KeyPair("server.crt", "server.key")
    if err != nil {
        fmt.Println(err)
        return
    }

    config := &tls.Config{
        Certificates: []tls.Certificate{cer},
        MaxVersion:   tls.VersionTLS12,
    }
    ... ...
}

我们基于server.go创建了server_tls12.go,在这个新源文件中,我们在tls.Config中增加一个配置MaxVersion,并将其值设置为tls.VersionTLS12,其含义是其最高支持的TLS版本为TLS 1.2。这样当我们使用client.go与基于server_tls12.go运行的服务端程序建连时,我们将得到下面输出:

$go run client.go
====client: supportedVersions: [304 303], cipherSuites: [c02b c02f c02c c030 cca9 cca8 c009 c013 c00a c014 9c 9d 2f 35 c012 a 1301 1302 1303]
====client: choose tls 1.2, server use ciphersuite: [0xc02f]
hello, world from server

我们看到,交互的双方最后选择了TLS 1.2版本,使用的密码套件为0xc02f,即TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256。

同理,如果你想在client端配置最高支持TLS 1.2版本的话,也可以采用同样的方式,大家可以看看本文对应代码库中的client_tls12.go这个源文件,这里就不赘述了。

到这里,一些小伙伴可能有了一个疑问:我们可以配置使用的TLS的版本,那么对于TLS 1.3而言,我们是否可以配置要使用的密码套件呢?答案是目前不可以,理由来自于Config.CipherSuites字段的注释:“Note that TLS 1.3 ciphersuites are not configurable”:

// $GOROOT/src/crypto/tls/common.go

type Config struct {
    ... ...
    // CipherSuites is a list of enabled TLS 1.0–1.2 cipher suites. The order of
    // the list is ignored. Note that TLS 1.3 ciphersuites are not configurable.
    //
    // If CipherSuites is nil, a safe default list is used. The default cipher
    // suites might change over time.
    CipherSuites []uint16
    ... ...
}

tls包会根据系统是否支持AES加速来选择密码套件,如果支持AES加速,就使用下面的defaultCipherSuitesTLS13,这样AES相关套件会被优先选择,否则defaultCipherSuitesTLS13NoAES会被使用,TLS_CHACHA20_POLY1305_SHA256会被优先选择:

// $GOROOT/src/crypto/tls/cipher_suites.go

// defaultCipherSuitesTLS13 is also the preference order, since there are no
// disabled by default TLS 1.3 cipher suites. The same AES vs ChaCha20 logic as
// cipherSuitesPreferenceOrder applies.
var defaultCipherSuitesTLS13 = []uint16{
    TLS_AES_128_GCM_SHA256,
    TLS_AES_256_GCM_SHA384,
    TLS_CHACHA20_POLY1305_SHA256,
}   

var defaultCipherSuitesTLS13NoAES = []uint16{
    TLS_CHACHA20_POLY1305_SHA256,
    TLS_AES_128_GCM_SHA256,
    TLS_AES_256_GCM_SHA384,
}

注:joe shaw曾写过一篇文章“Abusing go:linkname to customize TLS 1.3 cipher suites”,文中描述了一种通过go:linkname定制TLS 1.3密码套件的方法,有兴趣的小伙伴们可以去阅读一下。

5. 建连速度benchmark

最后我们再来看看相较于TLS 1.2,TLS 1.3的建连速度究竟快了多少。考虑到两个版本在RTT数量上的差异,即网络延迟对建连速度影响较大,我特意选择了一个ping在20-30ms的网络。我们为TLS 1.2和TLS 1.3分别建立Benchmark Test:

// https://github.com/bigwhite/experiments/blob/master/go-and-tls13/benchmark/benchmark_test.go

package main

import (
    "crypto/tls"
    "testing"
)

func tls12_dial() error {
    conf := &tls.Config{
        InsecureSkipVerify: true,
        MaxVersion:         tls.VersionTLS12,
    }

    conn, err := tls.Dial("tcp", "192.168.11.10:8443", conf)
    if err != nil {
        return err
    }
    conn.Close()
    return nil
}

func tls13_dial() error {
    conf := &tls.Config{
        InsecureSkipVerify: true,
    }

    conn, err := tls.Dial("tcp", "192.168.11.10:8443", conf)
    if err != nil {
        return err
    }
    conn.Close()
    return nil
}

func BenchmarkTls13(b *testing.B) {
    b.ReportAllocs()

    for i := 0; i < b.N; i++ {
        err := tls13_dial()
        if err != nil {
            panic(err)
        }
    }
}

func BenchmarkTls12(b *testing.B) {
    b.ReportAllocs()

    for i := 0; i < b.N; i++ {
        err := tls12_dial()
        if err != nil {
            panic(err)
        }
    }
}

server部署在192.168.11.10上,针对每个benchmark test,我们给予10s钟的测试时间,下面是运行结果:

$go test -benchtime 10s -bench .
goos: linux
goarch: amd64
pkg: demo
cpu: Intel(R) Core(TM) i7-9700 CPU @ 3.00GHz
BenchmarkTls13-8        216   56036809 ns/op   47966 B/op     608 allocs/op
BenchmarkTls12-8        145   82395933 ns/op   26655 B/op     283 allocs/op
PASS
ok  demo 37.959s

我们看到相对与TLS 1.2,TLS 1.3建连速度的确更快些。不过从内存分配的情况来看,Go TLS 1.3的实现似乎更复杂一些。

6. 参考资料

  • RFC 8446:The Transport Layer Security (TLS) Protocol Version 1.3 – https://datatracker.ietf.org/doc/rfc8446/
  • 前向安全 – https://sunhuachuang.gitbooks.io/sun-note/content/cryptography/forward_backward_secrecy.html

本文涉及的源码可以在这里下载。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2022年,Gopher部落全面改版,将持续分享Go语言与Go应用领域的知识、技巧与实践,并增加诸多互动形式。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

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

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

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

2022年博客回顾与总结

本文永久链接 – https://tonybai.com/2023/01/11/2022-blog-summary

2022年对我来说,也是十分忙碌和充实的一年。尽管和2021年相比,成果物没那么多^_^。

伴随着二宝的长大,我发现自己的闲暇时间被进一步“压缩”,还好大宝上初中后领悟到了自驱学习的重要性和相关方法后,她的学习现在基本不需要我过问了。

2022年初,《Go语言精进之路:从新手到高手的编程思想、方法和技巧》系列1、2册上市后取得了不错的口碑,纸版书售卖量也还不错,在年中的时候都进入二印了,这也让我有机会修复一些勘误表中的问题,让读者拿到内容更准确的的版本。年中,我还借助谢大组织的“GoCN社区的Go读书会”分享了《Go语言精进之路》这本书的写作历程、内容导读以及个人的一些读书方法和经验。

我在极客时间的《Go语言第一课》专栏由于口碑相传,得到了很多Gopher的关注和学习,我也很积极的回答学员们的各种问题。目前该专栏大约排在极客时间周学习排行榜15名左右,不过还进不了首页推荐,和那些常驻首页的大V课程还没法比^_^。

2022年应谢大之邀,原本计划在GopherChina 2022之前的培训环节做一期《Go高级工程师训练营》培训的,但GopherChina因为疫情原因两次推迟,最终线下大会被取消,没能成行。期望在2023年能把这个培训补上。

2022年是我进入智能网联汽车这个赛道的第二个年头,精力主要花在研发几个重要的核心产品上,包括:车云通信产品、车端的基于DSL的数据处理产品、云端的流数据处理和时序数据存储产品等,跨度很大,难度很大。目前车云通信产品已经部署在我们主要客户的生产环境,为2023车型提供车云通道能力,另外我们也在与国内一些大主机厂做POC测试。时序数据存储产品进入关键的设计阶段,这块经验的确不足,需要投入较大精力学习、思考和尝试,2023年我将投入较大精力在这个产品上。

在博客写作方面,我仍然保持高昂的热情,粗略统计了一下,今年写了有80余篇。和2021年一样,这里我也根据阅读数量选出了2022年本博客最受欢迎的若干篇文章(排名不分先后):

复盘了一下2022年的博客文章,感觉目前的博客选题更多是“工作和学习中遇到的问题”来驱动的,还缺少系统化的规划和组织,2023年在这方面需要加强。

最后展望一下2023年!

在纸版书写作方面,2023年是否开启《Go语言精进之路》第三册、 是否扩写《Go语言第一课》专栏,然后整理成纸版书出版等都是可尝试的但未确定的事情。

专栏方面也有一些不成熟的选题想法:

  • 如何写出地道的Go代码
  • 深入理解Go核心技术
  • Go高级工程师必知必会(在培训的基础上扩充)

Gopher部落知识星球也将进入运营的第三个年头,2022年尝试做出了一些改变,效果还不错。2023年争取再聚焦一下:围绕少而精的几个主题做高质量分享。

2022年最大的“损失”是微博账号被冻结了,目前只能暂时用小号。之前的账号啥时候恢复也不清楚,也可能会永远失去那个账号。失去了微博这个重要的私域流量,损失还是蛮大的:(

2023年,由于时序数据存储这个产品的原因,可能会真正开始学习Rust语言,虽然之前了解过多次,但都是从入门到放弃了。这回有了产品和项目驱动,希望不会“重蹈覆辙”^_^。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2022年,Gopher部落全面改版,将持续分享Go语言与Go应用领域的知识、技巧与实践,并增加诸多互动形式。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

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

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! 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