ike‘s blog

mac软件推荐

Fri, 13 Dec 2024 00:00:00 GMT

2024年度最香产品：MAC MINI M4 正式登场！经过几天的抢购，我终于在京东买到了 MAC MINI M4，发货等了一个月。到手后折腾了几天，虽然新鲜劲儿过了，但作为办公电脑，它的表现还是不错的。回想上次用 Mac Mini 是在 M1 刚发售时，买来玩了几个月，最后发现自己并没有太大需求，于是出掉了。这次我以 3500 元的价格再买了一台 M4，希望它能作为我的工作电脑。

废话不多说，下面是我这边记录的一些已安装的软件，都是一些必备的好用软件：

Microsoft Office/Excel/PPT 三件套办公必备，没啥好介绍的，工作中一定会用到，比 WPS 好用多了。
BetterDisplay 我用的是 4K 显示器，分辨率适配后字体变得非常小，图标和软件也显得很小。为了不降低分辨率，我使用了 BetterDisplay，这个软件不仅能调整分辨率，还能修改亮度，算是一个不错的解决方案。
超级右键 Mac 里的复制、粘贴、删除等操作相比 Windows 确实不那么顺手。超级右键可以扩展右键功能，例如直接快速打开常用目录、删除文件、新建文件、剪切粘贴等，使用起来非常便利。
VSCode 宇宙第一 IDE，不解释。
Termius 用来登录服务器。Windows 上一般使用 MobaXterm，因此在 Mac 上也想找一个好用的终端，最终发现 Termius 非常好用。
有道翻译主要用于划词翻译，记单词、翻译句子等，算是学习英语的工具。不过有时复制时容易误点。
Chrome 习惯了跨系统的多端浏览器同步书签，所以还是选择 Chrome 浏览器。
CotEditor 我想找一个类似 Notepad++ 的轻量级文本编辑器。试了几个 Atom 之类的，感觉都太繁琐。后来在商店里发现 CotEditor，确实不错，功能够用。
Pixea 比系统自带的图片浏览器好用，简洁方便。
ClashX 懂的都懂，实用的梯子。
Keeweb 密码管理软件，使用体验还不错。

希望这些软件能对使用 Mac Mini 的朋友们有所帮助！

用Siri来控制Windows电脑开机关机吧

Mon, 26 Feb 2024 00:00:00 GMT

前因

自从手机从iphone换成Android后，咱的13香就没啥用了，只能放桌子上当时钟，感觉有点浪费啊，所以研究了下苹果的HomeKit，用旧手机当智能中控岂不更好！网上查了下，貌似也蛮简单的。开搞开搞！

准备

买一个能够连接homekit的智能插座，网上蛮多的，一个插座也就20~50不等，我买的是meross的，好像说是外贸货，反正到手是日本那边的，还行。买来后插上电，用手机先连接2.4g的wifi后扫描下二维码后按提示就可以让插座联网了，加入后只要网络正常，就可以用手机控制插座开关了。
设置电脑bios，通电后自动启动机器。我的外星人台式机是开机后按F2就可以进入bios，然后找到高级选项--电源选项里有个开机改成通电就Power On就好了。
给Windows账号加上密码，就是登陆要输入密码才能登陆，这样可以让其他手机或者服务器进行ssh登陆。
电脑安装OpenSSH。打开Powershell，然后Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0命令，出现进度条后等待安装完毕。然后net start sshd即可启动ssh服务。当然别忘了在防火墙的入站规则里加上TCP的22端口规则允许。还有就是在Windows的服务里找到OpenSSH然后手动改成自动，这样就开机自动启动啦。然后还有就是要把电脑的IP改成静态的，不能DHCP动态分配。最后可以尝试在Powershell里ssh 你的用户名@你的服务器IP，然后输入你的密码就可以正常SSH登陆啦！

嘿 Siri

准备工作都弄完后，现在就轮到iphone了，先在家庭里创建2个场景，一个是关电脑，就是控制插座关闭电源，另一个的开电脑，控制插座开启电源。弄完后点击试试，看看插座是不是可以正常点一下就开启和关闭了。
打开苹果的快捷指令，创建一个新的快捷指令，名称叫打开电脑,里面只需要添加开电脑的场景即可。这样只需要喊"嘿！sir，打开电脑" ，就可以开启插座然后通电开机啦。
再创建一个新的快捷指令，名称叫关闭电脑,然后添加通过SSH发送命令,把服务器的ip、22端口号、用户名、密码都填写，脚本的话填写shutdown -s -t 1。然后再添加等待60秒，最后再添加关电脑的场景即可。这样通过siri喊"嘿！sir，关闭电脑"，就可以实现快速关机了！

语音控制

上面通过嘿siri来控制快捷指令来运行关机貌似会有点小问题，因为要等待60s后才会执行下一步，siri好像默认不会等那么久，所以换一种方式，用iphone的辅助功能。里面有个语音控制，开启后新增语音关闭电脑然后运行对应的快捷指令即可，这下连siri都不用了，直接说关闭电脑就好了！

控制中台

iphone的家庭里其实还有一个小功能，就是开启引导界面，然后输入密码设置，你会发现界面会钉在家庭的控制页面，且不会切换，这样就相当于把手机作为了中台，只需要连接电源然后挂在墙上或者桌子上，就可以当一个完美的控制中台啦~

最后

家里马上也要开始装修弄家具了，之前也有了解一些智能家居，但感觉都不是很实用，大部分也就是一些回家后自动开灯，开电器。起床自动打开窗帘和播放音乐之类的，为了这些多花好几万感觉不是很划算，那还不如就简单点用智能插座加场景设置和快捷指令来控制，这样成本低，自己diy，体验也不错。虽然有一些局限性，但本来就图新鲜，好玩就行了~

clickhouse的一些优化建议和工具

Tue, 09 Jan 2024 00:00:00 GMT

起因

自从用cloki+clickhouse来替代日志系统后真是一波三折，问题不断Orz。只能感叹不亏是小众的开源工具，还是一堆坑，下面记一下踩到的一些坑和对clickhouse的优化。

Q：主查询最后的查询会进行全表查询，但是left join的time_series_dist表巨大，有几百G，几十亿条数据，导致每次查询都得全部读取到内存里，一次查询占用80G内存，查询5分钟还查不出结果！

# 查询语句
WITH sel_a AS
    (
        SELECT
            samples.string AS string,
            samples.fingerprint AS fingerprint,
            samples.timestamp_ns AS timestamp_ns
        FROM cloki.samples_v3_dist AS samples
        WHERE ((samples.timestamp_ns >= 1704440225031000000) AND (samples.timestamp_ns <= 1704440525031000000)) AND (samples.fingerprint IN (
            SELECT sel_1.fingerprint
            FROM
            (
                SELECT fingerprint
                FROM cloki.time_series_gin
                WHERE (key = 'app') AND (val = 'myapp')
            ) AS sel_1
            ANY INNER JOIN
            (
                SELECT fingerprint
                FROM cloki.time_series_gin
                WHERE (key = 'cluster') AND (val = 'test-prod')
            ) AS sel_2 ON sel_1.fingerprint = sel_2.fingerprint
        ))
        ORDER BY timestamp_ns DESC
        LIMIT 100
    )
SELECT
    JSONExtractKeysAndValues(time_series.labels, 'String') AS labels,
    sel_a.*
FROM sel_a
ANY LEFT JOIN cloki.time_series_dist AS time_series ON sel_a.fingerprint = time_series.fingerprint
ORDER BY
    labels DESC,
    timestamp_ns DESC

A: 估计是开源cloki根据的bug，而且和orderby也有区别，调查了蛮多优化建议，其中比较有用的是

让表的orderby和查询的orderby一致，这样可以减少最后排序时间，所以我把ORDER BY fingerprint改成ORDER BY (fingerprint, labels)。
left join后的表尽量要是小表，不过这里是固定了所以没法优化，所以只能减少表的大小，还好这个表只是存储标签，把TTL（生命周期）改成1天后就好多了。
网上还有说让经常查询的key作为主键分区，相当于做了索引，也可以加快查询速度和效率，所以我PARTITION BY date改成了PARTITION BY fingerprint，但其实是有问题的！因为PARTITION BY是分区，如果是date的话，一天一个分区，这样查询如果是跨天查询就很快，如果改成fingerprint会变成每一个数据一个分区！CK集群直接报错Too many parts (100018) in all partitions in total，分区中存在过多的数据分片了，赶紧删了重新改回来了date，没有完全懂的东西还是不要乱动的好。当然可以把分区时间改成半天，也有一定的效果。
```
 CREATE TABLE cloki.time_series
 (
     `date` Date,
     `fingerprint` UInt64,
     `labels` String,
     `name` String,
   INDEX idx_fingerprint_labels (fingerprint) TYPE minmax GRANULARITY 8192
 )
 ENGINE = ReplicatedReplacingMergeTree('/clickhouse/tables/time_series/{shard}', '{replica}', date)
 PARTITION BY date
 ORDER BY (fingerprint, labels)
 TTL date + toIntervalDay(1)
 SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1, merge_with_ttl_timeout = 3600
```

R：查询问题解决后，基本上每次查询都可以在10s内完成，而且内存也不需要太大了，clickhouse里也有一些users.xml的default标签参数可以优化查询啥的，例如
max_threads 这个值不要太高，一般是默认就好了，并不是说线程越高越好，越高内存占用也越大
distributed_product_mode ReplicatedReplacingMergeTree+Distributed的分布式表一定要弄为global，如果只是MergeTree+Distributed可以local
group_by_overflow_mode 默认是查询失败就throw丢弃，也可以改成查询超出内存后返回部分结果，一般不需要改
max_memory_usage 单个查询最大多少内存，默认是10g，当然也可以改大，我是改成90%的内存大小
max_bytes_before_external_group_by groupby超了多少内存后就写入到磁盘里，防止内存占用过多，虽然会影响效率，一般是改成max_memory_usage的一半
max_bytes_before_external_sort orderby超了多少内存后就写入到磁盘里，防止内存占用过多，虽然会影响效率，一般是改成max_memory_usage的一半

Q：clickhouse其实更适合一次性插入几百万的数据，而不是短时间内大量一条一条的数据插入，就好像现在cloki每一条日志都是一个insert请求，导致大量的单条插入给到clickhouse，然后ck集群的同步会扛不住，会报错merge速度比不上insert速度，然后zookeeper或clickhouse-keeper的负载非常高，触发表readonly的保护机制，只要没merge完就不给写入，因为没有缓存的中间件，一堆日志写入失败丢失。
A：说白了就是clickhouse的使用方法不对，如果是数据量不大还好，官方说只要超过500k每秒的插入，基本上就会导致同步不过来表readonly无法写入。所以网上有一些解决方法：

用buffer表来做缓冲，Buffer(database, table, num_layers, min_time, max_time, min_rows, max_rows, min_bytes, max_bytes [,flush_time [,flush_rows [,flush_bytes]]])，用下面的例子里的参数解释就是，如果满足最大max的100s或者100w行或者100m的数据其中一个条件，就触发缓存写入到目标表，又或者同时满足所有min的条件过了10s且1w行且10m的数据就会触发写入数据到目标表。不过这个方法官方也说了其实不怎么适用，因为本身clickhouse还是不适合用于短时间大量单条数据的插入，更适合单条插入大量数据的场景，官方建议是每秒不超过1条插入语句。

  CREATE TABLE cloki.samples_v3_buffer
(
    `fingerprint` UInt64,
    `timestamp_ns` Int64 CODEC(DoubleDelta),
    `value` Float64 CODEC(Gorilla),
    `string` String CODEC(ZSTD(5))
)
ENGINE = Buffer('cloki', 'samples_v3', 16, 10, 100, 10000, 1000000, 10000000, 100000000)

buffer表不管用，那就只能想想其他办法，还好这个问题也有解决，clickhouse-bulk 是第三方的开源小工具，主要目的就是把小插入变成大插入，只需要设置好配置文件nohup ./clickhouse-bulk -config config.json >/dev/null 2>&1 &启动即可，所有的小插入会先缓存然后满足配置条件后写入到clickhouse集群里，而且写入失败会生成dump文件，重新尝试插入，相当于缓存了。

    {
    "listen": ":8124",   #启动的端口，clickhouse是8123 ，这个是8124，小心别漏了分号
    "flush_count": 1000000,  #缓存多少行后写入，我这边指定的是100w行写入一次
    "flush_interval": 5000,  #缓存多少秒后写入，我这边指定5秒后写入
    "clean_interval": 0,     #清理内部表的频率，例如插入到不同的临时表，或作为解决query_id等问题的方法，单位：毫秒
    "remove_query_id": true,  #有些驱动程序发送的query_id会阻止批量插入
    "dump_check_interval": 60, #尝试发送转储文件的间隔（秒）；-1表示禁用，就是重新尝试插入dump文件的时间
    "debug": false,  # 记录传入的请求日志
    "log_queries": true, 
    "dump_dir": "dumps",   # 转储未发送的数据的目录（如果ClickHouse出错）
    "clickhouse": {
      "down_timeout": 60,  # 服务器宕机时等待的时间（秒）
      "connect_timeout": 10,  # 等待服务器连接的时间（秒）
      "tls_server_name": "", # 覆盖用于证书验证的TLS serverName（例如，如果在多个节点上共享相同的"cluster"证书）
      "insecure_tls_skip_verify": false, # 证书验证
      "servers": [
        "http://127.0.0.1:8123"
      ]
    },
    "use_tls": false,
    "tls_cert_file": "",
    "tls_key_file": ""
  }

最后

到目前为止大部分问题解决了，虽然还有一些小问题，但日志系统也慢慢趋于稳定，clickhouse数据库号称比传统mysql数据库快一万倍，但坑还是蛮多的，目前国内用的其实不多，但以后估计会变成香饽饽吧。

2023sumppary

Thu, 28 Dec 2023 00:00:00 GMT

迟来的2023年终总结：

关于工作

工作今年算运气不错吧，去年年底被裁员后，本来以为以咱的垃圾学历和技术，再加上互联网寒冬，估计要失业蛮久的。但运气看来还好，不到一个月就找到了新公司，薪资变化不大，不加班，标准的975，比之前公司感觉好了很多。好像我找工作一直都运气蛮好的，平均面试3次基本上都有一次可以过，毕业到现在也有8年多了吧，从上海到深圳，换了也有4家公司了，这是第五家了，平均2年一家公司，然后有一家是被裁员，也算是什么都经历过了。也不清楚程序员这行能干多久，有存款才有勇气。

关于开发

今年工作有了时间，就想着完成一些以前就想做的开发项目了，博客也算之一，所以就有了这个博客，虽然是用的开源的框架，但也弄了些自己的东西，例如分享啊，数据统计啊，评论，域名，CDN什么的，虽然没什么流量，但在网络上有了自己的一个网站还是蛮开心的。

除了博客外因为今年chatgpt的普及，很多以前很费时间的技术都可以简单的开发了，例如前端页面之类的，虽然技术力有限，但还是弄了一个chrome插件游戏来玩玩，还是蛮有趣的，以后有好点子说不定还可以继续开发一些好玩的浏览器插件。

关于旅游

今年总算可以正常出国旅游了，5月去了上海玩3天，10月去了东京-京都-大阪玩了8天。抛开工作烦恼和国内的压力，能到国外享受旅游真的很放松，看什么都很新鲜。就是国庆旅游花费贵了些，明年应该会办理三年多次的签证，以后淡季去玩应该会便宜很多。希望明年可以有另一半可以一起旅游hh

关于游戏

看了下PlayStation的游玩记录，今年竟然都没有超过10小时的ps5游戏时间，甚至都弄不出年度游玩报告，看来今年大部分时间都是在玩电脑和手游了，现在独占游戏越来越少，steam价格也便宜，还可以打mod。看来以后主机的使用率应该还会变低。明年还有老头环DLC、碧蓝幻想relink、黑神话，还是蛮期待的。

最后

感觉也没啥总结的了，希望明年越来越好吧，暴富！脱单！

记录一下我的第一个网页游戏Mazeball

Mon, 27 Nov 2023 00:00:00 GMT

游戏链接：

MazeBall

截图：

{width=200 height=200 }

游戏规则：

鼠标左键控制小球左右移动，点击页面，小球会根据鼠标的相对位置来移动。如果鼠标在小球的左边则左移，鼠标在小球的右边则右移，其他则不动。
鼠标右键控制小球向下移动。
键盘wsad也可以控制上下左右移动。
倒计时归零则游戏结束。
碰到红色障碍物则游戏结束。

游戏的玩法其实就是在限定的时间内看看能到达第几关，因为每通关一关只会增加5秒倒计时，但层数会增加，所以到越到后面迷宫越长，操作的时间是不够的。而且很容易出现误触导致失败，所以还是得小心控制小球移动，毕竟是突发奇想的一个简单益智类小游戏,可玩性不高，不过还是挺有意思的~

我也尝试上架了下chrome的插件商店，虽然没什么人下载，不过也算是熟悉了下发布插件的流程啦，只需要开通账号后绑定下信用卡（我用的招商visa卡），然后一次性支付5美元就可以上传插件了，填写一些应用描述和截图提交审核即可，还是蛮简单的。

如何使用Clickhouse的索引

Wed, 18 Oct 2023 00:00:00 GMT

简介

影响ClickHouse查询性能的因素很多。在大多数情况下，关键因素是ClickHouse在计算查询WHERE子句条件时是否可以使用主键。因此，选择适用于最常见查询模式的主键对于有效的表设计至关重要。用户通常依赖ClickHouse获取时间序列类型的数据，但他们通常希望根据其他业务维度(如客户id、网站URL或产品编号)分析相同的数据。在这种情况下，查询性能可能会相当差，因为可能需要对每个列值进行完整扫描才能应用WHERE子句条件。虽然ClickHouse在这些情况下仍然相对较快，但评估数百万或数十亿个单独的值将导致“非索引”查询的执行速度比基于主键的查询慢得多。 ClickHouse提供了一种不同类型的索引，在特定情况下可以显著提高查询速度。这些结构被标记为“跳过(Skip)”索引，因为它们使ClickHouse能够跳过读取保证没有匹配值的重要数据块。

介绍

Clickhouse索引的特点为: 排序索引+稀疏索引+列式存储, 因此相应的Clickhouse最合适的场景就是基于排序字段的范围过滤后的聚合查询。

因为排序索引, 所有基于排序字段的查询会明显由于MR类型计算, 否则Hive/Spark这类动态资源的更优由于稀疏索引, 点查询的效率可能没有KV型数据库高, 因此适合相对大范围的过滤条件因为列式存储, 数据压缩率高, 对应做聚合查询效率也会更高.

实践

因为表索引不好在创建表后再进行创建，所以最好在创建表的时候就计划好并创建，例如cloki的表主要是samples_v3和time_series_gin表是用作主要查询。
对于cloki.time_series_gin表：
对key列进行索引：ALTER TABLE cloki.time_series_gin_ ADD INDEX idx_key(key) TYPE minmax GRANULARITY 8192;
对val列进行索引：ALTER TABLE cloki.time_series_gin_ ADD INDEX idx_val(val) TYPE minmax GRANULARITY 8192;
对fingerprint列进行索引：ALTER TABLE cloki.time_series_gin_ ADD INDEX idx_fingerprint(fingerprint) TYPE minmax GRANULARITY 8192;

对于cloki.samples_v3表：
对timestamp_ns列进行索引：ALTER TABLE cloki.samples_v3_ ADD INDEX idx_timestamp_ns(timestamp_ns) TYPE minmax GRANULARITY 8192;
对fingerprint列进行索引：ALTER TABLE cloki.samples_v3_ ADD INDEX idx_fingerprint(fingerprint) TYPE minmax GRANULARITY 8192;
对string列进行索引：ALTER TABLE cloki.samples_v3_ ADD INDEX idx_string(string) TYPE minmax GRANULARITY 8192;

如果需要对已有的数据也进行索引，需要 ALTER TABLE cloki.samples_v3_ MATERIALIZE INDEX idx_timestamp_ns; 数据量较大，会非常慢。

参考

官方文档
 深入浅出clickhouse-index

如何从zookeeper切换为clickhouse—keeper

Tue, 17 Oct 2023 00:00:00 GMT

简介

clickhouse-keeper和zookeeper的功能类似，都能实现数据复制和分布式DDL查询，但也有不同之处，clickhouse分布式表使用zookeeper作为元数据的存储，客户端每次读写分布式表都会读写zookeeper，zookeeper是个小型的日志文件系统，在大范围读写时会进入只读模式。
clickhouse官方为了解决这个问题，自己开发了clickhouse-keeper来代替。clickhouse-keeper用C++语言编写，在Clickhouse的21.8版本开始引入，目前22.5版的写性能和zookeeper相当，读的性能比zookeeper好，最新版本已经读写性能都超过zookeeper，更加适配大量数据的Clickhouse集群。

对比

zookeeper：

使用java开发
运维不便
要求独立部署
zxid overflow问题
snapshot和log没有经过压缩
不支持读的线性一致性

keeper：

使用c++开发，技术栈与ck统一
即可独立部署，又可集成到ck中
没有zxid overflow问题
读写性能更好
支持对snapshot和log的压缩和校验
支持读写的线性一致性

部署

因为当前Clickhouse集群是用zookeeper作为数据复制和分布式查询的，切换为Clickhouse-keeper需要保留现有的数据，所以需要进行数据迁移，官方提供了相关的方法：
1、准备 clickhouse-keeper的配置文件 (config.xml)

<keeper_server>
      <tcp_port>9181</tcp_port>
      <server_id>1</server_id>  <!--第一台是1,第二台是2,第三台是3-->
      <log_storage_path>/var/lib/clickhouse/coordination/log</log_storage_path>
      <snapshot_storage_path>/var/lib/clickhouse/coordination/snapshots</snapshot_storage_path>

    <coordination_settings>
        <operation_timeout_ms>10000</operation_timeout_ms>
        <session_timeout_ms>30000</session_timeout_ms>
        <raft_logs_level>warning</raft_logs_level>
    </coordination_settings>

    <raft_configuration>
        <server>
            <id>1</id>
            <hostname>10.0.0.1</hostname>
            <port>9444</port>
        </server>
        <server>
            <id>2</id>
            <hostname>10.0.0.2</hostname>
            <port>9444</port>
        </server>
        <server>
            <id>3</id>
            <hostname>10.0.0.3</hostname>
            <port>9444</port>
        </server>
    </raft_configuration>
</keeper_server>

2、停止所有zk节点
3、重启zk leader节点，并再次停止(这一步是为了让leader节点生成一份snapshot)
4、运行clickhouse-keeper-converter（安装Clickhouse自带命令），生成keeper的snapshot文件

#示例命令
clickhouse-keeper-converter --zookeeper-logs-dir /var/lib/zookeeper/version-2 --zookeeper-snapshots-dir /var/lib/zookeeper/version-2 --output-dir /var/lib/clickhouse/keeper/snapshots

5、参考第一部修改配置，指定snapshots，启动keeper, 使其加载上一步中的snapshot。具体可以参考官方文档 6、重启clickhouse-server

参考

官方文档ZH
官方文档EN

cloki分布式查询和clickhouse副本存储

Mon, 04 Sep 2023 00:00:00 GMT

cloki

记录一些部署cloki分布式遇到的一些坑吧，cloki因为开源的，但是活跃度不高，所以蛮多坑的。

~~默认表不支持分布式~~ 最新的版本已经支持分布式表，只需要加CLUSTER_NAME的环境变量即可自动创建分布式表
下面的sql仅供参考，也可以自动创建完成后show create table your_table_name来查看创建表语句然后自己修改替换。

// NOTE: You also need to set "distributed_product_mode" to "global" in your profile.
// https://clickhouse.com/docs/en/operations/settings/settings-profiles/

CREATE TABLE cloki.samples_read on cluster ck_cluster(
    `fingerprint` UInt64, 
    `timestamp_ms` Int64, 
    `value` Float64, 
    `string` String
)
ENGINE = Merge('cloki', '^(samples|samples_v2)$');

////

CREATE VIEW cloki.samples_read_v2_1 on cluster ck_cluster(
    `fingerprint` UInt64, 
    `timestamp_ns` Int64, 
    `value` Float64, 
    `string` String
) AS SELECT fingerprint, timestamp_ms * 1000000 AS timestamp_ns, value, string FROM cloki.samples_read;

////

CREATE TABLE cloki.samples_read_v2_2 on cluster ck_cluster(
    `fingerprint` UInt64, 
    `timestamp_ns` Int64, 
    `value` Float64, 
    `string` String
)
ENGINE = Merge('cloki', '^(samples_read_v2_1|samples_v3)$');

////

CREATE TABLE cloki.samples_v3_ on cluster ck_cluster(
    `fingerprint` UInt64, 
    `timestamp_ns` Int64 CODEC(DoubleDelta), 
    `value` Float64 CODEC(Gorilla), 
    `string` String
)
ENGINE = ReplicatedMergeTree('/clickhouse/ck_cluster/tables/{shard}/{uuid}', '{replica}') 
PARTITION BY toStartOfDay(toDateTime(timestamp_ns / 1000000000)) 
ORDER BY timestamp_ns TTL toDateTime(timestamp_ns / 1000000000) + toIntervalDay(3650) 
SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1, merge_with_ttl_timeout = 3600;

CREATE TABLE cloki.samples_v3 on cluster ck_cluster(
    `fingerprint` UInt64, 
    `timestamp_ns` Int64 CODEC(DoubleDelta), 
    `value` Float64 CODEC(Gorilla), 
    `string` String
)
ENGINE = Distributed('ck_cluster', 'cloki', 'samples_v3_', fingerprint);

////

CREATE TABLE cloki.settings_ on cluster ck_cluster(
    `fingerprint` UInt64, 
    `type` String, 
    `name` String, 
    `value` String, 
    `inserted_at` DateTime64(9, 'UTC')
)
ENGINE = ReplicatedReplacingMergeTree('/clickhouse/ck_cluster/tables/{shard}/{uuid}', '{replica}', inserted_at) 
ORDER BY fingerprint 
SETTINGS index_granularity = 8192;

CREATE TABLE cloki.settings on cluster ck_cluster(
    `fingerprint` UInt64, 
    `type` String, 
    `name` String, 
    `value` String, 
    `inserted_at` DateTime64(9, 'UTC')
)
ENGINE = Distributed('ck_cluster', 'cloki', 'settings_', fingerprint);

////

CREATE TABLE cloki.time_series_ on cluster ck_cluster(
    `date` Date, 
    `fingerprint` UInt64, 
    `labels` String, 
    `name` String
)
ENGINE = ReplicatedReplacingMergeTree('/clickhouse/ck_cluster/tables/{shard}/{uuid}', '{replica}', date) 
PARTITION BY date 
ORDER BY fingerprint TTL date + toIntervalDay(3650) 
SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1, merge_with_ttl_timeout = 3600;

CREATE TABLE cloki.time_series on cluster ck_cluster(
    `date` Date, 
    `fingerprint` UInt64, 
    `labels` String, 
    `name` String
)
ENGINE = Distributed('ck_cluster', 'cloki', 'time_series_', fingerprint);

////

CREATE TABLE cloki.time_series_gin_ on cluster ck_cluster(
    `date` Date, 
    `key` String, 
    `val` String, 
    `fingerprint` UInt64
)
ENGINE = ReplicatedReplacingMergeTree('/clickhouse/ck_cluster/tables/{shard}/{uuid}', '{replica}') 
PARTITION BY date 
ORDER BY (key, val, fingerprint) TTL date + toIntervalDay(3650) 
SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1, merge_with_ttl_timeout = 3600;

CREATE TABLE cloki.time_series_gin on cluster ck_cluster(
    `date` Date, 
    `key` String, 
    `val` String, 
    `fingerprint` UInt64
)
ENGINE = Distributed('ck_cluster', 'cloki', 'time_series_gin_', fingerprint);

////

CREATE MATERIALIZED VIEW cloki.time_series_gin_view TO cloki.time_series_gin (
    `date` Date, 
    `key` String, 
    `val` String, 
    `fingerprint` UInt64
) AS SELECT date, pairs.1 AS key, pairs.2 AS val, fingerprint FROM cloki.time_series ARRAY JOIN JSONExtractKeysAndValues(time_series.labels, 'String') AS pairs;

////

CREATE TABLE cloki.ver_ on cluster ck_cluster(
    `k` UInt64, 
    `ver` UInt64
)
ENGINE = ReplicatedReplacingMergeTree('/clickhouse/ck_cluster/tables/{shard}/{uuid}', '{replica}', ver) 
ORDER BY k 
SETTINGS index_granularity = 8192;

CREATE TABLE cloki.ver on cluster ck_cluster(
    `k` UInt64, 
    `ver` UInt64
)
ENGINE = Distributed('ck_cluster', 'cloki', 'ver_', k);

////设置下日志默认保存时间，当前是7天

INSERT INTO cloki.settings (`fingerprint`, `type`, `name`, `value`, `inserted_at`) 
VALUES (990984054, 'rotate', 'v3_samples_days', '7', NOW())
, (4103757074, 'rotate', 'v3_time_series_days', '7', NOW())
, (cityHash64('update_v3_5'), 'update',
     'v3_1', toString(toUnixTimestamp(NOW())), NOW());

////

INSERT INTO cloki.ver (`k`, `ver`) 
VALUES (1, 10);

然后记得设置clickhouse的distributed_product_mode配置，可以添加到users.xml里

<profiles>
...
        <default>
            ...
            <distributed_product_mode>global</distributed_product_mode>
            ...
        </default>
...
</profiles>

最后重启clickhouse后检查下是否设置成功了 select * from system.settings where name like '%product%'

clickhouse

clickhouse 的分布式查询和副本配置也是需要注意

ReplicatedMergeTree： ReplicatedMergeTree是ClickHouse中的一种表引擎，用于在多个节点上复制和分布数据，以提供数据冗余和故障恢复能力。它使用了分片和复制的概念，并将数据按照主键范围分布在不同的节点上。

ReplicatedMergeTree使用MergeTree的存储和索引结构，该结构适合于大规模数据的插入和查询操作。数据按照主键进行排序，并且以数据块（block）的形式存储。每个数据块可以在多个副本节点上进行复制，以提供冗余和容错能力。

当数据写入ReplicatedMergeTree表时，数据会被分成多个数据块，并按照主键的顺序插入到合适的位置。数据块的数量和大小可以通过配置进行调整，以满足特定的需求。数据块在节点之间进行复制，以确保数据的冗余存储。

ReplicatedMergeTree表还提供了数据合并和清理机制。ClickHouse会周期性地合并数据块，以减少存储空间的使用和提高查询性能。同时，它还支持数据的分区和副本的自动管理。

Distributed： Distributed是ClickHouse中的另一种表引擎，用于将查询分发到多个节点上进行并行处理。它提供了分布式查询的能力，可以加速大规模数据查询操作。

Distributed表引擎通过逻辑上的表映射和查询分发来实现分布式查询。在创建Distributed表时，需要指定一个或多个表作为底层数据源。当执行查询时，ClickHouse会将查询解析为子查询，并将其分发到底层数据源上进行并行处理。最后，查询结果会被汇总到一个结果集中返回给用户。

Distributed表引擎隐藏了分布式查询的复杂性，并提供了透明的接口。用户可以像查询单个表一样查询Distributed表，而不需要关心底层数据的分布和位置。

配置需要注意分片配置和副本配置以及宏配置

使用ilogtail+cloki+clickhouse来做日志系统吧

Wed, 30 Aug 2023 00:00:00 GMT

简介

clickhouse就不说了，可以参考我前面的博文，这里主要介绍一下cloki和ilogtail。

ilogtail是阿里开源的一款轻量级的日志采集工具，针对k8s环境也有很好的优化，比filebeat轻，资源消耗低，采集效率也快一些。目前官方也支持多种输入、处理和输出，其中就包含输出到loki或者clickhouse。（要注意logtail是阿里自带的一个日志采集工具，只能采集到阿里的sls，ilogtail是开源社区的，支持多种插件）

cloki也是国外开源的一个工具，类似于loki，API也和loki一模一样，但是后台可以关联到更高效的clickhouse作为存储。（目前相关文章不多，但可用）

部署

因为所有的都是部署在k8s上的，所以直接上yaml文件吧

cloki

cloki-deployment.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: cloki
  labels:
    io.metrico.service: cloki
spec:
  replicas: 1
  selector:
    matchLabels:
      io.metrico.service: cloki
  strategy: {}
  template:
    metadata:
      annotations:
        qryn.cmd: qryn.dev
      creationTimestamp: null
      labels:
        io.metrico.service: cloki
    spec:
      containers:
        - env:
            - name: CLICKHOUSE_SERVER                   # 具体配置参考文档
              value: clickhouse                     
            - name: CLICKHOUSE_AUTH
              value: 'default:xxxxxx'
            - name: CLICKHOUSE_PORT
              value: '8123'
            - name: CLICKHOUSE_DB
              value: cloki
            - name: CLICKHOUSE_TSDB
              value: cloki
            - name: FASTIFY_METRICS
              value: 'true'
            - name: DEBUG
              value: 'true'
            - name: FASTIFY_BODYLIMIT
              value: '52428800'
            - name: CLUSTER_NAME     #用于ck集群
              value: 'my_cluster'
          image: qxip/qryn:latest
          name: cloki
          ports:
            - containerPort: 3100
          resources: {}
      restartPolicy: Always
status: {}

cloki-service.yml

apiVersion: v1
kind: Service
metadata:
  creationTimestamp: null
  labels:
    io.metrico.service: cloki
  name: cloki
spec:
  ports:
    - name: "3100"
      port: 3100
      targetPort: 3100
  selector:
    io.metrico.service: cloki
status:
  loadBalancer: {}

kubectl apply -f cloki-service.yaml,cloki-deployment.yaml -n ops

ilogtai

ilogtail-configmap.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: ilogtail-user-cm
  namespace: ops
data:
  loki_stdout.yaml: |
    enable: true
    inputs:
      - Type: service_docker_stdout
        Stderr: false
        Stdout: true                # 只采集标准输出
        IncludeK8sLabel:            # 采集nginx的日志，这里可以修改为label或者其他指定，具体看文档
          app: nginx
    processors:
      - Type: processor_default    # 默认不做数据处理
        SourceKey: content
    flushers:
      - Type: flusher_loki         #输出也可以改成stdout来测试，或者直接输出到clickhouse，具体看文档
        URL: http://cloki:3100/loki/api/v1/push
        TenantID: ilogtail
        StaticLabels:
          source: ilogtail

ilogtail-daemonset.yaml

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: ilogtail-ds
  namespace: ops
  labels:
    k8s-app: logtail-ds
spec:
  selector:
    matchLabels:
      k8s-app: logtail-ds
  template:
    metadata:
      labels:
        k8s-app: logtail-ds
    spec:
      tolerations:
        - operator: Exists                    # deploy on all nodes
      containers:
        - name: logtail
          env:
            - name: ALIYUN_LOG_ENV_TAGS       # add log tags from env
              value: _node_name_|_node_ip_
            - name: _node_name_
              valueFrom:
                fieldRef:
                  apiVersion: v1
                  fieldPath: spec.nodeName
            - name: _node_ip_
              valueFrom:
                fieldRef:
                  apiVersion: v1
                  fieldPath: status.hostIP
            - name: cpu_usage_limit           # iLogtail's self monitor cpu limit
              value: "1"
            - name: mem_usage_limit           # iLogtail's self monitor mem limit
              value: "512"
          image: >-
            sls-opensource-registry.cn-shanghai.cr.aliyuncs.com/ilogtail-community-edition/ilogtail:latest
          imagePullPolicy: IfNotPresent
          resources:
            limits:
              cpu: 1000m
              memory: 1Gi
            requests:
              cpu: 400m
              memory: 384Mi
          volumeMounts:
            - mountPath: /var/run                       # for container runtime socket
              name: run
            - mountPath: /logtail_host                  # for log access on the node
              mountPropagation: HostToContainer
              name: root
              readOnly: true
            - mountPath: /usr/local/ilogtail/checkpoint # for checkpoint between container restart
              name: checkpoint
            - mountPath: /usr/local/ilogtail/user_yaml_config.d # mount config dir
              name: user-config
              readOnly: true
      dnsPolicy: ClusterFirstWithHostNet
      hostNetwork: true
      volumes:
        - hostPath:
            path: /var/run
            type: Directory
          name: run
        - hostPath:
            path: /
            type: Directory
          name: root
        - hostPath:
            path: /etc/ilogtail-ilogtail-ds/checkpoint
            type: DirectoryOrCreate
          name: checkpoint
        - configMap:
            defaultMode: 420
            name: ilogtail-user-cm
          name: user-config

部署完后ilogtail就作为daemonset开始采集nginx的日志并输出到cloki里啦，因为loki是可以直接与grafana集成的，所以只需要在grafana里把cloki作为数据源加上，就可以直接可视化查询了！

clickhouse集群部署指南

Fri, 11 Aug 2023 00:00:00 GMT

起因

网上找到的集群安装博文各个都是复制粘贴，还缺胳膊少腿MD，各种坑，自己梳理下搭建过程。

步骤

zookeeper安装

wget https://downloads.apache.org/zookeeper/stable/apache-zookeeper-3.6.3-bin.tar.gz   #注意要下载bin.tar.gz
tar -xvf apache-zookeeper-3.6.3-bin.tar.gz  #解压到目录
cp zoo_sample.cfg zoo.cfg                   #参考下面zoo.cfg配置
mkdir -p /data/zookeeper/{data,logs}        #创建数据目录
echo "1" > /data/zookeeper/data/myid        #注意myid里的数字一定要和cfg里的server顺序一致
./zkServer.sh start                         #启动zk

zoo.cfg配置参考

tickTime=2000
dataDir=/data/zookeeper/data
dataLogDir=/data/zookeeper/logs
clientPort=2181
admin.serverPort=2182
initLimit=10
syncLimit=5
server.1=zk1:2888:3888
server.2=zk2:2888:3888
server.3=zk3:2888:3888

clickhouse安装

yum install -y yum-utils
yum-config-manager --add-repo https://packages.clickhouse.com/rpm/clickhouse.repo
yum install -y clickhouse-server clickhouse-client
chmod a+x /etc/clickhouse-server/*

配置

新建一个/etc/clickhouse-server/metrika.xml文件，添加zookeeper和集群配置

<yandex>
    <clickhouse_remote_servers>
        <!--自定义集群名称-->
        <ck_cluster>
            <!--定义集群的分片数量-->
            <shard>
                <internal_replication>true</internal_replication>
                <replica>
                    <host>ck1</host>
                    <port>9000</port>
                    <user>default</user>  <!--默认是default用户-->
                    <password>xxxxxxxxx</password> <!--你在user.xml里配置的密码-->
                </replica>
            </shard>
            <shard>
                <internal_replication>true</internal_replication>
                <replica>
                    <host>ck2</host>
                    <port>9000</port>
                    <user>default</user>
                    <password>xxxxxxxxx</password>
                </replica>
            </shard>
            <shard>
                <internal_replication>true</internal_replication>
                <replica>
                    <host>ck3</host>
                    <port>9000</port>
                    <user>default</user>
                    <password>xxxxxxxxx</password>
                </replica>
            </shard>
        </ck_cluster>
    </clickhouse_remote_servers>

    <networks>
        <ip>::</ip>
    </networks>

    <macros>
        <replica>ck1</replica>  <!--此处填写各个节点名称，唯一值，不能重复-->
    </macros>

    <zookeeper-servers>
        <node index="1">    <!--index 是你部署zookeeper的时候设置的myid-->
            <host>zk1</host>
            <port>2181</port>
        </node>
        <node index="2">
            <host>zk2</host>
            <port>2181</port>
        </node>
        <node index="3">
            <host>zk3</host>
            <port>2181</port>
        </node>
    </zookeeper-servers>


    <clickhouse_compression> <!--可加可不加-->
        <case>
            <min_part_size>10000000000</min_part_size>
            <min_part_size_ratio>0.01</min_part_size_ratio>
            <method>lz4</method>
        </case>
    </clickhouse_compression>
</yandex>

修改/etc/clickhouse-server/config.xml文件，把listen_host标签取消注释，并新增标签启用metrika的配置，如果默认有相关标签就注释掉，prometheus的标签可以用来监控集群状态。

    <listen_host>::</listen_host>
    <include_from>/etc/clickhouse-server/metrika.xml</include_from>
    <macros incl="macros" optional="true"/>
    <!-- <zookeeper incl="zookeeper-servers" optional="true" /> --># 这个是用来指定metrika里的clickhouse_remote_servers标签，如果是用clickhouse-keeper则不需要
    <remote_servers incl="clickhouse_remote_servers"/> # 这个是用来指定metrika里的clickhouse_remote_servers标签

    #辅助zookeeper，如果同步的数据量太大，一个zookeeper同步不过来，经常出现readonly表，则可以加多几个辅助zookeeper，只需要在表引擎地址前指定zookeeper名称即可，例如
    #ENGINE = ReplicatedReplacingMergeTree('zookeeper2:/clickhouse/tables/samples/{shard}', '{replica}')
    #但不能和主zookeeper一样，可以用自带的clickhouse-keeper，zookeeper用来做辅助
    <auxiliary_zookeepers> 
      <zookeeper2>
        <node>
            <host>10.0.0.1</host>
            <port>2181</port>
        </node>
        <node>
            <host>10.0.0.2</host>
            <port>2181</port>
        </node>
        <node>
            <host>10.0.0.3</host>
            <port>2181</port>
        </node>
      </zookeeper2>
    </auxiliary_zookeepers>

    <prometheus>
        <endpoint>/metrics</endpoint>
        <port>9363</port>
        <metrics>true</metrics>
        <events>true</events>
        <asynchronous_metrics>true</asynchronous_metrics>
        <status_info>true</status_info>
    </prometheus>

在config.d目录里新增keeper.xml文件：

<?xml version="1.0" ?>
<yandex>
    <keeper_server>
        <tcp_port>9181</tcp_port>
        <server_id>1</server_id> #这里也要记得不同服务器要不一样
        <log_storage_path>/data/clickhouse/coordination/log</log_storage_path>
        <snapshot_storage_path>/data/clickhouse/coordination/snapshots</snapshot_storage_path>

      <raft_configuration>
            <server>
               <id>1</id>
                 <hostname>10.0.0.1</hostname>
               <port>9444</port>
          </server>
          <server>
               <id>2</id>
                 <hostname>10.0.0.2</hostname>
               <port>9444</port>
          </server>
          <server>
               <id>3</id>
                 <hostname>10.0.0.3</hostname>
               <port>9444</port>
          </server>
      </raft_configuration>

    </keeper_server>

    <zookeeper>
        <node>
            <host>10.0.0.1</host> #不同服务器这个ip要换，尽量指定自己的zookeeper，防止都集中到单个一样的zookeeper里
            <port>9181</port>
        </node>
    </zookeeper>

    <distributed_ddl>
        <path>/clickhouse/cluster/task_queue/ddl</path>
    </distributed_ddl>
</yandex>

如果需要添加密码的话修改/etc/clickhouse-server/user.xml文件，把明文密码加到password标签中即可,或者也可以使用SHA256加密后的密码，请将其放置在 password_sha256_hex 配置段。

#shell生成加密密码的示例
  PASSWORD=$(base64 < /dev/urandom | head -c8); echo "$PASSWORD"; echo -n "$PASSWORD" | sha256sum | tr -d '-'

最后启动clickhouse-server.service service clickhouse-server restart

启动后可以lsof -i:8123 查看端口是否有启动，service clickhouse-server status服务是否正常启动，/var/log/clickhouse-server/clickhouse-server.err.log相关日志是否都正常，没有报错。

8123是默认客户端端口，用于接收客户端的连接和处理来自客户端的查询请求。 9000是默认数据端口，用于处理 ClickHouse 数据节点之间的内部通信。

没问题后执行clickhouse-client后即可登陆clickhouse。

登陆clickhouse后select * from system.clusters\G; 看下是否节点都可以正常，在服务器里echo stat | nc 127.0.0.1 9181检查9181端口的keeper是否也正常,如果都显示正常那就搭建完毕啦！

ps: users.xml里也可以配置一些自定义的配置，具体可以参考官方文档,下面是一些我这边用到的：

        <default>
          <load_balancing>random</load_balancing> #负载均衡
          <distributed_product_mode>global</distributed_product_mode> #分布式表一定得改成global，默认好像是local，只查询自己
          <group_by_overflow_mode>throw</group_by_overflow_mode> #如果内存查爆了，直接中断查询丢出报错，默认是throw，也可以改成不报错，丢出部分查询数据
          <max_memory_usage>64000000000</max_memory_usage> #单个查询最大能使用多大内存，这里是60g左右
          <max_bytes_before_external_group_by>32000000000</max_bytes_before_external_group_by> #group_by如果聚合大于30g，则溢出到磁盘了，用io代替内存
          <max_bytes_before_external_sort>32000000000</max_bytes_before_external_sort>#order_by如果聚合大于30g，则溢出到磁盘了，用io代替内存
        </default>

快速安装部署clickhouse和cloki

Fri, 28 Jul 2023 00:00:00 GMT

安装

clickhouse

yum install -y yum-utils
yum-config-manager --add-repo https://packages.clickhouse.com/rpm/clickhouse.repo
yum install -y clickhouse-server clickhouse-client
chmod a+x /etc/clickhouse-server/*

等待安装完成后修改/etc/clickhouse-server/config.xml文件，把listen_host标签取消注释

    <listen_host>::1</listen_host>
    <listen_host>127.0.0.1</listen_host>

如果需要添加密码的话修改/etc/clickhouse-server/user.xml文件，把明文密码加到password标签中即可,或者也可以使用SHA256加密后的密码，请将其放置在 password_sha256_hex 配置段。

#shell生成加密密码的示例
  PASSWORD=$(base64 < /dev/urandom | head -c8); echo "$PASSWORD"; echo -n "$PASSWORD" | sha256sum | tr -d '-'

最后启动clickhouse-server.service systemctl start clickhouse-server.service

启动后可以lsof -i:8123 查看端口是否有，systemctl status clickhouse-server.service服务是否正常启动。

没问题后执行clickhouse-client后即可登陆clickhouse。

cloki

安装命令

yum install npm
npm install nodejs
npm install -g cloki pm2

安装完成后启动,记得把yourpassword修改下

cd $(dirname $(readlink -f `which cloki`)) \
  && CLICKHOUSE_SERVER="localhost" CLICKHOUSE_AUTH="default:yourpassword" CLICKHOUSE_DB="cloki" \
  pm2 start cloki --name "cloki"

查看状态

pm2 status cloki
pm2 save
pm2 startup

使用

cloki是支持promtail、logstash、fluentd等常用的日志采集工具，这边用promtail为例。 config.yaml

server:
  http_listen_port: 29080
  grpc_listen_port: 0

positions:
  filename: /opt/promtail/positions.yaml

clients:
  - url: http://172.0.0.100:3100/loki/api/v1/push

scrape_configs:
- job_name: test-log
  pipeline_stages:
  static_configs:
  - targets:
      - localhost
    labels:
      hostname: test
      cluster: sz-test
      app: test
      __path__: /var/log/*log

配置完毕后启动promtail就可以采集路径下的日志并push到loki的api并存储到clickhouse中。

登陆部署的服务器3100端口即可访问cloki的查询界面，示例：

参考

官方GITHUB

快速部署thanos架构

Fri, 21 Jul 2023 00:00:00 GMT

介绍

Thanos 是一个用于扩展 Prometheus 的开源项目，通过将多个 Prometheus 实例和其他数据源组合在一起，实现了跨多个集群和地理位置的高可用性、长期存储和查询功能。Thanos 架构可以被描述为以下四个组件：

Prometheus：Thanos 使用 Prometheus 作为数据源，用于收集、存储和查询监控数据。Prometheus 是一个功能强大的开源监控系统，可以监控各种应用程序、服务和网络基础设施。
Thanos Sidecar：Thanos Sidecar 是一个负责将 Prometheus 数据推送到远程存储桶的代理。它可以将 Prometheus 实例的数据集成到 Thanos 系统中，通过使用 Thanos Store API，使得 Prometheus 实例的数据在 Thanos 中可查询。
Thanos Store Gateway：Thanos Store Gateway 是一个用于跨多个 Prometheus 实例聚合、存储和查询数据的组件。它可以将 Prometheus 实例和远程存储桶中的数据作为一个整体进行查询，提供了一个统一的数据视图。
Thanos Query：Thanos Query 是一个用于查询 Thanos Store Gateway 中存储的数据的组件。它提供了一个类似于 Prometheus 的查询语言，并能够跨多个 Prometheus 实例和存储桶进行查询，以提供全局的监控数据视图。

通过以上四个组件的协作，Thanos 架构实现了扩展性和高可用性，能够有效地存储和查询大量的监控数据。Thanos 还提供了许多其他的功能，例如数据压缩、数据分片、数据去重、数据合并等，可以进一步提高数据存储和查询的效率。

ps：thanos的receive模式这里就先不讲了，有兴趣的可以百度或者官网查看

前因

网上检索thanos大部分是简介或者架构啥的，部署也都是容器部署，不够简单上手，其实基础的thanos架构搭建很容易。

安装

github地址
下载后直接放到linux目录下就好了，每个prometheus节点都要部署一个！

部署

先直接上service文件： thanos-query.service

[Unit]
Description=Thanos Query
After=network-online.target

[Service]
Restart=on-failure
# --query.replica-label "replica" --query.replica-label "datacenter" --> 加上后，thanos query 查询同一节点的数据时，会自动去重
ExecStart=/opt/thanos/thanos query --http-address 0.0.0.0:19192 --grpc-address=0.0.0.0:11901 --store=10.0.0.1:19090,10.0.0.2:19090

[Install]
WantedBy=multi-user.target

thanos-sidecar.service

[Unit]
Description=Thanos Sidecar
After=network-online.target

[Service]
Restart=on-failure
# --prometheus.url 配置对应的prometheus 地址
# --tsdb.path 配置对应的prometheus 数据目录
ExecStart=/opt/thanos/thanos sidecar --prometheus.url=http://localhost:9090 --tsdb.path=/data/prometheus-data --grpc-address=0.0.0.0:19090 --http-address=0.0.0.0:19091

[Install]
WantedBy=multi-user.target

步骤

service文件和thanos文件都放好后，只需要 1、修改prometheus的配置新增额外标签：

global:
  scrape_interval:     15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  external_labels:
        datacenter: prometheus-02  #额外标签
rule_files:
   - "rules/*.yaml"
···下面配置省略···

2、在prometheus节点上都启动sidecar的服务。
3、在thanos节点上启动query的服务。
4、确认服务都正常启动完毕。

完毕！然后就可以访问thanos的http://10.0.0.1:19192 就可以访问thanos页面啦，点击Stores就可以看到有几个thanos节点正常连接了。

后续

如果你单个prometheus太大了，也可以使用thanos的架构来进行水平分片，把job_name多分几个，降低单个prometheus负载。如果还是会超时或者负载严重，可以换成receive模式，相当于prometheus把数据直接远程写入到thanos，然后thanos直接从本地数据里进行指标拉取。

如何使用go的jwt

Tue, 04 Jul 2023 00:00:00 GMT

什么是jwt

JWT 是一种轻量级的身份认证和授权机制，它可以在不同的系统之间安全地传递信息，JWT 的信息是以 JSON 格式存储在 Token 中，包含三部分：头部（header）、载荷（payload）和签名（signature）。其中，载荷部分包含了一些声明信息，比如 Token 的有效期、Token 的颁发者、Token 的使用者等。

jwt bearer和bearer token的区别

Bearer是HTTP授权标头的一种类型，用于指示在HTTP请求中使用OAuth 2.0访问令牌进行身份验证。

JWT Bearer是使用JSON Web Token（JWT）进行身份验证的一种方式，它将JWT作为Bearer令牌的值发送到服务器。

Bearer Token则是OAuth 2.0协议中使用的一种访问令牌类型，它表示访问令牌的类型是Bearer。Bearer Token是一种无状态的令牌，它通常具有一定的有效期，在有效期内可以使用该令牌进行身份验证和授权。Bearer Token可以使用各种技术实现，如JWT、OAuth 2.0、OpenID Connect等。

这里我们用的就是Bearer Token

安装jwt包

go get github.com/dgrijalva/jwt-go

一般jwt是配合go gin一起使用的

如何使用jwt


import (
	"time"

	"github.com/dgrijalva/jwt-go"
)


type TokenInterface interface {
	GenerateToken(id int, accountName string) (string, error)
	ParseToken(token string) (*Claims, error)
}

type Token struct {
	JwtSecret  string // 加密秘钥
	ExpireTime int    // 多少小时过期
}

func NewToken(f ...func(token *Token)) TokenInterface {
	t := &Token{}
	for _, i := range f {
		i(t)
	}
	// 未赋值则初始化
	if t.ExpireTime == 0 {
		t.ExpireTime = 24
	}
	if t.JwtSecret == "" {
		t.JwtSecret = "JwtSecret"
	}
	return t
}

type Claims struct {
	UserID      int    `json:"user_id"`
	AccountName string `json:"account_name"`
	jwt.StandardClaims
}

// GenerateToken 生成Token
func (t *Token) GenerateToken(id int, accountName string) (string, error) {
	nowTime := time.Now()
	expireTime := nowTime.Add(time.Duration(t.ExpireTime) * time.Hour)

	claims := Claims{
		UserID:      id,
		AccountName: accountName,
		StandardClaims: jwt.StandardClaims{
			ExpiresAt: time.Now().Add(TokenExpireDuration).Unix(),
			Issuer:    "my-project",
		},
	}

	tokenClaims := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	token, err := tokenClaims.SignedString([]byte(t.JwtSecret))

	return token, err
}

// ParseToken 解析Token
func (t *Token) ParseToken(token string) (*Claims, error) {
	tokenClaims, err := jwt.ParseWithClaims(token, &Claims{}, func(token *jwt.Token) (interface{}, error) {
		return []byte(t.JwtSecret), nil
	})

	if tokenClaims != nil {
		if claims, ok := tokenClaims.Claims.(*Claims); ok && tokenClaims.Valid {
			return claims, nil
		}
	}
	return nil, err
}

func ValidatorQueryInfo(ctx *gin.Context) {

	authHeader := ctx.Request.Header.Get("Authorization")
	if authHeader == "" {
		err = errors.New("请求头中的auth为空")
		return
	}
	parts := strings.SplitN(authHeader, " ", 2)
	if !(len(parts) == 2 && parts[0] == "Bearer") {
		err = errors.New("请请求头中的auth格式错误")
		return
	}
	t := jwt.NewToken()
	claims, err := t.ParseToken(parts[1])
	if err != nil {
		err = errors.New("无效的token")
		return
	}
	log.DefaultLogs.Log.Error("jwt解析正常", claims)
	return
}

如何修改git commit记录

Wed, 07 Jun 2023 00:00:00 GMT

前言

不小心在github上传了个人隐私或者私钥密码之类的代码，虽然下次代码里已经修复了，但是！commit记录里还是会有的，如果遇到有心人去扫描或者查询还是会泄露的。所以需要把以前的commit记录和历史都改掉！或者删掉，保护互联网个人信息，从你我做起！

修改历史commit的邮箱和用户名

用git filter-branch命令来修改：

git filter-branch命令让您通过重写<rev-list选项>中提到的分支来重写Git修订历史记录，并在每个修订版上应用自定义过滤器。这些过滤器可以修改每个树（例如，删除文件或对所有文件运行perl重写）或每个提交的信息。否则，将保留所有信息（包括原始提交时间或合并信息）。详细概要

git filter-branch --env-filter '
OLD_EMAIL="你的旧邮箱"
CORRECT_NAME="你的新用户名"
CORRECT_EMAIL="你的新邮箱地址"
if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_COMMITTER_NAME="$CORRECT_NAME"
    export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_AUTHOR_NAME="$CORRECT_NAME"
    export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL"
fi
' --tag-name-filter cat -- --branches --tags

等全部修改完成后用 git push --force命令即可修改完毕

修改历史commit的文件

<font color="#dd0000">相关文件可能也会删除！请提前备份好然后重新上传</font> 同样用git filterbranch命令来修改，先把代码git clone到本地后，然后

git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch path/to/sensitive_info' --prune-empty --tag-name-filter cat -- --all

或者

git filter-branch --tree-filter 'rm -f path/to/sensitive_info' HEAD

其中 path/to/sensitive_info 是要删除敏感信息的文件路径，可以使用通配符 * 删除所有文件中的敏感信息。

最后git push --force下就好啦，相关文件的提交记录就会全部删除。

业务容器化需要注意的一些地方

Thu, 01 Jun 2023 00:00:00 GMT

废话不多说，直接上yaml文件。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: java-web
  namespace: ops
  labels:
    app: java-web
spec:
  selector:
    matchLabels:
      app: java-web
  replicas: 2
  strategy:
    type: RollingUpdate
  template:
    metadata:
      name: java-web
      annotations:   # 第一点：新增注解
        loki.io/scrape: 'true' # 抓取直接输出的日志到loki里
        prometheus.io/path: /metrics #采集的监控地址
        prometheus.io/port: '2112'  #采集暴露的监控端口
        prometheus.io/scrape: 'true'  #打开采集开关
      labels:
        app: java-web
    spec:
      imagePullSecrets:  # 第二点：添加权限
        - name: my-docker #只有该用户才有pull镜像的权限
      containers:
        - name: java-web
          image: hb.ops.top/ops/java-web:5917f92c
          imagePullPolicy: IfNotPresent
          readinessProbe:  # 第三点：新增存活检测，当前是针对监控端口进行存活检测，也就是说只有当监控端口起来了，程序才算完全启动
            httpGet:
              port: 2112
              path: /metrics/prometheus
            initialDelaySeconds: 60
            successThreshold: 1
            failureThreshold: 3
            timeoutSeconds: 5
          startupProbe:
            httpGet:
              port: 2112
              path: /metrics/prometheus
            initialDelaySeconds: 60
            successThreshold: 1
            failureThreshold: 3
            timeoutSeconds: 5
          livenessProbe:
            httpGet:
              port: 2112
              path: /metrics/prometheus
            initialDelaySeconds: 60
            successThreshold: 1
            failureThreshold: 3
            timeoutSeconds: 5
          resources: # 第四点：设置资源限制，如果是java程序，建议limit比request大，这样可以合理分配堆内存和非堆内存
            requests:
              memory: 1024Mi
            limits:
              memory: 2048Mi
          ports:
            - name: web-port
              containerPort: 8889
          env: # 第五点：设置环境变量，可以设置时区，指定EVN环境，添加JAVA参数等
            - name: JVM_OPTS
              value: -javaagent:/opt/skywalking/skywalking-agent.jar -Xmx1G -Xms1G
            - name: TZ
              value: Asia/Shanghai
            - name: APOLLO_LABEL
              value: gray
            - name: SW_AGENT_NAME
              value: 'k8s-java-web'
            - name: SW_AGENT_COLLECTOR_BACKEND_SERVICES
              value: '10.0.0.123:11800'
            - name: ENV
              value: prod

---

apiVersion: v1
kind: Service
metadata:
  labels:
    app: java-web
  name: java-web
  namespace: ops
spec:
  ports:
  - name: java-web-port
    port: 8889
    protocol: TCP
    targetPort: 8889
    nodePort: 30009
  selector:
    app: java-web
  sessionAffinity: None
  type: NodePort
status:
  loadBalancer: {}

游戏企划

Fri, 26 May 2023 00:00:00 GMT

类型：网页游戏标签：RPG，卡牌，冒险，像素简介：主角是一名冒险者，游戏初期只有公会，公会接任务，公会负责发布新的任务，玩家接取任务后开始冒险。玩法：（参考兰斯，龙之皇冠）游戏分为探索和战斗：探索：玩家只需要选择3个卡牌其中一个进行路线选择，触发事件（战斗，恢复，故事，邂逅，陷阱等）战斗：只需要选择随机的卡牌，3张牌随机，行动完后抽一张，最多5张，不同的卡片消耗的行动值不一样，普通攻击不消耗。攻击牌，防御牌，魔法牌，道具牌等（开发初期战斗可以先不做，直接扣血）

游戏属于开源的，任何人和团队都可以上传任务，但要包含完整的任务剧情，新的角色以及相应的角色对话故事或道具卡牌等，运营只负责提供游戏框架，作为公会发布任务。只在新角色入队才需要支付签约费用，付费与作者分成。角色后续故事也可以作者免费发布，甚至限定条件，只有组队了的才能接取

角色任务：完整的剧情，对话，事件，战斗，立绘，卡牌

后续场所可以新增酒馆，教会、温泉和旅店等场所教会可以捐款，获得圣水，无效一次攻击

初始职业：盗贼，盾卫，魔法师，冒险者（主角）

战斗：横版战棋回合制上面画面是像素人物，分左右，左边友方，右边敌方。格子6*6，可选择站位。优先攻击前卫，但也有魔法攻击和偷袭之类的。

下面是4个角色的技能，选择好后点击开始战斗，下一次默认还是保存上一次的选择。

人物属性：行动值MP 体力值HP 物理攻击力（倍率计算）魔法攻击力（倍率计算）物理防御力（倍率计算）魔法防御力（倍率计算）

状态：物理：中毒，流血，眩晕魔法：冰冻，燃烧，麻痹

Prometheus Metrics精简优化2

Tue, 16 May 2023 00:00:00 GMT

前言

无意中看到一个可以查询当前prometheus有用到哪些指标的工具，感觉对大的prometheus集群应该蛮有用的，试试能不能降低一些prometheus负责吧。

工具

mimirtool

Mimirtool 是一个 CLI 工具，可用于涉及 Grafana Mimir 或 Grafana Cloud Metrics 的 Prometheus 兼容任务的各种操作。

下载方法

curl -fLo mimirtool https://github.com/grafana/mimir/releases/latest/download/mimirtool-linux-amd64

使用方法

提取Grafana 仪表板中用到的指标：

mimirtool analyze grafana --address=http://localhost:3000 --key="${GRAFANA_API_TOKEN}"

grafana的apikey可以在grafana页面的设置里获取，生成一个admin的key就好啦,运行完上面的命令后就可以得到metrics-in-grafana.json文件，里面就是grafana用到了哪些指标。

提取prometheus中rules用到的指标：

./mimirtool analyze rule-file my-prometheus-rule.yaml

my-prometheus-rule.yaml文件是prometheus的rules里的规则集合，把所有的规则都汇总到了这个文件里，要注意格式正确。运行命令后就会生成metrics-in-ruler.json文件，里面是prometheus的规则用到了哪些指标。

和当前prometheus采集的指标进行对比：

./mimirtool analyze prometheus --address=http://localhost:9090

运行后会生成prometheus-metrics.json文件，这个就是我们最终要的文件了，里面包含了哪些指标在用，哪些指标没有在用，然后就可以根据这些数据，修改prometheus的采集规则，筛选掉一些不用的指标。

总结

其实还是要结合prometheus的TSDB里的TOP指标来分析哪些指标是很大且无用的，并不是一味的drop指标就好，有些指标可能只是单纯的没有加相关的告警规则，例如ingress_control相关的指标和etcd相关的指标，还是需要结合告警来判断！

来在线听音乐吧

Fri, 05 May 2023 00:00:00 GMT

国内的音乐app都得收费才能听完整版，找到一个国外的音乐分享网站，音乐齐全还可以分享！

自己动手丰衣足食！后续看看能不能弄一个自动同步网易云音乐歌单或者排行榜之类的东西

audiomack

Chatgpt的API入门

Tue, 18 Apr 2023 00:00:00 GMT

chatgpt.py

import openai
from PIL import Image
import requests

class AI:
    def __init__(self):
        # 可以不需要指定api_base，用默认的就好了，前提是网络通，默认需要翻墙
        self.api_base = "https://XXX/api/v1"
        self.api_key = "sk-XXX"
        
    def chat(self,prompt,msg):
        openai.api_base = self.api_base
        openai.api_key = self.api_key
        chat_completion = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages = [
            # 系统消息，它有助于设置助手的行为
            {"role": "system", "content": prompt},
            # 用户消息，输入你的问题吧
            {"role": "user", "content": msg},
            # 我们还可以添加以前的对话，但你需要用while true循环把之前的消息也发送过去，很费token
            # {"role": "assistant", "content": messages},
        ],
        )
        response = chat_completion.choices[0].message.content
        print(response)
        return 

    def image(self,prompt):
        openai.api_base = self.api_base
        openai.api_key = self.api_key
        image_completion = openai.Image.create(
            #提示要生成什么样的图片
            prompt=prompt,
            #数量
            n=1,
            #大小
            size="512x512"
        )
        image_url = image_completion['data'][0]['url']
        r = requests.get(image_url)
        with open('test.png', 'wb') as f:
            f.write(r.content)
            img = Image.open('test.png')
            img.show()
        return

main.py

from service.chatgpt import AI
import json

def main():
    with open('data.json', "r", encoding="utf-8") as f:
        msg = json.dumps(json.load(f))
        prompt = "你现在是一个告警AI机器人,我会发送过去24小时的告警数据统计信息给你，请生成日报，要有时间范围、告警总数、TOP5告警，告警级别、告警分析、告警建议"
        ai = AI()
        ai.chat(prompt,msg)
    
    
if __name__ == "__main__":
    main()

收费：官方是 0.002 美刀/1000token，但是使用api必须把账号升级为付费账号，也就说要绑定国外的信用卡，很麻烦，目前只能用depay这种虚拟信用卡充USD来实现，或者用国内的一些代理之类的了，希望以后有更方便的方法吧。

参考：官方API文档

简单搭建国内也可以使用的chatgpt

Thu, 06 Apr 2023 00:00:00 GMT

起因

因为目前chatgpt是禁止国内访问的（包括HK和TW），所以要访问chatgpt就得翻墙，但是目前我用的梯子都非常不稳定！经常性的掉线，就很烦，2023年了，没法用google和chatgpt还怎么当程序员！经过我github上翻来翻去，总算找到几个大佬开源的webui，再配上vercel或railway之类的应用托管网站，然后再配上自己的域名，完美解决了国内访问问题！

PS：目前chatgpt的web界面是免费的，只要你注册了openai账号，就可以一直使用，但是api不是，免费账号使用api只能用3个月，且有额度限制，我的第一批注册的用户基本上4月1号就都过期了，虽然api付费很便宜，基本上10美元可以用一年，但需要绑定国外的卡，国内只能用depay之类的虚拟信用卡，很麻烦orz

准备

Yidadaa/ChatGPT-Next-Web 这个webui界面简洁，对移动端优化也不错，但只支持apikey方式使用。
Chanzhaoyu/chatgpt-web 这个webui支持apikey方式也支持session-token的方式。
adams549659584/go-proxy-bingai 新增一个bing的，github页面里有详细的介绍，基本上也是可以一键部署。
自己的域名（需要注册阿里云账号，然后填写信息模板申请后购买域名，一般top的域名第一年只需要9块钱）

搭建

搭建方式其实都差不多

点击进入到对应的github项目里，然后fork项目到自己的仓库里。
打开vercel 或者 railway,用github账号登陆。
新建project,选择从github仓库里导入,选择对应的仓库（如果找不到仓库，则需要加一下权限）。
按提示，需要填写一些环境变量，具体变量参考项目里的README，这里举例： ChatGPT-Next-Web： OPENAI_API_KEY ：你的apikey
CODE ：自定义访问密码

chatgpt-web:
OPENAI_API_KEY 和 OPENAI_ACCESS_TOKEN 二选一(OPENAI_ACCESS_TOKEN的话可以登陆chat.openai.com获取） AUTH_SECRET_KEY : 你的session
PORT : 3002
点击部署，等待部署完成。
点击domain，新建你的domain，例如我的是chat.ikeno.top,然后会生成一个cname的地址
登陆阿里云账号的DNS解析里，找到我的ikeno.top新增二级域名前缀chat，对应解析为cname，然后把地址也填写上cname.vercel-dns.com（如果是railway的填railway提供的地址），新增完毕后就可以解析成功啦！
登陆你的域名看看，是不是已经可以正常访问了！而且不需要梯子了，手机也可以流畅访问！输入你设置好的账号密码就可以丝滑提问啦。

Prometheus Metrics精简优化

Tue, 04 Apr 2023 00:00:00 GMT

Prometheus的TSDB Status里可以查看TOP10的指标：Top 10 series count by metric names,参考这个来优化指标吧！

筛选

推荐使用metric_relabel_configs

#保留
  metric_relabel_configs: 
  - source_labels: [__name__]
    regex: etcd_disk_backend_commit_duration_seconds_bucket|up
    action: keep   
#去除
  metric_relabel_configs:
  - source_labels: [__name__]
    regex: nginx_filter_.*
    action: drop

或者使用whitelist_regex或者blacklist_regex 举例：

# 只监控以http开头的指标
whitelist_regex: ^http.*

# 不监控以http开头的指标
blacklist_regex: ^http.*

合并

kube-apiserver的apiserver_request_duration_seconds_bucket指标数量太多尝试进行合并：

将0.1、0.2、0.5、1、2、5、10、30和+Inf的桶(bucket)合并为0.1的桶(bucket)，将0.3、0.6、1.5、3、6、15、30、60、120、300、600、1800、3600和+Inf的桶(bucket)合并为0.3的桶(bucket)，以此类推。

    relabel_configs:													
      - source_labels: [le]
        regex: "0\\.1|0\\.2|0\\.5|1|2|5|10|30|\\+Inf"
        action: replace
        target_label: le
        replacement: "0.1"
      - source_labels: [le]
        regex: "0\\.3|0\\.6|1\\.5|3|6|15|30|60|120|300|600|1800|3600|\\+Inf"
        action: replace
        target_label: le
        replacement: "0.3"
      - source_labels: [le]
        regex: "0\\.4|0\\.7|2\\.5|4|7|25|50|100|250|500|1000|1800|3600|\\+Inf"
        action: replace
        target_label: le
        replacement: "0.4"
      - source_labels: [le]
        regex: "1\\.5|5|15|30|60|300|1800|3600|\\+Inf"
        action: replace
        target_label: le
        replacement: "1.5"

Kubernetes的探针机制

Tue, 28 Mar 2023 00:00:00 GMT

演示

k8s里探针有三种：存活(livenessProbe)、就绪(readinessProbe)和启动(startupProbe)探针

直接演示一下代码吧

....省略其他....
      containers:
        - name: nginx
          image: registry.k8s.io/busybox:v1
          imagePullPolicy: IfNotPresent
          readinessProbe:
            httpGet:
              port: 1111
              path: /metrics/prometheus
            initialDelaySeconds: 60
            successThreshold: 1
            failureThreshold: 3
            timeoutSeconds: 5
          startupProbe:
            httpGet:
              port: 1111
              path: /metrics/prometheus
            initialDelaySeconds: 60
            successThreshold: 1
            failureThreshold: 3
            timeoutSeconds: 5
          livenessProbe:
            httpGet:
              port: 1111
              path: /metrics/prometheus
            initialDelaySeconds: 60
            successThreshold: 1
            failureThreshold: 3
            timeoutSeconds: 5
          resources:
            requests:
              memory: 1024Mi
            limits:
              memory: 2048Mi
....省略其他...

解释

readinessProbe: 用于确定容器是否已准备好接收网络流量。

当探针发现容器已经准备就绪时，Kubernetes 将开始将流量引导到容器中。使用 HTTP GET 方法检查容器的 /metrics/prometheus 路径是否可用，如果容器返回状态码 200，则认为容器已准备好接收流量。

initialDelaySeconds 表示在容器启动后多少秒后开始检查。 successThreshold 表示成功的最小连续计数。 failureThreshold 表示失败的最小连续计数。 timeoutSeconds 表示检查超时的秒数。

startupProbe: 用于确定容器是否正在启动中。

当探针发现容器正在启动时，Kubernetes 将等待一段时间，以允许容器完成启动过程，然后再检查容器是否已准备就绪。

initialDelaySeconds、successThreshold、failureThreshold 和 timeoutSeconds 参数的含义与 readinessProbe 中的相同。

livenessProbe: 用于确定容器是否正在运行。

当探针发现容器已停止运行时，Kubernetes 将自动重新启动容器。

initialDelaySeconds、successThreshold、failureThreshold 和 timeoutSeconds 参数的含义与 readinessProbe 中的相同。

使用场景

一般更新业务容器的时候，不加探针的话容器只要能正常启动，原先的容器就会被kill掉，但其实这个时候新的业务容器还没完全起来，这时候就会出现空挡，导致业务不可用，如果加上了探针，只有当新的容器业务完全起来了后，可以检测到监控指标了，才会把旧的kill掉，这样就可以无缝的滚动更新。而且有时候应用可能卡死了，内部出现一些error导致程序不可用，但容器并没有检测到挂掉之类的，探针这时候也可以检测到，然后自动重启。

其他

一般业务上云，要对业务的日志，监控，以及探针都需要添加，已确保业务上线后可以充分检测到运行情况，方便运维和开发定位和发现问题。

文章

推荐可以看看官方的文档配置存活、就绪和启动探针

本地部署chatAI【chatglm】

Mon, 20 Mar 2023 00:00:00 GMT

硬件需求

内存：16G以上
显卡：6G显存以上

下载地址

模型： chatglm-6b

Github：

B站大江户战士 UP主基于WEBUI开发的CHATUI界面，感兴趣可以关注下 chatglm_webui

安装方法

进入到chatglm_webui文件夹里运行以下命令安装依赖

pip install -r requirements.txt

可能会遇到问题

Q：python版本太低
A: 官网下载安装python3.6或以上的版本，然后修改系统环境变量 PATH
Q：C++依赖安装失败
A：下载C++的编译工具依赖：microsoft visual c++ build tools
Q：依赖安装失败
A：尝试用管理员权限启动CMD的命令提示符然后安装
Q：AssertionError: Torch not compiled with CUDA enabled
A：安装的python Torch是不包含显卡的版本，
Q：ERROR: No matching distribution found for torch==1.13.1+cu117
A：python -m pip install torch==1.13.1+cu117 torchvision==0.14.1+cu117 --extra-index-url https://download.pytorch.org/whl/cu117 --no-cache-dir
Q：python sentencepiece failed 或者 src/sentencepiece/sentencepiece_wrap.cxx(2822): fatal error C1083: A：尝试升级python3.6或以上的版本并安装microsoft visual c++ build tools
Q：Pip install sentencepiece failure
A: 尝试直接下载sentencepiece文件然后放到python的site-packages目录里，不行就升级pip或者更换python版本。

运行方法

1.把下载好的chatglm-6b文件夹直接放到chatglm_webui目录下 2.运行python main.py --low_vram （因为我的显卡只有8G显存，所以加了low_vram）

参数：

--path：指定模型所在文件夹，根目录不需要加
--low_vram：4-bit 量化，6GB 显存可用
--med_vram：8-bit 量化，10GB 显存可用
--cpu：CPU运行，32G 内存可用
--low_ram：CPU运行，16G 内存可用

UI界面

总结

当前单机版本的AI还属于调优阶段，没法和ChatGPT进行比较的，模型大小和参数的数量也不是一个数量级别，属于低智能AI。但meta的LLaMA和200G的模型也都开源了，相信过不了多久就可以做到真正的部署可实用的个人AI智能了，期待未来！

AI绘画工具webui简单入门之高清化

Sun, 19 Mar 2023 00:00:00 GMT

Webui直接生成出来的图会很模糊，而且有些地方细节不是很好，如果用作4k壁纸会感觉很别扭，所以需要高清修复。

步骤

打开webui的图生图，调整参数为：

缩放模式：拉伸
采样方法(Sampler)：DPM adaptive
宽度和高度在原有的基础上+64 ：1280*720 --> 1344*784
重绘幅度(Denoising)：0.15
脚本：使用SD放大（SD upscale）
放大算法：R-ESRGAN 4x+ Anime6B

其他参数默认即可，最后点击生成等待成果吧！

放大前：

放大后：

其他

最后再推荐一个网站，如果想要把生成的图做壁纸的话，可以把动漫图片用算法最大放大到2k甚至4K。
waifu2x

写在地下城邂逅Ⅳ·灾厄篇·完结之后

Sat, 18 Mar 2023 00:00:00 GMT

BGM

TV动画《期待在地下城邂逅有错吗 Ⅳ 深章灾厄篇》片尾曲切り傷
歌手：sajou no hana

<audio controls> <source src="http://music.163.com/song/media/outer/url?id=2024541034.mp3" type="audio/mpeg"> Your browser does not support the audio element. </audio>

感想

地错第四季也终于完结啦，新番里最好看的，不枉我每周四蹲首播啃生肉看完，这一季完完整整的把小说第14卷全部一次性讲完啦，完全是琉主场，琉的过去，眷族团灭的原因以及琉内心的变化，

最后也终于释怀了自己的过去，找到了属于自己的正义! ~~加入白兔后宫团（不是~~

不得不给节操社(J.C.STAFF)点个赞，还是保持了一贯的高制作水准，没有特别的崩坏，这一季看下来不管是剧情节奏还是画面音乐都非常棒！果然很喜欢这种王道的剧情啊，男孩与女孩的相遇，互相拯救的故事什么的，真是太棒了！

最后一幕琉的笑容真的太太太好看啦！

最近也把新的18卷小说看完了，白兔终于也到level5了，女神芙蕾雅线故事的高潮阶段也终于全部讲完，最后琉Level6救场的场景太帅啦！最后还直球告白贝尔！我宣布，琉股暴涨！诸君，我喜欢elf！

最后

外传剑姬神圣谭13 14卷貌似也快出了，看来大森真的想把每一个地错的角色魅力和眷族故事都展示出来，大森你给点力，学学某河马打字机，多出点！孩子爱看！

如何部署gitalk作为评论系统

Wed, 15 Mar 2023 00:00:00 GMT

Gitalk：

本来搭建好了博客，但是总觉的少了一些功能，没错，博客怎么能少了评论功能！（虽然可能没什么人评论）但本着我可以不用但不能没有的精神，刚好也有大大推荐了gitalk，就研究了下，发现集成第三方评论系统gitalk集成非常简单,只需要申请github账号的Secret然后前端里加下面一段代码就好了

    <script>
      import 'gitalk/dist/gitalk.css';
      import Gitalk from 'gitalk';
    
      const gitalk = new Gitalk({
        clientID: myclientID,
        clientSecret: mySecret,
        repo: 'myrepo',
        owner: 'myusername',
        admin: ['myusername'],
        id: window.location.pathname,
        distractionFreeMode: false
      });
    
      gitalk.render('gitalk-container');
    </script>
    
    <div id="gitalk-container"></div>

就搞定了！但是又有一个问题，就是ClientID和Secret是明文的，放到github上太危险了，那有什么好方法呢，查了下，vercel是支持环境变量的，astro也支持，那就好办了。查了一番官方文档，然后进行了以下操作，成功把vercel关联到项目，然后生成了.env文件。

npm i -g vercel
vercel --version
vercel login
vercel link --yes
vercel env ls
vercel env pull

接下来就简单了，只需要在Vercel的项目Setting中把Environment Variables添加下myclientID和mySecret，然后在代码里替换成import.meta.env.CLIENT_ID和import.meta.env.CLIENT_Secret就搞定！现在再push到github仓库里，就没有安全隐患了~

    <script>
      import 'gitalk/dist/gitalk.css';
      import Gitalk from 'gitalk';
    
      const gitalk = new Gitalk({
        clientID: import.meta.env.CLIENT_ID,
        clientSecret: import.meta.env.CLIENT_Secret,
        repo: 'myrepo',
        owner: 'myusername',
        admin: ['myusername'],
        id: window.location.pathname,
        distractionFreeMode: false
      });
    
      gitalk.render('gitalk-container');
    </script>
    
    <div id="gitalk-container"></div>

Twikoo

astro也支持twikoo的评论系统，后端参考官网Twikoo文档,前端只需要npm i twikoo然后配置

<script>
      import twikoo from "twikoo";
      twikoo({
        envId: "https://your vercel site", // your environment ID or url
        el: "#tcomment", // the container ID which will show the comment
        //lang: "en-GB", // language for the comment template. for the full list, refer to https://github.com/imaegoo/twikoo/blob/main/src/client/utils/i18n/index.js
      }).then(() => {
        console.log("comment loading success");
      });
</script>
<div id="tcomment"></div>

就可以了，当然别忘了再env.d.ts里吧declare module "twikoo";加上,声明下twikoo就不会报声明类型错误了。

Analytics

velcel还支持查看流量访问，只需要npm i -g vercel安装完velcel后在官网项目里启动Analytics里的Audiences,然后创建完目录后在页面里引入下面的代码就搞定了~

<script defer src="/_vercel/insights/script.js"></script>

AI绘画工具webui简单入门之工具安装

Tue, 14 Mar 2023 00:00:00 GMT

工具下载地址：

stable-diffusion-webui (推荐)

1.下载完成后运行webui-user.bat文件，会下载相关的依赖，国内网络可能需要翻墙或者用镜像站(修改launch.py文件把github地址都改为国内的镜像站地址)，也可以推荐dev-sidecar这个免费工具加速github。或者可以直接上b站检索秋葉aaakiup主，直接下载整合包,再或者直接下载第三方客户端

2.安装完成后再运行webui-user.bat文件后等待出现Running on local URL: http://127.0.0.1:7860 就可以访问127.0.0.1:7860打开webui页面啦。

3.打开后先别急，需要安装一些基础的插件，点击扩展，从网址安装，然后把git地址粘贴后安装即可，我这边推荐几个最常用的：

汉化插件安装完后：setting >> user interface >> Localization (requires restart) >> 选择 zh-CN >> apply setting >> reload ui

Control插件用来加载lora相关模型。

关键字补全插件用来补全prompt关键字的，适合英文小白~

4.安装完成后到设置里的显示所有页面，快捷设置列表填写sd_model_checkpoint,sd_vae然后重启webui，基础工具就安装好啦，接下来就是模型了！

模型下载地址：

Civitai

1.注册好账号后就可以查看很多网上分享的模型，找一个你最喜欢的，例如Counterfeit，点击下载即可。

2.下载好后记得要把模型放到 \webui\models\Stable-diffusion 目录下，这样才会读取到模型，Lora的模型要放到\webui\models\Lora里,有模型后就可以生成AI图片啦！

当然只是简单的模型还是不够的，后续进阶还需要用到vae模型，EasyNegative模型，lora模型，openpose模型，高清化等，这个后续有时间再梳理下，慢慢学习进步！

分享例子：

关键字： ((masterpiece,best quality)),1girl, solo, animal ears, rabbit, barefoot, knees up, dress, sitting, rabbit ears, short sleeves, looking at viewer, grass, short hair, smile, white hair, puffy sleeves, outdoors, puffy short sleeves, bangs, on ground, full body, animal, white dress, sunlight, brown eyes, dappled sunlight, day, depth of field

Negative关键字： EasyNegative, extra fingers,fewer fingers,

Steps: 20, Sampler: DPM++ 2M Karras, CFG scale: 10, Seed: 414619472, Size: 512x728, Model hash: 59ea4aa1d8, Model: cetusMix_cetusVersion3, Denoising strength: 0.7, Hires upscale: 2, Hires steps: 20, Hires upscaler: SwinIR_4x

grafanadb迁移到mysql

Mon, 13 Mar 2023 00:00:00 GMT

因为安全需求需要把grafana的数据库迁移到云上mysql，所以总结了一些遇到的问题：

先说步骤：

1.sqlite3 /var/lib/grafana/grafana.db .dump > grafana.sql

2.shell mysql -u username -p -h localhost database_name < grafana.sql

3.修改/etc/grafana/grafana.ini，添加

database type = mysql
host = localhost:3306
name = database_name
user = username
password = userpassword

4.然后重启grafana即可 systemctl restart grafana-server

PS:但是mysql语法和sqllite语法是有区别的，所以第二步之前需要修改grafana.sql的语法格式：

PRAGMA foreign_keys=OFF;BEGIN TRANSACTION;没有这个语句，需要删掉
🐦📊之类的表情最好不要有，存储会报错，虽然也可以解决（data是列名，TEXT是类型)： ALTER TABLE dashboard_version CHANGE data data TEXT CHARACTER SET utf8mb4 ;
AUTOINCREMENT 改为 AUTO_INCREMENT
TEXT默认一般不能有DEFAULT，最好改为VARCHAR(255)
TEXT格式是不能作为UNIQUE INDEX的必须要修改为VARCHAR(255)
datetime 可能会出现格式问题 2023-03-02 14:36:35.578526458+8:00 只要把最后的+8:00去掉就可以了

kubectl常用命令

Fri, 10 Mar 2023 00:00:00 GMT

用于替换现有的容器镜像或版本

kubectl set image deployment/DeploymentName -n NAMESPACE *=slpcat/rocketmq-exporter:latest

滚动的重启容器(优雅)

kubectl rollout restart deployment/DeploymentName -n NAMESPACE

回滚容器

kubectl rollout undo deployment/DeploymentName -n NAMESPACE`

设置/修改环境变量

kubectl set env deployment nginx-deploy DEPLOY_DATE="$(date)"

通过bash获得 pod 中某个容器的TTY，相当于登录容器

kubectl exec -it <pod-name> -c <container-name>  bash

查看容器的日志

kubectl logs <pod-name>
kubectl logs -f <pod-name> ### 实时查看日志
kubectl log  <pod-name>  -c <container_name> ### 若 pod 只有一个容器，可以不加 -c 
kubectl logs -l app=frontend ### 返回所有标记为 app=frontend 的 pod 的合并日志。

查看注释

kubectl explain pod
kubectl explain pod.apiVersion

查看节点 labels

kubectl get node --show-labels

重启 pod

kubectl get pod <POD名称> -n <NAMESPACE名称> -o yaml | kubectl replace --force -f -

修改网络类型

kubectl patch service istio-ingressgateway -n istio-system -p '{"spec":{"type":"NodePort"}}'

伸缩 pod 副本

可用于将Deployment及其Pod缩小为零个副本，实际上杀死了所有副本。当您将其缩放回1/1时，将创建一个新的Pod，重新启动您的应用程序。`

kubectl scale deploy/nginx-1 --replicas=0
kubectl scale deploy/nginx-1 --replicas=1

查看前一个 pod 的日志，logs -p 选项

kubectl logs --tail 100 -p user-klvchen-v1.0-6f67dcc46b-5b4qb > pre.log

复制容器里的文件

kubectl cp my-namespace/my-pod:/path/to/remote/file /path/to/local/file

一些Pod的yaml文件的资源清单和解释

apiVersion: v1     #必选，版本号，例如v1
kind: Pod       　 #必选，资源类型，例如 Pod
metadata:       　 #必选，元数据
  name: string     #必选，Pod名称
  namespace: string  #Pod所属的命名空间,默认为"default"
  labels:       　　  #自定义标签列表
    - name: string      　          
spec:  #必选，Pod中容器的详细定义
  containers:  #必选，Pod中容器列表
  - name: string   #必选，容器名称
    image: string  #必选，容器的镜像名称
    imagePullPolicy: [ Always|Never|IfNotPresent ]  #获取镜像的策略 
    command: [string]   #容器的启动命令列表，如不指定，使用打包时使用的启动命令
    args: [string]      #容器的启动命令参数列表
    workingDir: string  #容器的工作目录
    volumeMounts:       #挂载到容器内部的存储卷配置
    - name: string      #引用pod定义的共享存储卷的名称，需用volumes[]部分定义的的卷名
      mountPath: string #存储卷在容器内mount的绝对路径，应少于512字符
      readOnly: boolean #是否为只读模式
    ports: #需要暴露的端口库号列表
    - name: string        #端口的名称
      containerPort: int  #容器需要监听的端口号
      hostPort: int       #容器所在主机需要监听的端口号，默认与Container相同
      protocol: string    #端口协议，支持TCP和UDP，默认TCP
    env:   #容器运行前需设置的环境变量列表
    - name: string  #环境变量名称
      value: string #环境变量的值
    resources: #资源限制和请求的设置
      limits:  #资源限制的设置
        cpu: string     #Cpu的限制，单位为core数，将用于docker run --cpu-shares参数
        memory: string  #内存限制，单位可以为Mib/Gib，将用于docker run --memory参数
      requests: #资源请求的设置
        cpu: string    #Cpu请求，容器启动的初始可用数量
        memory: string #内存请求,容器启动的初始可用数量
    lifecycle: #生命周期钩子
        postStart: #容器启动后立即执行此钩子,如果执行失败,会根据重启策略进行重启
        preStop: #容器终止前执行此钩子,无论结果如何,容器都会终止
    livenessProbe:  #对Pod内各容器健康检查的设置，当探测无响应几次后将自动重启该容器
      exec:       　 #对Pod容器内检查方式设置为exec方式
        command: [string]  #exec方式需要制定的命令或脚本
      httpGet:       #对Pod内个容器健康检查方法设置为HttpGet，需要制定Path、port
        path: string
        port: number
        host: string
        scheme: string
        HttpHeaders:
        - name: string
          value: string
      tcpSocket:     #对Pod内个容器健康检查方式设置为tcpSocket方式
         port: number
       initialDelaySeconds: 0       #容器启动完成后首次探测的时间，单位为秒
       timeoutSeconds: 0    　　    #对容器健康检查探测等待响应的超时时间，单位秒，默认1秒
       periodSeconds: 0     　　    #对容器监控检查的定期探测时间设置，单位秒，默认10秒一次
       successThreshold: 0
       failureThreshold: 0
       securityContext:
         privileged: false
  restartPolicy: [Always | Never | OnFailure]  #Pod的重启策略
  nodeName: <string> #设置NodeName表示将该Pod调度到指定到名称的node节点上
  nodeSelector: obeject #设置NodeSelector表示将该Pod调度到包含这个label的node上
  imagePullSecrets: #Pull镜像时使用的secret名称，以key：secretkey格式指定
  - name: string
  hostNetwork: false   #是否使用主机网络模式，默认为false，如果设置为true，表示使用宿主机网络
  volumes:   #在该pod上定义共享存储卷列表
  - name: string    #共享存储卷名称 （volumes类型有很多种）
    emptyDir: {}       #类型为emtyDir的存储卷，与Pod同生命周期的一个临时目录。为空值
    hostPath: string   #类型为hostPath的存储卷，表示挂载Pod所在宿主机的目录
      path: string      　　        #Pod所在宿主机的目录，将被用于同期中mount的目录
    secret:       　　　#类型为secret的存储卷，挂载集群与定义的secret对象到容器内部
      scretname: string  
      items:     
      - key: string
        path: string
    configMap:         #类型为configMap的存储卷，挂载预定义的configMap对象到容器内部
      name: string
      items:
      - key: string
        path: string

在kubernetes中基本所有资源的一级属性都是一样的，主要包含5部分：

apiVersion 版本，由kubernetes内部定义，版本号必须可以用 kubectl api-versions 查询到
kind 类型，由kubernetes内部定义，版本号必须可以用 kubectl api-resources 查询到
metadata 元数据，主要是资源标识和说明，常用的有name、namespace、labels等
spec 描述，这是配置中最重要的一部分，里面是对各种资源配置的详细描述
status 状态信息，里面的内容不需要定义，由kubernetes自动生成

spec描述是主要关注的：

containers <[]Object> 容器列表，用于定义容器的详细信息
nodeName 根据nodeName的值将pod调度到指定的Node节点上
nodeSelector <map[]> 根据NodeSelector中定义的信息选择将该Pod调度到包含这些label的Node 上
hostNetwork 是否使用主机网络模式，默认为false，如果设置为true，表示使用宿主机网络
volumes <[]Object> 存储卷，用于定义Pod上面挂在的存储信息
restartPolicy 重启策略，表示Pod在遇到故障的时候的处理策略

这里推荐一个k8s的可视化工具 k9s

详细介绍： Kubernetes 集群管理工具 K9S

github: 项目地址

k9s是基于终端的资源仪表板。它只有一个命令行界面。无论在Kubernetes仪表板Web UI上做什么，都可以在终端使用K9s仪表板工具进行相同的操作。k9s持续关注Kubernetes集群，并提供命令以使用集群上定义的资源。

使用：下载后放到/bin/k9s 即可使用，需要安装kubectl
example: k9s -n ops  #即可查看ops的namespace

一些K8s的文章

【openai】我们把k8s集群扩展到了7500个节点

开始写博客啦

Thu, 09 Mar 2023 00:00:00 GMT

开始试试写博客，虽然感觉没啥特别要记录的，但也算一个小小的开始吧。

先记录一些实用的网址吧：

简单图床图床（不推荐）

vercel 海外站点托管平台

MARKDOWN 编辑器 MARKDOWN在线编辑器

子网掩码计算子网掩码计算

unix 时间戳转换时间戳转换

CHATGPT AICHAT

K8Syaml 生成器在线生成 K8S 的 yaml 文件

JSON 在线解析在线解析 Json 格式数据

路由跳转跟踪查询路由跳转

海外手机号海外的 SMS 手机号

freeDNS 免费的 DNS 域名

HuggingFace 相关模型下载

ControlNet SD 的插件

simplelogin 匿名邮箱

stackblitz 在线的IDE编辑器

upstash 免费的海外redis,kafka数据库

<audio controls> <source src="http://music.163.com/song/media/outer/url?id=409872504.mp3" type="audio/mpeg"> Your browser does not support the audio element. </audio>

隐私政策URL

Sun, 01 Jan 2023 00:00:00 GMT

本软件尊重并保护所有使用服务用户的个人隐私权。为了给您提供更准确、更有个性化的服务，本软件会按照本隐私权政策的规定使用和披露您的个人信息。但本软件将以高度的勤勉、审慎义务对待这些信息。除本隐私权政策另有规定外，在未征得您事先许可的情况下，本软件不会将这些信息对外披露或向第三方提供。本软件会不时更新本隐私权政策。您在同意本软件服务使用协议之时，即视为您已经同意本隐私权政策全部内容。本隐私权政策属于本软件服务使用协议不可分割的一部分。

1.适用范围

a)在您使用本软件网络服务，本软件自动接收并记录的您的手机上的信息，包括但不限于使用的语言、访问日期和时间、软硬件特征信息及您需求的网页记录等数据；

2.信息的使用

a)在获得您的数据之后，本软件会将其上传至服务器，以生成您的排行榜数据，以便您能够更好地使用服务。

3.信息披露

a)本软件不会将您的信息披露给不受信任的第三方。

b)根据法律的有关规定，或者行政或司法机构的要求，向第三方或者行政、司法机构披露；

c)如您出现违反中国有关法律、法规或者相关规则的情况，需要向第三方披露；

4.信息存储和交换

本软件收集的有关您的信息和资料将保存在本软件及（或）其关联公司的服务器上，这些信息和资料可能传送至您所在国家、地区或本软件收集信息和资料所在地的境外并在境外被访问、存储和展示。

Markdown Example

Sat, 01 Oct 2022 00:00:00 GMT

An h1 header

Paragraphs are separated by a blank line.

2nd paragraph. Italic, bold, and monospace. Itemized lists look like:

this one
that one
the other one

Note that --- not considering the asterisk --- the actual text content starts at 4-columns in.

Block quotes are written like so.

They can span multiple paragraphs, if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all in chapters 12--14"). Three dots ... will be converted to an ellipsis. Unicode is supported. ☺

An h2 header

Here's a numbered list:

first item
second item
third item

Note again how the actual text starts at 4 columns in (4 characters from the left side). Here's a code sample:

# Let me re-iterate ...
for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of indenting the block, you can use delimited blocks, if you like:

define foobar() {
    print "Welcome to flavor country!";
}

(which makes copying & pasting easier). You can optionally mark the delimited block for Pandoc to syntax highlight it:

import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i

An h3 header

Now a nested list:

First, get these ingredients:
- carrots
- celery
- lentils
Boil some water.

Dump everything in the pot and follow this algorithm:

 find wooden spoon
 unimage pot
 stir
 image pot
 balance wooden spoon precariously on pot handle
 wait 10 minutes
 goto first step (or shut off burner when done)

Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including that last line which continues item 3 above).

Here's a link to a website, to a local doc, and to a section heading in the current doc. Here's a footnote [^1].

[^1]: Footnote text goes here.

Tables can look like this:

size material color

9 leather brown 10 hemp canvas natural 11 glass transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports multi-line tables:

keyword text

red Sunsets, apples, and other red or reddish things.

green Leaves, grass, frogs and other things it's not easy being.

A horizontal rule follows.

Here's a definition list:

apples : Good for making applesauce. oranges : Citrus! tomatoes : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each term/definition pair to spread things out more.)

Here's a "line block":

| Line one | Line too | Line tree

and images can be specified like so:

Inline math equations go in like so: $\omega = d\phi / dt$. Display math should get its own line and be put in in double-dollarsigns:

$$I = \int \rho R^{2} dV$$

And note that you can backslash-escape any punctuation characters which you wish to be displayed literally, ex.: `foo`, *bar*, etc.

Include Video in the Posts

Mon, 01 Aug 2022 00:00:00 GMT

Just copy the embed code from YouTube or other platforms, and paste it in the markdown file.

---
title: Include Video in the Post
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili

Markdown Extended Features

Sun, 01 May 2022 00:00:00 GMT

GitHub Repository Cards

You can add dynamic cards that link to GitHub repositories, on page load, the repository information is pulled from the GitHub API.

::github{repo="Fabrizz/MMM-OnSpotify"}

Create a GitHub repository card with the code ::github{repo="<owner>/<repo>"}.

::github{repo="saicaca/fuwari"}

Admonitions

Following types of admonitions are supported: note tip important warning caution

:::note Highlights information that users should take into account, even when skimming. :::

:::tip Optional information to help a user be more successful. :::

:::important Crucial information necessary for users to succeed. :::

:::warning Critical content demanding immediate user attention due to potential risks. :::

:::caution Negative potential consequences of an action. :::

Basic Syntax

:::note
Highlights information that users should take into account, even when skimming.
:::

:::tip
Optional information to help a user be more successful.
:::

Custom Titles

The title of the admonition can be customized.

:::note[MY CUSTOM TITLE] This is a note with a custom title. :::

:::note[MY CUSTOM TITLE]
This is a note with a custom title.
:::

GitHub Syntax

[!TIP] The GitHub syntax is also supported.

> [!NOTE]
> The GitHub syntax is also supported.

> [!TIP]
> The GitHub syntax is also supported.

Simple Guides for Fuwari

Fri, 01 Apr 2022 00:00:00 GMT

image image source: Source

This blog template is built with Astro. For the things that are not mentioned in this guide, you may find the answers in the Astro Docs.

Front-matter of Posts

---
title: My First Blog Post
published: 2023-09-09
description: This is the first post of my new Astro blog.
image: ./image.jpg
tags: [Foo, Bar]
category: Front-end
draft: false
---

Attribute	Description
`title`	The title of the post.
`published`	The date the post was published.
`description`	A short description of the post. Displayed on index page.
`image`	The image image path of the post.<br/>1. Start with `http://` or `https://`: Use web image<br/>2. Start with `/`: For image in `public` dir<br/>3. With none of the prefixes: Relative to the markdown file
`tags`	The tags of the post.
`category`	The category of the post.
`draft`	If this post is still a draft, which won't be displayed.

Where to Place the Post Files

Your post files should be placed in src/content/posts/ directory. You can also create sub-directories to better organize your posts and assets.

src/content/posts/
├── post-1.md
└── post-2/
    ├── image.png
    └── index.md

Golang net/http & HTTP Serve 源码分析

Wed, 09 Mar 2022 00:00:00 GMT

这篇是转载的！不过还是很有用的，go的http可以推荐用gin，下次梳理下gin的教程好了

服务器在收到请求时，首先进入路由 Router，接着路由会根据 request 请求的路径，找到对应的处理器(Handler)，处理器再根据 request 进行处理并构造 response 进行返回。

利用标准库实现一个简单HTTP Server

向main.go文件写入如下内容：

package main

import (
    "fmt"
    "net/http"
)

// 方法一
type HelloContext struct {
    content string
}

func(h *HelloContext) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, h.content)
}

// 方法二
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, net/http! v2\n")
}

func main() {
    http.Handle("/v1", &HelloContext{content: "Hello, net/http! v1\n"})
    http.HandleFunc("/v2", helloHandler)
    http.ListenAndServe(":8080", nil)
}

运行后，可以用 curl 工具进行测试：

mac:~ $ curl 127.0.0.1:8080/v1
Hello, net/http! v1
mac:~ $ curl 127.0.0.1:8080/v2
Hello, net/http! v2

这段代码我们用 http.Handle 和 http.HandleFunc 两种方法分别在路径 /v1 和 /v2 上注册了两个 http.Handler。注意：Handle 和 Handler 是两个东西。
这两个 Handler 都对 request 进行了处理，并且通过 fmt.Fprintf 方法写入并返回数据。

处理器

http.Handler

先来了解一下 http.Handler (处理器)，

type Handler interface {
 ServeHTTP(ResponseWriter, *Request)
}

它被定义为一个拥有 ServeHTTP 方法的接口，也就是说任何类型，只要实现了 ServeHTTP 方法，就实现了 http.Handler 接口。

ServeHTTP 方法会读取 *Request 信息，并且向 ResponseWriter 写入 header 与 body 内容。

路由注册

http.Handle

从 main函数出发，来看 http.Handle 函数源码:

func Handle(pattern string, handler Handler) { 
  DefaultServeMux.Handle(pattern, handler) 
}

可以看到，http.Handle 函数调用了 DefaultServeMux.Handle 方法。

http.HandleFunc

再来看 http.HandleFunc 的源码：

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
 DefaultServeMux.HandleFunc(pattern, handler)
}

它也调用了 DefaultServeMux.HandleFunc 方法，再看此方法源码：

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
 if handler == nil {
  panic("http: nil handler")
 }
 mux.Handle(pattern, HandlerFunc(handler))
}

不难看出，http.Handle 和 http.HandleFunc 都调用了一个和 ServeMux 对象的 Handle 方法有关。

这两个方法的作用都是将传入的处理器 (Handler) 注册到对应的路由规则 (pattern)上。

比如，倒数第三行将处理器 helloHandler 注册到了路由规则 (路径) /v2 上。这样，当 HTTP 请求的地址是 /v2的时候，就由处理器 helloHandler 来负责处理请求，并且响应。

mux.Handle 方法中还有一个 http.HandlerFunc ，注意不是 HandleFunc。

适配器与处理器

http.HandlerFunc

type HandlerFunc func(ResponseWriter, *Request)

HandlerFunc 可以理解为一个适配器，它允许使用普通的函数成为处理器 Handler 对象，前提是这个普通函数拥有 func(ResponseWriter, *Request) 签名。

上文说到，任何类型只要实现了 ServeHTTP 方法，那它就实现了 Handler接口，它就是一个 Handler 类型。

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
 f(w, r)
}

这里呢，非常的巧妙，HandlerFunc 类型实现了 ServeHTTP 方法，并且又将 ServeHTTP方法的参数传给了自身。

也就是说：

一个普通的函数，只要参数是 ResponseWriter 和 *Request，或者换种标准点的说法，它的函数签名为 func(ResponseWriter,*Request)，那么它就是 HandlerFunc 类型。
由于 HandlerFunc 自身实现了 ServeHTTP方法，所以这个普通函数又实现了 Handler 接口，成了 Handler 类型。

到这里，如何注册、DefaultServeMux 和 ServeMux 是什么，我们暂时还不知道，为了便于理解，这个下文再说。

监听与服务

http.ListenAndServe

接着往下走，看一下 http.ListenAndServe 做了哪些事情：

// ListenAndServe listens on the TCP network address addr and then calls
// Serve with handler to handle requests on incoming connections.
// Accepted connections are configured to enable TCP keep-alives.
//
// The handler is typically nil, in which case the DefaultServeMux is used.
//
// ListenAndServe always returns a non-nil error.
func ListenAndServe(addr string, handler Handler) error {
 server := &Server{Addr: addr, Handler: handler}
 return server.ListenAndServe()
}

不难看出，http.ListenAndServe 负责监听 TCP 网络地址 addr, 代码中写的是:8080 也即是监听 8080 端口，并且处理相关的请求。

这里传入的第二个参数是 Handler 类型，根据注释可以看出：如果传入值为 nil ，那么将会使用 DefaultServeMux 。

服务复用器

DefaultServeMux

// DefaultServeMux is the default ServeMux used by Serve.
var DefaultServeMux = &defaultServeMux

var defaultServeMux ServeMux

说白了，DefaultServeMux 是 ServeMux 类型的一个实例，由标准库创建。

下面看 ServeMux 结构体的源码。

ServeMux

ServeMux 是一个结构体，它的作用是服务复用器。

type ServeMux struct {
 mu    sync.RWMutex
 m     map[string]muxEntry
 es    []muxEntry // slice of entries sorted from longest to shortest.
 hosts bool       // whether any patterns contain hostnames
}

因为涉及并发，所以这里有个读写锁 mu，主要用于保护下面的 map 类型的成员 m。

es 与 hosts 和路由规则匹配有关。

这里重点关注一下 m，它是一个 map ，key 是 string 类型的路由表达式，val 是 muxEntry 类型的结构体。

type muxEntry struct {
 h       Handler
 pattern string
}

muxEntry 结构体，描述了路由规则 pattern 对应的处理器 h。

mux.Handle

上文中，http.Handle 和 http.HandleFunc 都调用了 mux.Handle 方法。

它是结构体 ServeMux 的方法，也就是说，此方法主要把 Handler 对象注册到给定的 pattern 上，也即路由注册。

// Handle registers the handler for the given pattern.
// If a handler already exists for pattern, Handle panics.
func (mux *ServeMux) Handle(pattern string, handler Handler) {
  // 为了保护 ServeMux 成员 map 类型的 m 的读写，分别在方法开始和结束的时候进行加锁和解锁的操作。
 mux.mu.Lock()
 defer mux.mu.Unlock()
 // 如果路由规则 pattern 为空，则直接 panic。
 if pattern == "" {
  panic("http: invalid pattern")
 }
  // 如果 http.Handler 类型的处理器 handler 为空，则panic。
 if handler == nil {
  panic("http: nil handler")
 }
  // 如果路由规则 pattern 已经存在，则直接 panic。
 if _, exist := mux.m[pattern]; exist {
  panic("http: multiple registrations for " + pattern)
 }
 // 如果成员 m 为空，则 make 一个新的 map。
 if mux.m == nil {
  mux.m = make(map[string]muxEntry)
 }
  // 创建一个 muxEntry，并将 pattern 对应的 Handler 放进去。
 e := muxEntry{h: handler, pattern: pattern}
  // 写入 m， key 为 pattern ，value 为新建的 muxEntry 类型的 e ，也即新增一个路由规则。
 mux.m[pattern] = e
  // 如果路由规则以字符 / 结尾，则给将新建的 muxEntry 类型的 e 放到成员 es 中。
  // es 是一个切片，使用 http.appendSorted 方法加入元素，以确保 es 中的元素(路由)是从最长到最短。
 if pattern[len(pattern)-1] == '/' {
  mux.es = appendSorted(mux.es, e)
 }
  // 最后，如果路由规则不是以字符 / 开头，那么给成员 hosts 赋值 true 。
 if pattern[0] != '/' {
  mux.hosts = true
 }
}

mux.ServeHTTP

我把 ServeMux 的 ServeHTTP 方法简称为 mux.ServeHTTP，下文也是一样。

func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
 if r.RequestURI == "*" {
  if r.ProtoAtLeast(1, 1) {
   w.Header().Set("Connection", "close")
  }
  w.WriteHeader(StatusBadRequest)
  return
 }
 h, _ := mux.Handler(r)
 h.ServeHTTP(w, r)
}

ServeMux 结构体同样实现了 ServeHTTP 方法，也即它也实现了 Handler 接口，是一个 Handler 类型的对象。

但它并不负责处理具体的请求，篇幅有限，这里给出，调用的 mux.Handler 方法签名：

func (mux *ServeMux) handler(host, path string) (h Handler, pattern string)

总的来说，mux.ServeHTTP 调用了 mux.Handler 方法，通过 host 和 path 找到具体的处理器 Handler 和路由规则 pattern ，然后让对应的 Handler 的 ServeHTTP 方法去处理请求。

连接与请求的处理

其实搞懂上面方法以及其之间的关系，对于进一步的学习 Go Web 框架 (比如 Gin ) 就已经有很大的帮助了。从监听与服务开始，代码更加底层，这里我主要关心的是，一次请求是如何到达 ServeHTTP 的。

http.ListenAndServe 方法中，使用传入的监听地址 addr 和处理器 handler 初始化一个 HTTP 服务器 http.Server。

Server 结构体，主要定义了需要跑一个 HTTP Server 所需要的参数：

Server

type Server struct {
 Addr string
 Handler Handler // handler to invoke, http.DefaultServeMux if nil
  
 TLSConfig *tls.Config
 ReadTimeout time.Duration
 ReadHeaderTimeout time.Duration
 WriteTimeout time.Duration
 IdleTimeout time.Duration
 MaxHeaderBytes int
 TLSNextProto map[string]func(*Server, *tls.Conn, Handler)
 ConnState func(net.Conn, ConnState)
 ErrorLog *log.Logger
 BaseContext func(net.Listener) context.Context
 ConnContext func(ctx context.Context, c net.Conn) context.Context
 inShutdown atomicBool // true when server is in shutdown
 disableKeepAlives int32     // accessed atomically.
 nextProtoOnce     sync.Once // guards setupHTTP2_* init
 nextProtoErr      error     // result of http2.ConfigureServer if used
  
 mu         sync.Mutex
 listeners  map[*net.Listener]struct{}
 activeConn map[*conn]struct{}
 doneChan   chan struct{}
 onShutdown []func()
}

这些参数不是重点，接着往下。

server.ListenAndServe

func (srv *Server) ListenAndServe() error {
 if srv.shuttingDown() {
  return ErrServerClosed
 }
 addr := srv.Addr
 if addr == "" {
  addr = ":http"
 }
 ln, err := net.Listen("tcp", addr)
 if err != nil {
  return err
 }
 return srv.Serve(ln)
}

Server 结构体的 ListenAndServe 方法会监听 TCP 网络地址 addr ，然后调用 srv.Serve 处理传入连接的请求。

srv.Serve

func (srv *Server) Serve(l net.Listener) error {
 // ...省略部分
 for {
    // 循环监听 TCP 连接
  rw, err := l.Accept()
  if err != nil {
    ...省略部分 
  connCtx := ctx
  if cc := srv.ConnContext; cc != nil {
   connCtx = cc(connCtx, rw)
   if connCtx == nil {
    panic("ConnContext returned nil")
   }
  }
  tempDelay = 0
  c := srv.newConn(rw)
  c.setState(c.rwc, StateNew, runHooks) // before Serve can return
  go c.serve(connCtx)
 }
}

Serve 方法在 Listenner l 上接受传入的连接，并且为每一个连接创建 goroutine 。这些 gorutines 会读取请求并且调用 srv.Handler 去响应它们。

c.Serve

// Serve a new connection.
func (c *conn) serve(ctx context.Context) {
  // ...
 for {
    // 循环接受请求，一个连接可以处理多个请求
  w, err := c.readRequest(ctx)
  if c.r.remain != c.server.initialReadLimitSize() {
   // If we read any bytes off the wire, we're active.
   c.setState(c.rwc, StateActive, runHooks)
  }
  // 这行代码是重点
  serverHandler{c.server}.ServeHTTP(w, w.req)
  inFlightResponse = nil
  w.cancelCtx()
  if c.hijacked() {
   return
  }
 }
}

serverHandler

serverHandler 结构体是一个代理，它会代理 server 的 Handler 或 DefaultServeMux 。

type serverHandler struct {
 srv *Server
}

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
  // 这个 handler 就是最初 http.ListenAndServe 传入的 Handler 类型的 handler 。
 handler := sh.srv.Handler
  // 如果 http.ListenAndServe 第二个参数是 nil，那么使用 DefaultServeMux 。
 if handler == nil {
  handler = DefaultServeMux
 }
 if req.RequestURI == "*" && req.Method == "OPTIONS" {
  handler = globalOptionsHandler{}
 }
  
 if req.URL != nil && strings.Contains(req.URL.RawQuery, ";") {
  var allowQuerySemicolonsInUse int32
  req = req.WithContext(context.WithValue(req.Context(), silenceSemWarnContextKey, func() {
   atomic.StoreInt32(&allowQuerySemicolonsInUse, 1)
  }))
  defer func() {
   if atomic.LoadInt32(&allowQuerySemicolonsInUse) == 0 {
    sh.srv.logf("http: URL query contains semicolon, which is no longer a supported separator; parts of the query may be stripped when parsed; see golang.org/issue/25192")
   }
  }()
 }
  // 调用 handler 的 ServeHTTP 方法处理请求。
 handler.ServeHTTP(rw, req)
}

到这里，连接中的请求，就交给了 handler.ServeHTTP 也即 mux.ServeHTTP 方法来处理。

然后 mux.ServeHTTP 方法中，mux.Handler 方法，会根据 request 中的 host 和 path 信息，找到对应的 Handler，这个 Handler 再处理信息。

总结

Go net/http 标准库，能让我们轻易地写出一个高性能的 HTTP Server，但肯定不能满足实际业务开发，比如动态路由、中间件、鉴权等这是标准库所不具有的。

很多重复性的工作和常用的工具与特性要由框架来封装和实现，go 很多高性能框架比如 Gin 都是直接封装了 net/http，这一点难能可贵，由此可见 Go 标准库的价值。

所以学习优秀 Go web 框架的前提就是弄清楚 net/http Server 部分的源码，同时，也能方便更好的去使用和优化框架。
本文所使用的源码均来自 go 1.18.3，部分方法说明翻译自官方注释。

如有不当之处，请批评指出。

ike‘s blog

mac软件推荐

用Siri来控制Windows电脑开机关机吧

前因

准备

嘿 Siri

语音控制

控制中台

最后

clickhouse的一些优化建议和工具

起因

最后

2023sumppary

关于工作

关于开发

关于旅游

关于游戏

最后

记录一下我的第一个网页游戏Mazeball

游戏链接：

截图：

游戏规则：

如何使用Clickhouse的索引

简介

介绍

实践

参考

如何从zookeeper切换为clickhouse—keeper

简介

对比

部署

参考

cloki分布式查询和clickhouse副本存储

相关开源工具

cloki

clickhouse

使用ilogtail+cloki+clickhouse来做日志系统吧

相关开源工具

简介

部署

cloki

ilogtai

clickhouse集群部署指南

起因

步骤

zookeeper安装

clickhouse安装

配置

快速安装部署clickhouse和cloki

安装

clickhouse

cloki

使用

参考

快速部署thanos架构

介绍

前因

安装

部署

步骤

后续

如何使用go的jwt

什么是jwt

jwt bearer和bearer token的区别

安装jwt包

如何使用jwt

如何修改git commit记录

前言

修改历史commit的邮箱和用户名

修改历史commit的文件

业务容器化需要注意的一些地方

废话不多说，直接上yaml文件。

游戏企划

Prometheus Metrics精简优化2

前言

工具

下载方法

使用方法

总结

来在线听音乐吧

AI绘画工具webui简单入门之高清化

AI绘画工具webui简单入门之工具安装