Archive

Linux 内核之旅（二）：VFS

Linux 内核之旅（三）：虚拟内存管理

Linux 安全对抗收集

安全对抗case及检测策略

Linux 内核之旅（一）：进程

FILEBEAT ：一款轻量级日志采集器agent的实现与分析

数据的搬运工

golang eBPF 开发入门（五）

网络开发之 XDP/TC

主机入侵检测系统 Elkeid：设计与分析（一）

后台服务模块

golang eBPF 开发入门（三）

通信：eBPF 中的 Maps 数据结构分析与应用

golang eBPF 开发入门（二）

kprobe/uprobe/tracepoint/CO-RE 开发实践

数据结构与算法回顾（九）：bitmap

gopsutil 使用与分析

一个跨平台的采集库 && windows API 实现

Linux 系统调用汇总

收集常用的 ebpf 的系统调用：review && hook

WinTun && WinDivert 使用与分析

基于Clash等开源项目的一些技术实现总结

ego/gocache：一个缓存管理通用工具库的实现

CS144：一个轻量级 TCP 重组器的实现与分析

GOST 应用与分析（一）（未完待续）

GOST 项目的介绍及 TUNNEL 实现分析

Etcd 工程解析（一）

整体模块拆解

golang eBPF 开发入门（一）

GoZero 组件分析：executors（批处理组件）

重拾 Linux 网络（六）：DNS 劫持与代理

DNS 劫持代理 review

Linux Namespace && Cgroup

Linux 系统资源隔离与管理机制介绍

DPI with go：构建一个流量分析系统

golang 的包处理：gopacket

Envoy 应用入门（TODO）

frp穿透项目：设计与分析（一）

Pprof 调试经验汇总

重拾 Linux 网络（五）：TCP/IP 协议栈回顾

工作中遇到的那些协议栈相关的知识点汇总（基于 google-netstack 的应用开发）

再看 io.Copy

梳理一下容易被遗漏的细节问题

重拾 Linux 网络（四）：NAT

NAT 与 内网穿透

使用 Golang 实现 SSH 和 SSHD（四）

git over sshd：如何实现一个 git-sshd-server

Golang 网络编程（三）：tun 网络编程

golang tun 网络编程应用以及 gvisor 协议栈开发介绍

透明代理汇总：Transparent Proxy All In One

记录项目预研 / 开发的若干细节

Wireguard 实现原理与分析（一）

一个基于 golang 实现的 vpn-tunnel 分析

重拾 Linux 网络（二）：网卡 / 虚拟网卡、tap/tun 那些事

重拾 Linux 网络（三）：透明代理中的路由策略

重拾 Linux 网络（一）：iptables

如何利用 iptables 构建透明代理

MITM：中间人机制 review

如何优雅的实现 https mitm（透明劫持）

Kubernetes 应用改造（九）：CRD && Controller && Operator 入门

helm 入门与应用：Kubernetes 包管理器

使用 helm 部署 kubernetes 应用（helm V3）

bytes.Buffer 源码分析及应用

Sync.Pool 应用与分析（续）

Golang sync.Pool 源码分析

Singleflight：原理与应用（续）

如何安全且正确的使用 singleflight

Golang 并发：如何优雅实现并发 goroutine 若干细节

Golang errorgroup 应用（续）

Golang 闭包与递归：介绍与应用场景

Golang closure

go-redis/cache 库分析与使用

OpenSSH Certificate 与 Golang 的兼容性问题

再看认证流程

TLS（HTTPS）、OpenSSH 协议的那些细节

Golang 中的GC小结（未完待续）

微服务中的缓存（四）：内存缓存使用的一些技巧

记录项目中遇到的问题及解决方案

基于redis的分布式限频库分析：ratelimit（未完待续）

WebSocket：原理与应用

WebSocket 在 golang 中的应用介绍

Mysql：Session && Transaction

Mysql 基础回顾：会话与事务

Cronsun：任务统一集中管理（调度）系统设计与分析

分析一款典型的分布式任务调度系统

Bash 日常应用总结

A Linux Bash Cookbook

golang-LRU 缓存设计与实现（二）

分析 go-zero 中的进程内缓存库 collection.Cache 实现

分布式链路追踪（OpenTracing）之应用篇

使用 http/gin 构建 OpenTracing 机制

CAP 分析 && 实战：Gossip 协议

AP 协议：gossip && hashicorp/memberlist 分析

一种基于 TTY-based 的 kubernetes console 实现思路

如何使用 ssh 协议打通 kubernetes EXEC 登录？

Golang 的分布式缓存库：GroupCache 分析

分析一个 GroupCache 的应用

数据结构与算法回顾（五）：golang 的 container 包

list、heap 和 ring

Golang 中的错误处理

如何优雅的处理 Golang 错误以及 gRPC 的错误

数据结构与算法回顾（八）：海量整数排序的分治式解决思路

一道 pingcap 的算法题目

数据结构与算法回顾（三）：时间轮

一种高效的定时器算法实现（简单时间轮）

prometheus 查询 && 应用实践（进阶篇）

如何更好的使用 prometheus（With PromQL）

Mysql 项目应用笔记（二）

Mysql 索引与优化总结 - InnoDB 篇

Raft 协议分析与实战：构建自己的分布式缓存

hashicorp/raft的应用实战与分析

数据结构与算法回顾（四）：环形内存缓冲区 ringbuffer

一种高效进程间通信的机制：环形内存缓冲区

微服务项目中的自适应（Adaptive）技术分析与应用

分析 go-zero 框架中自适应技术的运用

Golang 网络编程（二）：轻量级 TCP 框架实现分析

分析典型的 TCP 框架：getty && xtcp

数据结构与算法回顾（二）：一种固定 Size 的高性能 hashtable 实现

一种高效的 hash 存储结构分析

Golang 网络编程：UDP 的若干细节

基于 Golang Udp 的高性能编程总结

数据结构与算法回顾（六）：Golang IO shaping

基于限流器的流量整形算法实现

关于 Kafka 应用开发知识点的整理（三）

一些关于 kafka 客户端库实践经验汇总

Golang 并发协程池实现分析（四）

分析 Jeffail/tunny 协程池实现

Mysql 项目应用笔记（一）

Mysql 日常使用总结

Hashcorp Vault 实战（应用篇）

更安全的 Secret 存储系统：Vault

基于 CRON 库扩展的分布式 Crontab 的实现

基于 golang 的分布式定时器任务模型的通用实现

使用 Golang 实现 RDP 和 VNC（一）

rdp/vnc 协议基础 && 使用（入门篇）

使用 Golang 实现 SSH 和 SSHD（三）

Bash 中的控制字符功能说明 && 分析

关于 Kafka 应用开发知识点的整理（二）

Kafka 的高可用（可靠）及 sarama 库的使用细节

微服务中的缓存（三）：缓存一致性原理 && 实践

一道美团的面试题：Redis 与 MySQL 双写一致性如何保证？

Golang 系统编程：如何实现对后台服务优雅的热重启？

网关的热重启机制：原理&&实现&&分析（fvbock/endless）

Golang CRON 库 Crontab 的使用与设计

基于 golang 的定时任务模型分析

Golang 标准库：net/http 应用（二）

net/http 客户端在项目中的应用经验小结

Golang httprouter 库分析

高效的路由框架 julienschmidt/httprouter 分析

Golang 并发协程池实现分析（三）

分析 Ants 协程池实现

Golang 的分布式任务队列：Asynq 分析

数据结构与算法回顾（一）：多阶 hash

一种高利用率的 hash 存储结构分析

数据结构与算法回顾（七）：Golang 中的 Sort 算法实现解析

排序算法回顾

Kubernetes 应用改造（八）：如何在 TKE 上搭建 Redis 环境

Statefulsets 应用场景

安全：KMS 的那些事

KMS 原理与使用

Golang ReverseProxy 分析

原生库的反向代理代码分析

GoWorkers 通用异步工作队列分析

分析一款基于 Golang 后台队列任务执行框架：jrallison/go-workers

一个基于 golang 的轻量级 IM 项目分析：gochat

分析一款实时通信 IM 项目 gochat

DiDi 开源 API 网关 gatekeeper （v1.0）项目分析

一个微服务网关的设计与实现

Golang 的分布式任务队列：Machinery （v1）分析（二）

Machinery 应用场景梳理&&使用说明

在 Golang 中实现 Openssl 的 AES-CBC-256 算法（With Salt）

开源熔断组件分析（一）：gobreaker

分析 Sony 的 gobreaker 熔断器实现（Circuit Breaker 的一种实现）

安全：SSO 认证协议的那些事

Hot Reload：Golang 如何实现配置文件优雅的热更新

配置文件的优雅热加载实现以及 viper 库的机制分析

项目开发：网关（Gateway）与反向代理（ReverseProxy）的那些事

Nginx 容器动态流量管理方案：Upsync

一种更为优雅的 Nginx 代理动态切换方案

Confd 使用 && 源码分析

Confd 源码分析：强大的动态配置更新（基于 etcdv3/redis 存储）

Kubernetes 应用改造（七）：存储那些事

Kubernetes 中的存储方案

HTTP(s) 代理中间件库：Oxy

分析基于 Golang 的 HTTP(s) 代理中间件库 Oxy：Part One

Kubernetes 零信任实战：Teleport

如何实现对 kubectl exec 的劫持？

Golang 的分布式任务队列：Machinery （v1）分析（一）

如何使用 Golang 实现通用的任务调度作业模型

使用 Golang 实现 SSH 和 SSHD（二）

golang-ssh 库使用 && gliderlabs/ssh 分析（实战篇）

Consul 服务治理的那些事（二）

Consul 的细节梳理

Kubernetes 应用改造（六）：使用原生 API 实现 gRPC 负载均衡

基于 kubernetes-API 实现 gRPC-LB：kuberesolver

Kubernetes 应用改造（五）：使用 NFS + Statefulsets 搭建 Etcd 集群

Statefulsets 应用 && PV/PVC 介绍

Gin 开发实践：如何实现限流中间件

在 Golang-Gin 框架中集成 Ratelimiter 限流中间件

Kratos 源码分析：Tracing （一）

分析 Kratos 的 opentracing 实现：概念与数据结构抽象

Kratos 源码分析：Tracing （二）

分析 Kratos 的 opentracing 实现：应用

Golang 并发协程池实现分析（二）

分析 Fasthttp 的 goroutine pool

Golang 并发协程池实现分析（一）

分析一款非常典型的 goroutine pool 实现

Kratos 源码分析：CGI 框架 BM （四）

分析基于 gin 改造的框架 blademaster：路由树构造算法

Docker 日常实践汇总

工作中的经验总结

基于 Golang 实现的负载均衡网关：gobetween 分析（二）

Metrics 采集技巧

gRPC 应用篇之客户端 Connection Pool

连接池的实现分析 && 是否需要 Tcp/gRPC 客户端连接池 ？&& 通用连接池的实现

Kratos 源码分析：CGI 框架 BM （三）

分析 CGI 框架 blademaster：路由

Kratos 源码分析：CGI 框架 BM （二）

分析 blademaster 中的拦截器实现及设计

基于 Golang 实现的延迟队列的设计与分析（二）

分析美图开源的延迟队列 lmstfy：数据结构与实现

基于 Golang 实现的延迟队列的设计与分析（一）

分析美图开源的延迟队列 lmstfy：架构与设计思路

Golang 标准库：net/http 分析（一）

net/http 客户端之 transport 分析

基于 Golang 实现的负载均衡网关：gobetween 分析（一）

分析一款 Golang 实现的四层代理 CLB：主要逻辑

Kratos 源码分析：CGI 框架 BM （一）

分析基于 gin 改造的框架 blademaster：基础

分布式限流：基于 Redis 实现

基于 Redis 实现的分布式限流方案总结

Golang Web/RPC 框架中的设计模式

装饰器模式及 Pipeline 模式回顾

gRPC 客户端长连接机制实现及 keepalive 分析

如何实现针对 gRPC 客户端的自动重连机制

Golang TCP 并发服务器框架：Zinx

一个基于 Golang 轻量级 TCP 并发服务器框架分析

Go-redis with Metrics：关键指标采集

魔改 go-redis 实现 Metrcis + Prometheus 关键指标上报

分布式一致性 hash 算法的实现分析

ketama 算法分析与应用

GoIM 源码分析（一）：Comet

分析 GoIM 对外服务模块 Comet

GoIM 源码分析（二）：Job

GoIM 源码分析（三）：Logic

GoIM 源码分析（四）：一些细节

GOIM

开源限流组件分析（一）：Uber 的 Leaky Bucket

分析 Uber 的基于 Leaky Bucket 的限流器

Kratos 源码分析：Warden 负载均衡算法之 P2C

分析 Warden 实现的负载均衡算法 P2C（Power of Two Choices）

Kratos 源码分析：Metrics 与 Prometheus 的集成与使用

分析 Kratos 的数据指标采集与使用

Kratos 源码分析：Errgroup 机制

分析原生的 errgroup 即 Kratos 的 errgroup

Kratos 源码分析：Warden 之 gRPC-Client 封装

分析 Warden 的 Client 端封装

Kratos 源码分析：Warden 之 gRPC-Server 封装

分析 Warden 的 Server 端封装

项目中 golang 相关的优化 Case 处理及解决

调优系列：如何使用 Golang 的 Pprof 工具进行内存分析以及 sync.Pool 优化（一）

GoIM 源码分析（零）：总览

分析基于 golang 的高并发的聊天服务器实现

Kratos 源码分析：Hbase 库封装

分析 Kratos 的 Hbase Client：How to Hook？

Prometheus 应用接入：使用 Prometheus 开发 Exporter

如何在项目中使用 Prometheus 及 Exporter 开发基础

Kratos 源码分析：限流器 Limiter

分析 Kratos 的 BBR 限流器实现

Kratos 源码分析：熔断器 Breaker

分析 Kratos 的熔断器实现

Kratos 源码分析：Naming 解析（下）

分析 Warden 中对 Naming 的调用及实例应用

Kratos 源码分析：ORM 之 Mysql 的封装

分析 Kratos 的数据库 MYSQL-API

Kratos 源码分析：Ecode 错误代码

分析 Kratos 的 Error-code

golang-LRU 缓存设计与实现

分析 一款高性能的本地缓存开源组件 CCache

一个轻量级的 golang 协程池的实现

使用 Golang-channel 实现工作池：批量并发处理

Fasthttp 高性能 HttpServer 最佳实践之二：bytebufferpool

分析 Fasthttp 的 byte 对象池实现

GoWorker 高性能队列分析

分析一款基于 Golang 后台队列任务执行框架：benmanns/goworker

关于 Kafka 应用开发知识点的整理（一）

在项目中使用 Python 的 kafka 进行开发

Xorm 使用总结（Mysql）

Xorm-Mysql 用法及避坑总结

Kratos 源码分析：超时（Timeout）传递

Context 的用法：Warden/Database 中的超时传递实现分析

Kratos 源码分析：Naming 解析（上）

分析 Naming 的多消费者订阅 - Watcher 模式

Kratos 源码分析：Warden 中的 gRPC validator

分析 Kratos 的 gRPC 中的字段验证器

Kratos 源码分析：Kratos 中的 Metadata 元数据

一种全局变量的存储方式：Metadata

Kratos 源码分析：Lazy Load Container

分析 Kratos 的懒对象容器及应用场景

基于 Golang 实现的定时器分析与实现（二）：最小堆 && 时间轮

Timer and Ticker： events in the future

gRPC 微服务构建之链路追踪（OpenTracing）

在 gRPC 服务中应用 OpenTracing：使用 Zipkin 和 Jaeger 进行路追踪

Kubernetes 应用改造（三）：负载均衡

Kubernetes 中的负载均衡总结

分布式锁：使用 Redis 实现

Redis 应用开发：分布式锁构建 && Redlock 实现分析

Etcd 开发中的细节梳理（总结）

如何更优雅的使用 Etcd 实现工作项目

Kratos 源码分析：gRPC-Warden 拦截器（链）及实现

Kratos 框架分析

理解 Kratos 的数据统计类型 Metrics（三）-- 未完待续

Metrics 的实战应用

Kratos 源码分析：理解 Kratos 的数据统计类型 Metrics（二）

分析 Kratos 框架中的 Metrics：LB 算法中的应用

Google SRE 弹性熔断算法实现分析

Google-SRE-Experience：Handling Overload

gRPC 应用之 Prometheus 监控接入

使用 gRPC 拦截器对接 Prometheus 监控介绍

Kratos 源码分析：计划

分析微服务开发框架 Kratos

微服务项目阶段小结（2020-05-01）

Kratos 源码分析：CPU 指标采集

了解 gopsutil 常用方法应用及 Linux 系统服务常用采集指标

gRPC 知识点备忘录（持续更新）

理解 Prometheus 的基本数据类型及应用（实践篇）

Prometheus 及 PromQL 的一些实践

Kratos 源码分析：理解 Kratos 的数据统计类型 Metrics（一）

分析 Kratos 框架中的 Metrics：滑动窗口

理解 Prometheus 的基本数据类型及应用（基础篇）

Prometheus 介绍及基础应用

微服务中的缓存（二）：微服务基础之多级服务缓存（Cache）

微服务应用中缓存的使用策略、问题及解决

Golang 并发模型：Pipelines and cancellation

Channel 的经典应用（基础）

OpenSSH Certificate 证书最佳实践

How Do We USE OpenSSH Certificate Properly?

Kubernetes Certificate 使用 && 总结

How to manipulate kubernetes's certificates？

开源限流组件分析（二）：Golang-time/rate 限速算法实现分析

分析 Golang 标准库提供的令牌桶限流器

开源限流组件分析（三）：JuJu-Ratelimit 限速算法实现分析

分析一款基于令牌桶实现的限速算法

微服务基础之限流（RateLimit）

限流的基础概念

理解 Hystrix-go 中的 RollingCount 实现

微服务基础之熔断保护（Breaker）

熔断器机制基础

一个 Http(s) 反向代理（网关）的实现分析

如何使用几百行代码实现一个高可用的反向代理服务

Golang 中的 sync.Pool 使用

调优系列：Golang 优化系列之临时对象池

Kratos 源码分析：分析 Warden 框架 Dynamic-WRR 负载均衡算法的实现

Warden 框架中的 WRR 算法代码分析

Golang 中网络编程开源项目汇总（持续更新）

我们可以从开源项目中学习到什么（二）

Golang 高性能 LocalCache：BigCache 设计与分析

如何在 Golang 构建一个高性能的本地缓存

Go-Micro 微服务框架使用入门

Go-Mirco 框架之基础

gRPC 微服务构建之日志（Logging）

zap库应用及使用 gRPC 实现zap日志拦截器（With Tracing）

Uber-Automaxprocs 分析

Docker 中的 CPU 调度总结

GOMAXPROCS 的坑

容器环境中使用 runtime.GOMAXPROCS 需谨慎

gRPC Interceptor：go-grpc-middleware 介绍与使用

优秀的 gRPC 开源中间件实现：go-grpc-middleware

使用 Golang 开发 generator（生成器）

生成器：一种程序逻辑优化的思路

微服务基础之链路追踪（OpenTracing）

Opentracing 的基础理论介绍

微服务中的缓存（一）：Cache 使用与优化

如何设计高效且合理的缓存使用策略

Go-Redis 连接池（Pool）源码分析

分析一款典型的 redis 连接池实现

gRPC 中的 Metadata

Golang的httputil.ReverseProxy使用（基础篇）

如何构建典型场景下的反向代理（reverse proxy）及排坑

gRPC 应用篇之自带组件

微服务基础（索引）

我的微服务入门之路

Redis 应用梳理篇（一）

如何在实战项目中灵活使用 Redis（go-redis） 及排坑

Golang 的 Channel（应用篇）

如何使用 channel 开发有保证的应用

玩转正则表达式（进阶篇）

贪婪 or 非贪婪，Python 版本

Raft 协议分析与实战（理论篇）

Raft：一种更容易理解的共识算法

Golang Slice 那些事

Slice 最佳实践

Perl 单行特技（One-Line）

神奇的胶水语言 Perl 文本处理

Hashcorp Vault 使用

更安全的 Secret 存储系统：vault

gRPC 源码分析之 Picker 篇

gRPC 客户端选择器实现分析

gRPC 应用篇之 Resolver 接口封装

如何封装 gRPC 的 Resolver（Kratos）

神奇的 Golang-IO 包

golang-IO 包使用经验（一）

Golang IO copy 系列方法探究

golang-IO 包使用经验（二）

Nginx 负载均衡及算法分析

Nginx 实现反向代理的项目使用与总结

Kubernetes 应用改造（二）：健康检查

健康检查与探针的应用

Golang 中有趣的后台项目汇总

可以从开源项目中学习到什么？

gRPC 源码分析之官方 Picker 实现

gRPC 客户端选择器分析（Picker With RoundRobin）

gRPC 之 Interceptor 实战篇

如何优雅的使用 gRPC 拦截器

gRPC 源码分析之 Balancer 篇

gRPC 客户端平衡器分析

gRPC 源码分析之 DnsResolver 篇

如何使用内置的 DNS 负载均衡器

gRPC 源码分析之 Resolver 篇

gRPC 客户端解析器实现分析

后台开发积累（2019 年）

感觉只是做了一点微小的工作

一个安全的 Web-Console 的实现思路

使用 xterm.js+Go-Gin 实现 Web-Console 的 SSH 登录

Etcd 应用开发之分布式锁

Etcd 应用开发（续）

Etcd 最佳实（踩）践（坑）

Etcd 日常踩坑集锦

使用 Golang 实现 SSH 和 SSHD（一）

golang-ssh 库使用（入门篇）

Kubernetes 应用改造（一）：Headless Service

使用 gRPC+Headless-Service 构建后端服务

Python 性能优化

使用 heapy 统计堆上的对象（内存）

Consul 服务治理的那些事（一）

使用 gRPC+Consul 构建高可用的后端服务

证书（Certificate）的那些事

项目开发中证书的使用梳理

基于 gRPC 的服务发现与负载均衡（基础篇）

gRPC 负载均衡架构分析

给 Jekyll 增加 Latex 公式渲染