kevinwan

kevinwan 查看完整档案

上海编辑南京大学  |  电子工程 编辑晓黑板  |  CTO 编辑 github.com/tal-tech/go-zero 编辑
编辑

go-zero作者

个人动态

kevinwan 发布了文章 · 2月5日

缓存设计的好,服务基本不会倒

本文由『Go开源说』第四期 go-zero 直播内容修改整理而成,视频内容较长,拆分成上下篇,本文内容有所删减和重构。

大家好,很高兴来到“GO开源说” 跟大家分享开源项目背后的一些故事、设计思想以及使用方法,今天分享的项目是 go-zero,一个集成了各种工程实践的 web 和 rpc 框架。我是Kevin,go-zero 作者,我的 github id 是 kevwan

go-zero 概览

go-zero 虽然是20年8月7号才开源,但是已经经过线上大规模检验了,也是我近20年工程经验的积累,开源后得到社区的积极反馈,在5个多月的时间里,获得了6k stars。多次登顶github Go语言日榜、周榜、月榜榜首,并获得了gitee最有价值项目(GVP),开源中国年度最佳人气项目。同时微信社区极为活跃,3000+人的社区群,go-zero爱好者们一起交流go-zero使用心得和讨论使用过程中的问题。

star

go-zero 如何自动管理缓存?

缓存设计原理

我们对缓存是只删除,不做更新,一旦DB里数据出现修改,我们就会直接删除对应的缓存,而不是去更新。

我们看看删除缓存的顺序怎样才是正确的。

  • 先删除缓存,再更新DB

我们看两个并发请求的情况,A请求需要更新数据,先删除了缓存,然后B请求来读取数据,此时缓存没有数据,就会从DB加载数据并写回缓存,然后A更新了DB,那么此时缓存内的数据就会一直是脏数据,知道缓存过期或者有新的更新数据的请求。如图

  • 先更新DB,再删除缓存

A请求先更新DB,然后B请求来读取数据,此时返回的是老数据,此时可以认为是A请求还没更新完,最终一致性,可以接受,然后A删除了缓存,后续请求都会拿到最新数据,如图

让我们再来看一下正常的请求流程:

  1. 第一个请求更新DB,并删除了缓存
  2. 第二个请求读取缓存,没有数据,就从DB读取数据,并回写到缓存里
  3. 后续读请求都可以直接从缓存读取

我们再看一下DB查询有哪些情况,假设行记录里有ABCDEFG七列数据:

  1. 只查询部分列数据的请求,比如请求其中的ABC,CDE或者EFG等,如图

  1. 查询单条完整行记录,如图

  1. 查询多条行记录的部分或全部列,如图

对于上面三种情况,首先,我们不用部分查询,因为部分查询没法缓存,一旦缓存了,数据有更新,没法定位到有哪些数据需要删除;其次,对于多行的查询,根据实际场景和需要,我们会在业务层建立对应的从查询条件到主键的映射;而对于单行完整记录的查询,go-zero 内置了完整的缓存管理方式。所以核心原则是:go-zero 缓存的一定是完整的行记录

下面我们来详细介绍 go-zero 内置的三种场景的缓存处理方式:

  1. 基于主键的缓存

    PRIMARY KEY (`id`)

    这种相对来讲是最容易处理的缓存,只需要在 redis 里用 primary key 作为 key 来缓存行记录即可。

  2. 基于唯一索引的缓存

    img

    在做基于索引的缓存设计的时候我借鉴了 database 索引的设计方法,在 database 设计里,如果通过索引去查数据时,引擎会先在 索引->主键tree 里面查找到主键,然后再通过主键去查询行记录,就是引入了一个间接层去解决索引到行记录的对应问题。在 go-zero 的缓存设计里也是同样的原理。

    基于索引的缓存又分为单列唯一索引和多列唯一索引:

    • 单列唯一索引如下:

      UNIQUE KEY `product_idx` (`product`)
    • 多列唯一索引如下:

      UNIQUE KEY `vendor_product_idx` (`vendor`, `product`)

    但是对于 go-zero 来说,单列和多列只是生成缓存 key 的方式不同而已,背后的控制逻辑是一样的。然后 go-zero 内置的缓存管理就比较好的控制了数据一致性问题,同时也内置防止了缓存的击穿、穿透、雪崩问题(这些在 gopherchina 大会上分享的时候仔细讲过,见后续 gopherchina 分享视频)。

    另外,go-zero 内置了缓存访问量、访问命中率统计,如下所示:

    dbcache(sqlc) - qpm: 5057, hit_ratio: 99.7%, hit: 5044, miss: 13, db_fails: 0

    可以看到比较详细的统计信息,便于我们来分析缓存的使用情况,对于缓存命中率极低或者请求量极小的情况,我们就可以去掉缓存了,这样也可以降低成本。

缓存代码解读

1. 基于主键的缓存逻辑

img

具体实现代码如下:

func (cc CachedConn) QueryRow(v interface{}, key string, query QueryFn) error {
  return cc.cache.Take(v, key, func(v interface{}) error {
    return query(cc.db, v)
  })
}

这里的 Take 方法是先从缓存里去通过 key 拿数据,如果拿到就直接返回,如果拿不到,那么就通过 query 方法去 DB 读取完整行记录并写回缓存,然后再返回数据。整个逻辑还是比较简单易懂的。

我们详细看看 Take 的实现:

func (c cacheNode) Take(v interface{}, key string, query func(v interface{}) error) error {
  return c.doTake(v, key, query, func(v interface{}) error {
    return c.SetCache(key, v)
  })
}

Take 的逻辑如下:

  • key 从缓存里查找数据
  • 如果找到,则返回数据
  • 如果找不到,用 query 方法去读取数据
  • 读到后调用 c.SetCache(key, v) 设置缓存

其中的 doTake 代码和解释如下:

// v - 需要读取的数据对象
// key - 缓存key
// query - 用来从DB读取完整数据的方法
// cacheVal - 用来写缓存的方法
func (c cacheNode) doTake(v interface{}, key string, query func(v interface{}) error,
  cacheVal func(v interface{}) error) error {
  // 用barrier来防止缓存击穿,确保一个进程内只有一个请求去加载key对应的数据
  val, fresh, err := c.barrier.DoEx(key, func() (interface{}, error) {
    // 从cache里读取数据
    if err := c.doGetCache(key, v); err != nil {
      // 如果是预先放进来的placeholder(用来防止缓存穿透)的,那么就返回预设的errNotFound
      // 如果是未知错误,那么就直接返回,因为我们不能放弃缓存出错而直接把所有请求去请求DB,
      // 这样在高并发的场景下会把DB打挂掉的
      if err == errPlaceholder {
        return nil, c.errNotFound
      } else if err != c.errNotFound {
        // why we just return the error instead of query from db,
        // because we don't allow the disaster pass to the DBs.
        // fail fast, in case we bring down the dbs.
        return nil, err
      }

      // 请求DB
      // 如果返回的error是errNotFound,那么我们就需要在缓存里设置placeholder,防止缓存穿透
      if err = query(v); err == c.errNotFound {
        if err = c.setCacheWithNotFound(key); err != nil {
          logx.Error(err)
        }

        return nil, c.errNotFound
      } else if err != nil {
        // 统计DB失败
        c.stat.IncrementDbFails()
        return nil, err
      }

      // 把数据写入缓存
      if err = cacheVal(v); err != nil {
        logx.Error(err)
      }
    }
    
    // 返回json序列化的数据
    return jsonx.Marshal(v)
  })
  if err != nil {
    return err
  }
  if fresh {
    return nil
  }

  // got the result from previous ongoing query
  c.stat.IncrementTotal()
  c.stat.IncrementHit()

  // 把数据写入到传入的v对象里
  return jsonx.Unmarshal(val.([]byte), v)
}

2. 基于唯一索引的缓存逻辑

因为这块比较复杂,所以我用不同颜色标识出来了响应的代码块和逻辑,block 2 其实跟基于主键的缓存是一样的,这里主要讲 block 1 的逻辑。

代码块的 block 1 部分分为两种情况:

  1. 通过索引能够从缓存里找到主键

    此时就直接用主键走 block 2 的逻辑了,后续同上面基于主键的缓存逻辑

  2. 通过索引无法从缓存里找到主键

    • 通过索引从DB里查询完整行记录,如有 error,返回
    • 查到完整行记录后,会把主键到完整行记录的缓存和索引到主键的缓存同时写到 redis
    • 返回所需的行记录数据
    // v - 需要读取的数据对象
    // key - 通过索引生成的缓存key
    // keyer - 用主键生成基于主键缓存的key的方法
    // indexQuery - 用索引从DB读取完整数据的方法,需要返回主键
    // primaryQuery - 用主键从DB获取完整数据的方法
    func (cc CachedConn) QueryRowIndex(v interface{}, key string, keyer func(primary interface{}) string,
      indexQuery IndexQueryFn, primaryQuery PrimaryQueryFn) error {
      var primaryKey interface{}
      var found bool
    
      // 先通过索引查询缓存,看是否有索引到主键的缓存
      if err := cc.cache.TakeWithExpire(&primaryKey, key, func(val interface{}, expire time.Duration) (err error) {
        // 如果没有索引到主键的缓存,那么就通过索引查询完整数据
        primaryKey, err = indexQuery(cc.db, v)
        if err != nil {
          return
        }
    
        // 通过索引查询到了完整数据,设置found,后面直接使用,不需要再从缓存读取数据了
        found = true
        // 将主键到完整数据的映射保存到缓存里,TakeWithExpire方法已经将索引到主键的映射保存到缓存了
        return cc.cache.SetCacheWithExpire(keyer(primaryKey), v, expire+cacheSafeGapBetweenIndexAndPrimary)
      }); err != nil {
        return err
      }
    
      // 已经通过索引找到了数据,直接返回即可
      if found {
        return nil
      }
    
      // 通过主键从缓存读取数据,如果缓存没有,通过primaryQuery方法从DB读取并回写缓存再返回数据
      return cc.cache.Take(v, keyer(primaryKey), func(v interface{}) error {
        return primaryQuery(cc.db, v, primaryKey)
      })
    }

    我们来看一个实际的例子

    func (m *defaultUserModel) FindOneByUser(user string) (*User, error) {
      var resp User
      // 生成基于索引的key
      indexKey := fmt.Sprintf("%s%v", cacheUserPrefix, user)
      
      err := m.QueryRowIndex(&resp, indexKey,
        // 基于主键生成完整数据缓存的key
        func(primary interface{}) string {
          return fmt.Sprintf("user#%v", primary)
        },
        // 基于索引的DB查询方法
        func(conn sqlx.SqlConn, v interface{}) (i interface{}, e error) {
          query := fmt.Sprintf("select %s from %s where user = ? limit 1", userRows, m.table)
          if err := conn.QueryRow(&resp, query, user); err != nil {
            return nil, err
          }
          return resp.Id, nil
        },
        // 基于主键的DB查询方法
        func(conn sqlx.SqlConn, v, primary interface{}) error {
          query := fmt.Sprintf("select %s from %s where id = ?", userRows, m.table)
          return conn.QueryRow(&resp, query, primary)
        })
      
      // 错误处理,需要判断是否返回的是sqlc.ErrNotFound,如果是,我们用本package定义的ErrNotFound返回
      // 避免使用者感知到有没有使用缓存,同时也是对底层依赖的隔离
      switch err {
        case nil:
          return &resp, nil
        case sqlc.ErrNotFound:
          return nil, ErrNotFound
        default:
          return nil, err
      }
    }

所有上面这些缓存的自动管理代码都是可以通过 goctl 自动生成的,我们团队内部 CRUD 和缓存基本都是通过 goctl 自动生成的,可以节省大量开发时间,并且缓存代码本身也是非常容易出错的,即使有很好的代码经验,也很难每次完全写对,所以我们推荐尽可能使用自动的缓存代码生成工具去避免错误。

Need more?

如果你想要更好的了解 go-zero 项目,欢迎前往官方网站上学习具体的示例。

视频回放地址

https://www.bilibili.com/video/BV1Jy4y127Xu

项目地址

https://github.com/tal-tech/go-zero

欢迎使用 go-zero 并 star 支持我们!

go-zero 系列文章见『微服务实践』公众号
查看原文

赞 2 收藏 2 评论 0

kevinwan 发布了文章 · 2月3日

go-zero解读与最佳实践(上)

本文有『Go开源说』第三期 go-zero 直播内容修改整理而成,视频内容较长,拆分成上下篇,本文内容有所删减和重构。

大家好,很高兴来到“GO开源说” 跟大家分享开源项目背后的一些故事、设计思想以及使用方法,今天分享的项目是 go-zero,一个集成了各种工程实践的 web 和 rpc 框架。我是Kevin,go-zero 作者,我的 github id 是 kevwan

go-zero 概览

go-zero 虽然是20年8月7号才开源,但是已经经过线上大规模检验了,也是我近20年工程经验的积累,开源后得到社区的积极反馈,在5个多月的时间里,获得了5.9k star。多次登顶github Go语言日榜、周榜、月榜榜首,并获得了gitee最有价值项目(GVP),开源中国年度最佳人气项目。同时微信社区极为活跃,3000+人的社区群,go-zero爱好者们一起交流go-zero使用心得和讨论使用过程中的问题。

star

下图中间三层是 go-zero 内建支持的服务治理相关组件,基本涵盖了微服务治理主要的能力,而且是基本不需要开发者自己配置的,默认方案已经是经过大规模线上项目调优的。

arch

微服务系统设计中的痛点

1. 微服务系统如何拆分?

  • 先粗后细,不要过细,切忌一个接口一个服务
  • 横向拆分,而非纵向,我们尽量不要超过三层调用
  • 单向调用,严禁循环调用
  • 禁止接口类型透传,在不同的层之间不要共享同一个数据定义,避免一处修改,影响其它
  • 没有依赖关系的串行调用改为并行,可以通过 core/mr 包降低响应延迟而不增加系统负载

    mr

2. 如何保障高并发高可用?

  • 良好的数据边界

    数据边界是微服务拆分的核心,不同的服务之间不要显示共享数据,而应该通过 rpc 共享。

  • 高效的缓存管理

    服务能否支撑高并发,缓存很关键。缓存机制不光要设计好,还需要通过工具尽可能让业务开发人员避免出错,因为缓存代码的编写有相当的难度,goctl 很好的生成了自动管理缓存的代码。

  • 优雅的熔断降载保护

    微服务系统一般都是由大量服务共同组合而成的,服务多了自然会有某个服务出现故障的风险,我们不能让某个服务的故障导致整个系统不可用,这就是服务雪崩,要避免雪崩,我们就需要有效隔离有故障的服务,从而降级可用。熔断和降载是防止服务雪崩的最有效手段之一。

  • 弹性伸缩能力

    对于高并发的系统来说,突发流量洪峰的情况下,系统需要能够及时水平扩容,go-zero 的自适应降载可以很好的配合 kubernetes 集群的自动水平伸缩能力。

  • 清晰的资源使用定义

    要想让系统保持稳定,我们一定要对资源使用做清晰的定义,比如我们到底在什么时候考虑扩充资源,是资源占用率达到了50%还是70%,必须对系统资源的使用状况有足够清晰的定义。

  • 高效的监控报警

    我在团队内部一直强调:没有度量就没有优化。我们必须对系统有高效的监控和及时的报警机制。这样才能让我们对整个系统的运行状态有足够的了解。

大型微服务项目从何下手?

overview

微服务系统大体上看起来如上图,但是我们并不是一定要业务一开始就上微服务,我们看看一个典型的微服务系统是怎么进化而来的,下面粗略的讲解一下大型微服务系统的进化过程。

  • 从单体服务开始

    项目刚开始,我们不要一味的追求技术的先进性,因为大部分项目是走不到高并发的那一天的,我们需要的是第一时间满足业务。

  • 业务优先,技术支撑

    我在团队里讲:架构是从业务中来,到业务中去。任何脱离了业务的技术都是自嗨,我们需要把满足业务需要作为第一优先级,技术需要支撑业务现在和可预期发展的需要即可。当然,有满足自身业务的现成的框架和最佳实践那是最好了,但不要让技术栈过于复杂,避免重心从业务转移到技术本身来。

  • 服务指标监控

    随着业务的发展,我们可能需要对技术做一定的升级和改造了,但是我们一直强调:没有度量就没有优化。所以我们需要及时加上对整个服务的关键指标的监控,从而让我们在了解系统的前提下进行必要的改造。

  • 数据拆分+缓存管理

    当业务发展到一定程度之后,基于监控,我们发现服务必须要做拆分了。那么我们第一步要做的是先把数据拆分清楚,数据拆分后,我们就可以加上对应的缓存管理,从而保障数据层面的稳定性。

  • 服务拆分

    相对于数据拆分,服务的拆分相对是比较容易的,基于拆分好的数据,对应出上层的服务,因为服务是无状态的,所以这个拆分就比较容易。

  • 支撑系统建设

    随着业务的发展,日常的系统维护工作就显得比较繁琐和容易出错了。此时,我们需要建设支撑系统,如何部署新服务,如何更新老服务,是不是要上 kubernetes,等等。

  • 自动化+工程建设

    当业务发展到一定程度,工程效率就是一个很大的问题了。goctl 就是为了解决自动化和工程效率问题而生,其中内置的 api, rpc, model, Dockerfile, k8s部署文件等的自动生成节省了我们大量时间,也避免了业务开发中的错误。

go-zero 组件剖析 + go-zero 最佳实践(待续)

如果你想要更好的了解 go-zero 项目,欢迎前往官方网站上学习具体的示例。

视频回放地址

https://www.bilibili.com/video/BV1Jy4y127Xu

项目地址

https://github.com/tal-tech/go-zero

欢迎使用 go-zero 并 star 支持我们!

go-zero 系列文章见『微服务实践』公众号
查看原文

赞 1 收藏 0 评论 0

kevinwan 关注了用户 · 2月1日

Jioby @shockerli

无善无恶心之体,有善有恶意之动。知善知恶是良知,为善去恶是格物。

https://shockerli.net

关注 442

kevinwan 赞了文章 · 2月1日

Go 语言优秀资源整理,为项目落地加速🏃(更新于2020.10.29)

最后更新于2020.10.29

Go 资料

Go 语言优秀资源整理,为项目落地加速🏃

GitHub 上稳定更新,觉得不错请点个 Star ❤️

如转载分享,请保留出处,谢谢 😆

原文地址: https://shockerli.net/post/go...

GitHub: https://github.com/shockerli/...


官网: https://golang.org

国内官网镜像(访问快~): https://golang.google.cn

GitHub: https://github.com/golang/go

开发者平台: https://go.dev

Wiki: https://github.com/golang/go/...

官方博客: https://blog.golang.org

指导原则

  • 简单性

    复杂性把可读的程序变得不可读,复杂性终结了很多软件项目。
  • 可读性

    代码是给人看的,代码阅读时长远超编写。程序必须可维护,那可读是第一步。
  • 生产率

    拥有众多的工具集和基础库,可以很简单方便的完成绝大多数工作。
    编译速度足够快,拥有动态语言的高效,但却不会面临动态语言不可靠的问题。
    自带编程规范,使得团队代码一致,也帮助开发者发现和避免潜在的错误。

Awesome

大牛

Go 语言方面的大牛,或者优秀 Go 项目的组织

文档

指南

文章

付费教程

成品项目

  • studygolang - Go 语言中文网
  • mkcert - 生成本地 HTTPS 加密证书的工具
  • Rainbond - 基于Docker、Kubernetes等容器技术的开源PaaS
  • NYADB2 - Go 实现的关系型数据库, 值得用于学习
  • EiBlog - 国产 博客
  • pan-light - 不限速的百度网盘客户端, 基于 Go + Qt5 开发
  • BaiduPCS-Go - 百度网盘客户端
  • daily-warm - 每天定时发邮件给你关心的人
  • pipe - 博客平台
  • mdr - 命令行下的 Markdown 阅读工具
  • miniflux - Feed 阅读器
  • 链滴笔记 - 桌面端笔记应用
  • wayback - 网页快照备份

静态网站生成器

学习项目

  • 1m-go-websockets - 该项目演示了如何用 Go 编写一个可以提供超过一百万个 websockets 连接、运行内存小于 1GB 的服务器
  • Go by Example - 通过实例学习 Go

开源类库

Web 框架

业务框架

项目骨架

TCP 框架

  • zinx - TCP并发服务器框架

中间件

  • Negroni - Web 中间件
  • csrf - CSRF 中间件
  • handlers - A collection of useful handlers for Go's net/http package

并发

命令行

  • urfave/cli - 命令行程序构建工具
  • Cobra - 命令行构建包
  • progressbar - 在终端上输出进度条
  • cheggaaa/pb - 终端进度条
  • mpb - 支持多个进度条
  • Color - 命令行文字颜色
  • termui - 终端仪表盘
  • gosu - 以指定的用户权限来运行脚本
  • tui - 终端 UI
  • gotop - 类 top 系统监控显示
  • go-colorable - Colorable writer for Windows
  • go-isatty - TTY 环境判断
  • fzf - 命令行下的文件 Finder
  • flaggy - 命令参数解析
  • go-daemon - daemon 进程包
  • pflag - 命令行参数处理
  • PIXterm - 在命令行终端中绘图
  • WTF - 一个命令行的信息仪表盘,可以定制显示内容
  • go-prompt - 命令行交互式输入
  • peco - 交互式过滤工具
  • termenv - 终端应用程序的高级 ANSI 样式和颜色支持
  • asciigraph - 在终端中绘制 ASCII 字符的图表
  • spinner - 涵盖70多种符号或进度条的控制器
  • tablewriter - 终端中输出表格内容
  • clop - 命令行解析包
  • go-flags - 命令行参数解析
  • termdash - 基于 Go Terminal 的仪表板系统
  • kong - 命令行解析
  • bubbletea - TUI 框架
  • pty - PTY for Go
  • vtclean - 从终端输出字符串中解析出纯文本

终端工具

  • vgrep - 支持滚动分页的 grep
  • GoTTY - 基于Web的命令行实时共享

路由

网络

  • DNS - DNS 库
  • CoreDNS - DNS 服务器
  • RoadRunner - PHP 应用服务器、进程管理器、负载均衡,用于替代 Nginx + FPM
  • GoReplay - 流量收集&回放
  • Sharingan - 滴滴开源的流量录制回放工具
  • Glorp - HTTP 拦截&重放的 CLI 工具
  • p2pspider - 种子嗅探器
  • torrent - BitTorrent 相关工具库
  • rain - BitTorrent 客户端和库
  • httpteleport - Teleports 10Gbps http traffic over 1Gbps networks
  • FIND3 - WiFi 设备发现
  • SubFinder - 子域名发现工具
  • ggz - 短网址服务
  • httpstat
  • grab - 文件下载
  • go-netty - 网络框架
  • gnet - 事件驱动 Go 网络框架
  • httplab - The interactive web server
  • yamux - Multiplexer
  • sftp - SFTP support for the go.crypto/ssh package
  • evio - 事件驱动网络框架(reactor 模式)
  • gaio - 事件驱动网络框架(proactor 模式)
  • httpretty - 在终端上漂亮地打印出 HTTP 请求
  • blocky - 作为局域网 DNS 代理拦截广告
  • lossy - 模拟 net.PacketConn 和 net.Conn 接口的带宽,延迟和数据包丢失
  • go-libp2p - P2P
  • go-ipfs-api - IPFS
  • go-multiaddr - multiaddr

网络代理

  • Caddy - 类似 Nginx 的 Web 服务器
  • Traefik - 反向代理&负载均衡
  • Proxy - golang 实现的高性能代理服务器
  • ProxyPool - 采集免费的代理资源为爬虫提供有效的IP代理
  • frp - 可用于内网穿透的高性能的反向代理应用
  • nps - 一款轻量级、高性能、功能强大的内网穿透代理服务器
  • MOSN - 云原生网络代理
  • Pomerium - 基于身份的反向代理
  • V2Ray
  • V2Fly - V2Ray 的社区版本

HTTP压测

HTTP

WebSocket

即时通信

  • Centrifugo - 实时消息服务器,可以与任何语言编写的应用程序后端结合使用
  • goim - 支持集群的 im 及实时推送服务
  • Tinode - 即时消息服务器,通过 websocket/JSON 或 gRPC/TCP 等协议传输
  • WebRTC - WebRTC 实现

网关

序列化/解压缩

RPC

邮件

消息

  • NSQ - 实时分布式消息平台
  • NATS - 云原生消息中间件

文件

模板引擎

代码生成

文本处理

Markdown

HTML

其他

文档

数学计算

  • decimal - 解决浮点数计算精度问题
  • fixed
  • apd - decimal 包
  • mathfmt - 将 LaTeX 语法的注释转换为数学公式格式

日期时间

  • now
  • when - 自然日期时间解析
  • Carbon - Carbon 时间处理库的 Go 语言实现
  • strftime - 时间格式化

配置

爬虫

  • Crawlab - 基于Golang的分布式爬虫管理平台,支持Python、NodeJS、Go、Java、PHP等多种编程语言以及多种爬虫框架
  • Colly - 网络爬虫框架
  • Pholcus - 支持分布式的高并发、重量级爬虫软件
  • go_spider
  • goquery
  • Muffet - 网站链接检查器
  • Creeper

数据库

数据库相关

数据库驱动

数据库引擎

  • etcd - KV 分布式存储
  • InfluxDB - 时间序列数据库
  • Prometheus - 服务监控系统 & 时间序列数据库
  • Thanos - 支持 Prometheus 简化部署、高可用、分布式存储
  • CockroachDB - SQL database
  • Cayley - 图数据库
  • RadonDB - 基于 MySQL 研发的新一代分布式关系型数据库
  • TiDB - 分布式关系型数据库,兼容 MySQL 协议
  • AresDB - Uber 开源的 GPU 驱动的实时分析存储&查询引擎
  • leveldb - LevelDB 的 Go 实现
  • Dgraph - 分布式图数据库
  • rqlite - 基于 SQLite 的轻量级分布式关系数据库
  • gaeadb
  • BadgerDB - KV 数据库
  • LBADD - 用 Go 实现的分布式 SQL 数据库
  • go-memdb - 建立在不可变 Radix 树上的内存数据库
  • VectorSQL - 应用于 IoT 和大数据的 DBMS 数据库,类似于 ClickHouse
  • BuntDB - 基于内存的KV数据库,支持磁盘持久化、ACID事务
  • TinySQL - 迷你分布式关系型数据库
  • groupcache - 分布式缓存
  • Tile38 - GEO 数据库
  • Redcon - 兼容 Redis 协议的自定义 Redis 服务,采用 BuntDB 和 Tile38 实现存储
  • genji - 文档内嵌型数据库

搜索

表单

  • validator
  • go-tagexpr - 字节跳动开源的结构体标签表达式解释器
  • schema - converts structs to and from form values

Auth

  • Casbin - 权限控制管理
  • pam-ussh - Uber's SSH certificate pam module
  • jwt-go - JWT for Go
  • jwt - JWT 轻量级实现
  • sessions - 后端 SESSION 服务
  • securecookie - cookie 加密/解密
  • Goth - Multi-Provider Authentication for Go
  • branca - 号称比 JWT 更安全的 token 解决方案

缓存

视频

  • goav - FFmpeg 视频处理
  • lal - 直播流媒体网络传输服务器
  • bililive-go - 直播录制工具
  • screego - 通过浏览器共享开发者屏幕

图形处理

  • barcode - 条形码/二维码生成器
  • picfit - 图片操作、裁剪、管理服务器
  • gmfs - 图片操作、裁剪、管理服务器
  • besticon - favicon 服务
  • Caire - 图片操作库
  • Imaging - 图片操作库
  • gocaptcha - 验证码生成
  • go-is-svg - 校验是否为 SVG 图片
  • identicon - 根据用户的 IP 、邮箱名等任意数据为用户产生漂亮的随机头像
  • prominentcolor - 识别图片的主要颜色
  • dchest/captcha - 生成和验证图片或音频验证码
  • bimg - 图片处理
  • imaginary - 图片处理服务
  • primitive - 用原始几何图形绘制图形
  • orly - 生成你自己的O'RLY动物书封面

图片识别

图表

构建编译

  • Mage - a Make/rake-like build tool using Go
  • GoReleaser - Go 多平台二进制文件打包、并支持发布到 Homebrew 的工具
  • goxc - 跨平台编译工具(因 1.5 版本开始已自带交叉编译,故已不再维护)
  • Task - 类似于 Make 的构建工具
  • codegangsta/gin - 热编译工具
  • Air - 热编译工具
  • gowatch - 热编译工具
  • Fresh - 热编译工具
  • dh-make-golang - 自动构建 Debian 包
  • pkger - 将静态文件打包成 Go 二进制文件
  • mewn - 静态文件嵌入打包到二进制文件
  • gobinaries - 不用安装Go就能编译安装Go编写的程序
  • NFPM - deb、rpm、apk 等打包工具

优雅升级

代码分析

调试

  • go-spew - 变量打印工具
  • Delve - Debug 工具
  • gdlv - Delve 界面版本
  • repr - 变量打印工具
  • pp - 彩色变量打印工具
  • ffmt - 变量打印工具
  • gops - 谷歌官方出品的 Go 程序监控调试工具
  • pprof
  • go-callvis - 可视化Go程序的调用图
  • q - 自动打印变量类型并且格式化输出
  • Litter
  • RDebug - 滴滴开源的一款用于 RD 研发、自测、调试的实用工具
  • debugcharts - Go 内存占用可视化调试工具
  • gcvis - 实时可视化 gctrace
  • pkg/profile
  • statsviz - 在浏览器中实时查看 Go 应用程序运行时统计信息(GC,MemStats 等)

测试

错误处理

  • errors
  • errorx
  • errwrap - Go tool to wrap and fix errors with the new %w verb directive
  • erris - Linter for errors.Is and errors.As
  • eris - 旨在通过错误包装,堆栈跟踪和输出格式为你提供对错误处理的更多控制
  • errlog - 使用静态和堆栈跟踪分析来快速确定哪个函数调用导致的错误
  • juju/errors
  • go-fault - GitHub 官方出品,基于标准库 http 中间件的故障注入库
  • merry - 支持堆栈、状态码的错误处理

安全

  • Kunpeng - 开源POC检测框架
  • nmap - 安全审计工具 nmap 开发包
  • Hetty - 用于安全研究的 HTTP 工具包,具有 Web 接口和代理日志查看器的拦截 HTTP 代理

系统信息

UUID

日志

监控

  • OpenFalcon - 小米开源的监控系统
  • Prometheus - 服务监控系统 & 时间序列数据库
  • Grafana - 分析监视平台, 支持 Graphite, Elasticsearch, OpenTSDB, Prometheus, InfluxDB 等数据源

    • grabana - 用 Go 代码快速创建 grafana dashboards
  • TeaWeb - 一款集静态资源、缓存、代理、统计、监控于一体的可视化智能WebServer
  • Jaeger - 分布式追踪系统
  • go-osstat - 系统指标统计
  • grafterm - Metrics dashboards on terminal
  • mymon - MySQL 运行监控

统计分析

  • Fathom - Web 站点统计
  • Signal - Web 站点统计
  • Veneur - 分布式实时数据处理管道
  • gonum - 科学计算相关

容器技术

集群管理

机器学习

  • goml - 机器学习库
  • GoLearn - 一个 "开箱即用" 的机器学习库
  • glow - 易用的分布式计算系统
  • Gobot - 机器人和物理计算语言库
  • Olivia - 神经网络
  • Pico - 基于像素强度比较的物体检测纸张的纯 Go 脸部检测库

算法

数据结构

依赖注入

JSON

依赖管理

微服务

Serverless

持续集成/部署

  • CDS - 持续集成服务
  • gopub
  • CodePub
  • syncd - 代码部署工具
  • Drone - 基于 Docker 的持续发布平台
  • Cyclone - 持续集成&发布平台
  • tbls - 用于记录数据库文档的 CI 友好工具

Git

  • gogs - 类似于 GitLab 的 Git 服务器
  • Gitea - 由 gogs 分叉出的 Git 服务器
  • go-git - Go 实现的 Git 操作
  • gitin - commit/branch/status explorer for git
  • hub - GitHub 命令行工具
  • git-o-matic - 一个监控 Git 仓库变化和自动 pull/push 的工具
  • gitbase - SQL 的方式查询 Git 日志
  • git-chglog - CHANGELOG 管理工具
  • chglog - CHANGELOG 管理工具
  • lazyhub - GitHub 的终端 UI 客户端
  • goaction - 在 Go 中编写 GitHub Action
  • bit - Git 命令增强版,支持文件和分支名称自动完成、命令和标志建议

限流器

编译器

  • TinyGo - 一个适用于微控制器、WebAssembly 和命令行工具的 Go 编译器
  • llir/llvm - LLVM 编译器
  • jit-compiler - JIT 编译器

解释器

  • participle - 通用的自定义语法解析包
  • GopherLua - VM and compiler for Lua in Go
  • go-lua - A Lua VM in pure Go
  • DCLua - Go Lua Compiler and VM
  • otto - JavaScript 解释器
  • goja - ECMAScript 5.1(+) 实现
  • v8go - Execute JavaScript from Go
  • gpython - Python Interpreter on Go
  • Grumpy - 转换 Python 为 Go 代码,谷歌开源
  • starlark-go - Starlark in Go
  • avo - Generate x86 Assembly with Go
  • wagon - WebAssembly 解释器
  • GopherJS - 把 Go 代码编译成 JavaScript 代码
  • Yaegi - Go 语言解释器
  • properties - Java properties scanner for Go
  • gobasic - A BASIC interpreter written in golang
  • golisp - Lisp 解释器
  • dst - Go Decorated Syntax Tree

PHP

自定义解释器

代码生成

编辑器

运行器

  • gore - 在线运行 Go 代码
  • nodebook - 在线运行多种语言

查询语言

游戏相关

桌面开发

  • Lorca - 用 Go 编写 HTML5 桌面程序,依赖 Chrome 进行 UI 渲染,但却不把 Chrome 打包到应用中
  • webview - 用 Go 构建跨平台的桌面软件
  • walk - Windows GUI toolkit
  • go-gtk - Go bindings for GTK
  • andlabs/ui - Platform-native GUI library for Go
  • fyne - Material Design 风格的 GUI
  • go-gl - Go bindings for OpenGL (generated via glow)
  • therecipe/qt - 基于 Qt 的跨全平台 UI 包
  • giu - 基于 Dear ImGui 的跨平台 GUI 框架
  • go-app - 一个 WebAssembly 框架,用于使用 Go,HTML 和 CSS 构建 GUI 应用
  • wails - 使用 Go 和 Web 技术创建桌面应用程序
  • chromedp - 纯 Go 语言实现的驱动浏览器的 Chrome DevTools Protocol,可用于爬虫、反爬虫、测试等场景
  • Rod - 一个为简化自动化和爬虫设计的 devtools driver,利用浏览器的 devtools 可编程接口来操控浏览器
  • go-astilectron - 基于 Electron 的跨平台开发
  • Gio - 跨平台 UI 框架,支持移动应用
  • nucular - 基于 Gio 的实现
  • GoVCL - 跨平台的 GUI 包

移动端

协程管理

  • ants - goroutine 池
  • tunny
  • go-workers - 安全地并发运行一组 worker,通过 channel 进行输入输出
  • Machine - 受 errgroup.Group 启发的协程管理

任务/定时器

微信

区块链

开发辅助包

代码生成

系统开发

  • LinuxKit - 为容器构建安全、便携、可移植操作系统的工具包

未归类

  • go-playground - 比官方更好用的 Go Playground
  • Robotgo - Golang 跨平台自动化系统,控制键盘鼠标位图和读取屏幕,窗口句柄以及全局事件监听
  • go-homedir
  • i18n - i18n 多语言工具包
  • Paginater - 分页工具
  • gls - Goroutine local storage
  • go-version - 版本号比较
  • go-semver - 语义版本
  • Metabolize - Decodes HTML meta tags into a Golang struct
  • otp - 一次性密码工具包(One Time Password utilities)
  • misspell - 常拼写错误的英语单词
  • CRDT - CRDT(Convergent and Commutative Replicated Data Types)最终一致性算法的实现
  • script - Making it easy to write shell-like scripts in Go
  • sysadmin-utils
  • licenseclassifier - 识别文件中的 license 类型
  • rose - 在 HTML 中嵌入和运行 Go 代码
  • esbuild - JavaScript 构建打包工具
  • clipboard - 跨平台的粘贴板实现
  • Timeliner - 搜集整理个人在社交网站上的数据并索引成时间线
  • hc - HomeKit 平台开发框架

logo

工具

资源站点


感谢您的阅读,觉得内容不错,点个赞吧 😆

原文地址: https://shockerli.net/post/go-awesome/
查看原文

赞 94 收藏 62 评论 0

kevinwan 发布了文章 · 2月1日

微服务实践之分布式定时任务

承接上篇:上篇文章讲到改造 go-zero 生成的 app module 中的 gateway & RPC 。本篇讲讲如何接入 异步任务 以及 log的使用

Delay Job

日常任务开放中,我们会有很多异步、批量、定时、延迟任务要处理,go-zero中有 go-queue,推荐使用 go-queue 去处理,go-queue 本身也是基于 go-zero 开发的,其本身是有两种模式:

  • dq : 依赖于 beanstalkd ,分布式,可存储,延迟、定时设置,关机重启可以重新执行,消息会丢失,使用非常简单,go-queue中使用了redis setnx保证了每个消息只被消费一次,使用场景主要是用来做日常任务使用
  • kq:依赖于 kafka ,这个就不多介绍啦,大名鼎鼎的 kafka ,使用场景主要是做日志用

我们主要说一下dq,kq使用也一样的,只是依赖底层不同,如果没使用过beanstalkd,没接触过beanstalkd的可以先google一下,使用起来还是挺容易的。

我在jobs下使用goctl新建了一个message-job.api服务

info(
    title: //消息任务
    desc: // 消息任务
    author: "Mikael"
    email: "13247629622@163.com"
)

type BatchSendMessageReq {}

type BatchSendMessageResp {}

service message-job-api {
    @handler batchSendMessageHandler // 批量发送短信
    post batchSendMessage(BatchSendMessageReq) returns(BatchSendMessageResp)
}

因为不需要使用路由,所以handler下的routes.go被我删除了,在handler下新建了一个jobRun.go,内容如下:

package handler

import (
    "fishtwo/lib/xgo"
    "fishtwo/app/jobs/message/internal/svc"
)


/**
* @Description 启动job
* @Author Mikael
* @Date 2021/1/18 12:05
* @Version 1.0
**/

func JobRun(serverCtx *svc.ServiceContext)  {
    xgo.Go(func() {
        batchSendMessageHandler(serverCtx)
    //...many job
    })
}

其实xgo.Go就是 go batchSendMessageHandler(serverCtx) ,封装了一下go携程,防止野生goroutine panic

然后修改一下启动文件message-job.go

package main

import (
   "flag"
   "fmt"

   "fishtwo/app/jobs/message/internal/config"
   "fishtwo/app/jobs/message/internal/handler"
   "fishtwo/app/jobs/message/internal/svc"

   "github.com/tal-tech/go-zero/core/conf"
   "github.com/tal-tech/go-zero/rest"
)

var configFile = flag.String("f", "etc/message-job-api.yaml", "the config file")

func main() {
   flag.Parse()

   var c config.Config
   conf.MustLoad(*configFile, &c)

   ctx := svc.NewServiceContext(c)
   server := rest.MustNewServer(c.RestConf)
   defer server.Stop()

   handler.JobRun(ctx)

   fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
   server.Start()
}

主要是handler.RegisterHandlers(server, ctx) 修改为handler.JobRun(ctx)

接下来,我们就可以引入dq了,首先在etc/xxx.yaml下添加dqConf

.....

DqConf:
  Beanstalks:
    - Endpoint: 127.0.0.1:7771
      Tube: tube1
    - Endpoint: 127.0.0.1:7772
      Tube: tube2
  Redis:
    Host: 127.0.0.1:6379
    Type: node

我这里本地用不同端口,模拟开了2个节点,7771、7772

在internal/config/config.go添加配置解析对象

type Config struct {
    ....
    DqConf dq.DqConf
}

修改handler/batchsendmessagehandler.go

package handler

import (
    "context"
    "fishtwo/app/jobs/message/internal/logic"
    "fishtwo/app/jobs/message/internal/svc"
    "github.com/tal-tech/go-zero/core/logx"
)

func batchSendMessageHandler(ctx *svc.ServiceContext){
    rootCxt:= context.Background()
    l := logic.NewBatchSendMessageLogic(context.Background(), ctx)
    err := l.BatchSendMessage()
    if err != nil{
        logx.WithContext(rootCxt).Error("【JOB-ERR】 : %+v ",err)
    }
}

修改logic下batchsendmessagelogic.go,写我们的consumer消费逻辑

package logic

import (
   "context"
   "fishtwo/app/jobs/message/internal/svc"
   "fmt"
   "github.com/tal-tech/go-zero/core/logx"
)

type BatchSendMessageLogic struct {
   logx.Logger
   ctx    context.Context
   svcCtx *svc.ServiceContext
}

func NewBatchSendMessageLogic(ctx context.Context, svcCtx *svc.ServiceContext) BatchSendMessageLogic {
   return BatchSendMessageLogic{
       Logger: logx.WithContext(ctx),
       ctx:    ctx,
       svcCtx: svcCtx,
   }
}


func (l *BatchSendMessageLogic) BatchSendMessage() error {
   fmt.Println("job BatchSendMessage start")

   l.svcCtx.Consumer.Consume(func(body []byte) {
       fmt.Printf("job BatchSendMessage %s \n" + string(body))
   })

   fmt.Printf("job BatchSendMessage finish \n")
   return nil
}

这样就大功告成了,启动message-job.go就ok课

go run message-job.go

之后我们就可以在业务代码中向dq添加任务,它就可以自动消费了

producer.Delay 向dq中投递5个延迟任务:

    producer := dq.NewProducer([]dq.Beanstalk{
        {
            Endpoint: "localhost:7771",
            Tube:     "tube1",
        },
        {
            Endpoint: "localhost:7772",
            Tube:     "tube2",
        },
    })

    for i := 1000; i < 1005; i++ {
        _, err := producer.Delay([]byte(strconv.Itoa(i)), time.Second * 1)
        if err != nil {
            fmt.Println(err)
        }
    }

producer.At 可以指定某个时间执行,非常好用,感兴趣的朋友自己可以研究下。

错误日志

在前面说到gateway改造时候,如果眼神好的童鞋,在上面的httpresult.go中已经看到了log的身影:

我们在来看下rpc中怎么处理的

是的,我在每个rpc启动的main中加入了grpc拦截器 https://www.yuque.com/tal-tec...,那让我们看看grpc拦截器里面做了什么

然后我代码里面使用github/pkg/errors这个包去处理错误的,这个包还是很好用的

所以呢:

我们在 grpc 中打印日志 logx.WithContext(ctx).Errorf("【RPC-SRV-ERR】 %+v",err)

api 中打印日志 logx.WithContext(r.Context()).Error("【GATEWAY-SRV-ERR】 : %+v ",err)

go-zero 中打印日志,使用 logx.WithContext 会把trace-id带入,这样一个请求下来,比如

user-api --> user-srv --> message-srv

那如果 messsage-srv 出错,他们三个是同一个 trace-id ,是不是就可以在elk通过输入这个trace-id一次性搜索出来这条请求报错堆栈信息呢?当然你也可以接入 jaeger、zipkin、skywalking 等,这个我暂时还没接入。

框架地址

https://github.com/tal-tech/go-zero

欢迎使用 go-zero 并 star 支持我们!👍

go-zero 系列文章见『微服务实践』公众号
查看原文

赞 0 收藏 0 评论 0

kevinwan 发布了文章 · 1月25日

企业项目迁移go-zero全攻略(二)

承接上篇:上篇文章讲到 go-zero 架构设计和项目设计。本篇文章接着这个项目设计,将生成的 app 模块gatewayRPC 进行改造。废话不多说,让我们开始!

gateway service

gateway 中我做了一些自定义,在端请求我们后台接口情况下,虽然多数情况是不需要关心错误码的,但是避免不了要某些场景还是需要根据固定错误码去做特殊处理,我自己定义了一个错误类,这个错误类只在 gateway 中使用:

err.go:

package xerr

import "fmt"

type CodeError struct {
   errCode int
   errMsg  string
}

// 属性
func (e *CodeError) GetErrCode() int {
   return e.errCode
}

func (e *CodeError) GetErrMsg() string {
   return e.errMsg
}

func (e *CodeError) Error() string {
   return fmt.Sprintf("ErrCode:%d,ErrMsg:%s", e.errCode, e.errMsg)
}

func New(errCode int, errMsg string) *CodeError {
   return &CodeError{errCode: errCode, errMsg: errMsg}
}

func NewErrCode(errCode int) *CodeError {
   return &CodeError{errCode: errCode, errMsg: MapErrMsg(errCode)}
}

func NewErrMsg(errMsg string) *CodeError {
   return &CodeError{errCode: BAD_REUQEST_ERROR, errMsg: errMsg}
}

errmsg.go

package xerr

var message map[int]string

func init()  {
   message = make(map[int]string)
   message[OK] = "SUCCESS"
   message[BAD_REUQEST_ERROR] = "服务器繁忙,请稍后再试"
   message[REUQES_PARAM_ERROR] = "参数错误"
   message[USER_NOT_FOUND] = "用户不存在"
}

func MapErrMsg(errcode int) string {
   if msg, ok := message[errcode]; ok {
      return msg
   } else {
      return "服务器繁忙,请稍后再试"
   }
}

errcode.go

package xerr

// 成功返回
const OK = 200

// 全局错误码
// 前3位代表业务,后三位代表具体功能
const BAD_REUQEST_ERROR = 100001
const REUQES_PARAM_ERROR = 100002

// 用户模块
const USER_NOT_FOUND = 200001

我将三个文件统一放在 lib/xerr 目录

有了错误码还不行,还要定义统一返回http的结果,goctl 生成的默认的是挺好的,但是没法符合我这种返回自定义错误码需求,于是我自己有写了一个统一返回结果的文件:

httpresult:

package xhttp

import (
   "fishtwo/lib/xerr"
   "fmt"
   "github.com/tal-tech/go-zero/core/logx"
   "github.com/tal-tech/go-zero/rest/httpx"
   "google.golang.org/grpc/status"
   "net/http"
   "github.com/pkg/errors"
)

// http方法
func HttpResult(r *http.Request,w http.ResponseWriter,resp interface{},err error)  {
   if err == nil {
      // 成功返回
      r:= Success(resp)
      httpx.WriteJson(w, http.StatusOK, r)
   } else {
      // 错误返回
      errcode := xerr.BAD_REUQEST_ERROR
      errmsg := "服务器繁忙,请稍后再试"
      if e,ok := err.(*xerr.CodeError);ok{
         // 自定义CodeError
         errcode = e.GetErrCode()
         errmsg = e.GetErrMsg()
      } else {
         originErr := errors.Cause(err) // err类型
         if gstatus, ok := status.FromError(originErr);ok{
            // grpc err错误
            errmsg = gstatus.Message()
         }
      }
      logx.WithContext(r.Context()).Error("【GATEWAY-SRV-ERR】 : %+v ",err)

      httpx.WriteJson(w, http.StatusBadRequest, Error(errcode,errmsg))
   }
}

// http参数错误返回
func ParamErrorResult(r *http.Request,w http.ResponseWriter,err error)  {
   errMsg := fmt.Sprintf("%s ,%s", xerr.MapErrMsg(xerr.REUQES_PARAM_ERROR), err.Error())
   httpx.WriteJson(w, http.StatusBadRequest, Error(xerr.REUQES_PARAM_ERROR,errMsg))
}

responsebean

package xhttp

type (
   NullJson struct {}

   ResponseSuccessBean struct {
      Code int         `json:"code"`
      Msg  string      `json:"msg"`
      Data interface{} `json:"data"`
   }
)

func Success(data interface{}) *ResponseSuccessBean {
   return &ResponseSuccessBean{200, "OK", data}
}


type ResponseErrorBean struct {
   Code int         `json:"code"`
   Msg  string      `json:"msg"`
}

func Error(errCode int,errMsg string) *ResponseErrorBean {
   return &ResponseErrorBean{errCode, errMsg}
}

放在 lib/xhttp下

然后改造了internal/handler/下通过goctl生成的代码:

当然你会说,每次生成完都要手动去改,好麻烦!

当当当当~~~ goctltemplate 来咯 https://www.yuque.com/tal-tec...

然后修改 ~/.goctl/api/handler.tpl:

package handler

import (
     "net/http"

     {{.ImportPackages}}
)

func {{.HandlerName}}(ctx *svc.ServiceContext) http.HandlerFunc {
   return func(w http.ResponseWriter, r *http.Request) {
      {{if .HasRequest}}var req types.{{.RequestType}}
      if err := httpx.Parse(r, &req); err != nil {
         xhttp.ParamErrorResult(r,w,err)
         return
      }{{end}}

      l := logic.New{{.LogicType}}(r.Context(), ctx)
      resp, err := l.Login(req)
      xhttp.HttpResult(r,w,resp,err)
   }
}

再重新生成看看,是不是就 beautiful 了,哈哈

然后在说我们的 gateway log,如果眼神好的用户,在上面的 httpresult.go 中已经看到了 log 的身影:

是的是的,这样处理就可以啦,这样只要有错误就会打印日志了,go-zero 已经把 trace-id 带进去了,啥?trace-id 不知道是啥?嗯,其实就是把一次请求通过此 id 串联起来,比如你 user-api 调用 user->srv 或者其他 srv,那要把他们这一次请求都串联起来,需要一个唯一标识别,这个 id 就是做这个,做链路追踪有很多,比如 jaegerzipkin

RPC service

modelrpc 服务中,官方文档推荐是将 model 放在 services 目录下,与每个 rpc 服务一层,但是个人感觉每个 model 对应一张表,一张表只能由一个服务去控制,哪个服务控制这张表就哪个服务拥有控制这个 model 权利,其他服务想访问就要通过 grpc,这是个人的想法,所以我把每个服务自己管控的 model 放在了 internal

enum:另外我在服务下加了 enum 枚举目录,因为其他 rpc 服务或者 api 服务会调用这个枚举去比对,我就放在 internal 外部

框架地址

https://github.com/tal-tech/go-zero

欢迎使用 go-zerostar 支持我们 👍


我为大家整理了 go-zero 作者去年广受好评的分享视频,详细分享了 go-zero 的设计理念和最佳实践。关注公众号「微服务实践」,回复 视频 获取;还可以回复 进群 和数千 go-zero 使用者交流学习。

go-zero 系列文章见『微服务实践』公众号
查看原文

赞 2 收藏 1 评论 0

kevinwan 发布了文章 · 1月23日

别再问我们用什么画图的了!问就是excalidraw

每次发 https://github.com/tal-tech/go-zero 相关文章时,都会有读者问我们用什么画图的。

这图什么工具画的呀?好看!

这个手绘风格真好看,用啥工具画的呀?

可不可以介绍下这个画图的工具?

诸如此类的问题,所以我决定写篇短文介绍下我们最常用的画图工具 https://excalidraw.com/

我们手绘风格的流程图、架构图等等都是通过 https://excalidraw.com/ 画的

  • 一个开源免费的画图软件
  • 个人目前看到的最舒服的画图软件
  • 支持多人协作

一些经验分享

  • 要把图形和文字放到一起拖动或者缩放,按住 shift 键一起选中,然后右键点击 group selection
  • 导出图片的四周空白(margin)太小不美观,官方拒绝解决(也没找到合适的默认margin尺寸),我们可以不使用导出图片,而是直接截屏,就可以控制margin大小了
  • 不要截屏保存图片后要记得保存 .excalidraw 文件,这样如有需要就可以直接修改了
  • 我们一般用 Code 风格的 Font family

再给大家几张我们画的图,让大家感受下 https://excalidraw.com/ 的魅力

  • 系统架构图
  • 原理讲解

  • 流程图

声明:这是个开源软件,我也没发现商业版,也没付过钱,也不认识作者(貌似国外的)。纯属用的舒服+问的人多,才简单写了这篇文章哈。非广告,也没收过任何费用,跟excalidraw.com官方无关,个人行为哈,好工具共分享而已
go-zero 系列文章见『微服务实践』公众号
查看原文

赞 3 收藏 2 评论 1

kevinwan 发布了文章 · 1月21日

企业项目迁移go-zero全攻略(一)

作者:Mikael

最近发现 golang 社区里出了一个新兴的微服务框架。看了一下官方提供的工具真的很好用,只需要定义好 .api 文件模版代码都可以一键生成,只需要关心业务;同时 core 中的工具极大减少了开发成本。

废话不多说,来看看这个微服务框架:go-zero

起源

聊聊与go-zero结缘

最先接触go-zero是2020年10月国庆假期,说来也巧,看到有人在go-micro群中问go-zero情况,当时go-zero作者在群中就大概回答了一下,引起了我的好奇,当时公司用的go-micro1.x,因为go-micro版本真的太混乱了,2还没多少人用明白,现在又搞了个3,而且这几个大版本之间高度不兼容,简直一团糟。我抱着好奇心去github.com查看了go-zero,当时并没有因为它的star数、文档少而放弃,哈哈,抱着试玩的心态去go get它,从此发现了新大陆,并加入了go-zero群,开始了go-zero之旅。

选择它的几点原因

  • 微服务:在现在这个大环境下,单体服务诟病已经越来越多了,项目大起来之后 “牵一发而动全身” 的教训比比皆是,维护越来越困难,测试测起来也是很头疼,构建速度慢等等,在这样趋势下拥抱微服务成为了大趋势,go-zero就是一个微服务框架并且能为我解决很多实际项目中遇到的痛点、难点
  • 稳定性:内外同源。稳定性是我很看重的,他们公司内外同源势必保证了此框架的稳定性。
  • 高并发:经历了2020年疫情期间,“晓黑板” 轻松获得支撑千万日活服务
  • 工作效率:说到工作效率,必须要提的就是goctl,goctl配合go-zero所有代码基本都是可以通过这个工具生成,只需要关心自己的业务逻辑即可,包括一键生成dockerfile,k8s的yaml文件,简直不要太爽,大大提高了工作效率
  • 代码质量:大概看了一些go-zero的源码,代码质量上感觉还是没得喷的,至少感觉比我自己写的好很多,哈哈,这个每个人看法不同,大家可以去亲自看一下。
  • 团队:当时加了go-zero作者微信,感觉他为人很谦和,无论问一些比较基础的东西还是一些线上实战经验,也总是会耐心给我解答、意见,在使用期间我也提了一些bug,go-zero团队都能及时的解决,迭代速度真的让我惊艳。大家应该都知道,在国内做开源有多么不容易。
  • 对比go其他微服务框架:go的微服务框架大概我玩过go-micro、go-kit、kratos、rpcx、go-zero。

    • go-micro我开始就说了是版本真心有点混乱
    • go-kit也不错但是资料相对来说较少
    • kratos经过b站源码泄漏大家应该都知道它了,前一段时间都断更了,差点安乐死,毛神在issue中说太忙了,不过他们在出2.0版本了,还是很期待
    • rpcx 玩了一下玩的不多,但是他们宣传是“好未来”也在用,go-zero就是“好未来”的呀,哈哈
    • go-zero 上面我都说过了,就不再提了。

设计架构

在介绍go-zero实际使用前,先说一下整体架构,更方便理解

go-zero-k8s架构

CI/CD

Step1:本地deveploer开发好代码之后提交到gitlab(这里分支就不详细说明了)

Step2:jenkins,使用pipline方式部署

  • 从gitlab拉取代码
  • docker build ,基于最新gitlab上的code构建镜像
  • docker push,将构建好的镜像推送到镜像仓库(当然一般都是有自己私有镜像仓库比如harbor,用阿里云的也可以)
  • kubectl apply -f xxx.yaml :使用kubectl 部署到k8s中 (阿里云k8s容器服务那么好用,不用岂不可惜?)

kubectl部署之后,k8s就会根据你的service中的yaml定义的镜像来你的镜像仓库拉取刚才你打包的最新镜像,so~~上线成功啦!

嗯,有的同学说,阿里云k8s好用是好用,可是我不会写or不想写Dockerfile,不会写k8s的yaml or 不想写,没关系,goctl说放开它,让我来

生成 Dockerfile

$ goctl docker -go user.go 

生成k8s yaml

$ goctl kube deploy -name user-api -namespace blog -image user:v1 -o user.yaml -port 2233

所以,就是这么简单

访问流程

app/web/pc 透过防火墙,首先访问到阿里云的负载均衡SLB,同时SLB可以将你的后端服务器ip隐藏起来,同时可以预防DDOS攻击,虽然有额度的,但是好过没有~~,然后SLB访问到前面的nginx,nginx作为代理使用,k8s中的service通过 nodeport方式暴露出来在nignx中代理到该service,同时在nginx中上报日志到kafka,然后api可以在etcd中拿到多个rpc节点,调用多个后端rpc服务,rpc负责跟db交互、或者调用其他rpc获取数据(当然api、rpc之间是通过etcd动态发现的)返回给api,api就是聚合数据,然后层层返回到客户端。

整体架构都是高可用高可用

项目设计

项目地址:https://github.com/Mikaelemmm...

go的项目比较灵活不像java已经形成统一标准化了,所以对于不同项目的结构都不一样,我的做法是如下:

1610618953808

整个项目使用的一个大仓,项目fishtwo根目录下:

  • app : 应用内部程序
  • build:构建、以及脚本等
  • lib:应用程序用到的内部库
  • app下分为3个模块:

    • gateway:api服务
    • services: rpc服务
    • jobs:日常要处理的任务(这个可以使用 go-zero 作者的 go-queue ,测试了下很好用,哈哈,后面搞好也会写进来)

下一篇我们来看看:

  1. 怎么改造 gateway 服务
  2. 怎么改造 rpc 服务
  3. jobs 怎么定义?怎么和项目结合?
未完待续~~~

框架地址

https://github.com/tal-tech/go-zero

欢迎使用 go-zero 并 star 支持我们 👍

go-zero 系列文章见『微服务实践』公众号
查看原文

赞 3 收藏 1 评论 0

kevinwan 发布了文章 · 1月12日

windows下如何玩转火热的go-zero

作者:阿啄debugIT

前言

go-zero 是一个集成了各种工程实践的 web 和 rpc 框架。通过弹性设计保障了大并发服务端的稳定性,经受了充分的实战检验。

go-zero 包含极简的 API 定义和生成工具 goctl,可以根据定义的 api 文件一键生成 Go, iOS, Android,
Kotlin, Dart, TypeScript, JavaScript 代码,并可直接运行。

这么牛,怎么不想去试一下?!

go语言环境搭建

配置GO语言环境

新增go的代理

GOPROXY=https://goproxy.io,direct,https://mirrors.aliyun.com/goproxy/,https://goproxy.cn,https://athens.azurefd.net,https://gonexus.dev
image

设置环境变量

环境变量path中添加 %GOROOT%\bin;%GOPATH%\bin
image

在vscode的配置

安装插件
image

关键是go语言环境在vscode的配置,如下:

{
    "go.goroot": "D:\\go",
    "go.gopath": "D:\\go_project",
    "go.inferGopath": false,
    "go.toolsGopath": "D:\\go_project",

    "window.zoomLevel": 0,
    "git.autofetch": true,
    "terminal.integrated.shell.windows": "powershell.exe",    // 也可以使用 cmd.exe
    "workbench.colorTheme": "Monokai Pro (Filter Machine)",
    "workbench.iconTheme": "Monokai Pro (Filter Machine) Icons",
    "editor.renderControlCharacters": false,
    "editor.snippetSuggestions": "top",
    "editor.suggest.snippetsPreventQuickSuggestions": true,
    "breadcrumbs.enabled": true,
    "terminal.explorerKind": "external",
    "editor.cursorStyle": "block",
    "editor.links": false,
    "editor.mouseWheelZoom": true,
    "editor.renderLineHighlight": "all",
    "editor.suggest.shareSuggestSelections": true,
    "outline.icons": true,
    "search.showLineNumbers": true,
    "search.smartCase": true,

    // package 查找模式
    "go.gocodePackageLookupMode": "go",
    "go.gotoSymbol.includeGoroot": true,
    "go.gotoSymbol.includeImports": true,

    // build 相关
    "go.buildOnSave": "off",
    "go.gocodeAutoBuild": true,
    "go.installDependenciesWhenBuilding": true,
    "go.buildFlags": [],
    "go.buildTags": "",
    "go.coverOnSingleTest": true,

    "go.useCodeSnippetsOnFunctionSuggest": true,
    "go.useCodeSnippetsOnFunctionSuggestWithoutType": true,

    "go.docsTool": "guru",
    "go.formatTool": "goimports",
    "go.lintTool": "golangci-lint",
    "go.lintOnSave": "package",
    "go.lintFlags": [
        "--fast"
    ],
    "go.formatFlags": [],
    "go.vetFlags": [],
    "go.vetOnSave": "package",
    "go.generateTestsFlags": [],

    "go.liveErrors": {
        "enabled": true,
        "delay": 500
    },
    "go.gocodeFlags": [
        "-builtin",
        "-ignore-case",
        "-unimported-packages"
    ],
    "go.enableCodeLens": {
        "references": true,
        "runtest": true
    },
    "go.delveConfig": {
        "dlvLoadConfig": {
            "followPointers": true,
            "maxVariableRecurse": 1,
            "maxStringLen": 64,
            "maxArrayValues": 64,
            "maxStructFields": -1
        },
        "apiVersion": 2,
        "showGlobalVariables": true
    },
    "go.editorContextMenuCommands": {
        "toggleTestFile": true,
        "addTags": true,
        "removeTags": true,
        "testAtCursor": true,
        "testFile": true,
        "testPackage": true,
        "generateTestForFunction": true,
        "generateTestForFile": true,
        "generateTestForPackage": true,
        "addImport": true,
        "testCoverage": true,
        "playground": true,
        "debugTestAtCursor": true
    },
    "go.playground": {
        "openbrowser": false,
        "share": false,
        "run": false
    },
    "go.addTags": {
        "tags": "json",
        "options": "json=omitempty",
        "promptForTags": true,
        "transform": "snakecase"
    },
    "go.removeTags": {
        "tags": "",
        "options": "",
        "promptForTags": false
    },
    "[go]": {
        "editor.codeActionsOnSave": {
            "source.organizeImports": true
        },
    },
    "go.alternateTools": {
        "go-langserver": "gopls",
    },
    "go.useLanguageServer": false,
    "go.languageServerFlags": [],
    "go.languageServerExperimentalFeatures": {
        "format": true,
        "autoComplete": true,
        "rename": true,
        "goToDefinition": true,
        "hover": true,
        "signatureHelp": true,
        "goToTypeDefinition": true,
        "goToImplementation": true,
        "documentSymbols": true,
        "workspaceSymbols": true,
        "findReferences": true,
        "diagnostics": false
    }
}

参考链接:https://www.cnblogs.com/chnmi...

克隆go-zero

github地址:https://github.com/tal-tech/g...

学习视频地址:https://talkgo.org/t/topic/729

语雀文档资料:https://www.yuque.com/tal-tec...

image

玩goctl工具

goctl是go-zero微服务框架下的代码生成工具,其可以快速提升开发效率,让开发人员将时间重点放在业务coding上……

查询很多资料都不说的,不清晰,总是报command not found: goctl错误。

我也是将goctl工具安装到 $GOPATH/bin 目录下

image?x-oss-

环境变量也配置了,最后发现,所有网上博客都没有说,把 $GOPATH/bin,加入系统环境path变量。加入以后,重启电脑,就可以正常使用goctl工具。

image

接下来,就是体验goctl工具。

体验goctl工具

C:\Users\domin>d:

D:\>cd D:\go-learn

D:\go-learn>goctl api new greet
[32mDone.[0m

D:\go-learn>cd greet

D:\go-learn\greet>go mod init
go mod init: go.mod already exists

D:\go-learn\greet>go mod tidy
go: finding module for package github.com/tal-tech/go-zero/core/logx
go: finding module for package github.com/tal-tech/go-zero/rest
go: finding module for package github.com/tal-tech/go-zero/rest/httpx
go: finding module for package github.com/tal-tech/go-zero/core/conf
go: found github.com/tal-tech/go-zero/core/conf in github.com/tal-tech/go-zero v1.1.2
go: found github.com/tal-tech/go-zero/rest in github.com/tal-tech/go-zero v1.1.2
go: found github.com/tal-tech/go-zero/rest/httpx in github.com/tal-tech/go-zero v1.1.2
go: found github.com/tal-tech/go-zero/core/logx in github.com/tal-tech/go-zero v1.1.2

D:\go-learn\greet>go run greet.go -f etc/greet-api.yaml
Starting server at 0.0.0.0:8888...
{"@timestamp":"2021-01-10T01:04:05.746+08","level":"stat","content":"CPU: 0m, MEMORY: Alloc=0.6Mi, TotalAlloc=0.6Mi, Sys=6.6Mi, NumGC=0"}
{"@timestamp":"2021-01-10T01:04:05.751+08","level":"stat","content":"(api) shedding_stat [1m], cpu: 0, total: 0, pass: 0, drop: 0"}
{"@timestamp":"2021-01-10T01:05:05.747+08","level":"stat","content":"CPU: 0m, MEMORY: Alloc=0.6Mi, TotalAlloc=0.6Mi, Sys=6.6Mi, NumGC=0"}
{"@timestamp":"2021-01-10T01:05:05.751+08","level":"stat","content":"(api) shedding_stat [1m], cpu: 0, total: 0, pass: 0, drop: 0"}
{"@timestamp":"2021-01-10T01:06:05.746+08","level":"stat","content":"CPU: 0m, MEMORY: Alloc=0.6Mi, TotalAlloc=0.6Mi, Sys=6.6Mi, NumGC=0"}
{"@timestamp":"2021-01-10T01:06:05.750+08","level":"stat","content":"(api) shedding_stat [1m], cpu: 0, total: 0, pass: 0, drop: 0"}
{"@timestamp":"2021-01-10T01:07:05.746+08","level":"stat","content":"CPU: 0m, MEMORY: Alloc=0.6Mi, TotalAlloc=0.6Mi, Sys=6.6Mi, NumGC=0"}
{"@timestamp":"2021-01-10T01:07:05.752+08","level":"stat","content":"(api) shedding_stat [1m], cpu: 0, total: 0, pass: 0, drop: 0"}
{"@timestamp":"2021-01-10T01:08:05.744+08","level":"stat","content":"CPU: 0m, MEMORY: Alloc=0.6Mi, TotalAlloc=0.6Mi, Sys=6.6Mi, NumGC=0"}
{"@timestamp":"2021-01-10T01:08:05.750+08","level":"stat","content":"(api) shedding_stat [1m], cpu: 0, total: 0, pass: 0, drop: 0"}
{"@timestamp":"2021-01-10T01:09:05.746+08","level":"stat","content":"CPU: 0m, MEMORY: Alloc=0.6Mi, TotalAlloc=0.6Mi, Sys=6.6Mi, NumGC=0"}
{"@timestamp":"2021-01-10T01:09:05.750+08","level":"stat","content":"(api) shedding_stat [1m], cpu: 0, total: 0, pass: 0, drop: 0"}

image

再另外开一个cmd窗口

C:\Users\domin>d:

D:\>cd D:\go-learn\greet

D:\go-learn\greet>goctl api java -api greet.api -dir greet
[32mDone.[0m

D:\go-learn\greet>curl -i http://localhost:8888/from/you
HTTP/1.1 200 OK
Content-Type: application/json
Date: Sat, 09 Jan 2021 17:09:06 GMT
Content-Length: 14

image

生成的代码

image

总结

除了goctl神器,go-zero还有很多的小工具。

  1. 流数据处理利器:fx。如java8的lambda,,go-zero也有了!fx.Filter().Sort().Head() ,让数组的复杂处理变得简单。
  2. List itemmapReduce降低服务相应时间:mr.Finish(), mr.Map().Reduce(), 跟并发处理waitGroup说拜拜。
  3. etcd服务发现的集成:p2c的算法发现服务,避免开发人员点对点或nginx的转发服务,安装一个etcd就完事了。
  4. jwt集成api:轻松拥有一个jwt的后台服务。
  5. 集成Prometheus:轻松拥有一个带监控的golang后台服务。

Go语言主要用作服务器端开发,其定位是用来开发“大型软件”的,适合于很多程序员一起开发大型软件,并且开发周期长,支持云计算的网络服务。Go语言能够让程序员快速开发,并且在软件不断的增长过程中,它能让程序员更容易地进行维护和修改。它融合了传统编译型语言的高效性和脚本语言的易用性和富于表达性。

Go语言作为服务器编程语言,很适合处理日志、数据打包、虚拟机处理、文件系统、分布式系统、数据库代理等;网络编程方面,Go语言广泛应用于Web应用、API应用、下载应用等;除此之外,Go语言还可用于内存数据库和云平台领域,目前国外很多云平台都是采用Go开发。

参考链接:https://www.jianshu.com/p/6fbba7f7ced3

go-zero地址:https://github.com/tal-tech/go-zero


本篇文章由一文多发平台ArtiPub自动发布

查看原文

赞 3 收藏 1 评论 1

kevinwan 发布了文章 · 1月6日

从代码到部署微服务实战(一)

当前微服务已经成为服务端开发的主流架构,而Go语言因其简单易学、内置高并发、快速编译、占用内存小等特点也越来越受到开发者的青睐,微服务实战系列文章将从实战的角度和大家一起学习微服务相关的知识。本系列文章将以一个“博客系统”由浅入深的和大家一起一步步搭建起一个完整的微服务系统

该篇文章为微服务实战系列的第一篇文章,我们将基于go-zero+gitlab+jenkins+k8s构建微服务持续集成和自动构建发布系统,先对以上模块做一个简单介绍:

  • go-zero 是一个集成了各种工程实践的 web 和 rpc 框架。通过弹性设计保障了大并发服务端的稳定性,经受了充分的实战检验
  • gitlab 是一款基于 Git 的完全集成的软件开发平台,另外,GitLab 且具有wiki以及在线编辑、issue跟踪功能、CI/CD 等功能
  • jenkins 是基于Java开发的一种持续集成工具,用于监控持续重复的工作,旨在提供一个开放易用的软件平台,使软件的持续集成变成可能
  • kubernetes 常简称为K8s,是用于自动部署、扩展和管理容器化应用程序”的开源系统。该系统由Google设计并捐赠给Cloud Native Computing Foundation(今属Linux基金会)来使用。它旨在提供“跨主机集群的自动部署、扩展以及运行应用程序容器的平台

devops1

实战主要分为五个步骤,下面针对以下的五个步骤分别进行详细的讲解

  1. 第一步环境搭建,这里我采用了两台ubuntu16.04服务器分别安装了gitlab和jenkins,采用xxx云弹性k8s集群
  2. 第二步生成项目,这里我采用go-zero提供的goctl工具快速生成项目,并对项目做简单的修改以便测试
  3. 第三部生成Dockerfile和k8s部署文件,k8s部署文件编写复杂而且容易出错,goctl工具提供了生成Dockerfile和k8s部署文件的功能非常的方便
  4. Jenkins Pipeline采用声明式语法构建,创建Jenkinsfile文件并使用gitlab进行版本管理
  5. 最后进行项目测试验证服务是否正常

<img data-original="https://gitee.com/kevwan/static/raw/master/doc/images/experiment_step.png" alt="experiment_step" style="zoom: 50%;" />

环境搭建

首先我们搭建实验环境,这里我采用了两台ubuntu16.04服务器,分别安装了gitlab和jenkins。gtilab使用apt-get直接安装,安装好后启动服务并查看服务状态,各组件为run状态说明服务已经启动,默认端口为9090直接访问即可

gitlab-ctl start  // 启动服务

gitlab-ctl status // 查看服务状态

run: alertmanager: (pid 1591) 15442s; run: log: (pid 2087) 439266s
run: gitaly: (pid 1615) 15442s; run: log: (pid 2076) 439266s
run: gitlab-exporter: (pid 1645) 15442s; run: log: (pid 2084) 439266s
run: gitlab-workhorse: (pid 1657) 15441s; run: log: (pid 2083) 439266s
run: grafana: (pid 1670) 15441s; run: log: (pid 2082) 439266s
run: logrotate: (pid 5873) 1040s; run: log: (pid 2081) 439266s
run: nginx: (pid 1694) 15440s; run: log: (pid 2080) 439266s
run: node-exporter: (pid 1701) 15439s; run: log: (pid 2088) 439266s
run: postgres-exporter: (pid 1708) 15439s; run: log: (pid 2079) 439266s
run: postgresql: (pid 1791) 15439s; run: log: (pid 2075) 439266s
run: prometheus: (pid 10763) 12s; run: log: (pid 2077) 439266s
run: puma: (pid 1816) 15438s; run: log: (pid 2078) 439266s
run: redis: (pid 1821) 15437s; run: log: (pid 2086) 439266s
run: redis-exporter: (pid 1826) 15437s; run: log: (pid 2089) 439266s
run: sidekiq: (pid 1835) 15436s; run: log: (pid 2104) 439266s

jenkins也是用apt-get直接安装,需要注意的是安装jenkins前需要先安装java,过程比较简单这里就不再演示,jenkins默认端口为8080,默认账号为admin,初始密码路径为/var/lib/jenkins/secrets/initialAdminPassword,初始化安装推荐的插件即可,后面可以根据自己的需要再安装其它插件

k8s集群搭建过程比较复杂,虽然可以使用kubeadm等工具快速搭建,但距离真正的生产级集群还是有一定差距,因为我们的服务最终是要上生产的,所以这里我选择了xxx云的弹性k8s集群版本为1.16.9,弹性集群的好处是按需收费没有额外的费用,当我们实验完成后通过kubectl delete立马释放资源只会产生很少的费用,而且xxx云的k8s集群给我们提供了友好的监控页面,可以通过这些界面查看各种统计信息,集群创建好后需要创建集群访问凭证才能访问集群

  • 若当前访问客户端尚未配置任何集群的访问凭证,即 ~/.kube/config 内容为空,可直接将访问凭证内容并粘贴入 ~/.kube/config 中
  • 若当前访问客户端已配置了其他集群的访问凭证,需要通过如下命令合并凭证

    KUBECONFIG=~/.kube/config:~/Downloads/k8s-cluster-config kubectl config view --merge --flatten > ~/.kube/config
    export KUBECONFIG=~/.kube/config

配置好访问权限后通过如下命令可查看当前集群

kubectl config current-context

查看集群版本,输出内容如下

kubectl version

Client Version: version.Info{Major:"1", Minor:"16", GitVersion:"v1.16.9", GitCommit:"a17149e1a189050796ced469dbd78d380f2ed5ef", GitTreeState:"clean", BuildDate:"2020-04-16T11:44:51Z", GoVersion:"go1.13.9", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"16+", GitVersion:"v1.16.9-eks.2", GitCommit:"f999b99a13f40233fc5f875f0607448a759fc613", GitTreeState:"clean", BuildDate:"2020-10-09T12:54:13Z", GoVersion:"go1.13.9", Compiler:"gc", Platform:"linux/amd64"}

到这里我们的试验已经搭建完成了,这里版本管理也可以使用github

生成项目

整个项目采用大仓的方式,目录结构如下,最外层项目命名为blog,app目录下为按照业务拆分成的不同的微服务,比如user服务下面又分为api服务和rpc服务,其中api服务为聚合网关对外提供restful接口,而rpc服务为内部通信提供高性能的数据缓存等操作

   ├── blog
   │   ├── app
   │   │   ├── user
   │   │   │   ├── api
   │   │   │   └── rpc
   │   │   ├── article
   │   │   │   ├── api
   │   │   │   └── rpc

项目目录创建好之后我们进入api目录创建user.api文件,文件内容如下,定义服务端口为2233,同时定义了一个/user/info接口

type UserInfoRequest struct {
    Uid int64 `form:"uid"`
}

type UserInfoResponse struct {
    Uid   int64  `json:"uid"`
    Name  string `json:"name"`
    Level int    `json:"level"`
}

@server(
    port: 2233
)
service user-api {
    @doc(
        summary:  获取用户信息
    )
    @server(
        handler:  UserInfo
    )
    get /user/info(UserInfoRequest) returns(UserInfoResponse)
}

定义好api文件之后我们执行如下命令生成api服务代码,一键生成真是能大大提升我们的生产力呢

goctl api go -api user.api -dir .

代码生成后我们对代码稍作改造以便后面部署后方便进行测试,改造后的代码为返回本机的ip地址

func (ul *UserInfoLogic) UserInfo(req types.UserInfoRequest) (*types.UserInfoResponse, error) {
    addrs, err := net.InterfaceAddrs()
    if err != nil {
        return nil, err
    }
    var name string
    for _, addr := range addrs {
        if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() && ipnet.IP.To4() != nil {
            name = ipnet.IP.String()
        }
    }

    return &types.UserInfoResponse{
        Uid:   req.Uid,
        Name:  name,
        Level: 666,
    }, nil
}

到这里服务生成部分就完成了,因为本节为基础框架的搭建所以只是添加一些测试的代码,后面会继续丰富项目代码

生成镜像和部署文件

一般的常用镜像比如mysql、memcache等我们可以直接从镜像仓库拉取,但是我们的服务镜像需要我们自定义,自定义镜像有多重方式而使用Dockerfile则是使用最多的一种方式,使用Dockerfile定义镜像虽然不难但是也很容易出错,所以这里我们也借助工具来自动生成,这里就不得不再夸一下goctl这个工具真的是棒棒的,还能帮助我们一键生成Dockerfile呢,在api目录下执行如下命令

goctl docker -go user.go

生成后的文件稍作改动以符合我们的目录结构,文件内容如下,采用了两阶段构建,第一阶段构建可执行文件确保构建独立于宿主机,第二阶段会引用第一阶段构建的结果,最终构建出极简镜像

FROM golang:alpine AS builder

LABEL stage=gobuilder

ENV CGO_ENABLED 0
ENV GOOS linux
ENV GOPROXY https://goproxy.cn,direct

WORKDIR /build/zero

RUN go mod init blog/app/user/api
RUN go mod download
COPY . .
COPY /etc /app/etc
RUN go build -ldflags="-s -w" -o /app/user user.go


FROM alpine

RUN apk update --no-cache && apk add --no-cache ca-certificates tzdata
ENV TZ Asia/Shanghai

WORKDIR /app
COPY --from=builder /app/user /app/user
COPY --from=builder /app/etc /app/etc

CMD ["./user", "-f", "etc/user-api.yaml"]

然后执行如下命令创建镜像

docker build -t user:v1 app/user/api/

这个时候我们使用docker images命令查看镜像会发现user镜像已经创建,版本为v1

REPOSITORY                            TAG                 IMAGE ID            CREATED             SIZE
user                                  v1                  1c1f64579b40        4 days ago          17.2MB

同样,k8s的部署文件编写也比较复杂很容易出错,所以我们也使用goctl自动来生成,在api目录下执行如下命令

goctl kube deploy -name user-api -namespace blog -image user:v1 -o user.yaml -port 2233

生成的ymal文件如下

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-api
  namespace: blog
  labels:
    app: user-api
spec:
  replicas: 2
  revisionHistoryLimit: 2
  selector:
    matchLabels:
      app: user-api
  template:
    metadata:
      labels:
        app: user-api
    spec:
      containers:
      - name: user-api
        image: user:v1
        lifecycle:
          preStop:
            exec:
              command: ["sh","-c","sleep 5"]
        ports:
        - containerPort: 2233
        readinessProbe:
          tcpSocket:
            port: 2233
          initialDelaySeconds: 5
          periodSeconds: 10
        livenessProbe:
          tcpSocket:
            port: 2233
          initialDelaySeconds: 15
          periodSeconds: 10
        resources:
          requests:
            cpu: 500m
            memory: 512Mi
          limits:
            cpu: 1000m
            memory: 1024Mi

到此生成镜像和k8s部署文件步骤已经结束了,上面主要是为了演示,真正的生产环境中都是通过持续集成工具自动创建镜像的

Jenkins Pipeline

jenkins是常用的继续集成工具,其提供了多种构建方式,而pipeline是最常用的构建方式之一,pipeline支持声名式和脚本式两种方式,脚本式语法灵活、可扩展,但也意味着更复杂,而且需要学习Grovvy语言,增加了学习成本,所以才有了声明式语法,声名式语法是一种更简单,更结构化的语法,我们后面也都会使用声名式语法

这里再介绍下Jenkinsfile,其实Jenkinsfile就是一个纯文本文件,也就是部署流水线概念在Jenkins中的表现形式,就像Dockerfile之于Docker,所有的部署流水线逻辑都可在Jenkinsfile文件中定义,需要注意,Jenkins默认是不支持Jenkinsfile的,我们需要安装Pipeline插件,安装插件的流程为Manage Jenkins -> Manager Plugins 然后搜索安装即可,之后便可构建pipeline了

<img data-original="https://gitee.com/kevwan/static/raw/master/doc/images/pipeline_build.png" alt="pipeline_build" style="zoom: 33%;" />

我们可以直接在pipeline的界面中输入构建脚本,但是这样没法做到版本化,所以如果不是临时测试的话是不推荐这种方式的,更通用的方式是让jenkins从git仓库中拉取Jenkinsfile并执行

首先需要安装Git插件,然后使用ssh clone方式拉取代码,所以,需要将git私钥放到jenkins中,这样jenkins才有权限从git仓库拉取代码

将git私钥放到jenkins中的步骤是:Manage Jenkins -> Manage credentials -> 添加凭据,类型选择为SSH Username with private key,接下来按照提示进行设置就可以了,如下图所示

<img data-original="https://gitee.com/kevwan/static/raw/master/doc/images/gitlab_tokens.png" alt="gitlab_tokens" style="zoom:50%;" />

然后在我们的gitlab中新建一个项目,只需要一个Jenkinsfile文件

gitlab_jenkinsfile

在user-api项目中流水线定义选择Pipeline script from SCM,添加gitlab ssh地址和对应的token,如下图所示

<img data-original="https://gitee.com/kevwan/static/raw/master/doc/images/jenkinsfile_responsitory.png" alt="jenkinsfile_responsitory" style="zoom:40%;" />

接着我们就可以按照上面的实战步骤进行Jenkinsfile文件的编写了

  • 从gitlab拉取代码,从我们的gitlab仓库中拉取代码,并使用commit_id用来区分不同版本

    stage('从gitlab拉取服务代码') {
        steps {
            echo '从gitlab拉取服务代码'
            git credentialsId: 'xxxxxxxx', url: 'http://xxx.xxx.xxx.xxx:xxx/blog/blog.git'
            script {
                commit_id = sh(returnStdout: true, script: 'git rev-parse --short HEAD').trim()
            }
        }
    }
  • 构建docker镜像,使用goctl生成的Dockerfile文件构建镜像

    stage('构建镜像') {
        steps {
            echo '构建镜像'
            sh "docker build -t user:${commit_id} app/user/api/"
        }
    }
  • 上传镜像到镜像仓库,把生产的镜像push到镜像仓库

    stage('上传镜像到镜像仓库') {
        steps {
            echo "上传镜像到镜像仓库"
            sh "docker login -u xxx -p xxxxxxx"
            sh "docker tag user:${commit_id} xxx/user:${commit_id}"
            sh "docker push xxx/user:${commit_id}"
        }
    }
  • 部署到k8s,把部署文件中的版本号替换,从远程拉取镜,使用kubectl apply命令进行部署

    stage('部署到k8s') {
        steps {
            echo "部署到k8s"
            sh "sed -i 's/<COMMIT_ID_TAG>/${commit_id}/' app/user/api/user.yaml"
            sh "cp app/user/api/user.yaml ."
            sh "kubectl apply -f user.yaml"
        }
    }

    完整的Jenkinsfile文件如下

    pipeline {
        agent any
    
        stages {
            stage('从gitlab拉取服务代码') {
                steps {
                    echo '从gitlab拉取服务代码'
                    git credentialsId: 'xxxxxx', url: 'http://xxx.xxx.xxx.xxx:9090/blog/blog.git'
                    script {
                        commit_id = sh(returnStdout: true, script: 'git rev-parse --short HEAD').trim()
                    }
                }
            }
            stage('构建镜像') {
                steps {
                    echo '构建镜像'
                    sh "docker build -t user:${commit_id} app/user/api/"
                }
            }
            stage('上传镜像到镜像仓库') {
                steps {
                    echo "上传镜像到镜像仓库"
                    sh "docker login -u xxx -p xxxxxxxx"
                    sh "docker tag user:${commit_id} xxx/user:${commit_id}"
                    sh "docker push xxx/user:${commit_id}"
                }
            }
            stage('部署到k8s') {
                steps {
                    echo "部署到k8s"
                    sh "sed -i 's/<COMMIT_ID_TAG>/${commit_id}/' app/user/api/user.yaml"
                    sh "kubectl apply -f app/user/api/user.yaml"
                }
            }
        }
    }

    到这里所有的配置基本完毕,我们的基础框架也基本搭建完成,下面开始执行pipeline,点击左侧的立即构建在下面Build History中就回产生一个构建历史序列号,点击对应的序列号然后点击左侧的Console Output即可查看构建过程的详细信息,如果构建过程出现错误也会在这里输出

    buid_step

构建详细输出如下,pipeline对应的每一个stage都有详细的输出

Started by user admin
Obtained Jenkinsfile from git git@xxx.xxx.xxx.xxx:gitlab-instance-1ac0cea5/pipelinefiles.git
Running in Durability level: MAX_SURVIVABILITY
[Pipeline] Start of Pipeline
[Pipeline] node
Running on Jenkins in /var/lib/jenkins/workspace/user-api
[Pipeline] {
[Pipeline] stage
[Pipeline] { (Declarative: Checkout SCM)
[Pipeline] checkout
Selected Git installation does not exist. Using Default
The recommended git tool is: NONE
using credential gitlab_token
 > git rev-parse --is-inside-work-tree # timeout=10
Fetching changes from the remote Git repository
 > git config remote.origin.url git@xxx.xxx.xxx.xxx:gitlab-instance-1ac0cea5/pipelinefiles.git # timeout=10
Fetching upstream changes from git@xxx.xxx.xxx.xxx:gitlab-instance-1ac0cea5/pipelinefiles.git
 > git --version # timeout=10
 > git --version # 'git version 2.7.4'
using GIT_SSH to set credentials 
 > git fetch --tags --progress git@xxx.xxx.xxx.xxx:gitlab-instance-1ac0cea5/pipelinefiles.git +refs/heads/*:refs/remotes/origin/* # timeout=10
 > git rev-parse refs/remotes/origin/master^{commit} # timeout=10
Checking out Revision 77eac3a4ca1a5b6aea705159ce26523ddd179bdf (refs/remotes/origin/master)
 > git config core.sparsecheckout # timeout=10
 > git checkout -f 77eac3a4ca1a5b6aea705159ce26523ddd179bdf # timeout=10
Commit message: "add"
 > git rev-list --no-walk 77eac3a4ca1a5b6aea705159ce26523ddd179bdf # timeout=10
[Pipeline] }
[Pipeline] // stage
[Pipeline] withEnv
[Pipeline] {
[Pipeline] stage
[Pipeline] { (从gitlab拉取服务代码)
[Pipeline] echo
从gitlab拉取服务代码
[Pipeline] git
The recommended git tool is: NONE
using credential gitlab_user_pwd
 > git rev-parse --is-inside-work-tree # timeout=10
Fetching changes from the remote Git repository
 > git config remote.origin.url http://xxx.xxx.xxx.xxx:9090/blog/blog.git # timeout=10
Fetching upstream changes from http://xxx.xxx.xxx.xxx:9090/blog/blog.git
 > git --version # timeout=10
 > git --version # 'git version 2.7.4'
using GIT_ASKPASS to set credentials 
 > git fetch --tags --progress http://xxx.xxx.xxx.xxx:9090/blog/blog.git +refs/heads/*:refs/remotes/origin/* # timeout=10
 > git rev-parse refs/remotes/origin/master^{commit} # timeout=10
Checking out Revision b757e9eef0f34206414bdaa4debdefec5974c3f5 (refs/remotes/origin/master)
 > git config core.sparsecheckout # timeout=10
 > git checkout -f b757e9eef0f34206414bdaa4debdefec5974c3f5 # timeout=10
 > git branch -a -v --no-abbrev # timeout=10
 > git branch -D master # timeout=10
 > git checkout -b master b757e9eef0f34206414bdaa4debdefec5974c3f5 # timeout=10
Commit message: "Merge branch 'blog/dev' into 'master'"
 > git rev-list --no-walk b757e9eef0f34206414bdaa4debdefec5974c3f5 # timeout=10
[Pipeline] script
[Pipeline] {
[Pipeline] sh
+ git rev-parse --short HEAD
[Pipeline] }
[Pipeline] // script
[Pipeline] }
[Pipeline] // stage
[Pipeline] stage
[Pipeline] { (构建镜像)
[Pipeline] echo
构建镜像
[Pipeline] sh
+ docker build -t user:b757e9e app/user/api/
Sending build context to Docker daemon  28.16kB

Step 1/18 : FROM golang:alpine AS builder
alpine: Pulling from library/golang
801bfaa63ef2: Pulling fs layer
ee0a1ba97153: Pulling fs layer
1db7f31c0ee6: Pulling fs layer
ecebeec079cf: Pulling fs layer
63b48972323a: Pulling fs layer
ecebeec079cf: Waiting
63b48972323a: Waiting
1db7f31c0ee6: Verifying Checksum
1db7f31c0ee6: Download complete
ee0a1ba97153: Verifying Checksum
ee0a1ba97153: Download complete
63b48972323a: Verifying Checksum
63b48972323a: Download complete
801bfaa63ef2: Verifying Checksum
801bfaa63ef2: Download complete
801bfaa63ef2: Pull complete
ee0a1ba97153: Pull complete
1db7f31c0ee6: Pull complete
ecebeec079cf: Verifying Checksum
ecebeec079cf: Download complete
ecebeec079cf: Pull complete
63b48972323a: Pull complete
Digest: sha256:49b4eac11640066bc72c74b70202478b7d431c7d8918e0973d6e4aeb8b3129d2
Status: Downloaded newer image for golang:alpine
 ---> 1463476d8605
Step 2/18 : LABEL stage=gobuilder
 ---> Running in c4f4dea39a32
Removing intermediate container c4f4dea39a32
 ---> c04bee317ea1
Step 3/18 : ENV CGO_ENABLED 0
 ---> Running in e8e848d64f71
Removing intermediate container e8e848d64f71
 ---> ff82ee26966d
Step 4/18 : ENV GOOS linux
 ---> Running in 58eb095128ac
Removing intermediate container 58eb095128ac
 ---> 825ab47146f5
Step 5/18 : ENV GOPROXY https://goproxy.cn,direct
 ---> Running in df2add4e39d5
Removing intermediate container df2add4e39d5
 ---> c31c1aebe5fa
Step 6/18 : WORKDIR /build/zero
 ---> Running in f2a1da3ca048
Removing intermediate container f2a1da3ca048
 ---> 5363d05f25f0
Step 7/18 : RUN go mod init blog/app/user/api
 ---> Running in 11d0adfa9d53
[91mgo: creating new go.mod: module blog/app/user/api
[0mRemoving intermediate container 11d0adfa9d53
 ---> 3314852f00fe
Step 8/18 : RUN go mod download
 ---> Running in aa9e9d9eb850
Removing intermediate container aa9e9d9eb850
 ---> a0f2a7ffe392
Step 9/18 : COPY . .
 ---> a807f60ed250
Step 10/18 : COPY /etc /app/etc
 ---> c4c5d9f15dc0
Step 11/18 : RUN go build -ldflags="-s -w" -o /app/user user.go
 ---> Running in a4321c3aa6e2
[91mgo: finding module for package github.com/tal-tech/go-zero/core/conf
[0m[91mgo: finding module for package github.com/tal-tech/go-zero/rest/httpx
[0m[91mgo: finding module for package github.com/tal-tech/go-zero/rest
[0m[91mgo: finding module for package github.com/tal-tech/go-zero/core/logx
[0m[91mgo: downloading github.com/tal-tech/go-zero v1.1.1
[0m[91mgo: found github.com/tal-tech/go-zero/core/conf in github.com/tal-tech/go-zero v1.1.1
go: found github.com/tal-tech/go-zero/rest in github.com/tal-tech/go-zero v1.1.1
go: found github.com/tal-tech/go-zero/rest/httpx in github.com/tal-tech/go-zero v1.1.1
go: found github.com/tal-tech/go-zero/core/logx in github.com/tal-tech/go-zero v1.1.1
[0m[91mgo: downloading gopkg.in/yaml.v2 v2.4.0
[0m[91mgo: downloading github.com/justinas/alice v1.2.0
[0m[91mgo: downloading github.com/dgrijalva/jwt-go v3.2.0+incompatible
[0m[91mgo: downloading go.uber.org/automaxprocs v1.3.0
[0m[91mgo: downloading github.com/spaolacci/murmur3 v1.1.0
[0m[91mgo: downloading github.com/google/uuid v1.1.1
[0m[91mgo: downloading google.golang.org/grpc v1.29.1
[0m[91mgo: downloading github.com/prometheus/client_golang v1.5.1
[0m[91mgo: downloading github.com/beorn7/perks v1.0.1
[0m[91mgo: downloading github.com/golang/protobuf v1.4.2
[0m[91mgo: downloading github.com/prometheus/common v0.9.1
[0m[91mgo: downloading github.com/cespare/xxhash/v2 v2.1.1
[0m[91mgo: downloading github.com/prometheus/client_model v0.2.0
[0m[91mgo: downloading github.com/prometheus/procfs v0.0.8
[0m[91mgo: downloading github.com/matttproud/golang_protobuf_extensions v1.0.1
[0m[91mgo: downloading google.golang.org/protobuf v1.25.0
[0mRemoving intermediate container a4321c3aa6e2
 ---> 99ac2cd5fa39
Step 12/18 : FROM alpine
latest: Pulling from library/alpine
801bfaa63ef2: Already exists
Digest: sha256:3c7497bf0c7af93428242d6176e8f7905f2201d8fc5861f45be7a346b5f23436
Status: Downloaded newer image for alpine:latest
 ---> 389fef711851
Step 13/18 : RUN apk update --no-cache && apk add --no-cache ca-certificates tzdata
 ---> Running in 51694dcb96b6
fetch http://dl-cdn.alpinelinux.org/alpine/v3.12/main/x86_64/APKINDEX.tar.gz
fetch http://dl-cdn.alpinelinux.org/alpine/v3.12/community/x86_64/APKINDEX.tar.gz
v3.12.3-38-g9ff116e4f0 [http://dl-cdn.alpinelinux.org/alpine/v3.12/main]
v3.12.3-39-ge9195171b7 [http://dl-cdn.alpinelinux.org/alpine/v3.12/community]
OK: 12746 distinct packages available
fetch http://dl-cdn.alpinelinux.org/alpine/v3.12/main/x86_64/APKINDEX.tar.gz
fetch http://dl-cdn.alpinelinux.org/alpine/v3.12/community/x86_64/APKINDEX.tar.gz
(1/2) Installing ca-certificates (20191127-r4)
(2/2) Installing tzdata (2020f-r0)
Executing busybox-1.31.1-r19.trigger
Executing ca-certificates-20191127-r4.trigger
OK: 10 MiB in 16 packages
Removing intermediate container 51694dcb96b6
 ---> e5fb2e4d5eea
Step 14/18 : ENV TZ Asia/Shanghai
 ---> Running in 332fd0df28b5
Removing intermediate container 332fd0df28b5
 ---> 11c0e2e49e46
Step 15/18 : WORKDIR /app
 ---> Running in 26e22103c8b7
Removing intermediate container 26e22103c8b7
 ---> 11d11c5ea040
Step 16/18 : COPY --from=builder /app/user /app/user
 ---> f69f19ffc225
Step 17/18 : COPY --from=builder /app/etc /app/etc
 ---> b8e69b663683
Step 18/18 : CMD ["./user", "-f", "etc/user-api.yaml"]
 ---> Running in 9062b0ed752f
Removing intermediate container 9062b0ed752f
 ---> 4867b4994e43
Successfully built 4867b4994e43
Successfully tagged user:b757e9e
[Pipeline] }
[Pipeline] // stage
[Pipeline] stage
[Pipeline] { (上传镜像到镜像仓库)
[Pipeline] echo
上传镜像到镜像仓库
[Pipeline] sh
+ docker login -u xxx -p xxxxxxxx
WARNING! Using --password via the CLI is insecure. Use --password-stdin.
WARNING! Your password will be stored unencrypted in /var/lib/jenkins/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded
[Pipeline] sh
+ docker tag user:b757e9e xxx/user:b757e9e
[Pipeline] sh
+ docker push xxx/user:b757e9e
The push refers to repository [docker.io/xxx/user]
b19a970f64b9: Preparing
f695b957e209: Preparing
ee27c5ca36b5: Preparing
7da914ecb8b0: Preparing
777b2c648970: Preparing
777b2c648970: Layer already exists
ee27c5ca36b5: Pushed
b19a970f64b9: Pushed
7da914ecb8b0: Pushed
f695b957e209: Pushed
b757e9e: digest: sha256:6ce02f8a56fb19030bb7a1a6a78c1a7c68ad43929ffa2d4accef9c7437ebc197 size: 1362
[Pipeline] }
[Pipeline] // stage
[Pipeline] stage
[Pipeline] { (部署到k8s)
[Pipeline] echo
部署到k8s
[Pipeline] sh
+ sed -i s/<COMMIT_ID_TAG>/b757e9e/ app/user/api/user.yaml
[Pipeline] sh
+ kubectl apply -f app/user/api/user.yaml
deployment.apps/user-api created
[Pipeline] }
[Pipeline] // stage
[Pipeline] }
[Pipeline] // withEnv
[Pipeline] }
[Pipeline] // node
[Pipeline] End of Pipeline
Finished: SUCCESS

可以看到最后输出了SUCCESS说明我们的pipeline已经成了,这个时候我们可以通过kubectl工具查看一下,-n参数为指定namespace

kubectl get pods -n blog

NAME                       READY   STATUS    RESTARTS   AGE
user-api-84ffd5b7b-c8c5w   1/1     Running   0          10m
user-api-84ffd5b7b-pmh92   1/1     Running   0          10m

我们在k8s部署文件中制定了命名空间为blog,所以在执行pipeline之前我们需要先创建这个namespance

kubectl create namespace blog

服务已经部署好了,那么接下来怎么从外部访问服务呢?这里使用LoadBalancer方式,Service部署文件定义如下,80端口映射到容器的2233端口上,selector用来匹配Deployment中定义的label

apiVersion: v1
kind: Service
metadata:
  name: user-api-service
  namespace: blog
spec:
  selector:
    app: user-api
  type: LoadBalancer
  ports:
    - protocol: TCP
      port: 80
      targetPort: 2233

执行创建service,创建完后查看service输出如下,注意一定要加上-n参数指定namespace

kubectl apply -f user-service.yaml
kubectl get services -n blog

NAME               TYPE           CLUSTER-IP   EXTERNAL-IP      PORT(S)        AGE
user-api-service   LoadBalancer   <none>       xxx.xxx.xxx.xx   80:32470/TCP   79m

这里的EXTERNAL-IP 即为提供给外网访问的ip,端口为80

到这里我们的所有的部署任务都完成了,大家最好也能亲自动手来实践一下

测试

最后我们来测试下部署的服务是否正常,使用EXTERNAL-IP来进行访问

curl "http://xxx.xxx.xxx.xxx:80/user/info?uid=1"

{"uid":1,"name":"172.17.0.5","level":666}

curl http://xxx.xxx.xxx.xxx:80/user/info\?uid\=1

{"uid":1,"name":"172.17.0.8","level":666}

curl访问了两次/user/info接口,都能正常返回,说明我们的服务没有问题,name字段分别输出了两个不同ip,可以看出LoadBalancer默认采用了Round Robin的负载均衡策略

总结

以上我们实现了从代码开发到版本管理再到构建部署的DevOps全流程,完成了基础架构的搭建,当然这个架构现在依然很简陋。在本系列后续中,我们将以这个博客系统为基础逐渐的完善整个架构,比如逐渐的完善CI、CD流程、增加监控、博客系统功能的完善、高可用最佳实践和其原理等等

工欲善其事必先利其器,好的工具能大大提升我们的工作效率而且能降低出错的可能,上面我们大量使用了[goctl]()工具简直有点爱不释手了哈哈哈,下次见

由于个人能力有限难免有表达有误的地方,欢迎广大观众姥爷批评指正!

项目地址

https://github.com/tal-tech/go-zero

欢迎使用并 star 支持我们!👏

go-zero 系列文章见『微服务实践』公众号
查看原文

赞 2 收藏 3 评论 0

认证与成就

  • 获得 38 次点赞
  • 获得 0 枚徽章 获得 0 枚金徽章, 获得 0 枚银徽章, 获得 0 枚铜徽章

擅长技能
编辑

开源项目 & 著作
编辑

  • go-zero

    go-zero 是一个集成了各种工程实践的 web 和 rpc 框架。通过弹性设计保障了大并发服务端的稳定性,经受了充分的实战检验。 go-zero 包含极简的 API 定义和生成工具 goctl,可以根据定义的 api 文件一键生成 Go, iOS, Android, Kotlin, Dart, TypeScript, JavaScript 代码,并可直接运行。

注册于 2013-07-16
个人主页被 2.3k 人浏览