飞行的蜗牛

vuePress-theme-reco 极客学长    2013 - 2025
飞行的蜗牛 飞行的蜗牛

Choose mode

  • dark
  • auto
  • light
首页
分类
  • 技术杂谈
  • Database
  • Docker
  • PHP
  • 随笔杂谈
  • 前端开发
  • FunnyTools
  • Jekyll
  • 读书笔记
  • Java
  • SpringBoot
  • 区块链技术
  • IPFS
  • C/C++
  • Filecoin
  • Golang
  • Sharding-JDBC
  • 分布式存储
  • Lotus-源码系列
  • Lotus
  • 框架源码系列
  • Spring-源码系列
  • AI
  • ChatGPT
  • Stable Diffusion
  • DeepSeek-R1
  • DeepSeek-V3
标签
时间抽
关于作者
开源项目
GeekAI (opens new window)
author-avatar

极客学长

154

文章

151

标签

首页
分类
  • 技术杂谈
  • Database
  • Docker
  • PHP
  • 随笔杂谈
  • 前端开发
  • FunnyTools
  • Jekyll
  • 读书笔记
  • Java
  • SpringBoot
  • 区块链技术
  • IPFS
  • C/C++
  • Filecoin
  • Golang
  • Sharding-JDBC
  • 分布式存储
  • Lotus-源码系列
  • Lotus
  • 框架源码系列
  • Spring-源码系列
  • AI
  • ChatGPT
  • Stable Diffusion
  • DeepSeek-R1
  • DeepSeek-V3
标签
时间抽
关于作者
开源项目
GeekAI (opens new window)
  • Lotus 新手运维手册,持续更新...

    • 常用环境变量
      • lotus daemon 操作
        • 1. 查看节点信息
        • 2. 查看链同步状态
        • 3. 修改 mpool 配置
        • 4. 疏通消息,加快上链
      • 链快照操作
        • 1. 导出当前链快照
        • 2. 导入快照
        • 3. 压缩区块数据
      • 钱包私钥的备份和删除
        • 手动下载 proof 参数
          • lotus-miner 操作
            • lotus-worker 操作
              • 订单操作
                • 手动终止 Faulty 的扇区
                  • 设置时区
                    • RAID 操作
                      • LVM 操作
                        • 开启 CPU 性能模式
                          • 创建 swap 分区
                            • 临时修改某个进程的 max open files 参数
                              • 磁盘检测工具
                                • 关闭系统软件更新
                                  • 原语云 lotus 运维
                                    • 动态设置 Miner 任务调度算法
                                    • 设置 Worker 运行参数
                                    • 设置存储运行参数
                                    • 动态配置 Worker 运行状态
                                    • 手动声明扇区
                                    • 重新初始化矿工
                                    • 时空证明异常排查
                                    • 爆块证明异常排查
                                  • 参考链接

                                  Lotus 新手运维手册,持续更新...

                                  vuePress-theme-reco 极客学长    2013 - 2025

                                  Lotus 新手运维手册,持续更新...


                                  极客学长 2021-05-12 0 新手上路

                                  吴军

                                  所谓的经验,不是简单的将上一次成功的过程复制一遍,而是在暂时看不到前途的时候,知道该坚持还是退回来。

                                  本文是一份 Lotus 新手运维手册,会持续更新,老司机请不要在此停留。

                                  # 常用环境变量

                                  Lotus 数据目录: LOTUS_PATH

                                  export LOTUS_PATH=/gamma/lotus/data
                                  

                                  Miner 数据目录:LOTUS_STORAGE_PATH

                                  export LOTUS_STORAGE_PATH=/gamma/lotus-storage-miner/data
                                  

                                  IPFS 网关地址: IPFS_GATEWAY, 用于下载复制证明参数加速

                                  export IPFS_GATEWAY=https://proof-parameters.s3.cn-south-1.jdcloud-oss.com/ipfs/
                                  

                                  临时文件夹路径: TMPDIR

                                  export TMPDIR=/cache/tmp
                                  

                                  proof 证明参数路径: FIL_PROOFS_PARAMETER_CACHE

                                  export FIL_PROOFS_PARAMETER_CACHE=/gamma/filecoin-proof-parameters
                                  

                                  PreCommit1 proof parents 缓存路径(可以减少 56G 内存)

                                  export FIL_PROOFS_PARENT_CACHE=/gamma/filecoin-parents
                                  

                                  最大化内存参数: FIL_PROOFS_MAXIMIZE_CACHING

                                  export FIL_PROOFS_MAXIMIZE_CACHING=1
                                  

                                  使用 GPU 进行 Precommit2 加速: FIL_PROOFS_USE_GPU_COLUMN_BUILDER

                                  export FIL_PROOFS_USE_GPU_COLUMN_BUILDER=1
                                  

                                  提示:

                                  启用 PreCommit1 SDR 多核加速(为每个 PC1 任务绑定共享一组 L3 缓存的一组 CPU),能大大提高 PC1 的密封效率, 我本人使用 3970x 实测结果为 2h17min,并行三个扇区。不过目前官方提示该项加速还不是很稳定。 我本人测试的结果也是这样,依赖于绑核的稳定性,有的时候会绑错,尤其是对于多路 CPU。

                                  FIL_PROOFS_USE_MULTICORE_SDR=1
                                  

                                  设置 Rust 日志等级:

                                  # optional: Trace,Info,Warn,Debug,Error
                                  export RUST_LOG=Debug
                                  

                                  开启详细的报错日志追踪:

                                  RUST_BACKTRACE=1
                                  

                                  启用源码编译底层库:

                                  export FFI_BUILD_FROM_SOURCE=1
                                  

                                  启动小扇区支持:(一般用于本地测试网络)

                                  export FIL_USE_SMALL_SECTORS=true
                                  

                                  设置自定义 GPU 参数:

                                  export BELLMAN_CUSTOM_GPU="GeForce RTX 2070 SUPER:2560"
                                  

                                  # lotus daemon 操作

                                  # 1. 查看节点信息

                                  # 查看本节点所监听的地址:
                                  lotus net listen
                                  
                                  /ip4/127.0.0.1/tcp/37103/p2p/12D3KooWNvqwb1gbgMNLFXtMAXP3ZwgTVgaLXbDUNqpWDQuKd1sh
                                  /ip4/192.168.1.101/tcp/37103/p2p/12D3KooWNvqwb1gbgMNLFXtMAXP3ZwgTVgaLXbDUNqpWDQuKd1sh
                                  /ip6/::1/tcp/46335/p2p/12D3KooWNvqwb1gbgMNLFXtMAXP3ZwgTVgaLXbDUNqpWDQuKd1sh
                                  # 查看连接的节点列表:
                                  lotus net peers
                                  

                                  手动连接其他节点, 这个在你同步的时候发现自动同步失败,无法获取可用节点的时候特别有用:

                                  # usage
                                  lotus net connect <PEER_ADDR>
                                  # e.g
                                  lotus net connect /ip4/119.33.53.66/tcp/37103/p2p/12D3KooWNvqwb1gbgMNLFXtMAXP3ZwgTVgaLXbDUNqpWDQuKd1sh
                                  

                                  这个在你同步的时候无法正常同步链上数据时候特别有用, 这时可以试下在启动 daemon 的时候禁用自动连接 peers ,然后手动连接到一个正常节点,例如:

                                  lotus daemon --bootstrap=false
                                  lotus net connect <PEER_ADDR>
                                  

                                  <PEER_ADDR> 可以是任意一个能够正常同步数据的节点地址。

                                  # 2. 查看链同步状态

                                  lotus sync status
                                  # 等待链同步完成
                                  lotus sync wait  # 该命令会实时显示同步状态以及待同步区块高度
                                  

                                  如果出现 Error 则说明链同步有问题,如果状态是 completed,则说明链同步已经完成,可以进行其他操作了。 如果同步出错的话,你可以手动强制将你的本地链头区块指向某个高度:

                                  # usage
                                  lotus chain sethead --epoch=<height>
                                  # e.g
                                  lotus chain sethead --epoch=3960
                                  

                                  # 3. 修改 mpool 配置

                                  # usage
                                  lotus mpool config <val>
                                  # e.g
                                  lotus mpool config '{"PriorityAddrs":[],"SizeLimitHigh":30000,"SizeLimitLow":20000,"ReplaceByFeeRatio":1.25,"PruneCooldown":60000000000,"GasLimitOverestimation":1.5}'
                                  

                                  这个配置非常有用,你可以用来做一些高级的操作。比如,如果你想设置你的节点为某个钱包发送的交易优先打包,你可以这样设置:

                                  # usage
                                  lotus mpool config '{"PriorityAddrs":[<address>],"SizeLimitHigh":30000,"SizeLimitLow":20000,"ReplaceByFeeRatio":1.25,"PruneCooldown":60000000000,"GasLimitOverestimation":1.5}'
                                  # e.g
                                  lotus mpool config '{"PriorityAddrs":["t3r3afkf3ooeukknwx45g4t475pduslpkov32nvodv6xzbuliccka7qsax32m34yfbd7q3fwxapfb2isea6dnq"],"SizeLimitHigh":30000,"SizeLimitLow":20000,"ReplaceByFeeRatio":1.25,"PruneCooldown":60000000000,"GasLimitOverestimation":1.5}'
                                  

                                  # 4. 疏通消息,加快上链

                                  你可以使用下面的命令自动计算并增加 gas 费用:

                                  # usage
                                  lotus mpool replace  --auto <address> <nonce>
                                  # e.g
                                  lotus mpool replace  --auto t3xxxxx 1234
                                  

                                  注意:

                                  这个命令最好手动调用,如果自动调用的话,最后的结果可能让你支付超高额度的 Gas 费用,有矿工为此付出了惨烈的代价,支付了一笔 700 多 FIL 的手续费。

                                  大多数情况下我们都是手动梳通消息:

                                  lotus mpool replace --gas-feecap=<GFC> --gas-premium=<GP> --gas-limit=<GL> <CID>
                                  

                                  具体操作如下:

                                  1. 首先在区块浏览器找到当前最新的一个区块的 ProveSector 类型的消息(或者跟你要梳通的消息的同类型的消息),记录他们的 Gas Fee Cap($gasFeeCap) 和 Gas Used($gasUsed)。

                                  2. 找到当前的要替换消息的 Gas Premium($oldGasPremium)。

                                  3. 计算上 replace 消息中的变量的值并替换:

                                    GFC=$gasFeeCap
                                    GP=$oldGasPremium * 1.252
                                    GL=$gasUsed * 1.1
                                    # CID 表示要替换的消息的 cid。
                                    

                                  # 链快照操作

                                  # 1. 导出当前链快照

                                  通常如果你不是做钱包或者交易所的话,你并不需要全节点,你可以直接从官方提供的快照来同步,或者从其他节点导出快照,再导入到当前 daemon. 这样可以节省不少同步的时间。 可以使用以下方式创建完整的 CAR 快照:

                                  # usage 
                                  lotus chain export <filename> 
                                  # e.g
                                  lotus chain export lotus-chain-2020-12-02.car
                                  

                                  通过上面的命令你可以导出一个完整的 lotus chain 快照。不过这个快照比较大,可能超过 100 GB。 所以更常用的方式是使用下面的命令导出一个阉割版的快照, 就是只导出最新的区块,跳过以前的旧消息。

                                  # usage
                                  lotus chain export --skip-old-msgs --recent-stateroots=<stateroots-num> <filename>
                                  # e.g
                                  lotus chain export --skip-old-msgs --recent-stateroots=2000 lotus_chain_2020_12_02.car
                                  

                                  --recent-stateroots 参数指定要导出的状态根数。 --skip-old-msgs 参数表示只导出那些 stateroots 直接引用的区块。

                                  # 2. 导入快照

                                  在首次启动 daemon 的时候执行导入快照。

                                  # Without verification
                                  lotus daemon --import-snapshot <filename>
                                  # With verification
                                  lotus daemon --import-chain <filename>
                                  

                                  如果你希望在快照导入之后就立即退出守护进程,(例如在docker环境中很有用),请在命令中添加 --halt-after-import 标志:

                                  lotus daemon --import-snapshot=<filename> --halt-after-import=true
                                  # e.g
                                  lotus daemon --import-snapshot=lotus_chain_2020_12_02.car --halt-after-import=true
                                  

                                  # 3. 压缩区块数据

                                  随着你的节点同步的区块越来越多,占用的磁盘空间也越来越大,而磁盘存的越满,访问的速度就会越慢,最关键是你可能压根不想要这么多区块数据,99% 的 Miner 的需求都是一样的:在保持链同步正常的情况下,区块数据越精简越好,不想多存一个区块。 如果你也是这么想的,那么定期去压缩一下区块数据可能是你的一个刚需。

                                  1. 停止 Lotus 守护进程:

                                    lotus daemon stop
                                    
                                  2. 删除 $LOTUS_PATH 路径中 datastore/chain/ 文件夹的内容:

                                    # <LOTUS_PATH> 替换为你的 $LOTUS_PATH 变量内容,默认值为 `~/.lotus`
                                    rm -rf <LOTUS_PATH>/datastore/chain/* 
                                    
                                  3. 使用最小快照启动守护进程:

                                    # 下载最小区块快照
                                    wget https://fil-chain-snapshots-fallback.s3.amazonaws.com/mainnet/minimal_finality_stateroots_latest.car -O lotus_chain_minimal.car
                                    # 或者在本地导出最小区块快照
                                    lotus chain export --skip-old-msgs=true --recent-stateroots=900 lotus_chain_minimal.car
                                    lotus daemon --import-snapshot=lotus_chain_minimal.car 
                                    

                                  # 钱包私钥的备份和删除

                                  1. 导出/导入钱包私钥到文件

                                    # usage
                                    lotus wallet export <address> > <file>
                                    # e.g
                                    lotus wallet export f3xxx > wallet.key
                                    

                                    导出之后我们需要再导入刚刚导出的私钥,确保备份的私钥能正确导入:



                                     

                                    lotus wallet import wallet.key
                                    # 如果提示 key already exists 则表示备份的私钥是有效的
                                    ERROR: saving to keystore: checking key before put 'wallet-f3rf5kmk2xenqukta4jkuk3xn5tbwrrylstd7inuzu6hhwtang6jk3edkxqzokbqs7wojbz23pkdadkg5wzmbq': key already exists
                                    

                                    警告

                                    不要把钱包私钥通过任何形式的网络传输,包括但不限于微信,Telegram, 邮箱等方式。建议直接用 U 盘拷贝多份存放在不同的地方。

                                  2. 删除钱包私钥,切记删除私钥之后还要删除文件!!!

                                    # usage
                                    lotus wallet delete <address>
                                    # e.g
                                    lotus wallet delete f3xxxx
                                    # 删除钱包之后记得还要把钱包文件删除,文件在 LOTUS_PATH 目录下的 keystore 文件夹里面
                                    # 所有被删除的钱包地址,都是以 ORZGC43 开头的文件,你把这些文件全删了就 OK 了
                                    rm -rf $LOTUS_PATH/keystore/ORZGC43*
                                    

                                    警告

                                    wallet delete 命令并不会删除私钥文件,所以切记在使用命令删除私钥之后还需要手动删除私钥文件,否则一旦文件被盗,对方可以通过私钥文件恢复私钥!!!

                                  # 手动下载 proof 参数

                                  # 首先记得开启京东云的代理
                                  export IPFS_GATEWAY="https://proof-parameters.s3.cn-south-1.jdcloud-oss.com/ipfs/"
                                  # usage 
                                  lotus fetch-params --proving-params <sector_size>
                                  # e.g    
                                  lotus fetch-params --proving-params 32GiB  
                                  

                                  # lotus-miner 操作

                                  1. 查看矿工当前信息,包括算算力,山区密封情况

                                    lotus-storage-miner info
                                    Miner: t0109653
                                    Sector Size: 32 GiB
                                    Byte Power:   1.812 TiB / 4.888 PiB (0.0362%)
                                    Actual Power: 1.81 Ti / 4.73 Pi (0.0374%)
                                    	Committed: 1.844 TiB
                                    	Proving: 1.812 TiB (32 GiB Faulty, 1.69%)
                                    Expected block win rate: 6.4627/day (every 3h42m48s)
                                    
                                    Miner Balance: 128.044817705754006786
                                    	PreCommit:   0
                                    	Locked:      128.043278061722026245
                                    	Available:   0.001539644031980541
                                    Worker Balance: 49.947643260499744805
                                    Market (Escrow):  0.000000000000004064
                                    Market (Locked):  0.000000000000004064
                                    
                                    Sectors:
                                    	Total: 72
                                    	Proving: 58
                                    	PreCommit1: 12
                                    	PreCommit2: 1
                                    	SealPreCommit1Failed: 1
                                    

                                    这是我们自己测试矿工的 info,目前已经跑了 2 天了。这里大概解释一下各项数据的意思:

                                    • Byte Power: 已完成 Proving 的算力
                                    • Actual Power: 实际有效算力
                                    • Committed: 已完成 Commiting 的算力
                                    • 32 GiB Faulty: 被标记为 Faulty 扇区总大小,也就是无效算力。
                                    • Expected block win rate: 预期竞争出块胜出的概率,6.4627/day 标识平均每天可以出 6 个块。
                                    • Miner Balance: 当前挖矿收益(广大矿工最关注的)
                                    • Locked: 挖矿收益锁仓的份额(前期的收益几乎全部锁仓了)

                                    其他都是大家一眼都能看懂的,这里就不解释了。

                                  2. 质押扇区

                                    # 质押一个由随机数据填充的扇区(垃圾数据)
                                    lotus-miner sectors pledge
                                    
                                  3. 查看扇区状态

                                    # 列举所有扇区信息:
                                    lotus-miner sectors list
                                    # 查看某个扇区的当前状态
                                    lotus-miner sectors status <sector_id>
                                    # e.g
                                    lotus-miner sectors status 1
                                    # 查看 sector 详细日志
                                    lotus-miner sectors status --log 1
                                    
                                  4. 修改扇区的状态

                                    # usage 
                                    lotus-miner sectors update-state --really-do-it=true <sector_id> <state>
                                    # e.g
                                    lotus-miner sectors update-state --really-do-it=true 0 FailedUnrecoverable
                                    

                                    警告:

                                    update-state 需要谨慎操作,因为操作不当可能会发生一些难以预料的奇怪的错误。

                                  5. 删除扇区

                                    # usage
                                    lotus-miner sectors remove --really-do-it=true <sector_id>
                                    # e.g
                                    lotus-miner sectors remove --really-do-it=true 1
                                    

                                    警告:

                                    扇区一旦删除将不可恢复,请谨慎操作,以免误删。

                                  6. 设置订单价格:

                                    # usage
                                    lotus-miner deals set-ask --price=<val> --max-piece-size=<val>
                                    # e.g
                                    lotus-miner deals set-ask  --price='1000000' --max-piece-size=34359738368
                                    
                                  7. 查看 Worker 列表

                                    lotus-miner sealing workers
                                    

                                    查看当前 miner 任务调度列表

                                    lotus-miner sealing jobs
                                    

                                    如果你发现一个任务长时间没有完成(也许是 worker 掉线了),你可以使用下面的命令取消任务:

                                    # 终止指定的任务(通常用来处理长时间没有响应的任务)
                                    lotus-miner sealing abort <job-id>
                                    
                                  8. 增加存储路径

                                    # 设置数据存储路径,该路径用来存储最终密封好的数据
                                    # 执行该命令可能需要一点时间等待
                                    lotus-miner storage attach --store --init /path/to/persistent_storage
                                    
                                    # 设置密封扇区的存储路径,密封完成之后该路径下的数据会被自动清空,相当于临时目录
                                    # 执行该命令可能需要一点时间等待
                                    lotus-miner storage attach --seal --init /path/to/fast_cache
                                    

                                    以上两个命令都是在启动了 miner 之后才可以执行,是一种动态添加存储路径的方式,非常灵活。 你还可以在命令中添加权重 --weight=10,默认权重是 10。 执行该命令后,可通过以下命令查看存储列表:

                                    lotus-miner storage list
                                    

                                  # lotus-worker 操作

                                  启动 Worker 命令:

                                  # 启动 worker
                                  lotus-seal-worker run --address=192.168.1.100:2345 --precommit1=true --precommit2=false --commit=false
                                  # 打印当前 worker 信息
                                  lotus-worker info
                                  # 标记某个worker停止接单(做完当前的任务)
                                  lotus-worker set --enabled=false
                                  # 让某个 worker 重新接单
                                  lotus-worker set --enabled=true
                                  

                                  启动 worker 需要注意以下几点:

                                  1. 需要给 worker 指定一个在局域网可以访问的 IP 地址以及一个本机未被使用的端口。
                                  2. precommit1、precommit2 和 commit 默认是启用的,如果想要禁用,可以设置为 false
                                  3. 需要注意机器的内存与功能的划分,比如:
                                    • 如果你打算让当前 Worker 参与 P1,则至少需要 128GB 内存。
                                    • 如果你打算让当前 Worker 参与 P2,则至少需要 64GB 内存。
                                    • 如果你打算让当前 Worker 参与 C2,则至少需要 192GB 内存。

                                  # 订单操作

                                  1. 导入数据

                                    # usage
                                    lotus client import <file>
                                    # e.g
                                    lotus client import hello.txt
                                    Import 23, Root bafk2bzacebuc55ftl4c2m6h2ng3zx4eo6svtaivkl66xxopfermkhl3dwnypk
                                    
                                  2. 发送订单

                                    # usage
                                    lotus client deal <dataCid> <minerID> <price> <duration>
                                    # e.g
                                    lotus client deal bafk2bzacebuc55ftl4c2m6h2ng3zx4eo6svtaivkl66xxopfermkhl3dwnypk f09675 0.0000000005 518400
                                    # 成功之后会返回一个消息回执,类似下面这样:
                                    bafyreigw63qjia7dulwcn6d6fhlobhiewlvd4fsnpmbmdhvjszhzbeewjm
                                    

                                    矿工的信息可以通过下面的命令查询到:

                                    # usage
                                    lotus client query-ask <minerId>
                                    # e.g
                                    lotus client query-ask f09675
                                    

                                    输出信息:

                                    Ask: f09675
                                    Price per GiB: 0.0000000005 FIL
                                    Verified Price per GiB: 0.00000000005 FIL
                                    Max Piece size: 32 GiB
                                    

                                    <duration> 是指订单的有效期,单位是区块高度,也就是说多少个区块以后该订单失效。当前 duration 的最小值 51840,也就是说你最少要存半年。

                                  3. 查看订单状态,需要你提交订单时返回的交易回执

                                    # usage
                                    lotus client get-deal <CID>
                                    # e.g 
                                    gamma_lotus client get-deal bafyreigw63qjia7dulwcn6d6fhlobhiewlvd4fsnpmbmdhvjszhzbeewjm
                                    

                                    输出结果类似:

                                    {
                                    	"DealInfo: ": {
                                    		"ProposalCid": {
                                    		"/": "bafyreigw63qjia7dulwcn6d6fhlobhiewlvd4fsnpmbmdhvjszhzbeewjm"
                                    		},
                                    		"State": 26,
                                    		"Message": "unexpected deal status while waiting for data request: 11 (StorageDealFailing). Provider message: deal rejected: false\n",
                                    		"Provider": "f09675",
                                    		"DataRef": null,
                                    		"PieceCID": {
                                    		"/": "baga6ea4seaqgriqpswklnzyxxpnirxj37otzgfgpcwpksi2a3ttglxqap5tbsby"
                                    		},
                                    		"Size": 16256,
                                    		"PricePerEpoch": "500000000",
                                    		"Duration": 522292,
                                    		"DealID": 0,
                                    		"CreationTime": "2020-10-21T12:32:52.702939009+08:00",
                                    		"Verified": false
                                    	}
                                    }
                                    

                                    因为我当前这个矿工是拒绝接收非官方机器人以外的订单,所以你看到订单的状态是 rejected 被拒绝了。

                                  4. 列出当前节点所有订单

                                    lotus client list-deals
                                    

                                  # 手动终止 Faulty 的扇区

                                  你可能会遇到这种情况,有些错误扇区可能由于文件损坏了,一直恢复不了,结果在区块浏览器老是显示有几个错误扇区,这个时候你们老板说这样业务数据不好看,影响销售,让你把这几个错误扇区 抹掉。

                                  1. 编译 lotus-shed 工具

                                    cd <lotus-code-path>
                                    make lotus-shed
                                    
                                  2. 终止扇区

                                    先估算一下终止扇区需要支付多少币,然后确保你 Owner 钱包余额要大于这个值。

                                    export LOTUS_PATH=<lotus-path>
                                    export LOTUS_MINER_PATH=<lotus-miner-path>
                                    # usage
                                    ./lotus-shed sectors termination-estimate <Sector-IDS> # 可传入多个扇区 ID
                                    # e.g
                                    ./lotus-shed sectors termination-estimate 1 2 3
                                    

                                    然后再执行终止扇区操作:

                                    export LOTUS_PATH=<lotus-path>
                                    export LOTUS_MINER_PATH=<lotus-miner-path>
                                    # usage
                                    ./lotus-shed sectors terminate --really-do-it <Sector-IDS> # 可传入多个扇区 ID
                                    # e.g
                                    ./lotus-shed sectors terminate --really-do-it 1 2 3
                                    

                                  # 设置时区

                                  # 设置时区
                                  timedatectl set-timezone Asia/Shanghai
                                  # 设置硬件时间
                                  hwclock --hctosys
                                  # 同步时间服务器
                                  apt-get install ntpdate -y
                                  ntpdate -u cn.ntp.org.cn
                                  

                                  # RAID 操作

                                  1. 创建 RAID0 磁盘阵列

                                    mdadm -Cv /dev/md0 -a yes -n {num} -l 0 /dev/sda /dev/sdb /dev/sdc ...
                                    # {num} 是磁盘数量
                                    mdadm -Ds >> /etc/mdadm/mdadm.conf 
                                    
                                  2. 销毁 RAID0 阵列

                                    mdadm -S /dev/md0
                                    # 清楚超级块信息
                                    mdadm --zero-superblock /dev/sda 
                                    

                                  # LVM 操作

                                  1. 扩展 vg 大小

                                    # 直接扩展到指定的大小
                                    lvextend -L 1785G /dev/ubuntu-vg/ubuntu-lv
                                    # 增加容量
                                    lvextend -L +10G /dev/ubuntu-vg/ubuntu-lv
                                    
                                  2. 扩展文件系统大小

                                    resize2fs /dev/ubuntu-vg/ubuntu-lv
                                    
                                  3. 删除 LVM

                                    lvremove  <lvm-name>
                                    
                                  4. 强制删除 LVM,有时候删除的时候提示 Logical volume XXX is used by another device.,此时可以使用 dmsetup 命令来强制删除 LVM 分区

                                    # 列出 LVM 分区
                                    dmsetup ls
                                    # 强制删除指定的分区
                                    dmsetup remove /dev/xxx
                                    lvremove -f /dev/xxx
                                    # 删除所有的 LVM
                                    dmsetup ls |awk -F ' ' '{print $1}' |xargs dmsetup remove
                                    

                                  # 开启 CPU 性能模式

                                  # 查看当前cpu的状态:
                                  cpufreq-info
                                  
                                  # 把 cpu调整到性能模式:
                                  sudo cpufreq-set -g performance
                                  
                                  # 将所有的 CPU 全部调整到性能模式
                                  echo "performance" | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
                                  

                                  # 创建 swap 分区

                                  # 创建 swap 文件
                                  fallocate -l 16G /swap.img
                                  # 更改权限
                                  chmod 0600 /swap.img
                                  # 创建 swap 分区
                                  mkswap /swap.img
                                  # 挂载 swap 分区
                                  swapon /swap.img
                                  

                                  # 临时修改某个进程的 max open files 参数

                                  对于已经启动的 Miner 进程,如果发现在做时空证明的时候报 too many open files 错误,而此时如果你又不想重启 Miner 进程,可以使用下面方法动态配置。

                                  prlimit --pid <pid> --nofile=1048576:1048576
                                  

                                  # 磁盘检测工具

                                  可以检测磁盘型号,通电时间(新盘还是二手盘),以及坏道数据量等。

                                  apt-get install smartmontools -y
                                  # print all disk informations
                                  smartctl -A /dev/sda
                                  

                                  # 关闭系统软件更新

                                  sed -i 's/^[^\/].*distro_id*/\/\/&/g' /etc/apt/apt.conf.d/50unattended-upgrades
                                  

                                  # 原语云 lotus 运维

                                  我们对 Lotus 调度层代码(Golang)和底层(Rust)都进行了一些优化,可以大大提升算力机的封装效率, 提升 Miner 的稳定性和挖矿产出。 详情请阅读 原语云 Lotus 代码优化 (opens new window)


                                  华丽分界线, 以下操作只有使用原语云维护的 lotus 系列软件才支持


                                  # 动态设置 Miner 任务调度算法

                                  应用场景:默认所有的任务调度算法都是使用 Smart 智能调度策略,该策略会根据你 Worker 的最大任务数,以及你当前运行的任务数,以及 Prepare 任务数,assign 任务数等参数算出当前所有任务中最适合接这个任务的 Worker。

                                  但是有些时候你可能需要临时切换到其他算法,比如你所有算力机器的性能都差不多的话,你可以会更倾向于使用轮询调度算法(round_robin)。 下面命令把 PC1 的调度算法设置为轮询调度策略:

                                  # 获取当前所有任务调度算法
                                  yy_lotus-miner sealing config list
                                  # 设置某中类型任务的调度算法
                                  yy_lotus-miner sealing config set --key=P1 --val=round_robin
                                  

                                  # 设置 Worker 运行参数

                                  1. 设置某台 Worker 任务数量,如把某台 Worker PC1 任务的并行数调整为 10:

                                    # usage
                                    yy_lotus-miner sealing worker set --key=MaxPreCommit1Num --val=10 --wid=<Worker-ID>
                                    # e.g
                                    yy_lotus-miner sealing worker set --key=MaxPreCommit1Num --val=10 --wid=23592e59-5524-4fa8-b494-8f76e6d9a9bc
                                    
                                  2. 设置某台机器暂停接新的任务,并把手头上的任务先做完:

                                    yy_lotus-miner sealing worker set --key=status --val=pause --wid=<Worker-ID>
                                    
                                  3. 设置某台暂停的机器重新接任务:

                                    yy_lotus-miner sealing worker set --key=status --val=running --wid=<Worker-ID>
                                    
                                  4. 故障机器下架维护,不再给它调度任务,也不再给他发心跳:

                                    yy_lotus-miner sealing worker set --key=status --val=exit --wid=<Worker-ID>
                                    

                                    以下是证明 Worker 参数设置操作

                                  5. 使用方法:

                                    yy_lotus-miner proving worker set --wid=<Worker-ID> --key=<key> --val=<value>
                                    
                                  6. 关闭某个证明 Worker 的时空证明计算功能

                                    yy_lotus-miner proving worker set --wid=<Worker-ID> --key=WindowWorker --val=false
                                    
                                  7. 设置某个证明 Worker 在进行时空证明计算的时候,一次最多批量计算的 Partition 数量。假如你有 15PiB 的算力, 那么每个 Deadline 应该有 5 个 Partition,此时你一台证明 Worker 可能不足以在规定的时间内完成所有 Partition 的时空证明计算, 这时你可以准备两台证明 Worker,每台计算 3 个 Partition 的时空证明。

                                    yy_lotus-miner proving worker set --wid=<Worker-ID> --key=BatchPartitions --val=3
                                    

                                  # 设置存储运行参数

                                  在 v1.14.1 版本之前,如果你想要修改存储设备的属性,需要修改对应存储目录的 sectorstore.json 文件,然后要重启 Miner 才能生效。 在 v1.14.1 版本之后,我们新增了 yy_lotus-miner storage set 命令行工具,允许你动态设置某个存储设备的参数而不需要重启 Miner,实时生效。

                                  比如,你的某个存储设备已经快存满了,你想把该存储设为只读,你可以通过执行下面的命令实现:

                                  # usage
                                  yy_lotus-miner storage set --really-do-it=true --store=false <Storage-ID>
                                  # e.g
                                  yy_lotus-miner storage set --really-do-it=true --store=false 408088fc-29ec-4cb9-9480-9539042b658e 
                                  

                                  # 动态配置 Worker 运行状态

                                  1. 设置某台机器暂停接新的任务,并把手头上的任务先做完:

                                    lotus-miner worker set --key=status --val=pause --wid=<Worker-ID>
                                    
                                  2. 设置某台暂停的机器重新接任务:

                                    lotus-miner worker set --key=status --val=running --wid=<Worker-ID>
                                    
                                  3. 故障机器下架维护,不再给它调度任务,也不再给他发心跳:

                                    lotus-miner worker set --key=status --val=exit --wid=<Worker-ID>
                                    

                                  # 手动声明扇区

                                  以下场景可能需要手动声明扇区位置:

                                  1. 部分 FinalizeFailed 的扇区。
                                  2. FinalizeSector 成功了,但是 yy_lotus-miner proving check 又提示 can not cache/sealed path,导致时空证明过不了,掉算力。

                                  此时我们可以手动完成 FinalizeSector 过程:

                                  1. 首先找到扇区文件在哪个机器上(假设扇区 ID 为 100, Miner ID 为 f01000):

                                    yy_lotus-miner storage find 100
                                    

                                    如果找不到的话,可以通过 【任务面板】 批量推送脚本到所有的 Worker 执行:

                                    ls -ld /yuanyu/lotus-p1-worker/data/cache/s-t01000-100
                                    ls -ld /yuanyu/lotus-p1-worker/data/sealed/s-t01000-100
                                    
                                  2. 手动拷贝扇区到你的扇区存盘路径,假设为 /data01,扇区所在 Worker 机器 IP 为 192.168.1.100

                                    scp -r root@192.168.1.100:/yuanyu/lotus-p1-worker/data/cache/s-t01000-100 /data01/cache
                                    scp -r root@192.168.1.100:/yuanyu/lotus-p1-worker/data/sealed/s-t01000-100 /data01/sealed
                                    
                                  3. 手动申明扇区,假设 /data01/sectorstore.json 文件对应的 Storage ID 为: e0d9481a-3d85-4464-8f0d-2af9a5c755d1

                                    # 声明 cache 文件
                                    yy_lotus-miner storage declare-sector --really-do-it=true --type=cache 100 e0d9481a-3d85-4464-8f0d-2af9a5c755d1
                                    # 声明 sealed 文件
                                    yy_lotus-miner storage declare-sector --really-do-it=true --type=sealed 100 e0d9481a-3d85-4464-8f0d-2af9a5c755d1
                                    
                                  4. 同时,你需要删除错误的 storage 声明(如果有的话)。

                                    yy_lotus-miner storage drop-sector --really-do-it=true --type=cache <SectorNumber> <Storage-ID>
                                    # 如果你想删除当前扇区在所有设备上的存储索引的话,你可以使用 --auto 参数
                                    yy_lotus-miner storage drop-sector --really-do-it=true --type=cache --auto=true <SectorNumber>
                                    

                                  # 重新初始化矿工

                                  如果你不小心手贱删除了 lotus-miner 的 datastore 文件夹,又无法恢复的话,那么大概率你的 Miner 是无法启动了,此时你需要重新初始化 Miner 。具体操作步骤如下:

                                  1. 重新声明 Miner PeerID,并生成 Miner 的初始化目录和文件。如果你当初创建 Miner 之后有备份 $LOTUS_MINER_PATH(默认 .lotusminer) 目录,那么你可以直接跳过此步骤。 假设你的 Owner 钱包地址为 f0xxxx, Miner ID 为 f01000:
                                    yy_lotus-miner init --owner=f0xxxx --actor=f01000 
                                    
                                  2. 按照你原来 Miner 配置重新修改配置文件 (config.toml,storage.json 等),并启动 Miner。
                                  3. 找到你的所有 Proving 扇区的最大扇区编号,这里假设为 9999,将当前 Miner 的 Next Sector ID 设置为 9999,这样继续做 AP 的时候扇区 ID 就会从 10000 开始,而不是从 0 开始。
                                    yy_lotus-miner sectors counter set --really-do-it=true 9999
                                    

                                  # 时空证明异常排查

                                  集群掉算力的排查流程如下:

                                  1. 检查 Miner GPU,网络是否工作正常。

                                  2. 检查 daemon 的同步是否正常。

                                  3. 检查网络挂载存储(NFS,Ceph等)能否正常访问,这里注意,是要 “能正常访问文件” 而不是挂载正常就行了。

                                  4. 检查 Miner 的日志,寻找最近一次 "computing window post" 和 "Submitted window post" 日志,前者是时空证明有没有做完以及做完的时间,时间大于 1600 秒的话通常都是有问题的,后者是看时空证明提交是否提交成功,如不成功爆什么错误。

                                  5. 检查一下是哪个 Partition 掉算力。

                                    yy_lotus-miner proving deadlines
                                    

                                    然后 check 一下当前序号的 partition ,一下扇区文件是否能找到:

                                    yy_lotus-miner proving check --only-bad 12
                                    

                                    如果返回为空的话,那说明你的扇区文件都是存在的,只是在做时空证明的时候由于某些原因(比如网络中断)没有完成正常读取,这种扇区等下此时时空证明自然会恢复的。 如果下次还是没有恢复的话,那就可能是扇区文件被损坏了,如果数量比较少(几个)的话,建议你直接 terminate 扇区算了,多的话,就要想办法修复数据了。

                                  # 爆块证明异常排查

                                  首先声明一下,我们这里说的集群爆块是否有异常,本质上是在说这个集群有没有丢快, 也就是说选中你出块了,但是有个各种原因你没有再规定的时间内正确提交 WinningPost, 导致这个丢失了,被别人抢走了。至于为什么没有选中你,这个不在我们的讨论范围之内。

                                  # 爆块流程

                                  我们需要先了解一下一轮成功的爆块要经过哪些环节(整个出块的时间只有 30 秒):

                                  1. 网络节点通过链上选举选中你作为下一个区块的生产者,这一步没有操作的空间,只能听天由命,唯一增加选中概率的办法就是增加算力。
                                  2. 选举完成并将结果同步到你的节点,这个时间通常为 6 秒,如果你同步延时,花了十几二十秒,那么丢快的概率将大大提升。
                                  3. 开始计算 WinningPost,这个时间通常在1-5秒,如果此时存在 GPU 资源竞争的话,通常都超过 30 秒了,没戏了。
                                  4. 将 WinningPost 结果上链,如果此时你的节点同步不正常的话,这将是致命的问题。

                                  # 排查流程

                                  1. 查找爆块的 Warmup 日志。Miner 在启动时候会做一次"热身 WinningPoSt",也就是测试下 Miner 的 WinningPoSt 功能是否正常。 你需要检查一下热身的结果:

                                    grep 'winning PoSt warmup successful' /yuanyu/lotus-miner/log/error.log 
                                    # 输出应该类似这样:
                                    winning PoSt warmup successful  {"took": 3.475028433}
                                    

                                    一般来说,winning PoSt 的时间不超过 10s。

                                  2. 通常 Miner 会持续输出 completed mineOne 的日志,每隔 30 秒输出一次。如果某条 completed mineOne 日志中出现了,"isWinner": true 这样的日志的话,那么通常就是你获得了一次爆块的机会。

                                    还有几个参数需要留意一下:

                                    参数名 说明
                                    baseDeltaSeconds: 执行 mineOne 的时间与 MiningBase 的 TipSet 时间差,通常这个值是 6s。
                                    nullRounds: mineOne 轮空的次数,通常为 0,如果链同步滞后的话,这个值就会大于 0。
                                    lateStart: mineOne 是否启动延时了,正常情况下为 false,抛开轮空的因素,如果 baseDeltaSeconds 大于 6s 的话,lateStart 就会变成 true。

                                    如果 lateStart 为 true 的话, mineOne 这个函数就会打印警告日志,你需要关注一天当中警告日志的条数,通常 20 条以内的话,属于比较正常的水平,如果太多的话就需要重点排查一下原因。

                                    # 统计警告日志条数,<date> 表示日期
                                    grep 'mineOne' error.log |grep 'WARN' |grep <date> |wc -l 
                                    # e.g 统计 2022-02-15 警报日志条数
                                    grep 'mineOne' error.log |grep 'WARN' |grep '2022-02-15' |wc -l
                                    
                                  3. 如果你在日志中看到类似 CAUTION: block production took longer than the block delay 或者 failed to create block 的日志,那么很遗憾,你丢了一个块,如果有很多这种日志的话,那么情况就比较糟糕了,你应该做点什么来杜绝这种现象发生。

                                  # 参考链接

                                  • 原语云 lotus 基础运维手册 (opens new window)
                                  • https://docs.filecoin.io/ (opens new window)
                                  • https://filecoin.filgo.info/ (opens new window)

                                  本站博文如非注明转载则均属作者原创文章,引用或转载无需申请版权或者注明出处,如需联系作者请加微信: geekmaster01

                                  Filecoin 技术选型系列2 - 存储选型 大话 Filecoin 之前世今生