hackerbs's Blog

随笔 - 《我始终是我》

2026-07-18T00:00:00.000Z

《我始终是我》

上一篇文章里，我讲了一套很冷的东西。重量、杠杆、交易、破圈——听起来像一台精密运转的机器。有人可能会觉得，这个人是不是太理性了，是不是把一切都算得太清楚了，是不是已经把自己活成了一个算法。

不是。

所以这篇文章，我想讲讲框架之下的那个人。

我确实热衷于拆解世界。GPU 集群怎么互联、IPO 招股书里的商业模式怎么运转、社会资源怎么流动、人脉的本质是什么——我看到任何复杂的东西，第一反应都是：它的底层逻辑是什么？它为什么会是这个样子？既然它是人制造出来的，那我就应该能理解它。

这是我的乐趣所在。我不满足于”它很厉害”这种模糊的评价，我要知道它厉害在哪，为什么能成立，以及这个逻辑能不能被我用在自己身上。

但这种拆解世界的冲动，并没有把我变成一个冷血的人。

我会在网络上刷到一个陌生人受苦的视频，沉默很久。我会因为路边一朵桂花被雨打落满地，站在那儿看半天，然后写”百年古树千年朽木，十里繁荣万里荒芜”。我会在看到国际新闻里某些无力改变的事情时，心里堵着，说不出来。

我没有关掉我的感性。我只是给它画了一条边界。

这条边界是：我的情绪和共情能力，只分配给那些我力所能及的事情。

听起来像一种冷漠。但恰恰相反——这是一种保护。如果我每天对世界上的每一件苦难都倾注全部情感，我会被压垮。不是因为我不行，是因为任何人都不行。人类的共情能力是一种有限资源，像体力一样，会耗尽。心理学管这个叫”同情疲劳”——长期沉浸在无法改变的苦难中，人会从共情变为麻木。

我不允许自己麻木。所以我做了选择：我能帮的，我尽全力；我帮不了的，我承认，然后暂时放下。

这不是”不在乎”。这是先让自己足够强，再回来面对那些我现在还扛不动的东西。

很多人以为，像我这样一天到晚想着”重量””杠杆””涟漪”的人，一定活得很紧绷、很累、很焦虑。

不是的。

我是一个会摆烂的人。我会刷一天抖音，打一整天游戏，什么都不想，什么都不做。但我不会因为摆烂而愧疚。因为我心里清楚：我远期的方向没有变，我今天躺平，不代表我迷失了。我只是在休息，不是在放弃。

这个区别很重要。

很多人摆烂之后会陷入自责——“我又浪费了一天””我怎么这么不自律””我是不是根本不够努力”。这种自责本质上是因为你没有一个锚。你不知道自己要去哪，所以每一分钟的偏离都会让你恐慌。但如果你有方向——一个真正想清楚了的、长期的方向——那短暂的偏离就不是迷失，是休整。

方向感比执行力更稳定。执行力会波动，方向不会。

这就是我这几年建立起来的松弛感。松弛不是因为不在乎，是因为我知道自己在哪条路上。走快走慢不是问题，只要方向对。

还有一个我想说的。

这套”重量-杠杆”的思维模型，只是我个人打磨出来的。但我不希望读者把它当成一个”人生公式”去套。因为没有一个模型能解释全部的人生。

纯粹理性的逻辑思维能分析商业，但它分析不了为什么一个母亲会在深夜给孩子掖被角。

纯粹理性的逻辑思维能拆解人脉的本质，但它拆解不了人为什么会在雨天的桂花树下站一整个黄昏。

纯粹理性的逻辑思维能用来优化我自己的成长路径，但当我的理性触达边界——碰到那些怎么想也想不通的东西——我会停下来。托靠于Allah。承认自己的有限。

这听起来矛盾：一个用逻辑拆解一切的人，同时也是一个信Allah的人。但在我看来，这两者恰恰构成一个完整的闭环：

穷尽理性，承认边界，交托信仰。

这不是分裂，这是自知。

这篇文章没有方法论，没有框架图，没有”第一步第二步第三步”。

它只是一份诚实的自述。

我是一个理性的人，但我没有抛弃感性。我是一个拆解系统的人，但我承认系统的边界。我会因为远方的苦难感到无力，但我选择聚焦于眼前能改变的事情。我会摆烂、会偷懒、会刷一天抖音什么都不做，但我清楚地知道我明天要去哪。

我的理想和道路，充满了冷静的解构和计算。但驱动这一切向前走的那个东西——不是理性。

是雨中的桂花。是陌生人的眼泪。是不愿意再做一个无能为力的旁观者的那种决心。

我自始至终都是我。

浮尘落尽后的清醒，没有让我冷漠。破局的物理学，没有让我变成机器。我依然会哭，会笑，会在某些瞬间停下来，认真地看着这个世界，然后对自己说——好的，继续走吧。

无论世界如何复杂，我始终是我。
无论世界如何苦难，我托靠真主。
即使世界终将毁灭，那便回归主。

I Have Always Been Myself

In the previous essay, I laid out something very cold. Weight, leverage, transactions, breaking out of one’s circle—it sounds like a precision machine running at full tilt. Some might wonder: is this person too rational? Does he calculate everything too clearly? Has he turned himself into an algorithm?

No.

So in this essay, I want to talk about the person beneath the framework.

I am indeed obsessed with taking the world apart. How GPU clusters interconnect, how the business model inside an IPO prospectus operates, how social resources flow, what the essence of personal connections really is—whenever I see anything complex, my first reaction is: what is its underlying logic? Why is it the way it is? Since it was built by humans, I ought to be able to understand it.

This is where my joy lies. I am not satisfied with a vague verdict like “it’s impressive.” I want to know precisely what makes it impressive, why it holds together, and whether that logic can be used on myself.

But this urge to dismantle the world has not turned me into a cold-blooded person.

I will come across a video of a stranger suffering and sit in silence for a long time. I will see a roadside osmanthus beaten to the ground by the rain, stand there watching it for ages, and then write: “A tree may stand a hundred years, yet becomes rotten wood across a thousand; ten miles of prosperity, ten thousand miles of desolation.” When I see things in the international news that I am powerless to change, something presses on my chest and I cannot put it into words.

I have not switched off my sensitivity. I have only drawn a boundary around it.

The boundary is this: my emotions and my capacity for empathy are given only to what lies within my power to affect.

It sounds like a kind of coldness. But it is exactly the opposite—it is a form of protection. If I poured all my feeling into every suffering in the world each day, I would be crushed. Not because I am incapable, but because no one is capable of it. Human empathy is a finite resource, like physical strength—it can be exhausted. Psychology calls this “compassion fatigue”: immersed for too long in suffering one cannot change, a person slides from empathy into numbness.

I will not allow myself to go numb. So I have made a choice: what I can help, I help with everything I have; what I cannot help, I acknowledge, and then set it down for now.

This is not “not caring.” It is making myself strong enough first, and then coming back to face the things I cannot yet carry.

Many people assume that someone like me, thinking about “weight,” “leverage,” and “ripples” all day long, must live in a state of constant tension, exhaustion, and anxiety.

Not so.

I am someone who slacks off. I can scroll Douyin for an entire day, play games all day long, think about nothing, do nothing. But I do not feel guilty about slacking off. Because I know clearly in my heart: my long-term direction has not changed. That I lie flat today does not mean I am lost. I am resting, not giving up.

That distinction matters.

Many people fall into self-reproach after slacking off—“I wasted another day,” “Why am I so undisciplined,” “Maybe I’m simply not hard-working enough.” At bottom, this self-reproach comes from having no anchor. You do not know where you are going, so every minute of deviation throws you into panic. But if you have a direction—one you have genuinely thought through, a long-term direction—then a brief detour is not being lost. It is regrouping.

A sense of direction is steadier than execution. Execution fluctuates; direction does not.

This is the ease I have built up over the past few years. Ease is not because I do not care. It is because I know which road I am on. Whether I walk fast or slow is not the problem—so long as the direction is right.

One more thing I want to say.

This “weight–leverage” mental model is something I hammered out for myself alone. But I do not want readers to treat it as a “life formula” to apply. Because no single model can account for an entire life.

Purely rational, logical thinking can analyze business, but it cannot explain why a mother tucks the blanket around her child in the middle of the night.

Purely rational, logical thinking can take apart the essence of personal connections, but it cannot account for why a person would stand beneath an osmanthus tree in the rain for an entire evening.

Purely rational, logical thinking can be used to optimize my own path of growth—but when my reason reaches its boundary, when it runs into what cannot be thought through no matter how hard I try, I stop. I entrust myself to Allah. I acknowledge my own limits.

This may sound contradictory: a person who dismantles everything with logic is also a person who believes in Allah. But to me, these two form precisely one complete loop:

Exhaust reason, acknowledge the boundary, entrust it to faith.

This is not a split. This is self-knowledge.

This essay has no methodology, no framework diagram, no “step one, step two, step three.”

It is only an honest account of myself.

I am a rational person, but I have not abandoned my sensitivity. I am someone who dismantles systems, but I acknowledge the limits of systems. I feel powerless before suffering in distant places, but I choose to focus on what I can change right in front of me. I slack off, I get lazy, I can scroll Douyin all day doing nothing—but I know clearly where I am going tomorrow.

My ideals and my path are filled with cold dissection and calculation. But the thing that drives all of it forward—is not reason.

It is the osmanthus in the rain. It is the tears of strangers. It is the resolve never to be a powerless bystander again.

I have, from beginning to end, always been myself.

The clarity after the floating dust settled did not make me cold. The physics of breaking through did not turn me into a machine. I still cry, still laugh, still stop at certain moments to look earnestly at this world, and then say to myself—alright, keep going.

However complex the world may be, I remain myself.
However full of suffering the world may be, I place my trust in Allah.
Even if the world is doomed to perish, then I return to the Lord.

随笔 - 《破局的物理学：重量、杠杆与涟漪》

2026-07-05T00:00:00.000Z

《破局的物理学：重量、杠杆与涟漪》

成年人的世界里，一切关系本质上都是交易。

这话不好听。但它让我站起来了。

很长一段时间我活在一种撕裂里。一边是浮尘落尽后的清醒——知道那些百年基业、名门望族，拉长到千年尺度不过朽木一堆；一边是眼睁睁看着别人在往上走，自己却连”破圈”的踏板都摸不到。

我试过焦虑，没用。我试过混圈子，更没用。没有东西能给别人的人，站在谁身边都是空气。

后来我停止向外找答案，开始向内搭模型。我反复问自己一个问题：我能提供什么？不能提供任何东西的人，凭什么让别人把资源给你？

答案在物理里。

重量

重量是你的硬通货。你的技能、你的成果、你用时间验证过的不可替代性。

这玩意骗不了人。你有没有重量，上手一试就知道。你可以吹一万个字，但一个项目砸下来，重量为零的人瞬间透明。

怎么积累重量？四个字：努力、沉淀、勤奋、不急躁。

这四个字单独看像鸡汤，但真正做过事的人知道它的真正含义——把眼前每一件小事做到超出预期。不是为老板，不是为领导，是为自己。因为每一件被做到极致的事，都会变成你的履历上一条无法被抹去的刻度。重量是堆出来的。跳槽堆不出来，混日子堆不出来。

没有重量的人，所有的”向上社交”都是自己骗自己。

杠杆

有重量，你能站在地上。但同等重量的两个人，撬动的世界可以天差地别。差在哪？

杠杆。

杠杆是你的认知、你的思维框架、你的信息差。

大多数人对认知提升的理解还停留在”多读书”。这太浅了。认知提升不是你读了多少本，而是你能不能看到别人看不到的底层结构。

拉长杠杆的方式除了读人物传记外，还可以读 IPO 招股书。

传记不是看故事，是看高手在命运交叉口的决策逻辑。那些瞬间里藏着一个人全部的认知框架，你可以直接拿过来装进自己的系统。

IPO 招股书是商业世界里最没水分的认知提纯。一份材料翻开，这家公司怎么赚钱、行业的底线在哪、市场如何运转，全在纸上。别人真金白银验证过的商业真相，你花几个小时就能看完。绝大多数人一辈子不会翻开一份招股书。你翻了，你的杠杆就比他们长了一截。

破圈

重量有了，杠杆有了，你就可以谈”人脉”了。

但人脉这个词已经被用烂了。太多人把它想象成”关系彩票”——偶遇一位大佬，对方一眼看中你的才华，从此平步青云。这不是人脉，这是幻想。

人脉不在圈子里，在你身边。

家庭资源好的人，家人朋友就是人脉。学历背景强的人，老师同学就是资源。如果你和我一样，什么都没有——你的直属领导、你的老板，就是你天然的人脉。 他们已经用结果证明了自己的成功，你要做的不是满世界找伯乐，而是成为他们手里最锋利的兵。

但这里有一个致命的顺序问题：不是先有人脉，再有能力。是先有能力，才有人脉。你不要去”找”人脉，你要让自己成为别人想资源的那个人。当你的重量足够沉、你的杠杆足够长，人脉会自己来找你。

而当你站到他们面前的时候，记住一件事：你不是去乞讨的。

你是去提供交易的选项。告诉对方”我能给你什么”，而不是”我需要你什么”。这是尊严。这是你多年努力堆出来的重量，赋予你的资格。

方向

重量和杠杆回答了”怎么走”。但它回答不了”往哪走”。

这是我自己花了最长时间才想明白的问题。我建了这个模型，把刀磨得锋利，把认知拉得深远，积累出了足够沉甸甸的重量——但然后呢？我撬动世界以后，往什么方向撬？

我给出的答案是这样的。

2020 年的一个雨天，我下班途中看着桂花被雨打落满地，写下了”百年古树千年朽木，十里繁荣万里荒芜”。那时候我以为自己看透了——繁荣是假的，基业是虚的，一切都是浮尘。但那个视角漏掉了一个关键问题：如果我对这个世界的态度仅仅停留在”看透”，那我就只是一个清醒的旁观者。清醒地看着世界塌陷，什么都不做——这恰恰是另一种形式的麻木。

我不愿意做旁观者。

所以我又写了 2025 年的那篇——《存在的痕迹，不在于石碑，而于涟漪》。石碑再好，终将风化。但你作为一颗石子砸向水面时激起的涟漪——你改变过的人、你传递出去的力量、你在这个世界上砸出来的动静——会一层一层扩散，永远荡漾下去。

这，大概就是方向。

我不是为了革命，不是为了改变全世界。但如果前行路上，我足够强大了，能顺手拉起身边跌倒的一个人——那我活过。如果涟漪够远，能传递到我看不见的地方——那我没白活。

浮尘落尽之后，石碑终成朽木，而涟漪不息……

The Physics of Breaking Through: Weight, Leverage, and Ripples

In the adult world, every relationship is, at bottom, a transaction.

That is not a pleasant thing to say. But it is what got me back on my feet.

For a long time I lived inside a tearing. On one side was the clarity after the floating dust settles—knowing that those century-old foundations and great families, stretched across a thousand years, are nothing but rotten wood. On the other side was watching other people climb upward while I could not even touch the stepping stone to break out of my circle.

I tried anxiety. Useless. I tried working the circles. Even more useless. Someone who has nothing to offer is like thin air, no matter who he stands beside.

Later I stopped searching outward for answers and started building the model inward. I asked myself one question over and over: What can I offer? What right does a person who can offer nothing have to expect others to hand their resources to him?

The answer lies in physics.

Weight

Weight is your hard currency. Your skills, your results, your irreplaceability as tested by time.

This cannot be faked. Whether you have weight becomes clear the moment you are put to the test. You can talk up ten thousand words, but the instant a project lands on you, someone with zero weight turns transparent.

How do you accumulate weight? Four words: effort, accumulation, diligence, patience.

Read separately, these four words sound like chicken soup for the soul—but anyone who has truly done the work knows what they really mean: do every small thing in front of you beyond what is expected. Not for the boss, not for the manager—for yourself. Because every thing carried to its utmost becomes a mark on your record that cannot be erased. Weight is piled up. Job-hopping cannot pile it up. Coasting through your days cannot pile it up.

For someone with no weight, all “upward networking” is nothing but deceiving oneself.

Leverage

With weight, you can stand on the ground. But two people of equal weight can move worlds of vastly different size. Where does the difference lie?

Leverage.

Leverage is your cognition, your mental frameworks, your information asymmetry.

Most people’s understanding of raising their cognition still stops at “read more books.” That is far too shallow. Raising cognition is not about how many books you have read—it is about whether you can see the underlying structures that others cannot see.

Besides reading biographies, there is another way to lengthen the lever: read IPO prospectuses.

Biographies are not for the stories—they are for the decision logic of masters at the crossroads of fate. Those moments hold a person’s entire cognitive framework, and you can lift it straight out and install it into your own system.

An IPO prospectus is the most undiluted distillation of cognition in the business world. Open one document and it is all there on paper: how this company makes money, where the bottom line of the industry lies, how the market operates. Commercial truths that others have verified with real money—you can read through them in a few hours. The overwhelming majority of people never open a prospectus in their entire life. You did, and your lever is a notch longer than theirs.

Breaking Through

With weight and leverage in place, you can finally talk about “personal network.”

But that word has been used to death. Too many people imagine it as a “relationship lottery”—you chance upon a big shot, he recognizes your talent at a glance, and from then on everything rises smoothly. That is not a network. That is fantasy.

Your network is not out in the circles. It is right beside you.

For those with good family resources, family and friends are their network. For those with strong academic backgrounds, teachers and classmates are their resources. If you are like me and have none of that—your direct supervisor, your boss, is your natural network. They have already proven their success with results. What you need to do is not roam the world looking for a talent scout, but become the sharpest soldier they have.

But here lies a fatal question of order: it is not network first and ability second. It is ability first, then network. Do not go out to “find” a network—make yourself into the person others want to invest in. When your weight is heavy enough and your leverage long enough, the network will come looking for you.

And when you stand before them, remember one thing: you are not there to beg.

You are there to offer a transaction. Tell the other person “this is what I can give you,” not “this is what I need from you.” That is dignity. That is the qualification your years of effort, piled into weight, have earned you.

Direction

Weight and leverage answer the question “how to walk.” But they cannot answer “which way to walk.”

This is the question that took me the longest to work out. I built this model, sharpened the blade, drew my cognition deep, accumulated weight heavy enough—and then what? After I pry the world open, in which direction do I pry?

Here is the answer I arrived at.

On a rainy day in 2020, walking home from work, I watched osmanthus blossoms beaten to the ground by the rain and wrote: “A tree may stand a hundred years, yet becomes rotten wood across a thousand; ten miles of prosperity, ten thousand miles of desolation.” At the time I thought I had seen through everything—prosperity is false, foundations are hollow, all of it is floating dust. But that view left out one crucial question: if my attitude toward this world stops at “seeing through it,” then I am nothing more than a clear-eyed bystander. Watching lucidly as the world caves in and doing nothing—that is precisely another form of numbness.

I am not willing to be a bystander.

So I wrote that 2025 piece—“The Traces of Existence: Not in Stone Monuments, But in Ripples.” However fine a stone monument may be, it will weather away in the end. But the ripples you stir when you strike the water like a stone—the people you have changed, the strength you have passed on, the stir you have made in this world—will spread outward, layer by layer, and keep on rippling forever.

This, roughly speaking, is direction.

I am not here for revolution, not here to change the whole world. But if, on the road ahead, I become strong enough to pull up one person who has fallen beside me—then I have lived. If the ripples travel far enough to reach places I cannot see—then I have not lived in vain.

After the floating dust settles, the stone monument becomes rotten wood in the end, while the ripples never cease……

随笔 - 《存在的痕迹：不在于石碑，而于涟漪》

2025-10-17T08:15:00.000Z

观此视频有感

人为什么有虚岁因为妈妈比其他人单独的拥有了你一年

《存在的痕迹：不在于石碑，而于涟漪》

小时候我就在想——
人生的价值是什么？
是钱吗？是权吗？是骄奢淫逸吗？

那些生不带来、死不带去的东西罢了。

人生没多长，
人生不应该只是一场体验，
人生应该留下些什么，
人生应该有价值。

钱、权，这些终将在你死去的那一刻消散。
或许你为家人带来了财富，让他们享了福，
我不能说这没有价值，
但这还不够，远远不够。
五十年、百年之后，他们也会逝去，
你的存在，也将被慢慢淡忘。

如果这世间没有了你存在的痕迹，
那么，你在这个世界上真的活过吗？

年幼的我，怀揣着科研的梦想，
认为知识是宝贵的财富。
我曾以为，一切都是虚妄，
唯有将知识——这人类的瑰宝——传承下去，
让若干年、数十年之后，
还有人使用这些知识，
那便是人生价值的体现。

后来，时间冲刷着一切。
麻木、迷茫，混杂着泥沙一团糟的日子，
似乎，好像也就这样活一辈子了。

苦难是什么？
是肉体上的饥寒交迫吗？
确实，那也是苦难。
可最痛苦的折磨是什么呢？
是当我遇见像那个视频里一样的事情时，
什么都做不了——
没有能力伸出援手，
没有能力改变任何，
只能眼睁睁地看着一切发生。
那种精神上的撕裂与无力，
不就是最大的苦难吗？

我年幼时满怀希望，
以科研去证明人生价值。
后来才发现，这并不如我想象中那般简单。
那是一个遥远的理想。
不过，无需气馁，也无需放弃。
在前行的路上，
若能拉起身边跌倒的人，
那亦是值得的。

无论如何，
我不喜欢这种苦难。
我不喜欢清醒地看着一切坍塌，
连逃避都成了奢望。

也许，这就是活着的意义吧——
即使努力是一种痛苦，
那就让更大的痛苦逼着自己前进。
比苦难甜，就行了。

勿要，力不能挽流年，唯有目送山河倾——追悔莫及

The Traces of Existence: Not in Stone Monuments, But in Ripples

When I was young, I often wondered—
What is the value of life?
Is it money? Power? Debauchery?
But these are merely things we cannot bring with us at birth, nor take with us in death.

Life is not long.
Life should not be just an experience.
Life ought to leave something behind,
Life ought to have value.

Money, power—these will vanish the moment you die.
Perhaps you have brought wealth to your family, granted them comfort.
I cannot say this holds no value,
But it is not enough, far from enough.
Fifty years, a century later, they too will pass away,
And your existence will slowly fade from memory.

If no trace of you remains in this world,
Then, have you truly lived at all?

As a child, I cherished dreams of scientific research,
Believing knowledge to be a precious treasure.
I once thought that all else was illusion,
That only knowledge—this gem of humanity—passed down through generations,
So that years, decades later,
People would still make use of this knowledge—
That would be the manifestation of life’s value.

But as time washed over everything,
Numbness, confusion, and days muddled with chaos
Made it seem as if living out a lifetime this way was just how things were.

What is suffering?
Is it the pangs of hunger and cold?
Yes, that too is suffering.
But what is the most agonizing torment?
It is when I encounter situations like the one in that video,
And can do nothing—
Unable to reach out and help,
Unable to change anything,
Only able to watch it all unfold before my eyes.
That spiritual tearing and powerlessness—
Is that not the greatest suffering of all?

In my youth, I was full of hope,
Determined to prove life’s value through scientific research.
Only later did I realize it was not as simple as I had imagined.
It was a distant ideal.
Yet, there is no need for despair, no need to give up.
On the path forward,
If we can lift up those who have fallen beside us,
That too is meaningful.

No matter what,
I do not like this kind of suffering.
I do not like watching everything collapse with clear eyes,
Where even escape becomes a luxury.

Perhaps this is the meaning of living—
Even if effort is a form of pain,
Let a greater pain compel you to move forward.
As long as it is sweeter than the suffering, it is enough.

Do not let it be
That you lack the strength to hold back the flowing years, and can only watch the mountains and rivers fall—
Left with nothing but regret.

اللّٰهُ أَكْبَرُ

IT场景专业术语表

2025-10-17T05:45:45.000Z

用于各IT场景的专业术语的中英文对照

工单场景

英文	英文全称	中文	释义
TC	Ticket Created	新建工单	工单已在系统中被成功创建，并进入待处理队列
PR	Pending Report	等待报告	工单处理因等待（用户、第三方或系统提供的）额外信息、日志或报告而暂时挂起
SM	Self-Maintenance	自行维护	问题由用户自行解决或无需运维团队介入（如过保服务器），随后工单可被关闭
R	Resolved	已解决	问题已被运维团队成功修复，该工单处理完毕
IW	In Warranty	在保内	表示设备或服务处于保修期内，维修通常由供应商免费提供
OOW	Out of Warranty	已过保	表示设备或服务已超出保修期，维修通常需要付费
TPM	Third-Party Maintenance	第三方维保	表示设备由原厂之外的第三方服务商提供维护支持

日常运维场景

英文	英文全称	中文	释义
Ops Task Status Board	Ops(Operations )	运维任务状态看板	一个实时展示运维任务进度和状态的可视化看板

关于服务器硬盘故障但带外没有错误日志的排障与报修笔记

2025-09-18T07:49:46.000Z

情况说明

收到系统发出IO占用率和IO延迟的告警，登录带外排查无任何错误日志，随后进入操作系统使用脚本批量排查smartctl日志，发现存在错误计数，因smartctl并非厂家带外的告警日志，所以特此向Inspur、H3C、Lenovo、DELL进行了咨询，其中提到了一些日志参数的告警，目前已收到H3C、Inspur的回复

厂商对日志中以下内容的告警表示认可并作为报修依据

硬盘类型	参数	翻译	说明	来源
SSD	ID 5 Reallocated_Sector_Ct	重分配扇区计数	因坏块被重新分配的扇区数量，值越高健康状况越差	新华三
SSD	ID 197 Current_Pending_Sector	当前待处理扇区计数	有潜在读写错误、待重新映射的扇区数量(>100更换)	浪潮/新华三
SSD	ID 187 Reported_Uncorrect	已报告的不可纠正错误	硬盘向主机报告的读/写过程中发生的不可恢复错误次数(>10更换)	浪潮
HDD	Total uncorrected errors	总无法纠正错误	所有无法纠正的读/写错误之和	浪潮/新华三
HDD	Verify total uncorrected errors	校验无法纠正错误	硬盘控制器自检时无法通过ECC纠正的错误总数，高值表示可靠性下降	新华三
HDD	Read total uncorrected errors	读无法纠正错误	读取/写入IO时无法通过ECC纠正的错误总数，高值表示可靠性下降	新华三
HDD	Elements in grown defect list	已增长缺陷列表中的元素	硬盘运行中登记的坏块数量，用于追踪坏块增长	@Icenowy于清华TUNA协会技术群组内回复

以下是辅助日志，作为协助排障参考，不作为直接依据

硬盘类型	参数	翻译	说明	来源
SSD	Reallocated Sector Count	重分配扇区计数	记录因物理损坏被替换到备用扇区的次数，数值增加说明介质退化(>500为不可靠)	浪潮
SSD	CRC Error Count	CRC 错误计数	记录主机与硬盘之间传输数据时发生的 CRC 校验错误次数，常见原因包括数据线接触不良、电磁干扰或接口问题，单盘较多则可能为该盘本体故障，多个硬盘则进一步筛查是否位于同一个硬盘背板或同一个SAS端口	浪潮
HDD	Non-medium error count	非介质故障	与上方SSD的是一样的意思	浪潮

清华大学TUNA协会技术群组

感谢@Icenowy于清华TUNA协会技术群组内回复提出参考Elements in grown defect list参数的值，该值是HDD独有的指标，记录的是在使用过长中新发现的物理坏块数，数值持续增长则意味着该硬盘可靠性正在下降

排查过程

对于JBOD模式的硬盘

# 使用smartctl直接查询即可
smartctl -a /dev/sdX

# 可以增加grep快速筛选想要查询的参数，在替换双引号中的即可
smartctl -a /dev/sdX | grep -E "Elements in grown defect list"

# 配合for迅速遍历磁盘，{a..z}则是遍历sda到sdz的所有盘
# 如果盘很多那可以直接写为{a..zz}，则是遍历sda到sdzz共702个盘
# [ -b "/dev/sd$i" ] test命令的简写，判断该设备是不是一个硬盘
# echo "sd$i"是在输出日志前输出盘号，避免不知道是哪个盘的报错
for i in {a..z}; do [ -b "/dev/sd$i" ] && echo "sd$i:" && sudo smartctl -a "/dev/sd$i" | grep "Elements in grown defect list"; done

对于LSI MegaRAID控制器，RAID模式的硬盘

# 由于硬盘由阵列卡接管，所以需要调用MegaRAID驱动程序才可访问
# /dev/sdX输入你挂载到系统的阵列，例如通常/dev/sda是RAID1系统盘
# 其中megaraid,后面的数字对应该硬盘是该阵列中的第几个盘，从编号0开始是第一个
smartctl -a -d megaraid,0 /dev/sdX

# 同样的grep筛选
smartctl -a -d megaraid,0 /dev/sdX | grep -E "Non-medium error count"

# 遍历快速排查所有盘
for raid in {a..z};do [ -b "/dev/sd$raid" ] && for disk in {0..20};do echo -e "\033[36;1m阵列 sd$raid 中硬盘 $disk 日志: " && smartctl -a -d megaraid,$disk /dev/sd$raid | grep -E "Non-medium error count";done;done

# 上方命令为单行，方便复制粘贴执行，以下是拆解后可读的版本
for raid in {a..z}; do # 遍历sda到sdz的设备
    [ -b "/dev/sd$raid" ] && # 判断是不是硬盘，不是就跳过
    for disk in {0..20}; do # 预设是0到20共21个硬盘，可以自行设置
        echo -e "\033[36;1m阵列 sd$raid 中硬盘 $disk 日志: " # 打印个开头，不然不知道是哪个设备的日志
        smartctl -a -d megaraid,$disk /dev/sd$raid | grep -E "Non-medium error count" # 根据你的需要调整grep筛选的内容
    done
done

进阶脚本

该脚本会在当前目录输出smartctl的日志源码到disk_error_$(date +%Y%m%d_%H%M%S).log文件

推荐使用此单行模式，复制粘贴直接用，不需要创建shell文件

log_file="disk_error_$(date +%Y%m%d_%H%M%S).log"; for raid in {a..d}; do [ -b "/dev/sd$raid" ] && for disk in {0..23}; do smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1 && output=$(smartctl -a -d megaraid,$disk /dev/sd$raid) && serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}') && if echo "$output" | grep -q "SSD"; then reallocated_sectors=$(echo "$output" | grep "Reallocated_Sector_Ct" | awk '{print $10}'); reallocated_sectors=${reallocated_sectors:-0}; current_pending=$(echo "$output" | grep "Current_Pending_Sector" | awk '{print $10}'); current_pending=${current_pending:-0}; reported_uncorrect=$(echo "$output" | grep "Reported_Uncorrect" | awk '{print $10}'); reported_uncorrect=${reported_uncorrect:-0}; offline_uncorrect=$(echo "$output" | grep "Offline_Uncorrectable" | awk '{print $10}'); offline_uncorrect=${offline_uncorrect:-0}; crc_errors=$(echo "$output" | grep "CRC_Error_Count" | awk '{print $10}'); crc_errors=${crc_errors:-0}; [ "$reallocated_sectors" -gt 0 ] || [ "$current_pending" -gt 0 ] || [ "$reported_uncorrect" -gt 0 ] || [ "$offline_uncorrect" -gt 0 ] || [ "$crc_errors" -gt 0 ] && echo "$output" >> "$log_file" && echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n\033[36;1m05 重分配扇区计数(Reallocated Sector Count)：\033[31;1m$reallocated_sectors\033[0m\n\033[36;1m197 当前待处理扇区(Current Pending Sector Count)：\033[31;1m$current_pending\033[0m\n\033[36;1m已报告的不可纠正错误(Reported Uncorrectable Errors)：\033[31;1m$reported_uncorrect\033[0m\n\033[36;1m离线不可纠正错误(Offline Uncorrectable)：\033[31;1m$offline_uncorrect\033[0m\n\033[36;1m接口CRC错误计数(CRC Error Count)：\033[31;1m$crc_errors\033[0m\n"; else read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}'); read_uncorrected=${read_uncorrected:-0}; verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}'); verify_uncorrected=${verify_uncorrected:-0}; total_uncorrected=$(echo "$output" | grep "Total uncorrected errors" | awk '{print $NF}'); total_uncorrected=${total_uncorrected:-0}; grown_defect_list=$(echo "$output" | grep "Elements in grown defect list" | awk '{print $NF}'); grown_defect_list=${grown_defect_list:-0}; non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}'); non_medium=${non_medium:-0}; [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$total_uncorrected" -gt 0 ] || [ "$grown_defect_list" -gt 0 ] || [ "$non_medium" -gt 0 ] && echo "$output" >> "$log_file" && echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n\033[36;1m读无法纠正错误(Read total uncorrected errors)：\033[31;1m$read_uncorrected\033[0m\n\033[36;1m校验无法纠正错误(Verify total uncorrected errors)：\033[31;1m$verify_uncorrected\033[0m\n\033[36;1m总无法纠正错误(Total uncorrected errors)：\033[31;1m$total_uncorrected\033[0m\n\033[36;1m已增长缺陷列表元素(Elements in grown defect list)：\033[31;1m$grown_defect_list\033[0m\n\033[36;1m非介质错误(Non-medium error count)：\033[31;1m$non_medium\033[0m\n"; fi; done; done

#!/bin/bash

# 日志文件以日期时间命名
log_file="disk_error_$(date +%Y%m%d_%H%M%S).log"

# 遍历可能的RAID设备（sda, sdb, sdc, sdd）
for raid in {a..d}; do
    if [ -b "/dev/sd$raid" ]; then
        for disk in {0..23}; do
            if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then
                output=$(smartctl -a -d megaraid,$disk /dev/sd$raid)

                serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}')

                if echo "$output" | grep -q "SSD"; then
                    # ================= SSD =================
                    reallocated_sectors=$(echo "$output" | grep "Reallocated_Sector_Ct" | awk '{print $10}')
                    reallocated_sectors=${reallocated_sectors:-0}

                    current_pending=$(echo "$output" | grep "Current_Pending_Sector" | awk '{print $10}')
                    current_pending=${current_pending:-0}

                    reported_uncorrect=$(echo "$output" | grep "Reported_Uncorrect" | awk '{print $10}')
                    reported_uncorrect=${reported_uncorrect:-0}

                    offline_uncorrect=$(echo "$output" | grep "Offline_Uncorrectable" | awk '{print $10}')
                    offline_uncorrect=${offline_uncorrect:-0}

                    crc_errors=$(echo "$output" | grep "CRC_Error_Count" | awk '{print $10}')
                    crc_errors=${crc_errors:-0}

                    if [ "$reallocated_sectors" -gt 0 ] || [ "$current_pending" -gt 0 ] || \
                       [ "$reported_uncorrect" -gt 0 ] || [ "$offline_uncorrect" -gt 0 ] || [ "$crc_errors" -gt 0 ]; then
                        echo "$output" >> "$log_file"
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n"
                        echo -e "\033[36;1m05 重分配扇区计数(Reallocated Sector Count)：\033[31;1m$reallocated_sectors\033[0m"
                        echo -e "\033[36;1m197 当前待处理扇区(Current Pending Sector Count)：\033[31;1m$current_pending\033[0m"
                        echo -e "\033[36;1m已报告的不可纠正错误(Reported Uncorrectable Errors)：\033[31;1m$reported_uncorrect\033[0m"
                        echo -e "\033[36;1m离线不可纠正错误(Offline Uncorrectable)：\033[31;1m$offline_uncorrect\033[0m"
                        echo -e "\033[36;1m接口CRC错误计数(CRC Error Count)：\033[31;1m$crc_errors\033[0m\n"
                    fi
                else
                    # ================= HDD =================
                    read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}')
                    read_uncorrected=${read_uncorrected:-0}

                    verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}')
                    verify_uncorrected=${verify_uncorrected:-0}

                    total_uncorrected=$(echo "$output" | grep "Total uncorrected errors" | awk '{print $NF}')
                    total_uncorrected=${total_uncorrected:-0}

                    grown_defect_list=$(echo "$output" | grep "Elements in grown defect list" | awk '{print $NF}')
                    grown_defect_list=${grown_defect_list:-0}

                    non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}')
                    non_medium=${non_medium:-0}

                    if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || \
                       [ "$total_uncorrected" -gt 0 ] || [ "$grown_defect_list" -gt 0 ] || [ "$non_medium" -gt 0 ]; then
                        echo "$output" >> "$log_file"
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n"
                        echo -e "\033[36;1m读无法纠正错误(Read total uncorrected errors)：\033[31;1m$read_uncorrected\033[0m"
                        echo -e "\033[36;1m校验无法纠正错误(Verify total uncorrected errors)：\033[31;1m$verify_uncorrected\033[0m"
                        echo -e "\033[36;1m总无法纠正错误(Total uncorrected errors)：\033[31;1m$total_uncorrected\033[0m"
                        echo -e "\033[36;1m已增长缺陷列表元素(Elements in grown defect list)：\033[31;1m$grown_defect_list\033[0m"
                        echo -e "\033[36;1m非介质错误(Non-medium error count)：\033[31;1m$non_medium\033[0m\n"
                    fi
                fi
            fi
        done
    fi
done

输出效果如下

关于DELL TSR日志(iDRAC)没有硬盘故障告警的报修办法

DELL通常只认可其自身硬件的告警日志。
在硬盘出现非致命故障，无法直观的在操作系统看到硬盘离线或RAID降级，同时TSR日志中没有记录到硬盘故障，iDRAC网页也没有显示硬盘故障时。
DELL通常不会认可运维工程师提供的smartctl日志和其他非DELL硬件报告的日志，
且有时smartctl也并不能很好的定位故障。

为此和DELL进行漫长的沟通后，最终定下来以下排障方式：

带外由故障日志时：提供TSR日志报修
带外没有故障日志时：提供TSR日志+perccli64 /call show alilog的日志用于报修

此外还可通过分析上文提到的smartctl日志和以下日志用于综合定位问题：

1
2
3

ls -l /sys/class/block > /tmp/lsblock.txt
perccli64 /call show alilog > /tmp/target.txt
perccli64 /call/eall/sall show all > /tmp/slot.txt

以下是本次案例的记录，可以作为排障及报修的参考

情况说明：
本次是日常巡检时运维平台报障IO延迟大于100ms
随后排查了带外，没有告警，继续排查smartctl，定位slot8存在无法纠正的错误记录1次。
随后向DELL提出报修，并上传TSR日志，但因为没有记录告警，所以DELL并不认可，要求进一步调查故障。
排障过程中针对smartctl -a -d megaraid输出的Error counter log，也就是上文解释的smartctl日志；
其中有巨量的Errors Corrected by ECC的fast纠正错误计数，达到了1737961798次，
针对该项报错，DELL不参考，并且未对此进行分析，所以只能自行分析。
结合硬盘运行时间约5.8年，且几乎从未停机；而这份报错是由RAID卡报告给smartctl，
所以在计数准确性上无法验证，同时鉴于运行了很长时间，计数的累计也是可能的因素；
此处有个疑点：该天文数字般的ECC纠错计数是否可能是整个RAID5阵列的纠错被记录到了其中？
再加上硬盘存在故障长期未发现，导致了频繁的纠错？
以上两个疑问仅为猜测，不过该ECC纠错确实会导致IO延迟增加。
在进一步的排查中发现slot9才是故障盘，且其中的Errors Corrected by ECC的fast纠正为0，
反而是delayed纠正为8396次，因此进一步核实这块盘才是真正的故障盘。
因为fast纠正是常规现象，delayed纠正才是有可能存在问题的，delayed纠正是无法快速纠错时进行的深度纠错

见此处说明

接下来讲如何通过分析perccli64 /call show alilog定位到了真正故障的硬盘
首先，perccli64，顾名思义，这是DELL PERC官方的工具，用于操作DELL RAID卡。
因为日志内容较多，所以选择使用perccli64 /call show alilog > /tmp/target.txt查询适配器日志并输出到文件。
随后使用vscode浏览发现，在35200行日志中，光是PD02和PD09的timeout就出现了11938行，
因此该日志足以说明slot2和slot9这两个硬盘出现了故障，
并进一步结合smartctl日志交叉验证了这两块盘存在故障，也就是上文说的delayed的错误计数。
随后同时将TSR日志和perccli64的alilog适配器日志提交给DELL，DELL认可并以此作为依据成功报修。

# PD02的timeout
24368: YY-MM-DD HH:MM:SS WARNING:Command timeout on PD 02(e0x20/s2) Path 5000c500cdda6095, CDB: 2a 00 0f 1a ee 00 00 00 80 00
# PD09的timeout
2413: YY-MM-DD HH:MM:SS WARNING:Command timeout on PD 09(e0x20/s9) Path 5000c500cdd04681, CDB: 4d 00 4e 00 00 00 00 00 04 00

# 同时在这份日志顶部部分也输出了RAID控制器和磁盘的详情
# Device Information部分的Slot Number也对应了PD02 PD09

2025-10-16最新消息：DELL高级工程师驳回了维修请求

然后给出了下面两篇文章

PowerEdge：某些企业硬盘驱动器上读取和验证 ECC 错误的 SMART 错误率较高

ScaleIO 硬件感知功能填写 PERC 术语

故障盘PD 02/09

slot2、9: TOSHIBA AL14SXB30ENY

slot3-8、10-13: Seagate ST300MP0026

结合上面两篇文章和硬盘情况来看，确实，iDRAC没有报故障，同时smartctl和perccli64调查出所谓的”故障”，恰好是两块TOSHIBA的硬盘。
TOSHIBA的其他硬盘确实也被记录到了文章中，提到了会在perccli64中误报timeout，
结合smartctl记录的ECC纠错数量为天文数字，侧面反映了DELL所说的smartctlECC纠错计数不可靠也是事实。
目前看来，维修诉求被DELL工程师驳回也属于合理范围
且故障仅仅体现在运维监测平台告警IO延迟达到128ms，持续时间不足1分钟，随后恢复
故本次报障取消

补充：

该问题提交给了DELL客户经理

您好，我这边有台XXX PowerEdge XXX，在我们运维监控平台发现告警 IO延迟过高，触发时值: XXXms。
针对该告警我们筛查了TSR日志，并未发现告警记录；
进一步筛查了smartctl日志，发现PD 02/09存在 perccli64告警 Command timeout on PD 02/09；
且smartctl记录到ECC delayed纠正8XXX次。
目前工程师回复提到了smartctl日志错误率，对于某些企业的硬盘仅供参考，实际现象：
其他Seagate硬盘存在1X亿次ECC fast纠错计数，故我们忽略该告警。
故障的PD02/09为TOSHIBA，存在8XXX次 ECC delayed纠错计数，不过尚未出现无法纠错和扇区故障记录，我们暂时忽略。
工程师回复提到了perccli64日志告警timeout，文章解释为：
某个供应商的固态硬盘（SSD）不支持其中一个命令（cdb= 4d 00 51 00 00 00 00 00 00 04 00）
复查后发现，PD 02/09恰好是TOSHIBA的硬盘，且在文章中也有提到TOSHIBA的某个型号SSD不支持该命令，且其他Seagate硬盘均为记录该错误。
故我们根据文章内容，忽略该告警。
鉴于本次排障报修涉及的日志和排障过程较为繁琐，目前理清楚前因后果之后，XXX要求我询问下您，看看这次的报障是驳回继续观察，还是说直接安排更换？

目前尚未收到回复…

DELL服务器硬盘IO告警排障思路

2025-09-17T03:04:28.000Z

系统报IO告警，在带外无异常的情况下，在操作系统中进行排障

故障现象

监测平台报障IO占用率和延迟过高

初步排障

登录带外观察是否有故障日志，无论是否有故障日志，均需要进一步进行二次核对

JBOD直通无RAID排障

使用smartctl命令观察磁盘健康状态，网络上有大量教程，不再赘述

如果磁盘本身无故障，观察输出结果中的199 UltraDMA CRC Error Count这一行是否有记录，这是硬件通信错误的日志，如果有记录到纠正次数，那就说明发生了硬件连接的问题，如硬盘背板故障，连接线故障，接口松动等

批量排障命令参考

for i in {a..z}; do [ -b "/dev/sd$i" ] && echo "sd$i:" && sudo smartctl -a "/dev/sd$i" | grep "199"; done

RAID阵列模式排障

做了阵列的磁盘无法直接使用smartctl进行排障，需要改为smartctl -a -d megaraid,3 /dev/sdX的方式排障，megaraid,后面跟你的硬盘的编号，/dev/sdX则是对应这个阵列在系统中的编号

范例：

# raid5阵列，挂载为/dev/sdb
# 阵列中disk2存在故障
smartctl -a -d megaraid,2 /dev/sdb

# 批量查询所有阵列所有盘
# 其中a..d是用于遍历/dev/sda-d，根据你的阵列情况调整
# 其中0..10是用于遍历一个阵列下有多少个硬盘，根据你的阵列情况调整
for raid in {a..d};do for disk in {0..10};do smartctl -a -d megaraid,$disk /dev/sd$raid | grep -i "CRC\|Error";done;done

HDD SSD二合一版

该脚本会在当前目录输出smartctl的日志源码到disk_error_$(date +%Y%m%d_%H%M%S).log文件

推荐使用此单行模式，复制粘贴直接用，不需要创建shell文件

log_file="disk_error_$(date +%Y%m%d_%H%M%S).log"; for raid in {a..d}; do [ -b "/dev/sd$raid" ] && for disk in {0..23}; do smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1 && output=$(smartctl -a -d megaraid,$disk /dev/sd$raid) && serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}') && if echo "$output" | grep -q "SSD"; then reallocated_sectors=$(echo "$output" | grep "Reallocated_Sector_Ct" | awk '{print $10}'); reallocated_sectors=${reallocated_sectors:-0}; current_pending=$(echo "$output" | grep "Current_Pending_Sector" | awk '{print $10}'); current_pending=${current_pending:-0}; reported_uncorrect=$(echo "$output" | grep "Reported_Uncorrect" | awk '{print $10}'); reported_uncorrect=${reported_uncorrect:-0}; offline_uncorrect=$(echo "$output" | grep "Offline_Uncorrectable" | awk '{print $10}'); offline_uncorrect=${offline_uncorrect:-0}; crc_errors=$(echo "$output" | grep "CRC_Error_Count" | awk '{print $10}'); crc_errors=${crc_errors:-0}; [ "$reallocated_sectors" -gt 0 ] || [ "$current_pending" -gt 0 ] || [ "$reported_uncorrect" -gt 0 ] || [ "$offline_uncorrect" -gt 0 ] || [ "$crc_errors" -gt 0 ] && echo "$output" >> "$log_file" && echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n\033[36;1m05 重分配扇区计数(Reallocated Sector Count)：\033[31;1m$reallocated_sectors\033[0m\n\033[36;1m197 当前待处理扇区(Current Pending Sector Count)：\033[31;1m$current_pending\033[0m\n\033[36;1m已报告的不可纠正错误(Reported Uncorrectable Errors)：\033[31;1m$reported_uncorrect\033[0m\n\033[36;1m离线不可纠正错误(Offline Uncorrectable)：\033[31;1m$offline_uncorrect\033[0m\n\033[36;1m接口CRC错误计数(CRC Error Count)：\033[31;1m$crc_errors\033[0m\n"; else read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}'); read_uncorrected=${read_uncorrected:-0}; verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}'); verify_uncorrected=${verify_uncorrected:-0}; total_uncorrected=$(echo "$output" | grep "Total uncorrected errors" | awk '{print $NF}'); total_uncorrected=${total_uncorrected:-0}; grown_defect_list=$(echo "$output" | grep "Elements in grown defect list" | awk '{print $NF}'); grown_defect_list=${grown_defect_list:-0}; non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}'); non_medium=${non_medium:-0}; [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$total_uncorrected" -gt 0 ] || [ "$grown_defect_list" -gt 0 ] || [ "$non_medium" -gt 0 ] && echo "$output" >> "$log_file" && echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n\033[36;1m读无法纠正错误(Read total uncorrected errors)：\033[31;1m$read_uncorrected\033[0m\n\033[36;1m校验无法纠正错误(Verify total uncorrected errors)：\033[31;1m$verify_uncorrected\033[0m\n\033[36;1m总无法纠正错误(Total uncorrected errors)：\033[31;1m$total_uncorrected\033[0m\n\033[36;1m已增长缺陷列表元素(Elements in grown defect list)：\033[31;1m$grown_defect_list\033[0m\n\033[36;1m非介质错误(Non-medium error count)：\033[31;1m$non_medium\033[0m\n"; fi; done; done

#!/bin/bash

# 日志文件以日期时间命名
log_file="disk_error_$(date +%Y%m%d_%H%M%S).log"

# 遍历可能的RAID设备（sda, sdb, sdc, sdd）
for raid in {a..d}; do
    if [ -b "/dev/sd$raid" ]; then
        for disk in {0..23}; do
            if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then
                output=$(smartctl -a -d megaraid,$disk /dev/sd$raid)

                serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}')

                if echo "$output" | grep -q "SSD"; then
                    # ================= SSD =================
                    reallocated_sectors=$(echo "$output" | grep "Reallocated_Sector_Ct" | awk '{print $10}')
                    reallocated_sectors=${reallocated_sectors:-0}

                    current_pending=$(echo "$output" | grep "Current_Pending_Sector" | awk '{print $10}')
                    current_pending=${current_pending:-0}

                    reported_uncorrect=$(echo "$output" | grep "Reported_Uncorrect" | awk '{print $10}')
                    reported_uncorrect=${reported_uncorrect:-0}

                    offline_uncorrect=$(echo "$output" | grep "Offline_Uncorrectable" | awk '{print $10}')
                    offline_uncorrect=${offline_uncorrect:-0}

                    crc_errors=$(echo "$output" | grep "CRC_Error_Count" | awk '{print $10}')
                    crc_errors=${crc_errors:-0}

                    if [ "$reallocated_sectors" -gt 0 ] || [ "$current_pending" -gt 0 ] || \
                       [ "$reported_uncorrect" -gt 0 ] || [ "$offline_uncorrect" -gt 0 ] || [ "$crc_errors" -gt 0 ]; then
                        echo "$output" >> "$log_file"
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n"
                        echo -e "\033[36;1m05 重分配扇区计数(Reallocated Sector Count)：\033[31;1m$reallocated_sectors\033[0m"
                        echo -e "\033[36;1m197 当前待处理扇区(Current Pending Sector Count)：\033[31;1m$current_pending\033[0m"
                        echo -e "\033[36;1m已报告的不可纠正错误(Reported Uncorrectable Errors)：\033[31;1m$reported_uncorrect\033[0m"
                        echo -e "\033[36;1m离线不可纠正错误(Offline Uncorrectable)：\033[31;1m$offline_uncorrect\033[0m"
                        echo -e "\033[36;1m接口CRC错误计数(CRC Error Count)：\033[31;1m$crc_errors\033[0m\n"
                    fi
                else
                    # ================= HDD =================
                    read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}')
                    read_uncorrected=${read_uncorrected:-0}

                    verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}')
                    verify_uncorrected=${verify_uncorrected:-0}

                    total_uncorrected=$(echo "$output" | grep "Total uncorrected errors" | awk '{print $NF}')
                    total_uncorrected=${total_uncorrected:-0}

                    grown_defect_list=$(echo "$output" | grep "Elements in grown defect list" | awk '{print $NF}')
                    grown_defect_list=${grown_defect_list:-0}

                    non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}')
                    non_medium=${non_medium:-0}

                    if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || \
                       [ "$total_uncorrected" -gt 0 ] || [ "$grown_defect_list" -gt 0 ] || [ "$non_medium" -gt 0 ]; then
                        echo "$output" >> "$log_file"
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD 磁盘 \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) 检测到异常：\033[0m\n"
                        echo -e "\033[36;1m读无法纠正错误(Read total uncorrected errors)：\033[31;1m$read_uncorrected\033[0m"
                        echo -e "\033[36;1m校验无法纠正错误(Verify total uncorrected errors)：\033[31;1m$verify_uncorrected\033[0m"
                        echo -e "\033[36;1m总无法纠正错误(Total uncorrected errors)：\033[31;1m$total_uncorrected\033[0m"
                        echo -e "\033[36;1m已增长缺陷列表元素(Elements in grown defect list)：\033[31;1m$grown_defect_list\033[0m"
                        echo -e "\033[36;1m非介质错误(Non-medium error count)：\033[31;1m$non_medium\033[0m\n"
                    fi
                fi
            fi
        done
    fi
done

输出效果如下

以下部分的忽略掉即可，老版本的

# 批量巡检脚本 - 适用于HDD

# 遍历可能的RAID设备（sda, sdb, sdc, sdd）
for raid in {a..d}; do
    # 检查设备是否存在
    if [ -b "/dev/sd$raid" ]; then
        # 遍历每个RAID设备上的物理磁盘（0到23号）
        for disk in {0..23}; do
            # 检查磁盘是否可访问（尝试获取基本信息，输出重定向到/dev/null）
            if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then
                # 获取完整的SMART数据
                output=$(smartctl -a -d megaraid,$disk /dev/sd$raid)

                # 从输出中提取序列号
                serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}')

                # 提取读取无法纠正错误次数（最后一列）
                read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}')

                # 提取验证无法纠正错误次数（最后一列）
                verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}')

                # 提取非介质错误次数（最后一列）
                non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}')

                # 检查是否有任何错误（任一错误计数大于0）
                if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$non_medium" -gt 0 ]; then
                    # 将有错误的磁盘完整SMART数据追加到日志文件
                    echo "$output" >> disk_error.log

                    # 输出格式化错误信息
                    echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"
                    echo -e "\033[36;1m读取错误无法纠正次数：\033[31;1m$read_uncorrected\033[36;1m"
                    echo -e "\033[36;1m磁盘自检无法纠错次数：\033[31;1m$verify_uncorrected\033[36;1m"
                    echo -e "\033[36;1m非介质错误次数：\033[31;1m$non_medium\033[36;1m"
                    echo -e "\n"
                fi
            fi
        done
    fi
done

# 整合为一行，一条龙服务
for raid in {a..d}; do if [ -b "/dev/sd$raid" ]; then for disk in {0..23}; do if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then output=$(smartctl -a -d megaraid,$disk /dev/sd$raid); serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}'); read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}'); verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}'); non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}'); if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$non_medium" -gt 0 ]; then echo "$output" >> disk_error.log; echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"; echo -e "\033[36;1m读取错误无法纠正次数：\033[31;1m$read_uncorrected\033[36;1m"; echo -e "\033[36;1m磁盘自检无法纠错次数：\033[31;1m$verify_uncorrected\033[36;1m"; echo -e "\033[36;1m非介质错误次数：\033[31;1m$non_medium\033[36;1m"; echo -e "\n"; fi; fi; done; fi; done

# 批量巡检脚本 - 适用于SSD

# 遍历可能的RAID设备（sda, sdb, sdc, sdd）
for raid in {a..d}; do
    # 检查设备是否存在
    if [ -b "/dev/sd$raid" ]; then
        # 遍历每个RAID设备上的物理磁盘（0到23号）
        for disk in {0..23}; do
            # 检查磁盘是否可访问（尝试获取基本信息，输出重定向到/dev/null）
            if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then
                # 获取完整的SMART数据
                output=$(smartctl -a -d megaraid,$disk /dev/sd$raid)

                # 从输出中提取序列号
                serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}')

                # 检测磁盘类型（SSD或HDD）
                if echo "$output" | grep -q "SSD"; then
                    # SSD磁盘：使用Media_and_Data_Integrity_Errors等属性
                    media_errors=$(echo "$output" | grep "Media_and_Data_Integrity_Errors" | awk '{print $10}')
                    media_errors=${media_errors:-0}

                    # 对于SSD，我们主要关注媒体错误和ECC错误
                    uncorrected_errors=$(echo "$output" | grep "Error_Information_Log_Entries" | awk '{print $10}')
                    uncorrected_errors=${uncorrected_errors:-0}

                    # 检查SSD错误
                    if [ "$media_errors" -gt 0 ] || [ "$uncorrected_errors" -gt 0 ]; then
                        echo "$output" >> disk_error.log
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"
                        echo -e "\033[36;1m媒体和数据完整性错误：\033[31;1m$media_errors\033[36;1m"
                        echo -e "\033[36;1m错误信息日志条目：\033[31;1m$uncorrected_errors\033[36;1m"
                        echo -e "\n"
                    fi
                else
                    # HDD磁盘：使用原有的错误计数器
                    read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}')
                    read_uncorrected=${read_uncorrected:-0}

                    verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}')
                    verify_uncorrected=${verify_uncorrected:-0}

                    non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}')
                    non_medium=${non_medium:-0}

                    # 检查HDD错误
                    if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$non_medium" -gt 0 ]; then
                        echo "$output" >> disk_error.log
                        echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"
                        echo -e "\033[36;1m读取错误无法纠正次数：\033[31;1m$read_uncorrected\033[36;1m"
                        echo -e "\033[36;1m磁盘自检无法纠错次数：\033[31;1m$verify_uncorrected\033[36;1m"
                        echo -e "\033[36;1m非介质错误次数：\033[31;1m$non_medium\033[36;1m"
                        echo -e "\n"
                    fi
                fi
            fi
        done
    fi
done

# 一条龙服务
for raid in {a..d}; do if [ -b "/dev/sd$raid" ]; then for disk in {0..23}; do if smartctl -d megaraid,$disk /dev/sd$raid -i >/dev/null 2>&1; then output=$(smartctl -a -d megaraid,$disk /dev/sd$raid); serial=$(echo "$output" | grep "Serial number:" | awk '{print $3}'); if echo "$output" | grep -q "SSD"; then media_errors=$(echo "$output" | grep "Media_and_Data_Integrity_Errors" | awk '{print $10}'); media_errors=${media_errors:-0}; uncorrected_errors=$(echo "$output" | grep "Error_Information_Log_Entries" | awk '{print $10}'); uncorrected_errors=${uncorrected_errors:-0}; if [ "$media_errors" -gt 0 ] || [ "$uncorrected_errors" -gt 0 ]; then echo "$output" >> disk_error.log; echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 SSD Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"; echo -e "\033[36;1m媒体和数据完整性错误：\033[31;1m$media_errors\033[36;1m"; echo -e "\033[36;1m错误信息日志条目：\033[31;1m$uncorrected_errors\033[36;1m"; echo -e "\n"; fi; else read_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^read:" | awk '{print $NF}'); read_uncorrected=${read_uncorrected:-0}; verify_uncorrected=$(echo "$output" | grep -A 10 "Error counter log:" | grep "^verify:" | awk '{print $NF}'); verify_uncorrected=${verify_uncorrected:-0}; non_medium=$(echo "$output" | grep "Non-medium error count:" | awk '{print $NF}'); non_medium=${non_medium:-0}; if [ "$read_uncorrected" -gt 0 ] || [ "$verify_uncorrected" -gt 0 ] || [ "$non_medium" -gt 0 ]; then echo "$output" >> disk_error.log; echo -e "\033[36;1mRAID \033[32;1msd$raid \033[36;1m中的 HDD Disk \033[32;1m#$disk \033[36;1m(SN:\033[33;1m $serial) \033[36;1m存在以下错误：\n"; echo -e "\033[36;1m读取错误无法纠正次数：\033[31;1m$read_uncorrected\033[36;1m"; echo -e "\033[36;1m磁盘自检无法纠错次数：\033[31;1m$verify_uncorrected\033[36;1m"; echo -e "\033[36;1m非介质错误次数：\033[31;1m$non_medium\033[36;1m"; echo -e "\n"; fi; fi; fi; done; fi; done

以上部分的忽略掉即可，老版本的

原始错误日志解读

HDD范例

范例：

报错内容	翻译	说明
Error Corrected by ECC	ECC纠错	当某个扇区存在错误时，硬盘通过内置的错误校正码（ECC）机制自动完成的纠错次数。
Total errors corrected	已纠错总次数	记录累计成功纠正的错误总数（包含所有纠错方式）。
Correction algorithm invocations	纠错算法调用次数	硬盘调用纠错算法的次数，部分可能无需实际改写即可修复；一般无需重点关注。
Gigabytes processed	已处理数据量（GB）	表示在统计期间，通过 ECC 机制处理过的数据总量（以 GB 计）。
Total uncorrected errors	未能纠错总数	ECC 无法修复的错误次数，表示确实发生了数据损坏；若大于 0，需立即关注。
Non-medium error count	非介质错误计数	非存储介质本身的故障，例如接口、背板、线缆、电源等导致的通信或传输错误。
fast rereads	快速重读	通过快速重读实现的自动纠错，对性能影响较小。
delayed rereads	延迟重读	通过延迟重读实现的纠错，通常会增加 I/O 响应时间。
rewrites	重写	当重读成功后，将正确的数据重新写回故障扇区，以防止未来再次出错。

范例中ECC纠错2555次，且存在4次无法纠错，且非介质故障高达13次，该硬盘急需维护。

SSD范例

报错内容	翻译	说明
Reallocated Sector Count	重分配扇区计数	表示硬盘将坏掉或不可靠的扇区重映射到备用扇区的次数。数值大于 0 意味着盘体已经出现物理坏块。若持续增加，说明硬盘劣化严重，应尽快备份并考虑更换。
Reported Uncorrectable Errors	报告无法纠正错误	硬盘在正常读写中发生的、ECC 无法修复的错误次数。这类错误会导致数据直接损坏，是严重的健康警告指标。
Current Pending Sector Count	当前待处理扇区	等待进一步确认或重新分配的扇区数量。通常表示这些扇区在读写中出现问题，待后续重写确认是否稳定。若数值不降反升，说明盘体状态持续恶化。
Offline Uncorrectable	离线不可校正错误	硬盘在离线检测或自检时发现的无法修复错误。表示硬盘在后台扫描时检测到了坏块，可靠性降低。
CRC Error Count	接口 CRC 错误次数	表示主机与硬盘之间数据传输时出现的循环冗余校验错误，通常由线缆、接口、背板、电磁干扰或电源问题引起，而非硬盘介质损坏。

服务器稳定性及基准测试方法

2025-09-11T07:40:24.000Z

重要更新: 2025-11-4 硬盘测试开发了全自动测试工具，见下方硬盘测试部分

测试项

测试前准备

CPU调优

BIOS关闭超线程

方法：
BIOS里找CPU或者Socket Configuration，进入其中，找Processor Configuration，
进入其中关闭超线程即可
超线程在BIOS的写法通常有：

SMT
Logical Processor(LP)
Hyper-Threading

理由：
超线程的作用是让 CPU 能在一个线程等待（例如等待内存I/O）时，利用空闲执行单元去执行另一个线程。
所以对于CPU性能测试的浮点运算、以及CPU满载的业务场景，超线程导致的线程切换，反而会：

增加上下文切换与调度开销(Scheduler Overhead)
- 操作系统调度器看到两个逻辑核心，调度两个重量级任务上去，但实际上底层的物理核根本没法承担
导致缓存污染(Cache Pollution)
- 不同线程使用的数据不同，缓存反而会互相驱逐对方数据
- 这个问题与下文中根据L3缓存设计NB大小尤其相关

BIOS关闭C-State

方法：
BIOS里找CPU或者Socket Configuration，进入其中，找Advanced Power Management Configuration，
进入其中CPU C State Control，参数如下：

参数	解释	建议设置
Enable Monitor MWAIT	是否允许使用 MWAIT 指令进入 C-state	Disabled
CPU C6 report	是否让操作系统知道 C6 可用	Disabled
Enhanced Halt State (C1E)	启用增强型省电停机(降压降频)	Disabled
OS ACPI Cx	操作系统可用的最深 C 状态（如 ACPI C2）	设置为能选的最小值

补充：
上面是比较通用的写法，但我看到Lenovo写的是SST-PP……自行判断或者问下厂商吧
原理就是C-State设置0最好，就像Lenovo的SST-PP，BIOS里也写了，Level 0 TDP 185W，最高性能

理由：
C-State是省电休眠状态控制，除非你要省电，否则把它关了。
让性能最高，减少CPU状态切换导致的延迟，关不了就保持在C0使CPU始终活跃。

存储调优

RAID调优

Stripe Size(带宽): 1m
写入策略: Write Back(回写)
驱动器缓存: Drive Cache disabled(关闭磁盘缓存)
初始化方式: Fast Initialize(快速初始化)

文件系统调优

采用parted分区，gpt
分区从2048s扇区起，保持4k对齐
文件系统采用xfs即可

CPU基准测试

测试项	测试工具	参考业务场景	测试方式
双精度浮点运算 float64	HPL	该项测试为HPC行业标准，TOP500超级计算机排行榜均采用该方式评估	测试3次取均值

内存基准测试

测试项	测试工具	选择理由	测试方式
内存带宽	STREAM Benchmark	HPC内存带宽的行业标准测试，TOP500超级计算机排行榜均采用该方式评估	Copy/Scale/Add/Triad测试3次取均值

硬盘测试

重要更新: 2025-11-5 发布了v1.1版本，修复了读测试无IO导致测试结果失真的BUG
新增了实时显示FIO进度的功能

重要更新: 2025-11-4 发布了fio硬盘测试的全自动工具
工具涵盖了自动运行fio，通过预置的benchmark.fio文件自动运行60项基础测试
运行前检查其中的directory=/mnt/test/ ; 测试目录路径，请根据实际情况修改
补充：注意directory=后面一定是带/的，因为是目录
可以选择将需要测试的硬盘挂载到这个目录，或者修改为你想要的目录
runtime=30s ; 每个测试运行 30 秒，则是每项测试运行多久
ramp_time=5s ; 5秒预热，使设备进入稳定状态，这一条无需修改，作用是按照所设定的参数运行5秒确保硬盘跑起来，避免冷启动的性能过低或者波动
size=10G，这是测试文件的大小，注意根据你的容量并计算numjobs的数量，例如8个numjobs则是10G*8=80G硬盘空间
给full_auto设置执行权限，并确保benchmark.fio和该程序在一个目录即可
运行完成后会在当前目录生成原始数据的json文件和导出可读的xlsxExcel表格

仓库地址:https://github.com/1949hacker/fio_benchmark

可执行程序下载

测试项	测试工具	参考业务场景	测试方式
4k单队列	fio bs=4k iodepth=1	MySQL场景	测试3次取均值
4k 32队列	fio bs=4k iodepth=32	MongoDB场景	测试3次取均值
32k 32队列	fio bs=32k iodepth=32	高并发Web服务，Kafka日志刷盘，多线程缓存写入	测试3次取均值
1m 单队列	fio bs=1m iodepth=1	顺序读写，备份、视频流、镜像分发	测试3次取均值
1m 32队列	fio bs=1m iodepth=32	并发大文件读写，大规模备份，分布式存储，对象存储	测试3次取均值
硬盘压测	fio -numjobs=32 -bs=4k -iodepth=64 -directory	具体代码见下方及下文中有关于fio参数的解释

补充说明：除系统盘不能直接测试裸盘外，其他盘均应使用裸盘测试，如fio -filename=/dev/sdb和fio -filename=/dev/nvme0n1，直接指向硬盘块设备，而不是分区或路径

1	fio -name=disk_benchmark -size=5G -runtime=5d -time_base -direct=1 -ioengine=libaio -randrepeat=0 -numjobs=32 -group_reporting -bs=4k -rw=randrw -rwmixwrite=30 -directory=/home/test/ -iodepth=64

其中针对业务场景，根据单台服务器部署的业务数量适当设置numjobs以模拟操作系统/应用层并发。

例如单台服务器4个数据库，则fio bs=4k iodepth=32 numjobs=4。

iodepth对应单个线程的队列深度，用于存储设备并发能力测试

numjobs对应多个线程并发，用于测试操作系统/应用层并发能力

综合基准测试

测试项	测试工具	参考业务场景	测试方式
综合性能指数	GeekBench	横向比较整机性能，仅供参考	普通测试

CentOS 7.9.2009跑不了GeekBench 6

GeekBench历史版本

测试过程

AMD 9F14平台测试

补充：

可以先准备好fio程序的目录/root/fio
编译好hpl文件并确保目录是/root/hpl
编译好内存测试的stream并放在/root/memtest
当然，目录自由发挥也可以，改下方代码即可

1
2
3

# 一行代码搞定内存基准、CPU基准、存储基准的全自动测试
# 注意其中的目录和-np 24的参数根据下文内容，改为你自己的
cd /root/memtest/ && for i in {0..2};do ./stream 2>&1 | tee -a mem_$i.log;done && cd /root/hpl/bin/Linux_Intel64/ && for i in {0..2};do mpirun --allow-run-as-root -np 24 --map-by core --bind-to core ./xhpl 2>&1 | tee -a HPL_$i.out;done && cd /root/fio && ./full_auto.v2.2.0

安装CentOS 7.9.2009

替换源为清华大学CentOS-Vault源

在清华CentOS-Vault仓库输入小版本，获取命令

例如CentOS 7.9.2009如下

sed -e "s|^mirrorlist=|#mirrorlist=|g" \
    -e "s|^#baseurl=http://mirror.centos.org/centos/\$releasever|baseurl=https://mirrors.tuna.tsinghua.edu.cn/centos-vault/7.9.2009|g" \
    -e "s|^#baseurl=http://mirror.centos.org/\$contentdir/\$releasever|baseurl=https://mirrors.tuna.tsinghua.edu.cn/centos-vault/7.9.2009|g" \
    -i.bak \
    /etc/yum.repos.d/CentOS-*.repo

该命令执行后会将原本的所有源配置文件备份为带.bak后缀名的备份

可以通过下方的命令快速还原

# 启用bash扩展通配符
shopt -s extglob

# 使用通配符快速删除不带.bak的文件
rm !(*.bak) -f

# 使用for循环快速去掉.bak后缀
for f in *.bak;do mv -- "$f" "${f%.bak}";done

yum makecache更新源

yum install vim安装vim编辑器

# 更新源
yum makecache
# 安装vim
yum install vim
# 编辑ssh配置文件
vim /etc/ssh/sshd_config
# 设置心跳
# 取消注释，设置为每60秒发送一次心跳重复9999999次
ClientAliveInterval 60
ClientAliveCountMax 99999
# 设置允许root用户登录
# 取消注释并配置为yes
PermitRootLogin yes
# 重启ssh服务
systemctl restart sshd

准备CPU的Linpack测试

# 基础环境
# 安装OpenBLAS
# 安装OpenMPI
yum install -y epel-release && yum install gcc gcc-c++ gcc-gfortran cmake python3 zlib* -y && yum install -y openblas openblas-devel && yum install -y openmpi openmpi-devel

# 找到MPI的位置
find /usr -name "mpicc" 2>/dev/null
# 我的输出如下
/usr/lib64/openmpi/bin/mpicc
# 添加MPI到环境变量
echo 'export PATH=/usr/lib64/openmpi/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/lib64/openmpi/lib:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc
# 临时生效
export PATH=/usr/lib64/openmpi/bin:$PATH
export LD_LIBRARY_PATH=/usr/lib64/openmpi/lib:$LD_LIBRARY_PATH

# 复查一下系统中有没有openblas
ldconfig -p | grep openblas
# 输出通常如下所示
libopenblas64_.so.0 (libc6,x86-64) => /lib64/libopenblas64_.so.0
libopenblas64.so.0 (libc6,x86-64) => /lib64/libopenblas64.so.0
libopenblasp64_.so.0 (libc6,x86-64) => /lib64/libopenblasp64_.so.0
libopenblasp64.so.0 (libc6,x86-64) => /lib64/libopenblasp64.so.0
libopenblasp.so.0 (libc6,x86-64) => /lib64/libopenblasp.so.0
libopenblaso64_.so.0 (libc6,x86-64) => /lib64/libopenblaso64_.so.0
libopenblaso64.so.0 (libc6,x86-64) => /lib64/libopenblaso64.so.0
libopenblaso.so.0 (libc6,x86-64) => /lib64/libopenblaso.so.0
libopenblas.so.0 (libc6,x86-64) => /lib64/libopenblas.so.0

# 下载High Performance Linpack
# 去官网检查最新版https://www.netlib.org/benchmark/hpl/
wget https://www.netlib.org/benchmark/hpl/hpl-2.3.tar.gz
tar xvf hpl-2.3.tar.gz
mv hpl-2.3 hpl
mv hpl ~/
cd ~/hpl

# 从模板创建副本并改动编译器参数
# INTEL使用Make.Linux_Intel64
# AMD使用Make.Linux_ATHLON_FBLAS
cp setup/Make.Linux_ATHLON_FBLAS ./Make.Linux_ATHLON_FBLAS
vim Make.Linux_ATHLON_FBLAS

# 64行的ARCH的名称可以自定义，但没必要，需要和文件名后缀一致，如Make.Linux_ATHLON_FBLAS
# 后续make编译时会用到，如make arch=AMD_OpenBLAS
ARCH = Linux_ATHLON_FBLAS

# 配置openblas通用开源方案，保持测试结果的中立
# 避免MKL和AOCL BLIS/LibFLAME对于INTEL AMD的专项优化
# 修改配置使HPL走CBLAS接口，而不是老的Fortran BLAS
# 在配置文件中找到
HPL_DEFS     = $(F2CDEFS) $(HPL_OPTS) $(HPL_INCLUDES)

# 在末尾加上 -DHPL_CALL_CBLAS
HPL_DEFS     = $(F2CDEFS) $(HPL_OPTS) $(HPL_INCLUDES) -DHPL_CALL_CBLAS

# 找到CCFLAGS，添加-march=native
CCFLAGS      = $(HPL_DEFS) -fomit-frame-pointer -O3 -funroll-loops -W -Wall -march=native

# 默认的配置如下
LAdir        = $(HOME)/netlib/ARCHIVES/Linux_ATHLON
LAinc        =
LAlib        = $(LAdir)/libf77blas.a $(LAdir)/libatlas.a
# 修改为
LAdir   = /usr/lib64/openblas  # 你的 OpenBLAS库路径，find / -name libopenblas*
LAinc   =
LAlib   = -lopenblas

# 改为直接使用mpicc编译
# 修改CC
CC      = mpicc

# 注释掉84-86行左右的三行MP配置
# 在前面加#注释了就行
MPdir        = /usr/local/mpi
MPinc        = -I$(MPdir)/include
MPlib        = $(MPdir)/lib/libmpich.a


# 这部分是针对Intel的编译参数设置，AMD忽略
# --------- start ---------
OMP_DEFS  = -openmp
# 改为
OMP_DEFS  = -fopenmp

CCFLAGS = CCFLAGS  = $(HPL_DEFS) -O3 -w -ansi-alias -i-static -z noexecstack -z relro -z now -nocompchk -Wall
# 修改为
CCFLAGS  = $(HPL_DEFS) -O3 -w -Wall -fopenmp -fno-strict-aliasing -march=native -z noexecstack -z relro -z now

LINKFLAGS = $(CCFLAGS) $(OMP_DEFS) -mt_mpi
#修改为
LINKFLAGS = $(CCFLAGS) $(OMP_DEFS)
# --------- end ---------

# 编译HPL
make -f Make.top build_src arch=Linux_ATHLON_FBLAS
make -f Make.top build_tst arch=Linux_ATHLON_FBLAS


# 编辑HPL.dat
cd bin/Linux_ATHLON_FBLAS
# Intel是Linux_Intel64
cd bin/Linux_Intel64

mv HPL.dat HPL.dat.bak
vim HPL.dat

# HPL.dat范例，参数及其解析详见下方表格
HPLinpack benchmark input file
Innovative Computing Laboratory, University of Tennessee
HPL.out      output file name (if any)
6            device out (6=stdout,7=stderr,file)
1            # of problems sizes (N)
165120         Ns
1            # of NBs
384           NBs
0            PMAP process mapping (0=Row-,1=Column-major)
1            # of process grids (P x Q)
8            Ps
12            Qs
16.0         threshold
1            # of panel fact
2            PFACTs (0=left, 1=Crout, 2=Right)
1            # of recursive stopping criterium
4            NBMINs (>= 1)
1            # of panels in recursion
2            NDIVs
1            # of recursive panel fact.
1            RFACTs (0=left, 1=Crout, 2=Right)
1            # of broadcast
1            BCASTs (0=1rg,1=1rM,2=2rg,3=2rM,4=Lng,5=LnM)
1            # of lookahead depth
1            DEPTHs (>=0)
2            SWAP (0=bin-exch,1=long,2=mix)
64           swapping threshold
0            L1 in (0=transposed,1=no-transposed) form
0            U  in (0=transposed,1=no-transposed) form
1            Equilibration (0=no,1=yes)
8            memory alignment in double (> 0)
##### This line (no. 32) is ignored (it serves as a separator). ######
0                               Number of additional problem sizes for PTRANS
1200 10000 30000                values of N
0                               number of additional blocking sizes for PTRANS
40 9 8 13 13 20 16 32 64        values of NB

# 禁用防火墙
systemctl stop firewalld
setenforce 0
# 开始运行
mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl

# 使用htop查看硬件负载
yum install -y htop
htop

# 测试结果范例，其中183行和190行分别是测试结果和误差，附带了注释
================================================================================
HPLinpack 2.3  --  High-Performance Linpack benchmark  --   December 2, 2018
Written by A. Petitet and R. Clint Whaley,  Innovative Computing Laboratory, UTK
Modified by Piotr Luszczek, Innovative Computing Laboratory, UTK
Modified by Julien Langou, University of Colorado Denver
================================================================================

An explanation of the input/output parameters follows:
T/V    : Wall time / encoded variant.
N      : The order of the coefficient matrix A.
NB     : The partitioning blocking factor.
P      : The number of process rows.
Q      : The number of process columns.
Time   : Time in seconds to solve the linear system.
Gflops : Rate of execution for solving the linear system.

The following parameter values will be used:

N      :  165120
NB     :     384
PMAP   : Row-major process mapping
P      :       8
Q      :      12
PFACT  :   Right
NBMIN  :       4
NDIV   :       2
RFACT  :   Crout
BCAST  :  1ringM
DEPTH  :       1
SWAP   : Mix (threshold = 64)
L1     : transposed form
U      : transposed form
EQUIL  : yes
ALIGN  : 8 double precision words

--------------------------------------------------------------------------------

- The matrix A is randomly generated for each test.
- The following scaled residual check will be computed:
      ||Ax-b||_oo / ( eps * ( || x ||_oo * || A ||_oo + || b ||_oo ) * N )
- The relative machine precision (eps) is taken to be               1.110223e-16
- Computational tests pass if scaled residuals are less than                16.0

================================================================================
T/V                N    NB     P     Q               Time                 Gflops
--------------------------------------------------------------------------------
WR11C2R4      165120   384     8    12            1755.82             1.7094e+03
# 这里的1.7094e+03也就是1.7094*10^3 Gflops=1709.4GFlops=1.7094TFlops
HPL_pdgesv() start time Mon Sep 15 12:53:01 2025

HPL_pdgesv() end time   Mon Sep 15 13:22:17 2025

--------------------------------------------------------------------------------
||Ax-b||_oo/(eps*(||A||_oo*||x||_oo+||b||_oo)*N)=   4.65407372e-04 ...... PASSED
# 这里的PASSED说明误差合格，测试有效
# 误差为4.65407372*10^-4=0.00046540737
================================================================================

Finished      1 tests with the following results:
              1 tests completed and passed residual checks,
              0 tests completed and failed residual checks,
              0 tests skipped because of illegal input values.
--------------------------------------------------------------------------------

End of Tests.
================================================================================

HPL.dat的参数及其说明

在线生成HPL.dat文件的网站 HPL.dat

参数	说明
Nodes	对应CPU数量
Cores per Node	每个CPU多少核
Memory per Node(MB)	每个CPU有多少MB内存
Block Size(NB)	HPL运算的块大小

NB 块大小计算方式：

设置适当的块大小，使数据块能够很好的放入CPU的高速缓存（L2/L3 Cache），如果数据块不能放入高速缓存，则不得不从慢得多的主内存RAM中进行读取，从而导致性能瓶颈。

NB最好是PQ的整数倍，以我的AMD 9A14为例，L3为384MB，96核心

HPL将矩阵N分块成NB*NB的小块，然后分布在一个二维进程网格P行Q列上

所以如果任何一方过长，就会造成通信路径变长，从而导致性能开销大

为了使性能达到最优，需要使这个二维网格接近正方形，也就是PQ值相近，且同时P*Q需要等于核心数，以确保每个核心都有数据块在计算

PQ计算公式

使用在线生成则直接跳过此处即可，仅用作学习

# 根据内核数量取近似的能开方的整数
# 例如96核取100开方
# 然后用核数除平方根递归直到整除
96/10=9.6
96/9=10.66
96/8=12
# PQ则为8*12
# 该网格便由8行12列组成，接近正方形，避免了过长的通信路径
# 每个进程需要将分解结果广播给其他进程，所以过长的通信路径就意味着过长的通信开销
# 如图
- - - - - - -
- - - · - - -
- - - - - - -
# 对比过长的通信路径
- - - - - - - - ·- - - - - - -

NB块大小计算公式

# 首先查询CPU的L3缓存
# 然后用L3缓存除以核心数，算出每个核心能使用的缓存均值
# 根据float类型占4字节，double类型占8字节计算
# 该性能测试为双精度浮点运算，取8字节
# 先计算每个核心能使用多少字节的缓存
# AMD 9A14 L3 384MB/96核心
384/96=4MB/core
4*1024*1024=4,194,304Byte/core
# 然后除以双精度的8字节，计算出每个核心处理多少个双精度浮点数，也就是NB²
4194304/8=524288NB²
# 然后开方得出NB
524288开方约为724NB
# 为了避免撑爆L3缓存，只取一半值
724/2=362/core
# 现代x86 CPU的Cache Line是固定的64字节
# 为了保证AVX/AVX-512指令能每次搬运时都尽量填满
# 所以寻找64的倍数，且尽量接近L3 Cache的极限
# 这样计算出每个核心计算大概362个NB，每次指令搬运64字节，总共搬运约6次
362/64=5.65625 取整 6
# 计算每次64字节总共6次的整数
64*6=384
# 最终得出NB最优值为384

最终计算出NB为384

注意其中Nodes填的是有多少个CPU
Cores per Node则是每个CPU有多少物理内核
Memory per Node(MB)是每个CPU有多少内存可用，所以内存条也需要均匀安装
Block Size(NB)则是填入上方计算的值

在线生成后的HPL.dat如下，HPL只会读取第一列，数字后方的是注释，带#的也是注释

HPLinpack benchmark input file
Innovative Computing Laboratory, University of Tennessee
HPL.out      output file name (if any)
6            device out (6=stdout,7=stderr,file)
1            # of problems sizes (N)
165120         Ns
1            # of NBs
384           NBs
0            PMAP process mapping (0=Row-,1=Column-major)
1            # of process grids (P x Q)
8            Ps
12            Qs
16.0         threshold
1            # of panel fact
2            PFACTs (0=left, 1=Crout, 2=Right)
1            # of recursive stopping criterium
4            NBMINs (>= 1)
1            # of panels in recursion
2            NDIVs
1            # of recursive panel fact.
1            RFACTs (0=left, 1=Crout, 2=Right)
1            # of broadcast
1            BCASTs (0=1rg,1=1rM,2=2rg,3=2rM,4=Lng,5=LnM)
1            # of lookahead depth
1            DEPTHs (>=0)
2            SWAP (0=bin-exch,1=long,2=mix)
64           swapping threshold
0            L1 in (0=transposed,1=no-transposed) form
0            U  in (0=transposed,1=no-transposed) form
1            Equilibration (0=no,1=yes)
8            memory alignment in double (> 0)
##### This line (no. 32) is ignored (it serves as a separator). ######
0                               Number of additional problem sizes for PTRANS
1200 10000 30000                values of N
0                               number of additional blocking sizes for PTRANS
40 9 8 13 13 20 16 32 64        values of NB

根据这份文件，运行命令如下：

mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl
# --allow-run-as-root 允许root用户运行
# -np 96 启动96个MPI进程，与物理内核总数相同，不是线程数
# 如果你是4路每路20核那你就要填80，是所有CPU物理内核总数
# --map-by core MPI进程核CPU逻辑核心进行绑定
# --bind-to core 将每个进程锁定到core上运行，避免cache miss

# 显示的同时输出到文件，方便做为测试记录
mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl 2>&1 | tee -a HPL_0.out
# 一条命令实现运行完CPU基准后自动开始执行存储基准测试
# 在xhpl目录运行的
for i in {0..2};do mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl 2>&1 | tee -a HPL_$i.out;done && cd /root/fio/ && /root/fio/full_auto.v2.2.0

关于参数的解释在官网有详细说明HPL Tuning

进行内存的基准测试

使用STREAM Benchmark进行测试

源代码

# 安装编译工具
yum install gcc -y

# 下载源码，或者复制，都行
wget https://www.cs.virginia.edu/stream/FTP/Code/stream.c

# 编译stream
# 其中-DSTREAM_ARRAY_SIZE是设置每个数组的元素数量
# 测试的内存大小 = 物理内存上限 ÷ (数组个数 × 元素字节数)
# 物理内存上限取一半值，避免打到swap，256GB × 1/2 = 128GB = 137438953472 Bytes
# 数组个数 = 4 默认测试 Triad 核心项，需 a/b/c/d 4 个数组
# 元素字节数 = 8 推荐用 double 类型，兼顾精度和硬件带宽适配
# -DSTREAM_ARRAY_SIZE = 137438953472 ÷ (4 × 8) = 137438953472 ÷ 32 = 4294967296
gcc -O3 -fopenmp -DSTREAM_ARRAY_SIZE=4294967296 stream.c -o stream
# 实际编译中这个值太大了，超过程序的限制了，取一半就行了
# -O3编译器优化 -m64强制生成64位可执行文件
# -mcmodel=medium采用64位系统的内存模型，以支持超大全局数组 -fopenmp启用多线程并行框架
# -DTYPE=double定义元素类型为double高精度 -DSTREAM_TYPE=double同步内部的流类型与DTYPE一致
# -DN=2147483648冗余安全参数，用于兼容以N作为数组大小别名的源码
gcc -O3 -fopenmp -m64 -mcmodel=medium -DSTREAM_ARRAY_SIZE=2147483648 -DTYPE=double -DSTREAM_TYPE=double -DN=2147483648 stream.c -o stream


# 运行
./stream

# 直接输出到文件
./stream >> mem_test_0.log

输出结果如下，只需要第30行中Triad的带宽212674.9MB/s和延迟的平均值Avg time

-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 100000000 (elements), Offset = 0 (elements)
Memory per array = 762.9 MiB (= 0.7 GiB).
Total memory required = 2288.8 MiB (= 2.2 GiB).
Each kernel will be executed 10 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Number of Threads requested = 192
Number of Threads counted = 192
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 16443 microseconds.
   (= 16443 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:          254046.3     0.006921     0.006298     0.011713
Scale:         189664.1     0.008491     0.008436     0.008531
Add:           204691.7     0.011839     0.011725     0.011884
Triad:         212674.9     0.011320     0.011285     0.011350
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------

只取其中的典型值Triad即可，代表典型科学计算/数值模拟中的内存访问性能

硬盘性能fio测试

使用fio进行硬盘的性能测试，测试结果包含IOPS、带宽、延迟

# 安装fio
yum install fio

# 准备好测试路径或硬盘
# 这里采用指向目录的方式测试
# 如需直接测试硬盘，则指向硬盘即可
# -name=本次测试的名称，自定义即可
# -size=本次测试的文件大小，建议大于内存的2倍，避免某些文件系统使用内存缓存
# 鉴于CentOS 7.9.2009的xfs和参数设置了direct=1，所以size不用大于内存
# -runtime=运行时间，单位支持秒s、分m、时h、天d
# -time_base 即使写入了指定大小的文件，依旧继续重复写入，直到runtime时间结束
# -direct=1设置不使用系统缓存，直写
# -ioengine=libaio直接使用Linux的异步IO引擎
# -randrepeat=0设置每次IO的随机性都不同，模拟真实业务场景
# -numjobs=8设置8个进程，模拟真实业务场景
# -group_reporting多进程的运行结果汇总汇报
# -bs=4k 块大小4k
# -rw=randrw随机读写
# -rwmixwrite=30设置30%写70%读，模拟真实业务场景
# -filename=/root/fio 在/root目录下创建一个名为fio的文件进行测试
# -directory=/dir/上方的filename也可替换为该命令指向目录，会在目录下根据numjobs的数量生成多个文件测试
# 注意下你的目录容量，别装不下size*numjobs的文件
# -iodepth= IO队列深度

# 运行5分钟，采用路径模式8进程写入，模拟最真实的业务场景
fio -name=disk_benchmark -size=10G -runtime=5m -time_base -direct=1 -ioengine=libaio -randrepeat=0 -numjobs=8 -group_reporting -bs=4k -rw=randrw -rwmixwrite=30 -filename=/home/fio -iodepth=1

# 1m顺序混合30%写70%读范例
fio -name=disk_benchmark -size=5G -runtime=15s -time_base -direct=1 -ioengine=libaio -numjobs=8 -group_reporting -bs=1m -rw=rw -rwmixwrite=30 -filename=/home/fio/a -iodepth=1

# 运行结果如下
# 其中第38行则是读取性能的测试结果，55行是写入的性能测试结果，附带了注释说明
disk_benchmark: (g=0): rw=randrw, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=libaio, iodepth=32
...
fio-3.7
Starting 8 processes
disk_benchmark: Laying out IO file (1 file / 5120MiB)
Jobs: 8 (f=8): [m(8)][100.0%][r=339MiB/s,w=144MiB/s][r=86.8k,w=36.0k IOPS][eta 00m:00s]
disk_benchmark: (groupid=0, jobs=8): err= 0: pid=64509: Tue Sep 16 15:11:50 2025
  # 读取性能的测试结果在此，记录IOPS，和MB单位的353MB/s即可
   read: IOPS=86.2k, BW=337MiB/s (353MB/s)(5053MiB/15002msec)
    slat (nsec): min=1110, max=34081k, avg=51710.15, stdev=245614.51
    clat (usec): min=229, max=36569, avg=2081.87, stdev=914.48
    # 读取延迟取lat(total latency)总延迟的值即可，统一用微秒单位
    # Windows按住Alt然后直接按小数字键盘0181即可输出µ
    # Linux则是Ctrl+Shift+U输入00b5
    # MACOS则是Option+m输出µ
     lat (usec): min=237, max=37825, avg=2133.63, stdev=947.08
    clat percentiles (usec):
     |  1.00th=[  545],  5.00th=[  816], 10.00th=[ 1106], 20.00th=[ 1401],
     | 30.00th=[ 1614], 40.00th=[ 1795], 50.00th=[ 1958], 60.00th=[ 2147],
     | 70.00th=[ 2376], 80.00th=[ 2737], 90.00th=[ 3261], 95.00th=[ 3621],
     | 99.00th=[ 4490], 99.50th=[ 4817], 99.90th=[ 5538], 99.95th=[ 5866],
     | 99.99th=[21103]
   bw (  KiB/s): min=39944, max=45384, per=12.50%, avg=43106.80, stdev=948.51, samples=240
   iops        : min= 9986, max=11346, avg=10776.67, stdev=237.13, samples=240
   # 写入性能的测试结果在此，记录IOPS，和MB单位的353MB/s即可
  write: IOPS=37.0k, BW=145MiB/s (152MB/s)(2171MiB/15002msec)
    slat (nsec): min=1470, max=17704k, avg=54444.01, stdev=241994.82
    clat (usec): min=150, max=37077, avg=1887.95, stdev=964.94
    # 写入延迟取lat(total latency)总延迟的值即可，统一用微秒单位
    # Windows按住Alt然后直接按小数字键盘0181即可输出µ
    # Linux则是Ctrl+Shift+U输入00b5
    # MACOS则是Option+m输出µ
     lat (usec): min=153, max=37080, avg=1942.46, stdev=994.98
    clat percentiles (usec):
     |  1.00th=[  400],  5.00th=[  537], 10.00th=[  676], 20.00th=[ 1156],
     | 30.00th=[ 1418], 40.00th=[ 1614], 50.00th=[ 1795], 60.00th=[ 1991],
     | 70.00th=[ 2212], 80.00th=[ 2540], 90.00th=[ 3130], 95.00th=[ 3556],
     | 99.00th=[ 4490], 99.50th=[ 4817], 99.90th=[ 5604], 99.95th=[ 5997],
     | 99.99th=[18744]
   bw (  KiB/s): min=16736, max=19920, per=12.50%, avg=18519.40, stdev=504.91, samples=240
   iops        : min= 4184, max= 4980, avg=4629.82, stdev=126.23, samples=240
  lat (usec)   : 250=0.01%, 500=1.54%, 750=4.81%, 1000=4.07%
  lat (msec)   : 2=44.46%, 4=42.71%, 10=2.39%, 20=0.01%, 50=0.01%
  cpu          : usr=1.15%, sys=8.65%, ctx=508859, majf=0, minf=268
  IO depths    : 1=0.1%, 2=0.1%, 4=0.1%, 8=0.1%, 16=0.1%, 32=100.0%, >=64=0.0%
     submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     complete  : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.1%, 64=0.0%, >=64=0.0%
     issued rwts: total=1293511,555725,0,0 short=0,0,0,0 dropped=0,0,0,0
     latency   : target=0, window=0, percentile=100.00%, depth=32

Run status group 0 (all jobs):
   READ: bw=337MiB/s (353MB/s), 337MiB/s-337MiB/s (353MB/s-353MB/s), io=5053MiB (5298MB), run=15002-15002msec
  WRITE: bw=145MiB/s (152MB/s), 145MiB/s-145MiB/s (152MB/s-152MB/s), io=2171MiB (2276MB), run=15002-15002msec

Disk stats (read/write):
    dm-2: ios=1288781/553752, merge=0/0, ticks=1713741/644122, in_queue=2391609, util=100.00%, aggrios=1293378/555710, aggrmerge=132/23, aggrticks=1658421/619009, aggrin_queue=2289296, aggrutil=99.74%
  sda: ios=1293378/555710, merge=132/23, ticks=1658421/619009, in_queue=2289296, util=99.74% # 这里的util是硬盘负载，100%负载才说明榨干了硬盘性能

综合性能测试

使用CentOS 7.9.2009和GeekBench进行综合性能评估

下载地址 geekbench

# 解压下载的压缩包
tar -zxvf Geekbench-6.5.0-Linux.tar.gz

# 直接运行即可
./geekbench6

# 如果提示
/root/Geekbench-6.5.0-Linux/geekbench_avx2: /lib64/libm.so.6: version `GLIBC_2.27' not found (required by /root/Geekbench-6.5.0-Linux/geekbench_avx2)

# 系统glibc版本过低，使用旧版本GeekBench
https://cdn.geekbench.com/Geekbench-5.5.1-Linux.tar.gz

稳定性测试

鉴于HPL测试本身就会使服务器CPU内存满载，所以直接在上文CPU测试的基础上直接变成重复执行即可做到稳定性测试，配合带外观察CPU温度内存等是否故障即可

# 循环运行100次
for i in {1..100};do "hpl代码";done
# 以我的AMD 9A14为例
for i in {1..100};do mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl && echo -e "\033[36;1m第 $i 次运行完成！";done

使用该脚本运行并将运行结果也进行统计，方便同时观察性能是否有波动

for i in {1..1000}; do
    echo -e "\033[34;1m=== 第 $i 次运行开始 ===\033[0m"

    # 运行测试并保存输出到临时文件
    # 记得将其替换为你自己的对应命令
    mpirun --allow-run-as-root -np 96 --map-by core --bind-to core ./xhpl > hpl_run_$i.log 2>&1

    # 提取关键指标
    gflops=$(grep -A1 "T/V.*N.*NB.*P.*Q" hpl_run_$i.log | grep -v "T/V\|--" | awk '{print $NF}')
    error=$(grep "||Ax-b||_oo" hpl_run_$i.log | awk -F'= ' '{print $2}' | awk '{print $1}')
    status=$(grep "PASSED\|FAILED" hpl_run_$i.log | awk '{print $NF}')

    # 输出结果
    echo -e "Gflops: \033[32;1m$gflops\033[0m"
    echo -e "Error:  \033[33;1m$error\033[0m"
    echo -e "Status: \033[36;1m$status\033[0m"
    echo -e "\033[36;1m第 $i 次运行完成！\033[0m"
    echo ""

    # 可选：保存汇总结果到文件
    echo "运行$i, $gflops, $error, $status" >> hpl_summary.csv

    # 可选：删除临时日志文件以节省空间
    # rm hpl_run_$i.log
done

# 最终汇总统计
echo -e "\033[35;1m=== 所有运行完成 ===\033[0m"
echo "总运行次数: 1000"
echo "PASSED 次数: $(grep -c "PASSED" hpl_summary.csv)"
echo "FAILED 次数: $(grep -c "FAILED" hpl_summary.csv)"

异常宕机BMC日志无参考价值时的排障思路

2025-09-10T10:35:21.000Z

巡检发现异常宕机，带外日志仅有一条热复位的记录

BMC日志如下：

SYS_Restart 系统启动/重新启动开始热复位 - 触发

仅有一条热复位记录，无物理按键记录，无操作系统发起重启记录

排障思路	命令
排查启动日志	`journalctl -b
排查内核缓冲区	`dmesg --level=err,warn`
排查是否有内核崩溃转储文件	`ls -la /var/crash/`
排查是否有硬件错误	`journalctl -k
排查watchdog是否触发	`journalctl -k
排查过热日志	`journalctl -k
检查内存不足事件	`journalctl -k
检查 CPU 或 I/O 阻塞	`sar -q -f /var/log/sa/sa10`
检查内存错误计数	`dmidecode -t memory
检查电源日志	`journalctl -k

记录一次分析[服务器SSD报故障随后自行恢复正常现象]

2025-09-09T09:36:21.000Z

日常巡检时发现带外出现INTEL SSD故障告警，随后又自行恢复，间隔约30分钟，无人工介入。

smartctl -a /dev/sda

故障原因推测	排障思路
硬盘背板接触问题	检查smartctl中`ID 199 UltraDMA CRC Error Count`的值，是否存在CRC校验错误
NAND闪存寿命是否不足	检查smartctl中`ID 233 Media Wearout Indicator`的值
是否存在坏扇区	检查smartctl中`ID 5 Reallocated sector ct`的值
硬盘备用空间是否不足	检查smartctl中`ID 232 Available Reservd space`的值

实例：

1
2
3

Media Wearout Indicator: 当前值0 临界值100 - 健康
Reallocated Sector Count: 当前值0 临界值75 - 健康
Available Reservd Spare: 当前值0 临界值100 - 健康

关于DELL PowerEdge报错Correctable memory error logging disabled for a memory device的说明

2025-09-04T08:16:54.000Z

关于DELL PowerEdge R740XD iDRAC报内存设备的可纠正内存错误日志记录已禁用问题的说明及解答

巡检发现：iDRAC报错Correctable memory error logging disabled for a memory

致电800-858-0613核实BIOS固件版本低于2.10，固件过旧，属于遗留问题

关于该报错的解释为：BIOS关闭了对于ECC纠错记录的保存，仅仅是没有记录进行了ECC纠错，实际上并不影响使用，可能存在的风险为：无法知晓ECC进行了多少次纠错。

2025-9-4已致电DELL800-858-0613核实，该信息可信

DELL报错The PERC1 battery is low

2025-09-04T06:56:26.000Z

关于DELL iDRAC日志中PERC报错问题的记录及解答

报错信息如下

Sun Jul 06 2025 07:24:49The PERC1 battery is operating normally.
Sun Jul 06 2025 06:50:13The PERC1 battery is low.
Mon Apr 07 2025 04:22:23The PERC1 battery is operating normally.
Mon Apr 07 2025 04:20:18The PERC1 battery is low.

报错内容为PERC电量低，随后又恢复正常，错误复现周期为3个月

查询发现DELL官方文档有记录《了解 PERC 电池错误》，其中《充电问题示例》中的报错疑似与该报错一致，但报错循环周期不同。

查询后了解到PERC是DELL阵列卡的电池，也就是俗称的RAID卡的BBU（Battery Backup Unit），而其中每三个月复现一次的该报错为DELL PERC的正常循环充放电操作，属于正常现象

总结

PERC每3个月重复报错The PERC1 battery is low.随后恢复The PERC1 battery is operating normally.

该报错为RAID卡BBU，电池的充放电报错，每3个月为周期的循环报错是DELL的自检行为，属于正常现象。

2025-9-4已致电DELL800-858-0613核实，该信息可信

Python实现自动将GFWList规则转换为Clash规则

2025-03-05T06:50:15.000Z

环境介绍

代理客户端为Clash Verge Rev

直达官方github仓库

机场为狗狗加速

直达官网

使用邀请码享注册优惠pGwFvdKk

高性能海外机场，免费试用，优惠套餐，解锁流媒体，全球首家支持 Hysteria 协议。
海外团队，无跑路风险，高达 50% 返佣
集群负载均衡设计，高速专线(兼容老客户端)，极低延迟，无视晚高峰，4K 秒开
全球首家 Hysteria 协议机场，现已上线更快的 Hysteria2 协议(Clash Verge 客户端最佳搭配)
解锁流媒体及 ChatGPT

套餐	流量	详情
标准套餐	160G	限速150M，无审计，年付9折
高级套餐	200G	不限速，无审计，年付8折,最新Hysteria协议
豪华套餐	500G	不限速,无审计,2年付6折,最新Hysteria2协议,东南亚节点,微信客服技术支持

开发环境

Python 3.13.2

Clash配置文件的介绍

其余部分不做介绍,采用机场的配置即可

本文只涉及rules:部分,其余部分直接复制下方从狗狗加速官方提取的配置即可

proxies和proxy-groups部分不需要填写,让机场的配置文件覆盖即可,当然下面部分的配置也可以留空,让机场覆盖,只填写rules:部分就可以实现分流

在编辑配置文件之前,先订阅,然后查看当前配置就可以看到机场的rules:,可以先将其备份,添加到GFWList的规则之前,也就是程序中的最高优先级规则部分

mode: rule
mixed-port: 7897
allow-lan: false
log-level: info
external-controller: 127.0.0.1:9097
secret: ''
unified-delay: true
tun:
  mtu: 1500
  auto-detect-interface: true
  auto-route: true
  device: Mihomo
  dns-hijack:
  - any:53
  stack: mixed
  strict-route: false
  enable: true
dns:
  enable: true
  use-system-hosts: false
  listen: 127.0.0.1:5335
  default-nameserver:
  - 180.76.76.76
  - 182.254.118.118
  - 8.8.8.8
  - 180.184.2.2
  enhanced-mode: fake-ip
  fake-ip-range: 198.18.0.1/16
  fake-ip-filter:
  - '*.lan'
  - stun.*.*.*
  - stun.*.*
  - time.windows.com
  - time.nist.gov
  - time.apple.com
  - time.asia.apple.com
  - '*.ntp.org.cn'
  - '*.openwrt.pool.ntp.org'
  - time1.cloud.tencent.com
  - time.ustc.edu.cn
  - pool.ntp.org
  - ntp.ubuntu.com
  - ntp.aliyun.com
  - ntp1.aliyun.com
  - ntp2.aliyun.com
  - ntp3.aliyun.com
  - ntp4.aliyun.com
  - ntp5.aliyun.com
  - ntp6.aliyun.com
  - ntp7.aliyun.com
  - time1.aliyun.com
  - time2.aliyun.com
  - time3.aliyun.com
  - time4.aliyun.com
  - time5.aliyun.com
  - time6.aliyun.com
  - time7.aliyun.com
  - '*.time.edu.cn'
  - time1.apple.com
  - time2.apple.com
  - time3.apple.com
  - time4.apple.com
  - time5.apple.com
  - time6.apple.com
  - time7.apple.com
  - time1.google.com
  - time2.google.com
  - time3.google.com
  - time4.google.com
  - music.163.com
  - '*.music.163.com'
  - '*.126.net'
  - musicapi.taihe.com
  - music.taihe.com
  - songsearch.kugou.com
  - trackercdn.kugou.com
  - '*.kuwo.cn'
  - api-jooxtt.sanook.com
  - api.joox.com
  - joox.com
  - y.qq.com
  - '*.y.qq.com'
  - streamoc.music.tc.qq.com
  - mobileoc.music.tc.qq.com
  - isure.stream.qqmusic.qq.com
  - dl.stream.qqmusic.qq.com
  - aqqmusic.tc.qq.com
  - amobile.music.tc.qq.com
  - '*.xiami.com'
  - '*.music.migu.cn'
  - music.migu.cn
  - '*.msftconnecttest.com'
  - '*.msftncsi.com'
  - localhost.ptlogin2.qq.com
  - '*.*.*.srv.nintendo.net'
  - '*.*.stun.playstation.net'
  - xbox.*.*.microsoft.com
  - '*.ipv6.microsoft.com'
  - '*.*.xboxlive.com'
  - speedtest.cros.wr.pvp.net
  nameserver:
  - 180.76.76.76
  - 119.29.29.29
  - 180.184.1.1
  - 223.5.5.5
  - 8.8.8.8
  - https://223.6.6.6/dns-query#h3=true
  - https://223.5.5.5/dns-query
  - https://cloudflare-dns.com/dns-query
  - https://doh.pub/dns-query
  fallback:
  - https://000000.dns.nextdns.io/dns-query#h3=true
  - https://101.101.101.101/dns-query
  - https://208.67.220.220/dns-query
  - tls://8.8.4.4
  - tls://1.0.0.1:853
  - https://cloudflare-dns.com/dns-query
  - https://dns.google/dns-query
  fallback-filter:
    geoip: true
    ipcidr:
    - 240.0.0.0/4
    - 0.0.0.0/32
    - 127.0.0.1/32
    domain:
    - +.google.com
    - +.facebook.com
    - +.twitter.com
    - +.youtube.com
    - +.xn--ngstr-lra8j.com
    - +.google.cn
    - +.googleapis.cn
    - +.googleapis.com
    - +.gvt1.com
  ipv6: false
external-controller-cors:
  allow-private-network: true
  allow-origins:
  - '*'

profile:
  store-selected: true

rules部分

规则参数:

DOMAIN - 匹配完整域名,不包含子域名.例如:- DOMAIN,example.com,DIRECT

DOMAIN-SUFFIX - 匹配域名后缀,可以匹配子域名.例如:- DOMAIN-SUFFIX,example.com,PROXY

DOMAIN-KEYWORD - 匹配域名中包含的关键字,不限定位置.例如:- DOMAIN-KEYWORD,google,PROXY

PROCESS-NAME(仅 Clash for Windows / Clash Meta 支持) - 匹配进程名,仅适用于 TUN 模式.例如:- PROCESS-NAME,chrome.exe,PROXY

IP-CIDR - 匹配IPv4 地址段,可以带 no-resolve 以防止 Clash 进行 DNS 解析.例如:- IP-CIDR,192.168.1.0/24,DIRECT
如果不想 Clash 解析 IP 地址对应的域名,可以加 no-resolve:- IP-CIDR,192.168.1.0/24,DIRECT,no-resolve

IP-CIDR6 - 匹配IPv6 地址段,用法与 IP-CIDR 类似.例如:- IP-CIDR6,2400:3200::/32,DIRECT

GEOIP - 匹配IP 地址归属地(基于 GeoIP 数据库).例如: - GEOIP,CN,DIRECT
如果要让 Clash 不解析域名,可以加 no-resolve:- GEOIP,CN,DIRECT,no-resolve

MATCH - 匹配所有流量,通常作为最后的兜底规则.例如:- MATCH,PROXY

其中的DIRECT为直连,PROXY为你的proxy-groups的name部分,例如狗狗加速的name: 狗狗加速.com和name: 🔥ChatGPT

1 2	# 以狗狗加速机场的代理组"🔥ChatGPT"为例 - DOMAIN-KEYWORD,openai,🔥ChatGPT

Clash 按规则的先后顺序进行匹配，第一个匹配成功的规则生效，后面的规则不会再被执行。因此，一般规则顺序建议：

PROCESS-NAME 规则
DOMAIN 规则
DOMAIN-SUFFIX 规则
DOMAIN-KEYWORD 规则
IP-CIDR / IP-CIDR6 规则
GEOIP 规则
MATCH 规则（兜底）

代码

import re
import base64
import requests
import ipaddress

# GFWList 地址
GFWLIST_URL = "https://raw.githubusercontent.com/gfwlist/gfwlist/master/gfwlist.txt"

# 预置规则 - 来源于上文提到的机场的规则和你自己手动添加的规则
# 此处预置了狗狗加速机场的规则
highest_priority_rules = """rules:
- DOMAIN,subapi.doggysub.uk,DIRECT
- PROCESS-NAME,v2ray,DIRECT
- PROCESS-NAME,xray,DIRECT
- PROCESS-NAME,naive,DIRECT
- PROCESS-NAME,trojan,DIRECT
- PROCESS-NAME,trojan-go,DIRECT
- PROCESS-NAME,ss-local,DIRECT
- PROCESS-NAME,privoxy,DIRECT
- PROCESS-NAME,leaf,DIRECT
- PROCESS-NAME,v2ray.exe,DIRECT
- PROCESS-NAME,xray.exe,DIRECT
- PROCESS-NAME,naive.exe,DIRECT
- PROCESS-NAME,trojan.exe,DIRECT
- PROCESS-NAME,trojan-go.exe,DIRECT
- PROCESS-NAME,ss-local.exe,DIRECT
- PROCESS-NAME,privoxy.exe,DIRECT
- PROCESS-NAME,leaf.exe,DIRECT
- PROCESS-NAME,Surge,DIRECT
- PROCESS-NAME,Surge 2,DIRECT
- PROCESS-NAME,Surge 3,DIRECT
- PROCESS-NAME,Surge 4,DIRECT
- PROCESS-NAME,Surge%202,DIRECT
- PROCESS-NAME,Surge%203,DIRECT
- PROCESS-NAME,Surge%204,DIRECT
- PROCESS-NAME,Thunder,DIRECT
- PROCESS-NAME,DownloadService,DIRECT
- PROCESS-NAME,qBittorrent,DIRECT
- PROCESS-NAME,Transmission,DIRECT
- PROCESS-NAME,fdm,DIRECT
- PROCESS-NAME,aria2c,DIRECT
- PROCESS-NAME,Folx,DIRECT
- PROCESS-NAME,NetTransport,DIRECT
- PROCESS-NAME,uTorrent,DIRECT
- PROCESS-NAME,WebTorrent,DIRECT
- PROCESS-NAME,aria2c.exe,DIRECT
- PROCESS-NAME,BitComet.exe,DIRECT
- PROCESS-NAME,fdm.exe,DIRECT
- PROCESS-NAME,NetTransport.exe,DIRECT
- PROCESS-NAME,qbittorrent.exe,DIRECT
- PROCESS-NAME,Thunder.exe,DIRECT
- PROCESS-NAME,ThunderVIP.exe,DIRECT
- PROCESS-NAME,transmission-daemon.exe,DIRECT
- PROCESS-NAME,transmission-qt.exe,DIRECT
- PROCESS-NAME,uTorrent.exe,DIRECT
- PROCESS-NAME,WebTorrent.exe,DIRECT
- PROCESS-NAME,aDrive.exe,DIRECT
- DOMAIN-SUFFIX,services.googleapis.cn,狗狗加速.com
- DOMAIN-SUFFIX,xn--ngstr-lra8j.com,狗狗加速.com
- DOMAIN,safebrowsing.urlsec.qq.com,DIRECT
- DOMAIN,safebrowsing.googleapis.com,DIRECT
- DOMAIN,developer.apple.com,狗狗加速.com
- DOMAIN-SUFFIX,digicert.com,狗狗加速.com
- DOMAIN,ocsp.apple.com,狗狗加速.com
- DOMAIN,ocsp.comodoca.com,狗狗加速.com
- DOMAIN,ocsp.usertrust.com,狗狗加速.com
- DOMAIN,ocsp.sectigo.com,狗狗加速.com
- DOMAIN,ocsp.verisign.net,狗狗加速.com
- DOMAIN-SUFFIX,apple-dns.net,狗狗加速.com
- DOMAIN,testflight.apple.com,狗狗加速.com
- DOMAIN,sandbox.itunes.apple.com,狗狗加速.com
- DOMAIN,itunes.apple.com,狗狗加速.com
- DOMAIN-SUFFIX,apps.apple.com,狗狗加速.com
- DOMAIN-SUFFIX,blobstore.apple.com,狗狗加速.com
- DOMAIN,cvws.icloud-content.com,狗狗加速.com
- DOMAIN-SUFFIX,mzstatic.com,DIRECT
- DOMAIN-SUFFIX,itunes.apple.com,DIRECT
- DOMAIN-SUFFIX,icloud.com,DIRECT
- DOMAIN-SUFFIX,icloud-content.com,DIRECT
- DOMAIN-SUFFIX,me.com,DIRECT
- DOMAIN-SUFFIX,aaplimg.com,DIRECT
- DOMAIN-SUFFIX,cdn20.com,DIRECT
- DOMAIN-SUFFIX,cdn-apple.com,DIRECT
- DOMAIN-SUFFIX,akadns.net,DIRECT
- DOMAIN-SUFFIX,akamaiedge.net,DIRECT
- DOMAIN-SUFFIX,edgekey.net,DIRECT
- DOMAIN-SUFFIX,mwcloudcdn.com,DIRECT
- DOMAIN-SUFFIX,mwcname.com,DIRECT
- DOMAIN-SUFFIX,apple.com,DIRECT
- DOMAIN-SUFFIX,apple-cloudkit.com,DIRECT
- DOMAIN-SUFFIX,apple-mapkit.com,DIRECT
- DOMAIN,browser-intake-datadoghq.com,🔥ChatGPT
- DOMAIN,chat.openai.com.cdn.cloudflare.net,🔥ChatGPT
- DOMAIN,gemini.google.com,🔥ChatGPT
- DOMAIN,openai-api.arkoselabs.com,🔥ChatGPT
- DOMAIN,openaicom-api-bdcpf8c6d2e9atf6.z01.azurefd.net,🔥ChatGPT
- DOMAIN,openaicomproductionae4b.blob.core.windows.net,🔥ChatGPT
- DOMAIN,production-openaicom-storage.azureedge.net,🔥ChatGPT
- DOMAIN,static.cloudflareinsights.com,🔥ChatGPT
- DOMAIN-SUFFIX,ai.com,🔥ChatGPT
- DOMAIN-SUFFIX,algolia.net,🔥ChatGPT
- DOMAIN-SUFFIX,api.statsig.com,🔥ChatGPT
- DOMAIN-SUFFIX,auth0.com,🔥ChatGPT
- DOMAIN-SUFFIX,chatgpt.com,🔥ChatGPT
- DOMAIN-SUFFIX,chatgpt.livekit.cloud,🔥ChatGPT
- DOMAIN-SUFFIX,client-api.arkoselabs.com,🔥ChatGPT
- DOMAIN-SUFFIX,events.statsigapi.net,🔥ChatGPT
- DOMAIN-SUFFIX,featuregates.org,🔥ChatGPT
- DOMAIN-SUFFIX,host.livekit.cloud,🔥ChatGPT
- DOMAIN-SUFFIX,identrust.com,🔥ChatGPT
- DOMAIN-SUFFIX,intercom.io,🔥ChatGPT
- DOMAIN-SUFFIX,intercomcdn.com,🔥ChatGPT
- DOMAIN-SUFFIX,launchdarkly.com,🔥ChatGPT
- DOMAIN-SUFFIX,oaistatic.com,🔥ChatGPT
- DOMAIN-SUFFIX,oaiusercontent.com,🔥ChatGPT
- DOMAIN-SUFFIX,observeit.net,🔥ChatGPT
- DOMAIN-SUFFIX,openai.com,🔥ChatGPT
- DOMAIN-SUFFIX,openaiapi-site.azureedge.net,🔥ChatGPT
- DOMAIN-SUFFIX,openaicom.imgix.net,🔥ChatGPT
- DOMAIN-SUFFIX,segment.io,🔥ChatGPT
- DOMAIN-SUFFIX,sentry.io,🔥ChatGPT
- DOMAIN-SUFFIX,stripe.com,🔥ChatGPT
- DOMAIN-SUFFIX,turn.livekit.cloud,🔥ChatGPT
- DOMAIN-SUFFIX,sora.com,🔥ChatGPT
- DOMAIN-KEYWORD,openai,🔥ChatGPT
- DOMAIN,api.msn.com,🔥ChatGPT
- DOMAIN,api.statsig.com,🔥ChatGPT
- DOMAIN,assets.msn.com,🔥ChatGPT
- DOMAIN,browser-intake-datadoghq.com,🔥ChatGPT
- DOMAIN,chat.openai.com.cdn.cloudflare.net,🔥ChatGPT
- DOMAIN,copilot.microsoft.com,🔥ChatGPT
- DOMAIN,gateway.bingviz.microsoft.net,🔥ChatGPT
- DOMAIN,gateway.bingviz.microsoftapp.net,🔥ChatGPT
- DOMAIN,in.appcenter.ms,🔥ChatGPT
- DOMAIN,location.microsoft.com,🔥ChatGPT
- DOMAIN,odc.officeapps.live.com,🔥ChatGPT
- DOMAIN,openai-api.arkoselabs.com,🔥ChatGPT
- DOMAIN,openaicomproductionae4b.blob.core.windows.net,🔥ChatGPT
- DOMAIN,production-openaicom-storage.azureedge.net,🔥ChatGPT
- DOMAIN,r.bing.com,🔥ChatGPT
- DOMAIN,self.events.data.microsoft.com,🔥ChatGPT
- DOMAIN,services.bingapis.com,🔥ChatGPT
- DOMAIN,static.cloudflareinsights.com,🔥ChatGPT
- DOMAIN,sydney.bing.com,🔥ChatGPT
- DOMAIN,www.bing.com,🔥ChatGPT
- DOMAIN-SUFFIX,algolia.net,🔥ChatGPT
- DOMAIN-SUFFIX,api.microsoftapp.net,🔥ChatGPT
- DOMAIN-SUFFIX,auth0.com,🔥ChatGPT
- DOMAIN-SUFFIX,bing-shopping.microsoft-falcon.io,🔥ChatGPT
- DOMAIN-SUFFIX,challenges.cloudflare.com,🔥ChatGPT
- DOMAIN-SUFFIX,chatgpt.com,🔥ChatGPT
- DOMAIN-SUFFIX,chatgpt.livekit.cloud,🔥ChatGPT
- DOMAIN-SUFFIX,client-api.arkoselabs.com,🔥ChatGPT
- DOMAIN-SUFFIX,edgeservices.bing.com,🔥ChatGPT
- DOMAIN-SUFFIX,events.statsigapi.net,🔥ChatGPT
- DOMAIN-SUFFIX,featuregates.org,🔥ChatGPT
- DOMAIN-SUFFIX,host.livekit.cloud,🔥ChatGPT
- DOMAIN-SUFFIX,identrust.com,🔥ChatGPT
- DOMAIN-SUFFIX,intercom.io,🔥ChatGPT
- DOMAIN-SUFFIX,intercomcdn.com,🔥ChatGPT
- DOMAIN-SUFFIX,launchdarkly.com,🔥ChatGPT
- DOMAIN-SUFFIX,oaistatic.com,🔥ChatGPT
- DOMAIN-SUFFIX,oaiusercontent.com,🔥ChatGPT
- DOMAIN-SUFFIX,observeit.net,🔥ChatGPT
- DOMAIN-SUFFIX,openai.com,🔥ChatGPT
- DOMAIN-SUFFIX,openaiapi-site.azureedge.net,🔥ChatGPT
- DOMAIN-SUFFIX,openaicom.imgix.net,🔥ChatGPT
- DOMAIN-SUFFIX,segment.io,🔥ChatGPT
- DOMAIN-SUFFIX,sentry.io,🔥ChatGPT
- DOMAIN-SUFFIX,stripe.com,🔥ChatGPT
- DOMAIN-SUFFIX,turn.livekit.cloud,🔥ChatGPT
- DOMAIN-KEYWORD,openaicom-api,🔥ChatGPT
- DOMAIN,ai.google.dev,🔥ChatGPT
- DOMAIN,alkalimakersuite-pa.clients6.google.com,🔥ChatGPT
- DOMAIN,makersuite.google.com,🔥ChatGPT
- DOMAIN-SUFFIX,bard.google.com,🔥ChatGPT
- DOMAIN-SUFFIX,deepmind.com,🔥ChatGPT
- DOMAIN-SUFFIX,deepmind.google,🔥ChatGPT
- DOMAIN-SUFFIX,gemini.google.com,🔥ChatGPT
- DOMAIN-SUFFIX,generativeai.google,🔥ChatGPT
- DOMAIN-SUFFIX,proactivebackend-pa.googleapis.com,🔥ChatGPT
- DOMAIN-SUFFIX,apis.google.com,🔥ChatGPT
- DOMAIN-KEYWORD,colab,🔥ChatGPT
- DOMAIN-KEYWORD,developerprofiles,🔥ChatGPT
- DOMAIN-KEYWORD,generativelanguage,🔥ChatGPT
- DOMAIN,cdn.usefathom.com,🔥ChatGPT
- DOMAIN-SUFFIX,anthropic.com,🔥ChatGPT
- DOMAIN-SUFFIX,claude.ai,🔥ChatGPT
- DOMAIN-SUFFIX,razie.ai,🔥ChatGPT
- DOMAIN-SUFFIX,razie.aws.intellij.net,🔥ChatGPT
- DOMAIN-SUFFIX,etbrains.ai,🔥ChatGPT
- DOMAIN-SUFFIX,meta.com,🔥ChatGPT
- DOMAIN-SUFFIX,cn,DIRECT
- DOMAIN-KEYWORD,-cn,DIRECT
- DOMAIN-SUFFIX,126.com,DIRECT
- DOMAIN-SUFFIX,126.net,DIRECT
- DOMAIN-SUFFIX,127.net,DIRECT
- DOMAIN-SUFFIX,163.com,DIRECT
- DOMAIN-SUFFIX,360buyimg.com,DIRECT
- DOMAIN-SUFFIX,36kr.com,DIRECT
- DOMAIN-SUFFIX,acfun.tv,DIRECT
- DOMAIN-SUFFIX,air-matters.com,DIRECT
- DOMAIN-SUFFIX,aixifan.com,DIRECT
- DOMAIN-KEYWORD,alicdn,DIRECT
- DOMAIN-KEYWORD,alipay,DIRECT
- DOMAIN-KEYWORD,taobao,DIRECT
- DOMAIN-SUFFIX,amap.com,DIRECT
- DOMAIN-SUFFIX,autonavi.com,DIRECT
- DOMAIN-KEYWORD,baidu,DIRECT
- DOMAIN-SUFFIX,bdimg.com,DIRECT
- DOMAIN-SUFFIX,bdstatic.com,DIRECT
- DOMAIN-SUFFIX,bilibili.com,DIRECT
- DOMAIN-SUFFIX,bilivideo.com,DIRECT
- DOMAIN-SUFFIX,caiyunapp.com,DIRECT
- DOMAIN-SUFFIX,clouddn.com,DIRECT
- DOMAIN-SUFFIX,cnbeta.com,DIRECT
- DOMAIN-SUFFIX,cnbetacdn.com,DIRECT
- DOMAIN-SUFFIX,cootekservice.com,DIRECT
- DOMAIN-SUFFIX,csdn.net,DIRECT
- DOMAIN-SUFFIX,ctrip.com,DIRECT
- DOMAIN-SUFFIX,dgtle.com,DIRECT
- DOMAIN-SUFFIX,dianping.com,DIRECT
- DOMAIN-SUFFIX,douban.com,DIRECT
- DOMAIN-SUFFIX,doubanio.com,DIRECT
- DOMAIN-SUFFIX,duokan.com,DIRECT
- DOMAIN-SUFFIX,easou.com,DIRECT
- DOMAIN-SUFFIX,ele.me,DIRECT
- DOMAIN-SUFFIX,feng.com,DIRECT
- DOMAIN-SUFFIX,fir.im,DIRECT
- DOMAIN-SUFFIX,frdic.com,DIRECT
- DOMAIN-SUFFIX,g-cores.com,DIRECT
- DOMAIN-SUFFIX,godic.net,DIRECT
- DOMAIN-SUFFIX,gtimg.com,DIRECT
- DOMAIN,cdn.hockeyapp.net,DIRECT
- DOMAIN-SUFFIX,hongxiu.com,DIRECT
- DOMAIN-SUFFIX,hxcdn.net,DIRECT
- DOMAIN-SUFFIX,iciba.com,DIRECT
- DOMAIN-SUFFIX,ifeng.com,DIRECT
- DOMAIN-SUFFIX,ifengimg.com,DIRECT
- DOMAIN-SUFFIX,ipip.net,DIRECT
- DOMAIN-SUFFIX,iqiyi.com,DIRECT
- DOMAIN-SUFFIX,jd.com,DIRECT
- DOMAIN-SUFFIX,jianshu.com,DIRECT
- DOMAIN-SUFFIX,knewone.com,DIRECT
- DOMAIN-SUFFIX,le.com,DIRECT
- DOMAIN-SUFFIX,lecloud.com,DIRECT
- DOMAIN-SUFFIX,lemicp.com,DIRECT
- DOMAIN-SUFFIX,luoo.net,DIRECT
- DOMAIN-SUFFIX,meituan.com,DIRECT
- DOMAIN-SUFFIX,meituan.net,DIRECT
- DOMAIN-SUFFIX,mi.com,DIRECT
- DOMAIN-SUFFIX,miaopai.com,DIRECT
- DOMAIN-SUFFIX,microsoft.com,DIRECT
- DOMAIN-SUFFIX,microsoftonline.com,DIRECT
- DOMAIN-SUFFIX,miui.com,DIRECT
- DOMAIN-SUFFIX,miwifi.com,DIRECT
- DOMAIN-SUFFIX,mob.com,DIRECT
- DOMAIN-SUFFIX,netease.com,DIRECT
- DOMAIN-SUFFIX,office.com,DIRECT
- DOMAIN-SUFFIX,office365.com,DIRECT
- DOMAIN-KEYWORD,officecdn,DIRECT
- DOMAIN-SUFFIX,oschina.net,DIRECT
- DOMAIN-SUFFIX,ppsimg.com,DIRECT
- DOMAIN-SUFFIX,pstatp.com,DIRECT
- DOMAIN-SUFFIX,qcloud.com,DIRECT
- DOMAIN-SUFFIX,qdaily.com,DIRECT
- DOMAIN-SUFFIX,qdmm.com,DIRECT
- DOMAIN-SUFFIX,qhimg.com,DIRECT
- DOMAIN-SUFFIX,qhres.com,DIRECT
- DOMAIN-SUFFIX,qidian.com,DIRECT
- DOMAIN-SUFFIX,qihucdn.com,DIRECT
- DOMAIN-SUFFIX,qiniu.com,DIRECT
- DOMAIN-SUFFIX,qiniucdn.com,DIRECT
- DOMAIN-SUFFIX,qiyipic.com,DIRECT
- DOMAIN-SUFFIX,qq.com,DIRECT
- DOMAIN-SUFFIX,qqurl.com,DIRECT
- DOMAIN-SUFFIX,rarbg.to,DIRECT
- DOMAIN-SUFFIX,ruguoapp.com,DIRECT
- DOMAIN-SUFFIX,segmentfault.com,DIRECT
- DOMAIN-SUFFIX,sinaapp.com,DIRECT
- DOMAIN-SUFFIX,smzdm.com,DIRECT
- DOMAIN-SUFFIX,snapdrop.net,DIRECT
- DOMAIN-SUFFIX,sogou.com,DIRECT
- DOMAIN-SUFFIX,sogoucdn.com,DIRECT
- DOMAIN-SUFFIX,sohu.com,DIRECT
- DOMAIN-SUFFIX,soku.com,DIRECT
- DOMAIN-SUFFIX,speedtest.net,DIRECT
- DOMAIN-SUFFIX,sspai.com,DIRECT
- DOMAIN-SUFFIX,suning.com,DIRECT
- DOMAIN-SUFFIX,taobao.com,DIRECT
- DOMAIN-SUFFIX,tencent.com,DIRECT
- DOMAIN-SUFFIX,tenpay.com,DIRECT
- DOMAIN-SUFFIX,tianyancha.com,DIRECT
- DOMAIN-SUFFIX,tmall.com,DIRECT
- DOMAIN-SUFFIX,tudou.com,DIRECT
- DOMAIN-SUFFIX,umetrip.com,DIRECT
- DOMAIN-SUFFIX,upaiyun.com,DIRECT
- DOMAIN-SUFFIX,upyun.com,DIRECT
- DOMAIN-SUFFIX,veryzhun.com,DIRECT
- DOMAIN-SUFFIX,weather.com,DIRECT
- DOMAIN-SUFFIX,weibo.com,DIRECT
- DOMAIN-SUFFIX,xiami.com,DIRECT
- DOMAIN-SUFFIX,xiami.net,DIRECT
- DOMAIN-SUFFIX,xiaomicp.com,DIRECT
- DOMAIN-SUFFIX,ximalaya.com,DIRECT
- DOMAIN-SUFFIX,xmcdn.com,DIRECT
- DOMAIN-SUFFIX,xunlei.com,DIRECT
- DOMAIN-SUFFIX,yhd.com,DIRECT
- DOMAIN-SUFFIX,yihaodianimg.com,DIRECT
- DOMAIN-SUFFIX,yinxiang.com,DIRECT
- DOMAIN-SUFFIX,ykimg.com,DIRECT
- DOMAIN-SUFFIX,youdao.com,DIRECT
- DOMAIN-SUFFIX,youku.com,DIRECT
- DOMAIN-SUFFIX,zealer.com,DIRECT
- DOMAIN-SUFFIX,zhihu.com,DIRECT
- DOMAIN-SUFFIX,zhimg.com,DIRECT
- DOMAIN-SUFFIX,zimuzu.tv,DIRECT
- DOMAIN-SUFFIX,zoho.com,DIRECT
- DOMAIN,fastly-download.epicgames.com,DIRECT
- DOMAIN,epicgames-download1.akamaized.net,DIRECT
- DOMAIN,steamcdn-a.akamaihd.net,DIRECT
- DOMAIN-SUFFIX,steamserver.net,DIRECT
- DOMAIN-SUFFIX,cm.steampowered.com,DIRECT
- DOMAIN-SUFFIX,synology.com,DIRECT
- DOMAIN-SUFFIX,dyndns.org,DIRECT
- DOMAIN-SUFFIX,egdownload.fastly-edge.com,DIRECT
- DOMAIN-KEYWORD,amazon,狗狗加速.com
- DOMAIN-KEYWORD,google,狗狗加速.com
- DOMAIN-KEYWORD,gmail,狗狗加速.com
- DOMAIN-KEYWORD,youtube,狗狗加速.com
- DOMAIN-KEYWORD,facebook,狗狗加速.com
- DOMAIN-SUFFIX,fb.me,狗狗加速.com
- DOMAIN-SUFFIX,fbcdn.net,狗狗加速.com
- DOMAIN-KEYWORD,twitter,狗狗加速.com
- DOMAIN-KEYWORD,instagram,狗狗加速.com
- DOMAIN-KEYWORD,dropbox,狗狗加速.com
- DOMAIN-SUFFIX,twimg.com,狗狗加速.com
- DOMAIN-KEYWORD,blogspot,狗狗加速.com
- DOMAIN-SUFFIX,youtu.be,狗狗加速.com
- DOMAIN-KEYWORD,whatsapp,狗狗加速.com
- DOMAIN-SUFFIX,ipleak.net,狗狗加速.com
- DOMAIN-SUFFIX,browserscan.net,狗狗加速.com
- DOMAIN-SUFFIX,surfsharkdns.com,狗狗加速.com
- DOMAIN-SUFFIX,edns.ip-api.com,狗狗加速.com
- DOMAIN-SUFFIX,dnsleaktest.com,狗狗加速.com
- DOMAIN-SUFFIX,dnsleak.com,狗狗加速.com
- DOMAIN-SUFFIX,expressvpn.com,狗狗加速.com
- DOMAIN-SUFFIX,nordvpn.com,狗狗加速.com
- DOMAIN-SUFFIX,surfshark.com,狗狗加速.com
- DOMAIN-SUFFIX,perfect-privacy.com,狗狗加速.com
- DOMAIN-SUFFIX,browserleaks.com,狗狗加速.com
- DOMAIN-SUFFIX,browserleaks.org,狗狗加速.com
- DOMAIN-SUFFIX,browserleaks.net,狗狗加速.com
- DOMAIN-SUFFIX,vpnunlimited.com,狗狗加速.com
- DOMAIN-SUFFIX,whoer.net,狗狗加速.com
- DOMAIN-SUFFIX,whrq.net,狗狗加速.com
- DOMAIN-KEYWORD,admarvel,REJECT
- DOMAIN-KEYWORD,admaster,REJECT
- DOMAIN-KEYWORD,adsage,REJECT
- DOMAIN-KEYWORD,adsmogo,REJECT
- DOMAIN-KEYWORD,adsrvmedia,REJECT
- DOMAIN-KEYWORD,adwords,REJECT
- DOMAIN-KEYWORD,adservice,REJECT
- DOMAIN-SUFFIX,appsflyer.com,REJECT
- DOMAIN-KEYWORD,domob,REJECT
- DOMAIN-SUFFIX,doubleclick.net,REJECT
- DOMAIN-KEYWORD,duomeng,REJECT
- DOMAIN-KEYWORD,dwtrack,REJECT
- DOMAIN-KEYWORD,guanggao,REJECT
- DOMAIN-KEYWORD,lianmeng,REJECT
- DOMAIN-SUFFIX,mmstat.com,REJECT
- DOMAIN-KEYWORD,mopub,REJECT
- DOMAIN-KEYWORD,omgmta,REJECT
- DOMAIN-KEYWORD,openx,REJECT
- DOMAIN-KEYWORD,partnerad,REJECT
- DOMAIN-KEYWORD,pingfore,REJECT
- DOMAIN-KEYWORD,supersonicads,REJECT
- DOMAIN-KEYWORD,uedas,REJECT
- DOMAIN-KEYWORD,umeng,REJECT
- DOMAIN-KEYWORD,usage,REJECT
- DOMAIN-SUFFIX,vungle.com,REJECT
- DOMAIN-KEYWORD,wlmonitor,REJECT
- DOMAIN-KEYWORD,zjtoolbar,REJECT
- DOMAIN-SUFFIX,linkedin.com,狗狗加速.com
- DOMAIN-SUFFIX,licdn.com,狗狗加速.com
- DOMAIN-SUFFIX,9to5mac.com,狗狗加速.com
- DOMAIN-SUFFIX,abpchina.org,狗狗加速.com
- DOMAIN-SUFFIX,adblockplus.org,狗狗加速.com
- DOMAIN-SUFFIX,adobe.com,狗狗加速.com
- DOMAIN-SUFFIX,akamaized.net,狗狗加速.com
- DOMAIN-SUFFIX,alfredapp.com,狗狗加速.com
- DOMAIN-SUFFIX,amplitude.com,狗狗加速.com
- DOMAIN-SUFFIX,ampproject.org,狗狗加速.com
- DOMAIN-SUFFIX,android.com,狗狗加速.com
- DOMAIN-SUFFIX,angularjs.org,狗狗加速.com
- DOMAIN-SUFFIX,aolcdn.com,狗狗加速.com
- DOMAIN-SUFFIX,apkpure.com,狗狗加速.com
- DOMAIN-SUFFIX,appledaily.com,狗狗加速.com
- DOMAIN-SUFFIX,appshopper.com,狗狗加速.com
- DOMAIN-SUFFIX,appspot.com,狗狗加速.com
- DOMAIN-SUFFIX,arcgis.com,狗狗加速.com
- DOMAIN-SUFFIX,archive.org,狗狗加速.com
- DOMAIN-SUFFIX,armorgames.com,狗狗加速.com
- DOMAIN-SUFFIX,aspnetcdn.com,狗狗加速.com
- DOMAIN-SUFFIX,att.com,狗狗加速.com
- DOMAIN-SUFFIX,awsstatic.com,狗狗加速.com
- DOMAIN-SUFFIX,azurewebsites.net,狗狗加速.com
- DOMAIN-SUFFIX,bing.com,狗狗加速.com
- DOMAIN-SUFFIX,bintray.com,狗狗加速.com
- DOMAIN-SUFFIX,bit.com,狗狗加速.com
- DOMAIN-SUFFIX,bit.ly,狗狗加速.com
- DOMAIN-SUFFIX,bitbucket.org,狗狗加速.com
- DOMAIN-SUFFIX,bjango.com,狗狗加速.com
- DOMAIN-SUFFIX,bkrtx.com,狗狗加速.com
- DOMAIN-SUFFIX,blog.com,狗狗加速.com
- DOMAIN-SUFFIX,blogcdn.com,狗狗加速.com
- DOMAIN-SUFFIX,blogger.com,狗狗加速.com
- DOMAIN-SUFFIX,blogsmithmedia.com,狗狗加速.com
- DOMAIN-SUFFIX,blogspot.com,狗狗加速.com
- DOMAIN-SUFFIX,blogspot.hk,狗狗加速.com
- DOMAIN-SUFFIX,bloomberg.com,狗狗加速.com
- DOMAIN-SUFFIX,box.com,狗狗加速.com
- DOMAIN-SUFFIX,box.net,狗狗加速.com
- DOMAIN-SUFFIX,cachefly.net,狗狗加速.com
- DOMAIN-SUFFIX,chromium.org,狗狗加速.com
- DOMAIN-SUFFIX,cl.ly,狗狗加速.com
- DOMAIN-SUFFIX,cloudflare.com,狗狗加速.com
- DOMAIN-SUFFIX,cloudfront.net,狗狗加速.com
- DOMAIN-SUFFIX,cloudmagic.com,狗狗加速.com
- DOMAIN-SUFFIX,cmail19.com,狗狗加速.com
- DOMAIN-SUFFIX,cnet.com,狗狗加速.com
- DOMAIN-SUFFIX,cocoapods.org,狗狗加速.com
- DOMAIN-SUFFIX,comodoca.com,狗狗加速.com
- DOMAIN-SUFFIX,crashlytics.com,狗狗加速.com
- DOMAIN-SUFFIX,culturedcode.com,狗狗加速.com
- DOMAIN-SUFFIX,d.pr,狗狗加速.com
- DOMAIN-SUFFIX,danilo.to,狗狗加速.com
- DOMAIN-SUFFIX,dayone.me,狗狗加速.com
- DOMAIN-SUFFIX,db.tt,狗狗加速.com
- DOMAIN-SUFFIX,deskconnect.com,狗狗加速.com
- DOMAIN-SUFFIX,disq.us,狗狗加速.com
- DOMAIN-SUFFIX,disqus.com,狗狗加速.com
- DOMAIN-SUFFIX,disquscdn.com,狗狗加速.com
- DOMAIN-SUFFIX,dnsimple.com,狗狗加速.com
- DOMAIN-SUFFIX,docker.com,狗狗加速.com
- DOMAIN-SUFFIX,dribbble.com,狗狗加速.com
- DOMAIN-SUFFIX,droplr.com,狗狗加速.com
- DOMAIN-SUFFIX,duckduckgo.com,狗狗加速.com
- DOMAIN-SUFFIX,dueapp.com,狗狗加速.com
- DOMAIN-SUFFIX,dytt8.net,狗狗加速.com
- DOMAIN-SUFFIX,edgecastcdn.net,狗狗加速.com
- DOMAIN-SUFFIX,edgekey.net,狗狗加速.com
- DOMAIN-SUFFIX,edgesuite.net,狗狗加速.com
- DOMAIN-SUFFIX,engadget.com,狗狗加速.com
- DOMAIN-SUFFIX,entrust.net,狗狗加速.com
- DOMAIN-SUFFIX,eurekavpt.com,狗狗加速.com
- DOMAIN-SUFFIX,evernote.com,狗狗加速.com
- DOMAIN-SUFFIX,fabric.io,狗狗加速.com
- DOMAIN-SUFFIX,fast.com,狗狗加速.com
- DOMAIN-SUFFIX,fastly.net,狗狗加速.com
- DOMAIN-SUFFIX,fc2.com,狗狗加速.com
- DOMAIN-SUFFIX,feedburner.com,狗狗加速.com
- DOMAIN-SUFFIX,feedly.com,狗狗加速.com
- DOMAIN-SUFFIX,feedsportal.com,狗狗加速.com
- DOMAIN-SUFFIX,fiftythree.com,狗狗加速.com
- DOMAIN-SUFFIX,firebaseio.com,狗狗加速.com
- DOMAIN-SUFFIX,flexibits.com,狗狗加速.com
- DOMAIN-SUFFIX,flickr.com,狗狗加速.com
- DOMAIN-SUFFIX,flipboard.com,狗狗加速.com
- DOMAIN-SUFFIX,g.co,狗狗加速.com
- DOMAIN-SUFFIX,gabia.net,狗狗加速.com
- DOMAIN-SUFFIX,geni.us,狗狗加速.com
- DOMAIN-SUFFIX,gfx.ms,狗狗加速.com
- DOMAIN-SUFFIX,ggpht.com,狗狗加速.com
- DOMAIN-SUFFIX,ghostnoteapp.com,狗狗加速.com
- DOMAIN-SUFFIX,git.io,狗狗加速.com
- DOMAIN-KEYWORD,github,狗狗加速.com
- DOMAIN-SUFFIX,globalsign.com,狗狗加速.com
- DOMAIN-SUFFIX,gmodules.com,狗狗加速.com
- DOMAIN-SUFFIX,godaddy.com,狗狗加速.com
- DOMAIN-SUFFIX,golang.org,狗狗加速.com
- DOMAIN-SUFFIX,gongm.in,狗狗加速.com
- DOMAIN-SUFFIX,goo.gl,狗狗加速.com
- DOMAIN-SUFFIX,goodreaders.com,狗狗加速.com
- DOMAIN-SUFFIX,goodreads.com,狗狗加速.com
- DOMAIN-SUFFIX,gravatar.com,狗狗加速.com
- DOMAIN-SUFFIX,gstatic.com,狗狗加速.com
- DOMAIN-SUFFIX,gvt0.com,狗狗加速.com
- DOMAIN-SUFFIX,hockeyapp.net,狗狗加速.com
- DOMAIN-SUFFIX,hotmail.com,狗狗加速.com
- DOMAIN-SUFFIX,icons8.com,狗狗加速.com
- DOMAIN-SUFFIX,ifixit.com,狗狗加速.com
- DOMAIN-SUFFIX,ift.tt,狗狗加速.com
- DOMAIN-SUFFIX,ifttt.com,狗狗加速.com
- DOMAIN-SUFFIX,iherb.com,狗狗加速.com
- DOMAIN-SUFFIX,imageshack.us,狗狗加速.com
- DOMAIN-SUFFIX,img.ly,狗狗加速.com
- DOMAIN-SUFFIX,imgur.com,狗狗加速.com
- DOMAIN-SUFFIX,imore.com,狗狗加速.com
- DOMAIN-SUFFIX,instapaper.com,狗狗加速.com
- DOMAIN-SUFFIX,ipn.li,狗狗加速.com
- DOMAIN-SUFFIX,is.gd,狗狗加速.com
- DOMAIN-SUFFIX,issuu.com,狗狗加速.com
- DOMAIN-SUFFIX,itgonglun.com,狗狗加速.com
- DOMAIN-SUFFIX,itun.es,狗狗加速.com
- DOMAIN-SUFFIX,ixquick.com,狗狗加速.com
- DOMAIN-SUFFIX,j.mp,狗狗加速.com
- DOMAIN-SUFFIX,js.revsci.net,狗狗加速.com
- DOMAIN-SUFFIX,jshint.com,狗狗加速.com
- DOMAIN-SUFFIX,jtvnw.net,狗狗加速.com
- DOMAIN-SUFFIX,justgetflux.com,狗狗加速.com
- DOMAIN-SUFFIX,kat.cr,狗狗加速.com
- DOMAIN-SUFFIX,klip.me,狗狗加速.com
- DOMAIN-SUFFIX,libsyn.com,狗狗加速.com
- DOMAIN-SUFFIX,line-apps.com,狗狗加速.com
- DOMAIN-SUFFIX,linode.com,狗狗加速.com
- DOMAIN-SUFFIX,lithium.com,狗狗加速.com
- DOMAIN-SUFFIX,littlehj.com,狗狗加速.com
- DOMAIN-SUFFIX,live.com,狗狗加速.com
- DOMAIN-SUFFIX,live.net,狗狗加速.com
- DOMAIN-SUFFIX,livefilestore.com,狗狗加速.com
- DOMAIN-SUFFIX,llnwd.net,狗狗加速.com
- DOMAIN-SUFFIX,macid.co,狗狗加速.com
- DOMAIN-SUFFIX,macromedia.com,狗狗加速.com
- DOMAIN-SUFFIX,macrumors.com,狗狗加速.com
- DOMAIN-SUFFIX,mashable.com,狗狗加速.com
- DOMAIN-SUFFIX,mathjax.org,狗狗加速.com
- DOMAIN-SUFFIX,medium.com,狗狗加速.com
- DOMAIN-SUFFIX,mega.co.nz,狗狗加速.com
- DOMAIN-SUFFIX,mega.nz,狗狗加速.com
- DOMAIN-SUFFIX,megaupload.com,狗狗加速.com
- DOMAIN-SUFFIX,microsofttranslator.com,狗狗加速.com
- DOMAIN-SUFFIX,mindnode.com,狗狗加速.com
- DOMAIN-SUFFIX,mobile01.com,狗狗加速.com
- DOMAIN-SUFFIX,modmyi.com,狗狗加速.com
- DOMAIN-SUFFIX,msedge.net,狗狗加速.com
- DOMAIN-SUFFIX,myfontastic.com,狗狗加速.com
- DOMAIN-SUFFIX,name.com,狗狗加速.com
- DOMAIN-SUFFIX,nextmedia.com,狗狗加速.com
- DOMAIN-SUFFIX,nsstatic.net,狗狗加速.com
- DOMAIN-SUFFIX,nssurge.com,狗狗加速.com
- DOMAIN-SUFFIX,nyt.com,狗狗加速.com
- DOMAIN-SUFFIX,nytimes.com,狗狗加速.com
- DOMAIN-SUFFIX,omnigroup.com,狗狗加速.com
- DOMAIN-SUFFIX,onedrive.com,狗狗加速.com
- DOMAIN-SUFFIX,onenote.com,狗狗加速.com
- DOMAIN-SUFFIX,ooyala.com,狗狗加速.com
- DOMAIN-SUFFIX,openvpn.net,狗狗加速.com
- DOMAIN-SUFFIX,openwrt.org,狗狗加速.com
- DOMAIN-SUFFIX,orkut.com,狗狗加速.com
- DOMAIN-SUFFIX,osxdaily.com,狗狗加速.com
- DOMAIN-SUFFIX,outlook.com,狗狗加速.com
- DOMAIN-SUFFIX,ow.ly,狗狗加速.com
- DOMAIN-SUFFIX,paddleapi.com,狗狗加速.com
- DOMAIN-SUFFIX,parallels.com,狗狗加速.com
- DOMAIN-SUFFIX,parse.com,狗狗加速.com
- DOMAIN-SUFFIX,pdfexpert.com,狗狗加速.com
- DOMAIN-SUFFIX,periscope.tv,狗狗加速.com
- DOMAIN-SUFFIX,pinboard.in,狗狗加速.com
- DOMAIN-SUFFIX,pinterest.com,狗狗加速.com
- DOMAIN-SUFFIX,pixelmator.com,狗狗加速.com
- DOMAIN-SUFFIX,pixiv.net,狗狗加速.com
- DOMAIN-SUFFIX,playpcesor.com,狗狗加速.com
- DOMAIN-SUFFIX,playstation.com,狗狗加速.com
- DOMAIN-SUFFIX,playstation.com.hk,狗狗加速.com
- DOMAIN-SUFFIX,playstation.net,狗狗加速.com
- DOMAIN-SUFFIX,playstationnetwork.com,狗狗加速.com
- DOMAIN-SUFFIX,pushwoosh.com,狗狗加速.com
- DOMAIN-SUFFIX,rime.im,狗狗加速.com
- DOMAIN-SUFFIX,servebom.com,狗狗加速.com
- DOMAIN-SUFFIX,sfx.ms,狗狗加速.com
- DOMAIN-SUFFIX,shadowsocks.org,狗狗加速.com
- DOMAIN-SUFFIX,sharethis.com,狗狗加速.com
- DOMAIN-SUFFIX,shazam.com,狗狗加速.com
- DOMAIN-SUFFIX,skype.com,狗狗加速.com
- DOMAIN-SUFFIX,smartdns狗狗加速.com.com,狗狗加速.com
- DOMAIN-SUFFIX,smartmailcloud.com,狗狗加速.com
- DOMAIN-SUFFIX,sndcdn.com,狗狗加速.com
- DOMAIN-SUFFIX,sony.com,狗狗加速.com
- DOMAIN-SUFFIX,soundcloud.com,狗狗加速.com
- DOMAIN-SUFFIX,sourceforge.net,狗狗加速.com
- DOMAIN-SUFFIX,spotify.com,狗狗加速.com
- DOMAIN-SUFFIX,squarespace.com,狗狗加速.com
- DOMAIN-SUFFIX,sstatic.net,狗狗加速.com
- DOMAIN-SUFFIX,st.luluku.pw,狗狗加速.com
- DOMAIN-SUFFIX,stackoverflow.com,狗狗加速.com
- DOMAIN-SUFFIX,startpage.com,狗狗加速.com
- DOMAIN-SUFFIX,staticflickr.com,狗狗加速.com
- DOMAIN-SUFFIX,steamcommunity.com,狗狗加速.com
- DOMAIN-SUFFIX,symauth.com,狗狗加速.com
- DOMAIN-SUFFIX,symcb.com,狗狗加速.com
- DOMAIN-SUFFIX,symcd.com,狗狗加速.com
- DOMAIN-SUFFIX,tapbots.com,狗狗加速.com
- DOMAIN-SUFFIX,tapbots.net,狗狗加速.com
- DOMAIN-SUFFIX,tdesktop.com,狗狗加速.com
- DOMAIN-SUFFIX,techcrunch.com,狗狗加速.com
- DOMAIN-SUFFIX,techsmith.com,狗狗加速.com
- DOMAIN-SUFFIX,thepiratebay.org,狗狗加速.com
- DOMAIN-SUFFIX,theverge.com,狗狗加速.com
- DOMAIN-SUFFIX,time.com,狗狗加速.com
- DOMAIN-SUFFIX,timeinc.net,狗狗加速.com
- DOMAIN-SUFFIX,tiny.cc,狗狗加速.com
- DOMAIN-SUFFIX,tinypic.com,狗狗加速.com
- DOMAIN-SUFFIX,tmblr.co,狗狗加速.com
- DOMAIN-SUFFIX,todoist.com,狗狗加速.com
- DOMAIN-SUFFIX,trello.com,狗狗加速.com
- DOMAIN-SUFFIX,trustasiassl.com,狗狗加速.com
- DOMAIN-SUFFIX,tumblr.co,狗狗加速.com
- DOMAIN-SUFFIX,tumblr.com,狗狗加速.com
- DOMAIN-SUFFIX,tweetdeck.com,狗狗加速.com
- DOMAIN-SUFFIX,tweetmarker.net,狗狗加速.com
- DOMAIN-SUFFIX,twitch.tv,狗狗加速.com
- DOMAIN-SUFFIX,txmblr.com,狗狗加速.com
- DOMAIN-SUFFIX,typekit.net,狗狗加速.com
- DOMAIN-SUFFIX,ubertags.com,狗狗加速.com
- DOMAIN-SUFFIX,ublock.org,狗狗加速.com
- DOMAIN-SUFFIX,ubnt.com,狗狗加速.com
- DOMAIN-SUFFIX,ulyssesapp.com,狗狗加速.com
- DOMAIN-SUFFIX,urchin.com,狗狗加速.com
- DOMAIN-SUFFIX,usertrust.com,狗狗加速.com
- DOMAIN-SUFFIX,v.gd,狗狗加速.com
- DOMAIN-SUFFIX,v2ex.com,狗狗加速.com
- DOMAIN-SUFFIX,vimeo.com,狗狗加速.com
- DOMAIN-SUFFIX,vimeocdn.com,狗狗加速.com
- DOMAIN-SUFFIX,vine.co,狗狗加速.com
- DOMAIN-SUFFIX,vivaldi.com,狗狗加速.com
- DOMAIN-SUFFIX,vox-cdn.com,狗狗加速.com
- DOMAIN-SUFFIX,vsco.co,狗狗加速.com
- DOMAIN-SUFFIX,vultr.com,狗狗加速.com
- DOMAIN-SUFFIX,w.org,狗狗加速.com
- DOMAIN-SUFFIX,w3schools.com,狗狗加速.com
- DOMAIN-SUFFIX,webtype.com,狗狗加速.com
- DOMAIN-SUFFIX,wikiwand.com,狗狗加速.com
- DOMAIN-SUFFIX,wikileaks.org,狗狗加速.com
- DOMAIN-SUFFIX,wikimedia.org,狗狗加速.com
- DOMAIN-SUFFIX,wikipedia.com,狗狗加速.com
- DOMAIN-SUFFIX,wikipedia.org,狗狗加速.com
- DOMAIN-SUFFIX,windows.com,狗狗加速.com
- DOMAIN-SUFFIX,windows.net,狗狗加速.com
- DOMAIN-SUFFIX,wire.com,狗狗加速.com
- DOMAIN-SUFFIX,wordpress.com,狗狗加速.com
- DOMAIN-SUFFIX,workflowy.com,狗狗加速.com
- DOMAIN-SUFFIX,wp.com,狗狗加速.com
- DOMAIN-SUFFIX,wsj.com,狗狗加速.com
- DOMAIN-SUFFIX,wsj.net,狗狗加速.com
- DOMAIN-SUFFIX,xda-developers.com,狗狗加速.com
- DOMAIN-SUFFIX,xeeno.com,狗狗加速.com
- DOMAIN-SUFFIX,xiti.com,狗狗加速.com
- DOMAIN-SUFFIX,yahoo.com,狗狗加速.com
- DOMAIN-SUFFIX,yimg.com,狗狗加速.com
- DOMAIN-SUFFIX,ying.com,狗狗加速.com
- DOMAIN-SUFFIX,yoyo.org,狗狗加速.com
- DOMAIN-SUFFIX,ytimg.com,狗狗加速.com
- DOMAIN-SUFFIX,signal.org,狗狗加速.com
- DOMAIN-SUFFIX,whispersystems.org,狗狗加速.com
- DOMAIN-SUFFIX,cangku.moe,狗狗加速.com
- DOMAIN-SUFFIX,tradingview.com,狗狗加速.com
- DOMAIN-SUFFIX,x.com,狗狗加速.com
- DOMAIN-SUFFIX,asmr.one,狗狗加速.com
- DOMAIN-SUFFIX,telegra.ph,狗狗加速.com
- DOMAIN-SUFFIX,telegram.org,狗狗加速.com
- DOMAIN-SUFFIX,t.me,狗狗加速.com
- DOMAIN-SUFFIX,telegram.me,狗狗加速.com
- IP-CIDR,91.108.4.0/22,狗狗加速.com,no-resolve
- IP-CIDR,91.108.8.0/21,狗狗加速.com,no-resolve
- IP-CIDR,91.108.16.0/22,狗狗加速.com,no-resolve
- IP-CIDR,91.108.56.0/22,狗狗加速.com,no-resolve
- IP-CIDR,149.154.160.0/20,狗狗加速.com,no-resolve
- IP-CIDR6,2001:67c:4e8::/48,狗狗加速.com,no-resolve
- IP-CIDR6,2001:b28:f23d::/48,狗狗加速.com,no-resolve
- IP-CIDR6,2001:b28:f23f::/48,狗狗加速.com,no-resolve
- IP-CIDR,120.232.181.162/32,狗狗加速.com,no-resolve
- IP-CIDR,120.241.147.226/32,狗狗加速.com,no-resolve
- IP-CIDR,120.253.253.226/32,狗狗加速.com,no-resolve
- IP-CIDR,120.253.255.162/32,狗狗加速.com,no-resolve
- IP-CIDR,120.253.255.34/32,狗狗加速.com,no-resolve
- IP-CIDR,120.253.255.98/32,狗狗加速.com,no-resolve
- IP-CIDR,180.163.150.162/32,狗狗加速.com,no-resolve
- IP-CIDR,180.163.150.34/32,狗狗加速.com,no-resolve
- IP-CIDR,180.163.151.162/32,狗狗加速.com,no-resolve
- IP-CIDR,180.163.151.34/32,狗狗加速.com,no-resolve
- IP-CIDR,203.208.39.0/24,狗狗加速.com,no-resolve
- IP-CIDR,203.208.40.0/24,狗狗加速.com,no-resolve
- IP-CIDR,203.208.41.0/24,狗狗加速.com,no-resolve
- IP-CIDR,203.208.43.0/24,狗狗加速.com,no-resolve
- IP-CIDR,203.208.50.0/24,狗狗加速.com,no-resolve
- IP-CIDR,220.181.174.162/32,狗狗加速.com,no-resolve
- IP-CIDR,220.181.174.226/32,狗狗加速.com,no-resolve
- IP-CIDR,220.181.174.34/32,狗狗加速.com,no-resolve
- IP-CIDR,24.199.123.28/32,🔥ChatGPT,no-resolve
- IP-CIDR,64.23.132.171/32,🔥ChatGPT,no-resolve
- IP-CIDR,24.199.123.28/32,🔥ChatGPT,no-resolve
- IP-CIDR,64.23.132.171/32,🔥ChatGPT,no-resolve
- DOMAIN,injections.adguard.org,DIRECT
- DOMAIN,local.adguard.org,DIRECT
- DOMAIN-SUFFIX,local,DIRECT
- IP-CIDR,127.0.0.0/8,DIRECT
- IP-CIDR,172.16.0.0/12,DIRECT
- IP-CIDR,192.168.0.0/16,DIRECT
- IP-CIDR,10.0.0.0/8,DIRECT
- IP-CIDR,17.0.0.0/8,DIRECT
- IP-CIDR,100.64.0.0/10,DIRECT
- IP-CIDR,224.0.0.0/4,DIRECT
- IP-CIDR6,fe80::/10,DIRECT
- GEOIP,CN,DIRECT
- MATCH,狗狗加速.com
"""

# 下载 GFWList 并 Base64 解码
response = requests.get(GFWLIST_URL)
decoded_data = base64.b64decode(response.text).decode("utf-8", errors="ignore")

# 解析 GFWList 规则并转换为 Clash 规则格式
rules = []
for line in decoded_data.split("\n"):
    line = line.strip()
    if not line or line.startswith("!") or line.startswith("[") or line.startswith("@@"):  # 忽略注释、无效行和白名单规则
        continue
    if line.startswith("||"):  # 处理 DOMAIN-SUFFIX 规则
        domain = line[2:]
        rules.append(f"DOMAIN-SUFFIX,{domain},狗狗加速.com")
    elif line.startswith("|http") or line.startswith("|https"):  # 处理 URL 规则
        match = re.search(r"\|\w+://([^/]+)", line)
        if match:
            domain = match.group(1)
            rules.append(f"DOMAIN,{domain},狗狗加速.com")
    elif line.startswith("."):  # 处理以点号开头的域名
        domain = line[1:]
        rules.append(f"DOMAIN-SUFFIX,{domain},狗狗加速.com")
    elif re.match(r"^\d+\.\d+\.\d+\.\d+(\/\d+)?$", line):  # 处理 IP 或 IP-CIDR 规则
        try:
            # 如果缺少子网掩码，则添加默认的 /32
            if '/' not in line:
                line += '/32'
            ipaddress.ip_network(line, strict=False)
            rules.append(f"IP-CIDR,{line},狗狗加速.com")
        except ValueError:
            continue  # 跳过无效的 IP 或 IP-CIDR
    else:  # 处理普通域名
        rules.append(f"DOMAIN,{line},狗狗加速.com")

# 记录规则去重
rule_dict = {}
removed_rules = []
invalid_rules = []

# 处理 GFWList 规则
for rule in rules:
    parts = rule.split(",")
    if len(parts) >= 3:
        rule_type, target, policy = parts[0].strip(), parts[1].strip(), parts[2].strip()
        key = f"{rule_type},{target}"

        # 处理 IP-CIDR 规则，确保 IP 和子网掩码合法
        if rule_type in ["IP-CIDR", "IP-CIDR6"]:
            try:
                ipaddress.ip_network(target, strict=False)  # 检测 CIDR 合法性
            except ValueError:
                invalid_rules.append(rule)  # 记录无效的规则
                continue  # 跳过此规则

        if key not in rule_dict:
            rule_dict[key] = rule  # 第一次出现的规则直接保留
        elif policy != "狗狗加速.com":
            removed_rules.append(rule)  # 记录被删除的规则

# 重新整理规则
filtered_rules = list(rule_dict.values())

# 将原始规则与过滤后的规则合并
all_rules = highest_priority_rules.strip() + "\n" + "\n".join([f"- {rule}" for rule in filtered_rules])

# 写入优化后的 YAML 文件
output_file = "rules.yaml"
with open(output_file, "w", encoding="utf-8") as f:
    f.write(all_rules)

# 打印被删除的冲突规则
if removed_rules:
    print("\n=== 以下规则因冲突被删除（仅保留'狗狗加速.com'的规则） ===")
    for rule in removed_rules:
        print(rule)

# 打印无效 IP-CIDR 规则
if invalid_rules:
    print("\n=== 以下无效的 IP-CIDR 规则已被移除 ===")
    for rule in invalid_rules:
        print(rule)

print(f"\n去重完成，优化后的 YAML 文件已保存为: {output_file}")

程序会将处理好的规则输出到当前目录,名为rules.yaml

执行前确保你能打得开GFWList,如果打不开,可以自行替换为打得开的链接

GFWList内容如下,打开如果不是这样的那就说明你找错链接了

规则的使用方法

程序输出的内容直接全选,然后打开Clash Verge Rev的订阅 -> 全局扩展覆写配置 -> 右键选择打开文件(如果点编辑会导致自动检查失败)

然后将程序的内容直接粘贴到文末即可

退出Clash Verge Rev,重新打开,使用TUN模式，刷新订阅，点开你的规则组，例如我的狗狗加速.com,按延迟排序,节点测速

因为规则有7361条,所以节点测速时重复点击,大概5分钟后才会测出正常速度,例如15-新加坡Hy2节点，87ms延迟

如果你和我一样用的狗狗加速,需要访问ChatGPT的话就选🔥ChatGPT这组

异地组网+Nginx反代 | 计算资源本地化

2025-02-17T08:59:52.000Z

本次部署的目的是利用本地高性能的计算资源和云服务器畅通无阻的公网，实现无公网环境也可正常部署业务。

本文所用到的技术如下

名称	作用	软件
单向异地组网	将云服务器和本地服务器组成局域网，因本地服务器没有公网，所以由云服务器建立UDP连接实现组网	WireGuard
反代	将对云服务器发起的访问根据配置的业务转发到本地服务器进行处理	Nginx
网络转发	配合wireguard实现对网络流量的路由和转发，确保组网的通畅	iptables

单向异地组网

2025.2.18补充：组网成功后大概十几分钟，被运营商墙了，太狗了，因为wireguard走的是UDP协议，被运营商检测到了。目前有两个思路，找运营商加个公网IP或者想其他办法组网
2025.2.18 10:55记录思路：使用udp2raw将UDP流量封装到TCP流量中，并伪装成HTTPS
2025.2.18 10:57补充，尝试udp2raw能打通后先用着，如果再次被封则换为xtls-rprx-vision透明代理UDP流量，实现最强HTTPS伪装

特性	`udp2raw`	`xtls-rprx-vision`
工作原理	把 UDP 伪装成 TCP 或 ICMP，进行 NAT 穿透	通过 Xray Vision 协议将流量伪装成 HTTPS/TLS
支持协议	任何 UDP 流量（WireGuard、IPSec、OpenVPN等）	任何 TCP/UDP 流量（支持 UDP over TCP）
流量伪装	可伪装为 TCP（HTTPS、SSH）或 ICMP	伪装成合法 HTTPS 流量
加密方式	XOR、AES（轻量级加密，防止 DPI 识别）	XTLS（高级 TLS 伪装，难以被识别）
端口	可伪装成 443（HTTPS）等，但仍是伪 TCP	直接监听 443 端口，真实 HTTPS 伪装
数据包特征	模拟 TCP，但仍然是 UDP 数据包封装	真实 HTTPS 流量，运营商难以检测
防 DPI	基本防御，部分 DPI 仍能检测出伪 TCP	最高级别防御，难以被识别
延迟	低，基本无影响	略高，取决于 TLS 处理开销
适用场景	适用于 UDP 被封但 TCP 可用的环境	适用于 DPI 严格的环境，如中国大陆或企业网络
是否需要证书	不需要	需要 TLS 证书（Let’s Encrypt 等）
稳定性	高，几乎无性能损耗	高，但 TLS 可能增加 CPU 负担
适合长期使用	可以，但可能被进一步分析	更适合长期使用，难以封锁

服务器部分

# 安装wireguard
apt install wireguard -y

# 生成私钥公钥到/etc/wireguard/目录下
wg genkey | tee /etc/wireguard/server_private.key | wg pubkey | tee /etc/wireguard/server_public.key
# 查看私钥公钥，稍后需要写入到配置文件中
cat /etc/wireguard/server_private.key
cat /etc/wireguard/server_public.key

在/etc/wireguard/下创建一个配置文件，例如wg0.conf，按如下所述写入配置：

[Interface]
Address = 10.0.0.1/24 # 服务器的局域网IP，/24是前缀，对应255.255.255.0
ListenPort = 26666 # 端口协议是UDP，端口可以自定义
PrivateKey = 云服务器私钥 # 刚刚生成的服务器私钥
DNS=8.8.8.8
MTU=1420

# 这部分是配置的iptables的转发，其中eth0替换为云服务器公网的网卡名称
# 原理：
# 允许wg0的流量通过iptables转发到eth0
# iptables -A FORWARD -i wg0 -j ACCEPT
# 将eth0上的流量进行源地址伪装，让对方以为来自局域网的流量是从公网IP发出的
# iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

# 端口启动时执行，其中-A是添加
PostUp   = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -A FORWARD -o wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
# 端口关闭时执行，其中-D是删除
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -D FORWARD -o wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

[Peer]
PublicKey = 内网服务器公钥 # 稍后在内网服务器生成的公钥
# 允许内网服务器连接，IP是10.0.0.2，前缀32对应255.255.255.255
# 作用是仅允许这一个IP连接。可以根据需要自行组合IP段和前缀
AllowedIPs = 10.0.0.2/32

# 编辑完配置文件后启动服务
# 其中wg-quick是wireguard的启动工具，@连接wg0，是配置文件的名称
sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0

内网服务器部分

# 与服务器一致，生成公钥私钥，只是名称是client开头
wg genkey | tee /etc/wireguard/client_private.key | wg pubkey | tee /etc/wireguard/client_public.key
# 查看公钥私钥，准备写入配置文件
cat /etc/wireguard/client_private.key
cat /etc/wireguard/client_public.key

在/etc/wireguard/下创建一个配置文件，例如wg0.conf，按如下所述写入配置：

[Interface]
Address = 10.0.0.2/24 # 10.0.0.2则是内网服务器在组网内的IP地址
PrivateKey = 内网服务器私钥

[Peer]
PublicKey = 云服务器公钥
AllowedIPs = 10.0.0.1/32 # 前缀32限制只允许云服务器IP连入
Endpoint = 云服务器IP:26666 # 指向云服务器IP和端口
PersistentKeepalive = 25

# 编辑完配置文件后启动服务
# 其中wg-quick是wireguard的启动工具，@连接wg0，是配置文件的名称
sudo systemctl enable wg-quick@wg0
sudo systemctl start wg-quick@wg0

共同配置部分

在内网和云服务器均开启转发

1 2	echo "net.ipv4.ip_forward=1" \| sudo tee -a /etc/sysctl.conf sysctl -p

反向代理

关于磁盘残留lvm的解决办法

2024-11-28T02:28:48.000Z

很多时候从其他机器拿过来的盘通常是没有经过格式化的，这样就会出现一些残留的lvm信息，导致无法正常使用。

出现该残留lvm的原因是因为设备映射器device mapper正在管理该磁盘，所以wipefs -a -f和dd if=/dev/zero of=/dev/disk命令无法清除该lvm

# lsblk显示如下
nvme0n1disk
└storage-datalvm

# ls -l /dev/mapper查询device mapper管理的磁盘信息
lrwxrwxrwx 1 root root 7 Nov 28 18:04 storage-data ->../dm-0

#dmsetup remove删除
dmsetup remove /dev/mapper/storage-data

C++编写fio测试工具 | C++写脚本，我在发疯

2024-11-15T06:05:38.000Z

我有病，拿C++写测试工具

仓库地址：https://github.com/1949hacker/studycplusplus

fio.hpp

main.cpp

fio.cpp

长文预警

fio.hpp代码

// fio.hpp
#ifndef FIO_HPP
#define FIO_HPP

// 设置测试参数
void setConfig();

// 创建预读文件
void init_read();

// 顺序写
void fio_seq_write();

// 顺序读
void fio_seq_read();

// 随机写
void fio_rand_write();

// 随机读
void fio_rand_read();

// 随机读写测试
void fio_randrw();

// 输出结果
void runReport();

#endif // FIO_HPP

main.cpp代码

#include "fio.hpp"
#include 
#include 
#include 
#include 
#include 
#include 
#include 

// Linux/macOS 下的 getch() 实现
int getch() {
  struct termios oldt, newt;
  int ch;
  tcgetattr(STDIN_FILENO, &oldt);
  newt = oldt;
  newt.c_lflag &= ~(ICANON | ECHO);
  tcsetattr(STDIN_FILENO, TCSANOW, &newt);
  ch = getchar();
  tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
  return ch;
}

using namespace std;

// 自定义流缓冲区类，将输出内容同时写入控制台和日志文件
class TeeBuf : public streambuf {
public:
  TeeBuf(streambuf *consoleBuf, streambuf *fileBuf)
      : consoleBuf(consoleBuf), fileBuf(fileBuf) {}

protected:
  virtual int overflow(int c) override {
    if (c == EOF) {
      return !EOF;
    } else {
      if (consoleBuf->sputc(c) == EOF)
        return EOF;
      if (fileBuf->sputc(c) == EOF)
        return EOF;
      return c;
    }
  }

  virtual int sync() override {
    if (consoleBuf->pubsync() == -1)
      return -1;
    if (fileBuf->pubsync() == -1)
      return -1;
    return 0;
  }

private:
  streambuf *consoleBuf;
  streambuf *fileBuf;
};

int main() {

  // 日志目录初始化
  int result = system("mkdir -p /var/log/fio_tool");

  if (result == 0) {
    std::cout << "\033[32m日志存储目录 /var/log/fio_tool 已成功创建。\033[0m"
              << std::endl;
  } else {
    std::cerr << "\033[31m创建目录 /var/log/fio_tool "
                 "时出现错误。请检查当前用户的运行权限！\033[0m"
              << std::endl;
    return 0;
  }

  // 获取时间并格式化文件名
  time_t log_time = time(nullptr);
  tm *localTime = localtime(&log_time);
  char timeStr[20];
  strftime(timeStr, sizeof(timeStr), "%Y-%m-%d-%H-%M-%S", localTime);
  string fileName = "/var/log/fio_tool/" + string(timeStr) + ".log";

  // 创建日志文件流
  ofstream logFile(fileName, ios::app);
  if (!logFile) {
    cerr << "\033[31m无法创建日志文件！\033[0m" << endl;
    return 1;
  } else {
    cout << "\033[32m成功创建日志文件：\033[0m" << fileName << endl;
  }

  // 重定向 cout 输出到日志文件和控制台
  TeeBuf teeBuf(cout.rdbuf(), logFile.rdbuf());
  streambuf *originalCoutBuf = cout.rdbuf(&teeBuf);

  cout << "\033[36m欢迎使用fio测试工具\n日志和输出的fio."
          "csv默认保存到/var/log/fio_tool/"
          "\n日志不会自行清除，运行前请自行清理日志文件和检查是否残留有测试文件"
          "\n输出的数据统一为KiB/s单位，iops无单位\n请<按键>"
          "选择你的测试内容：\n"
       << "1. 顺序写测试\n"
       << "2. 随机写测试\n\n\n"
       << "\033[31m-------分割线-------\n"
       << "进行读测试之前需要先创建预读文件，固定为测试路径下的init_read.[0-15]"
       << ".0共16个文件\n"
       << "请自行根据测试情况判断是否需要重新生成，如需重新生成，请删除后按"
       << "进行预读文件创建\n"
       << "如无需创建预读文件则直接按键开始测试即可！\n\n"
       << "测试完成后记得清理干净测试残留的文件和日志文件\n"
       << "-------分割线-------\033[36m\n\n\n"
       << "3. 顺序读测试\n"
       << "4. 随机读测试\n"
       << "5. 4k随机50%混合读写测试\n"
       << "r. 创建预读文件\n"
       << "f. Fullauto全自动测试"
       << "q. 退出程序\n"
       << "s. 你想骚一下？\033[0m" << endl;

  char choice;
  while (true) {
    choice = getch(); // Linux/macOS 下使用自定义 getch()

    cout << choice << endl; // 打印选项
    switch (choice) {
    case '1':
      setConfig();
      fio_seq_write();
      return 0;
    case '2':
      setConfig();
      fio_rand_write();
      return 0;
    case '3':
      setConfig();
      fio_seq_read();
      return 0;
    case '4':
      setConfig();
      fio_rand_read();
      return 0;
    case '5':
      setConfig();
      fio_randrw();
      return 0;
    case 'r':
      setConfig();
      init_read();
      return 0;
    case 'f':
      setConfig();
      fio_seq_write();
      fio_rand_write();
      init_read();
      fio_seq_read();
      fio_rand_read();
      fio_randrw();
      return 0;
    case 'q':
      cout << "程序已退出。" << endl;
      return 0;
    case 's':
      while (true) {
        cout << "骚个鸡儿啊，正事儿不干？我不懒得写炸机代码？" << endl;
      }
      return 0;
    default:
      cout << "\033[31m无效选项，请重新输入。\033[0m" << endl;
    }
  }

  // 恢复 cout 的原始缓冲区
  cout.rdbuf(originalCoutBuf);

  return 0;
}

fio.cpp代码

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

// 全局参数
int bwMin, bwMax, bwAvg, iopsMin, iopsMax, iopsAvg, bw[] = {0, 0, 0, 0, 0, 0},
                                                    iops[] = {0, 0, 0, 0, 0, 0};
string dir, fsize, ioengine, name, fio_cmd, runtime, direct, line;
stringstream fio_output;
vector> run_report;
vector row;
vector<int> values, bw_int, iops_int;

// 参数设置
void setConfig() {
  cout << "\033[36m测试路径（完整输入，带/结尾，如/mnt/iotest/）：";
  cin >> dir;
  cout << "测试文件大小，需要略大于内存大小，仅输入数字单位为G，size=";
  cin >> fsize;
  cout << "运行时长，至少30秒，仅输入数字单位为秒，runtime=";
  cin >> runtime;
  cout << "io测试引擎，Linux（NAS）输入libaio，ioengine=";
  cin >> ioengine;
  cout << "设置是否经过系统缓存，1不缓存，0操作系统缓存，direct=\033[0m";
  cin >> direct;
}

// 删除测试文件
void rm_file(string name) {
  string rm_command = "rm -rf " + dir + name;
  system(rm_command.c_str()); // 删除 /iopsTest 目录下的所有文件
  cout << "\033[32m临时文件已删除\033[0m" << endl;
}

void run_cmd(const string &cmd) {
  // 重置变量
  fio_output.str("");
  fio_output.clear();

  FILE *fp = popen(cmd.c_str(), "r");
  if (fp == nullptr) {
    cerr << "\033[31mError opening pipe!\033[0m" << endl;
    return;
  }

  // 从fio输出中获取数据
  char buffer[128];
  while (fgets(buffer, sizeof(buffer), fp) != nullptr) {
    fio_output << buffer;
  }
  fclose(fp);

  // DEBUG:显示fio的输出内容
  // cout << fio_output.str();
}

// 分析fio输出
void format(const int &i) {

  vector bw_num, iops_num;

  while (getline(fio_output, line)) {
    if (line.find("samples") != string::npos) {
      cout << "\033[32;1m筛选成功，原始数据：\033[0m" << line << endl;
      if (line.find("bw ") != string::npos) {
        if (line.find("MiB/s") != string::npos) {
          cout << "\033[32;1m检测到单位MiB/s，将转换为KiB/s\033[0m" << endl;
          // 提取带宽数字
          regex bw_regex(R"(\d+\.\d+|\d+)");
          smatch match;
          while (regex_search(line, match, bw_regex)) {
            // 检测到单位是MiB，则转换为KiB
            float bw_value_kib = stof(match.str());
            bw_value_kib *= 1024;
            int bw_value_bytes = static_cast<int>(bw_value_kib); // 转为整数
            bw_num.push_back(to_string(bw_value_bytes));
            line = match.suffix();
          }
        } else if (line.find("KiB/s") != string::npos) {
          cout << "\033[32;1m检测到单位KiB/s，直接提取\033[0m" << endl;
          // 提取带宽数字
          regex bw_regex(R"(\d+\.\d+|\d+)");
          smatch match;
          while (regex_search(line, match, bw_regex)) {
            bw_num.push_back(match.str());
            line = match.suffix();
          }
        }
      }
      if (line.find("iops") != string::npos) {
        // 提取IOPS数字
        regex iops_regex(R"(\d+\.\d+|\d+)");
        smatch match;
        while (regex_search(line, match, iops_regex)) {
          iops_num.push_back(match.str());
          line = match.suffix();
        }
      }
    }
  }
  // 转换为整数
  for (const string &s : bw_num) {
    bw_int.push_back(static_cast<int>(stof(s)));
  }
  for (const string &s : iops_num) {
    iops_int.push_back(static_cast<int>(stof(s)));
  }

  // DEBUG: 检查原始数据是否正常
  // for (int a : bw_int) {
  //   cout << "bw:" << a << endl;
  // }
  // for (int a : iops_int) {
  //   cout << "iops:" << a << endl;
  // }

  if (bw_int.size() > 7) {
    // 混合读写
    cout << "\033[32;1m" << name << " | 第" << i << "次带宽运行<读>结果:"
         << "min:" << bw_int[0] << "KiB/s max:" << bw_int[1]
         << "KiB/s avg:" << bw_int[3] << "KiB/s\n"
         << name << " | 第" << i << "次次IOPS运行<读>结果:"
         << "min:" << iops_int[0] << " max:" << iops_int[1]
         << " avg:" << iops_int[2] << endl;
    cout << name << " | 第" << i << "次带宽运行<写>结果:"
         << "min:" << bw_int[6] << "KiB/s max:" << bw_int[7]
         << "KiB/s avg:" << bw_int[9] << "KiB/s\n"
         << name << " | 第" << i << "次次IOPS运行<写>结果:"
         << "min:" << iops_int[5] << " max:" << iops_int[6]
         << " avg:" << iops_int[7] << "\033[0m" << endl;
    // 整理带宽和IOPS数据
    bw[0] += bw_int[0];
    bw[1] += bw_int[1];
    bw[2] += bw_int[3];
    bw[3] = bw_int[6];
    bw[4] += bw_int[7];
    bw[5] += bw_int[9];
    iops[0] += iops_int[0];
    iops[1] += iops_int[1];
    iops[2] += iops_int[2];
    iops[3] += iops_int[5];
    iops[4] += iops_int[6];
    iops[5] += iops_int[7];
  } else {
    cout << "\033[32;1m" << name << " | 第" << i << "次带宽运行结果:"
         << "min:" << bw_int[0] << "KiB/s max:" << bw_int[1]
         << "KiB/s avg:" << bw_int[3] << "KiB/s\n"
         << name << " | 第" << i << "次次IOPS运行结果:"
         << "min:" << iops_int[0] << " max:" << iops_int[1]
         << " avg:" << iops_int[2] << "\033[0m" << endl;
    // 整理带宽和IOPS数据
    bw[0] += bw_int[0];
    bw[1] += bw_int[1];
    bw[2] += bw_int[3];
    iops[0] += iops_int[0];
    iops[1] += iops_int[1];
    iops[2] += iops_int[2];
  }
}

void fio_sum(const string &name) {

  if (bw[3] != 0) {
    // 针对混合读写处理
    //  计算最小、最大和平均值
    int RbwMin = bw[0] / 3;
    int RbwMax = bw[1] / 3;
    int RbwAvg = bw[2] / 3;
    int RiopsMin = iops[0] / 3;
    int RiopsMax = iops[1] / 3;
    int RiopsAvg = iops[2] / 3;
    int WbwMin = bw[3] / 3;
    int WbwMax = bw[4] / 3;
    int WbwAvg = bw[5] / 3;
    int WiopsMin = iops[3] / 3;
    int WiopsMax = iops[4] / 3;
    int WiopsAvg = iops[5] / 3;
    // 将结果存储到数据表中，第一列是 名称，后面是6个值
    values = {RbwMin, RbwMax, RbwAvg, RiopsMin, RiopsMax, RiopsAvg,
              WbwMin, WbwMax, WbwAvg, WiopsMin, WiopsMax, WiopsAvg};
    row = {name};
    for (int val : values) {
      row.push_back(to_string(val)); // 将每个值转换为字符串并添加到行中
    }
    run_report.push_back(row); // 将这行添加到数据中
  } else {
    // 计算最小、最大和平均值
    int bwMin = bw[0] / 3;
    int bwMax = bw[1] / 3;
    int bwAvg = bw[2] / 3;
    int iopsMin = iops[0] / 3;
    int iopsMax = iops[1] / 3;
    int iopsAvg = iops[2] / 3;
    // 将结果存储到数据表中，第一列是 名称，后面是6个值
    values = {bwMin, bwMax, bwAvg, iopsMin, iopsMax, iopsAvg};
    row = {name};
    for (int val : values) {
      row.push_back(to_string(val)); // 将每个值转换为字符串并添加到行中
    }
    run_report.push_back(row); // 将这行添加到数据中
    // 重置
    values.clear();
    row.clear();
  }

  // 重置数据
  fill(begin(bw), end(bw), 0);
  fill(begin(iops), end(iops), 0);
}

void runReport() {

  // 打开文件用于追加写入
  ofstream outputFile("/var/log/fio_tool/fio.csv", ios::app);

  if (outputFile.is_open()) {
    // 如果文件为空，先写入表头（假设表头只在文件为空时写入一次）
    if (outputFile.tellp() == 0) {
      outputFile
          << "测试类型,带宽最小值,带宽最大值,带宽均值,IOPS最小值,"
             "IOPS最大值,IOPS均值,写带宽最小值,写带宽最大值,写带宽均值,"
             "写IOPS最小值,"
             "写IOPS最大值,写IOPS均值,(前6列数据在混合读写中作为读的数据)"
          << endl;
    }

    for (const auto &row : run_report) {
      for (const auto &cell : row) {
        outputFile << cell << ",";
      }
      outputFile << endl;
    }

    // 关闭文件
    outputFile.close();

    cout << "\033[32;1m数据已成功追加到fio.csv文件。\033[0m" << endl;
  } else {
    cerr << "\033[31;1m无法打开fio.csv文件进行追加写入。\033[0m" << endl;
  }
  cout << "\033[32;1m已重置run_report\033[0m" << endl;
  // 重置run_report
  run_report.clear();
}

// ---创建预读文件 start---
void init_read() {
  cout << "\033[32;1m预读文件的大小与测试文件一致，自动从之前的测试中获取\033["
          "0m\n";
  cout << "\033[31;1m正在为读取测试创建预读文件，请稍后..."
          "\n创建完毕后会出现提示，创建的文件数量为最大numjobs数量：16个，每个"
          "大小为" +
              fsize + "G"
       << "\033[0m" << endl;
  fio_cmd = "fio -name=init_read -size=" + fsize +
            "G -bs=1m -direct=1 -rw=write -ioengine=" + ioengine +
            " -numjobs=16 -group_reporting -iodepth=1 -directory=" + dir;
  run_cmd(fio_cmd);
  cout << "\033[32;"
          "1m预读文件创建完毕！！！\n预读文件创建完毕！！！\n预读文件创建完毕！"
          "！"
          "！\n\033[0m"
       << endl;
}
// ---创建预读文件 end---

// --- 顺序写start ---
void fio_seq_write() {
  // 重置数据
  bw_int.clear();
  iops_int.clear();
  // 文件
  cout << "\033[31;1m顺序写测试，共计50项，每项3次，每次 " << runtime
       << " 秒，共计 " << to_string((stoi(runtime) + 5) * 50 * 3) << " 秒，约 "
       << setprecision(2) << fixed
       << (double)(stoi(runtime) + 5) * 50 * 3 / 60 / 60
       << " 小时\n进行中...\033[0m" << endl;

  // 文件/文件夹
  string DorF[] = {"filename", "directory"};
  for (string dorf : DorF) {
    if (dorf.find("file") != string::npos) { // 如果是单文件

      // numjobs=1
      string numjobs[] = {"1"}; // 用数组配置numjobs
      for (string numjob : numjobs) {
        // bs=512/1024
        string bs_group[] = {"512", "1024"}; // 用数组配置bs块大小
        for (string bs : bs_group) {
          string iodepth_group[] = {"1", "2", "8", "16",
                                    "32"}; // 用数组配置iodepth循环
          // iodepth=1/2/8/16/32
          for (string iodepth : iodepth_group) {
            // 先写后读
            string rw = "write";
            name = rw + "_" + dorf + "_numjobs=" + numjob +
                   "_iodepth=" + iodepth + "_bs=" + bs + "k";
            // 重复运行3次
            for (int i = 1; i <= 3; i++) {
              // 构建文件夹fio命令
              fio_cmd = "fio -name=" + name + " -size=" + fsize +
                        "G -runtime=" + runtime + "s -time_base -bs=" + bs +
                        "k -direct=" + direct + " -rw=" + rw +
                        " -ioengine=" + ioengine + " -numjobs=" + numjob +
                        " -group_reporting -ramp_time=5 -iodepth=" + iodepth +
                        " -" + dorf + "=" + dir + to_string(i);
              // 输出本次运行的命令以便排障
              cout << "\033[36;1m第" << i << "次运行的命令是：" << fio_cmd
                   << "\033[0m" << endl;
              run_cmd(fio_cmd);
              format(i);
              // 重置数据
              bw_int.clear();
              iops_int.clear();
              rm_file(to_string(i)); //"rm -rf " + dir + ? rm -rf /mnt/?
            }
            fio_sum(name);
          }
          runReport();
        }
      }
    } else if (dorf.find("directory") != string::npos) {
      // numjobs=8/16
      string numjobs[] = {"8", "16"}; // 用数组配置numjobs
      for (string numjob : numjobs) {
        // bs=4k
        string bs_group[] = {"128", "256", "512", "1024"}; // 用数组配置bs块大小
        for (string bs : bs_group) {
          string iodepth_group[] = {"1", "2", "8", "16",
                                    "32"}; // 用数组配置iodepth循环
          // iodepth=1/2/8/16/32
          for (string iodepth : iodepth_group) {
            string rw = "write";
            // 重复运行3次
            name = rw + "_" + dorf + "_numjobs=" + numjob +
                   "_iodepth=" + iodepth + "_bs=" + bs + "k";
            for (int i = 1; i <= 3; i++) {
              // 构建文件夹fio命令
              fio_cmd = "mkdir -p " + dir + "dir_" + to_string(i) + "/" +
                        " && fio -name=" + name + " -size=" + fsize +
                        "G -runtime=" + runtime + "s -time_base -bs=" + bs +
                        "k -direct=" + direct + " -rw=" + rw +
                        " -ioengine=" + ioengine + " -numjobs=" + numjob +
                        " -group_reporting -ramp_time=5 -iodepth=" + iodepth +
                        " -" + dorf + "=" + dir + "dir_" + to_string(i) + "/";
              // 输出本次运行的命令以便排障
              cout << "\033[36;1m第" << i << "次运行的命令是：" << fio_cmd
                   << "\033[0m" << endl;
              run_cmd(fio_cmd);
              format(i);
              // 重置数据
              bw_int.clear();
              iops_int.clear();
              rm_file("dir_" + to_string(i));
            }
            fio_sum(name);
          }
          runReport();
        }
      }
    }
  }
}
// --- 顺序写end ---

// --- 顺序读start ---
void fio_seq_read() {
  // 重置数据
  bw_int.clear();
  iops_int.clear();
  // 文件
  cout << "\033[31;1m顺序读测试，共计50项，每项3次，每次预热5秒，每次测试" +
              runtime + "秒，共计" + to_string((stoi(runtime) + 5) * 50 * 3) +
              "秒，约 "
       << setprecision(2) << fixed
       << (double)(stoi(runtime) + 5) * 50 * 3 / 60 / 60
       << "小时\n进行中...\033[0m" << endl;

  // 文件/文件夹
  string DorF[] = {"filename", "directory"};
  for (string dorf : DorF) {
    if (dorf.find("file") != string::npos) { // 如果是单文件

      // numjobs=1
      string numjobs[] = {"1"}; // 用数组配置numjobs
      for (string numjob : numjobs) {
        // bs=512/1024
        string bs_group[] = {"512", "1024"}; // 用数组配置bs块大小
        for (string bs : bs_group) {
          string iodepth_group[] = {"1", "2", "8", "16",
                                    "32"}; // 用数组配置iodepth循环
          // iodepth=1/2/8/16/32
          for (string iodepth : iodepth_group) {
            string rw = "read";
            name = rw + "_" + dorf + "_numjobs=" + numjob +
                   "_iodepth=" + iodepth + "_bs=" + bs + "k";
            // 重复运行3次
            for (int i = 1; i <= 3; i++) {
              // 构建文件夹fio命令
              fio_cmd = "echo 3 > /proc/sys/vm/drop_caches && fio "
                        "-name=init_read -size=" +
                        fsize + "G -runtime=" + runtime +
                        "s -time_base -bs=" + bs + "k -direct=" + direct +
                        " -rw=" + rw + " -ioengine=" + ioengine +
                        " -numjobs=" + numjob +
                        " -group_reporting -ramp_time=5 -iodepth=" + iodepth +
                        " -" + dorf + "=" + dir + "init_read.0.0";
              // 输出本次运行的命令以便排障
              cout << "\033[36;1m第" << i << "次运行的命令是：" << fio_cmd
                   << "\033[0m" << endl;
              run_cmd(fio_cmd);
              format(i);
              // 重置数据
              bw_int.clear();
              iops_int.clear();
            }
            fio_sum(name);
          }
          runReport();
        }
      }
    } else if (dorf.find("directory") != string::npos) {
      // numjobs=8/16
      string numjobs[] = {"8", "16"}; // 用数组配置numjobs
      for (string numjob : numjobs) {
        // bs=4k
        string bs_group[] = {"128", "256", "512", "1024"}; // 用数组配置bs块大小
        for (string bs : bs_group) {
          string iodepth_group[] = {"1", "2", "8", "16",
                                    "32"}; // 用数组配置iodepth循环
          // iodepth=1/2/8/16/32
          for (string iodepth : iodepth_group) {
            // 先写后读
            string rw = "read";
            // 重复运行3次
            name = rw + "_" + dorf + "_numjobs=" + numjob +
                   "_iodepth=" + iodepth + "_bs=" + bs + "k";
            for (int i = 1; i <= 3; i++) {
              // 构建文件夹fio命令
              fio_cmd = "echo 3 > /proc/sys/vm/drop_caches && fio "
                        "-name=init_read -size=" +
                        fsize + "G -runtime=" + runtime +
                        "s -time_base -bs=" + bs + "k -direct=" + direct +
                        " -rw=" + rw + " -ioengine=" + ioengine +
                        " -numjobs=" + numjob +
                        " -group_reporting -ramp_time=5 -iodepth=" + iodepth +
                        " -" + dorf + "=" + dir;
              // 输出本次运行的命令以便排障
              cout << "\033[36;1m第" << i << "次运行的命令是：" << fio_cmd
                   << "\033[0m" << endl;
              run_cmd(fio_cmd);
              format(i);
              // 重置数据
              bw_int.clear();
              iops_int.clear();
            }
            fio_sum(name);
          }
          runReport();
        }
      }
    }
  }
}
// --- 顺序读end ---

// --- 随机读start ---
void fio_rand_read() {
  // 重置数据
  bw_int.clear();
  iops_int.clear();
  // 文件
  cout << "\033[31;1m随机读测试，共计15项，每项3次，每次预热5秒，每次测试" +
              runtime + "秒，共计" + to_string((stoi(runtime) + 5) * 15 * 3) +
              "秒，约 "
       << setprecision(2) << fixed
       << (double)(stoi(runtime) + 5) * 15 * 3 / 60 / 60
       << "小时\n进行中...\033[0m" << endl;
  // 文件/文件夹
  string DorF[] = {"filename", "directory"};
  for (string dorf : DorF) {
    if (dorf.find("file") != string::npos) { // 如果是单文件

      // numjobs=1
      string numjobs[] = {"1"}; // 用数组配置numjobs
      for (string numjob : numjobs) {
        // bs=512/1024
        string bs_group[] = {"4"}; // 用数组配置bs块大小
        for (string bs : bs_group) {
          string iodepth_group[] = {"1", "2", "8", "16",
                                    "32"}; // 用数组配置iodepth循环
          // iodepth=1/2/8/16/32
          for (string iodepth : iodepth_group) {
            string rw = "randread";
            name = rw + "_" + dorf + "_numjobs=" + numjob +
                   "_iodepth=" + iodepth + "_bs=" + bs + "k";
            // 重复运行3次
            for (int i = 1; i <= 3; i++) {
              // 构建文件夹fio命令
              fio_cmd =
                  "echo 3 > /proc/sys/vm/drop_caches && fio "
                  "-name=init_read -size=" +
                  fsize + "G -runtime=" + runtime + "s -time_base -bs=" + bs +
                  "k -direct=" + direct + " -rw=" + rw +
                  " -ioengine=" + ioengine + " -numjobs=" + numjob +
                  " -group_reporting -ramp_time=5 -readrepeat=0 -iodepth=" +
                  iodepth + " -" + dorf + "=" + dir + "init_read.0.0";
              // 输出本次运行的命令以便排障
              cout << "\033[36;1m第" << i << "次运行的命令是：" << fio_cmd
                   << "\033[0m" << endl;
              run_cmd(fio_cmd);
              format(i);
              // 重置数据
              bw_int.clear();
              iops_int.clear();
            }
            fio_sum(name);
          }
          runReport();
        }
      }
    } else if (dorf.find("directory") != string::npos) {
      // numjobs=8/16
      string numjobs[] = {"8", "16"}; // 用数组配置numjobs
      for (string numjob : numjobs) {
        // bs=4k
        string bs_group[] = {"4"}; // 用数组配置bs块大小
        for (string bs : bs_group) {
          string iodepth_group[] = {"1", "2", "8", "16",
                                    "32"}; // 用数组配置iodepth循环
          // iodepth=1/2/8/16/32
          for (string iodepth : iodepth_group) {
            // 先写后读
            string rw = "randread";
            // 重复运行3次
            name = rw + "_" + dorf + "_numjobs=" + numjob +
                   "_iodepth=" + iodepth + "_bs=" + bs + "k";
            for (int i = 1; i <= 3; i++) {
              // 构建文件夹fio命令
              fio_cmd =
                  "echo 3 > /proc/sys/vm/drop_caches && fio "
                  "-name=init_read -size=" +
                  fsize + "G -runtime=" + runtime + "s -time_base -bs=" + bs +
                  "k -direct=" + direct + " -rw=" + rw +
                  " -ioengine=" + ioengine + " -numjobs=" + numjob +
                  " -group_reporting -ramp_time=5 -readrepeat=0 -iodepth=" +
                  iodepth + " -" + dorf + "=" + dir;
              // 输出本次运行的命令以便排障
              cout << "\033[36;1m第" << i << "次运行的命令是：" << fio_cmd
                   << "\033[0m" << endl;
              run_cmd(fio_cmd);
              format(i);
              // 重置数据
              bw_int.clear();
              iops_int.clear();
            }
            fio_sum(name);
          }
          runReport();
        }
      }
    }
  }
}
// --- 随机读end ---

// --- 随机写开始 ---
void fio_rand_write() {
  // 重置数据
  bw_int.clear();
  iops_int.clear();
  cout << "\033[31;1m随机写测试，共计15项，每项3次，每次预热5秒，每次测试" +
              runtime + "秒，共计" + to_string((stoi(runtime) + 5) * 15 * 3) +
              "秒，约 "
       << setprecision(2) << fixed
       << (double)(stoi(runtime) + 5) * 15 * 3 / 60 / 60
       << "小时\n进行中...\033[0m" << endl;
  // 文件/文件夹
  string DorF[] = {"filename", "directory"};
  for (string dorf : DorF) {
    if (dorf.find("file") != string::npos) { // 如果是单文件
                                             // numjobs=8/16
      string numjobs[] = {"1"};              // 用数组配置numjobs
      for (string numjob : numjobs) {
        // bs=4k
        string bs_group[] = {"4"}; // 用数组配置bs块大小
        for (string bs : bs_group) {
          string iodepth_group[] = {"1", "2", "8", "16",
                                    "32"}; // 用数组配置iodepth循环
          // iodepth=1/2/8/16/32
          for (string iodepth : iodepth_group) {
            // 先写后读
            string rw = "randwrite";
            // 重复运行3次
            name = rw + "_" + dorf + "_numjobs=" + numjob +
                   "_iodepth=" + iodepth + "_bs=" + bs + "k";
            for (int i = 1; i <= 3; i++) {
              // 构建文件夹fio命令
              fio_cmd = "fio -name=" + name + " -size=" + fsize +
                        "G -runtime=" + runtime + "s -time_base -bs=" + bs +
                        "k -direct=" + direct + " -rw=" + rw +
                        " -ioengine=" + ioengine + " -numjobs=" + numjob +
                        " -group_reporting -ramp_time=5 -iodepth=" + iodepth +
                        " -" + dorf + "=" + dir + to_string(i);
              // 输出本次运行的命令以便排障
              cout << "\033[36;1m第" << i << "次运行的命令是：" << fio_cmd
                   << "\033[0m" << endl;
              run_cmd(fio_cmd);
              format(i);
              // 重置数据
              bw_int.clear();
              iops_int.clear();
              rm_file(to_string(i));
            }
            fio_sum(name);
          }
          runReport();
        }
      }
    } else if (dorf.find("directory") != string::npos) {
      // numjobs=8/16
      string numjobs[] = {"8", "16"}; // 用数组配置numjobs
      for (string numjob : numjobs) {
        // bs=4k
        string bs_group[] = {"4"}; // 用数组配置bs块大小
        for (string bs : bs_group) {
          string iodepth_group[] = {"1", "2", "8", "16",
                                    "32"}; // 用数组配置iodepth循环
          // iodepth=1/2/8/16/32
          for (string iodepth : iodepth_group) {
            // 先写后读
            string rw = "randwrite";
            // 重复运行3次
            name = rw + "_" + dorf + "_numjobs=" + numjob +
                   "_iodepth=" + iodepth + "_bs=" + bs + "k";
            for (int i = 1; i <= 3; i++) {
              // 构建文件夹fio命令
              fio_cmd = "mkdir -p " + dir + "dir_" + to_string(i) + "/" +
                        " && fio -name=" + name + " -size=" + fsize +
                        "G -runtime=" + runtime + "s -time_base -bs=" + bs +
                        "k -direct=" + direct + " -rw=" + rw +
                        " -ioengine=" + ioengine + " -numjobs=" + numjob +
                        " -group_reporting -ramp_time=5 -iodepth=" + iodepth +
                        " -" + dorf + "=" + dir + "dir_" + to_string(i) + "/";
              // 输出本次运行的命令以便排障
              cout << "\033[36;1m第" << i << "次运行的命令是：" << fio_cmd
                   << "\033[0m" << endl;
              run_cmd(fio_cmd);
              format(i);
              // 重置数据
              bw_int.clear();
              iops_int.clear();
              rm_file("dir_" + to_string(i));
            }
            fio_sum(name);
          }
          runReport();
        }
      }
    }
  }
}
// --- 随机写结束 ---

// --- 4k随机读写开始 ---
void fio_randrw() {
  // 重置数据
  bw_int.clear();
  iops_int.clear();
  // 文件
  cout << "\033[31;1m50%随机读写测试，共计15项，每项3次，每次" + runtime +
              "秒，共计" + to_string((stoi(runtime) + 5) * 15 * 3) + "秒，约"
       << setprecision(2) << fixed
       << (double)(stoi(runtime) + 5) * 15 * 3 / 60 / 60
       << "小时\n进行中...\033[0m" << endl;
  // 文件/文件夹
  string DorF[] = {"filename", "directory"};
  for (string dorf : DorF) {
    if (dorf.find("file") != string::npos) { // 如果是单文件
                                             // numjobs=8/16
      string numjobs[] = {"8", "16"};        // 用数组配置numjobs
      for (string numjob : numjobs) {
        // bs=4k
        string bs_group[] = {"4"}; // 用数组配置bs块大小
        for (string bs : bs_group) {
          string iodepth_group[] = {"1", "2", "8", "16",
                                    "32"}; // 用数组配置iodepth循环
          // iodepth=1/2/8/16/32
          for (string iodepth : iodepth_group) {
            // 先写后读
            string rw = "randrw";
            // 重复运行3次
            name = rw + "_" + dorf + "_numjobs=" + numjob +
                   "_iodepth=" + iodepth + "_bs=" + bs + "k";
            for (int i = 1; i <= 3; i++) {
              // 构建文件夹fio命令
              fio_cmd = "echo 3 > /proc/sys/vm/drop_caches && fio "
                        "-name=init_read -size=" +
                        fsize + "G -runtime=" + runtime +
                        "s -time_base -bs=" + bs + "k -direct=" + direct +
                        " -rw=" + rw + " -ioengine=" + ioengine +
                        " -numjobs=" + numjob +
                        " -group_reporting -ramp_time=5 -iodepth=" + iodepth +
                        " -" + dorf + "=" + dir + "init_read.0.0";
              // 输出本次运行的命令以便排障
              cout << "\033[36;1m第" << i << "次运行的命令是：" << fio_cmd
                   << "\033[0m" << endl;
              run_cmd(fio_cmd);
              format(i);
              // 重置数据
              bw_int.clear();
              iops_int.clear();
            }
            fio_sum(name);
          }
          runReport();
        }
      }
    } else if (dorf.find("directory") != string::npos) {
      // numjobs=8/16
      string numjobs[] = {"8", "16"}; // 用数组配置numjobs
      for (string numjob : numjobs) {
        // bs=4k
        string bs_group[] = {"4"}; // 用数组配置bs块大小
        for (string bs : bs_group) {
          string iodepth_group[] = {"1", "2", "8", "16",
                                    "32"}; // 用数组配置iodepth循环
          // iodepth=1/2/8/16/32
          for (string iodepth : iodepth_group) {
            // 先写后读
            string rw = "randrw";
            // 重复运行3次
            name = rw + "_" + dorf + "_numjobs=" + numjob +
                   "_iodepth=" + iodepth + "_bs=" + bs + "k";
            for (int i = 1; i <= 3; i++) {
              // 构建文件夹fio命令
              fio_cmd = "echo 3 > /proc/sys/vm/drop_caches && fio "
                        "-name=init_read -size=" +
                        fsize + "G -runtime=" + runtime +
                        "s -time_base -bs=" + bs + "k -direct=" + direct +
                        " -rw=" + rw + " -ioengine=" + ioengine +
                        " -numjobs=" + numjob +
                        " -group_reporting -ramp_time=5 -iodepth=" + iodepth +
                        " -" + dorf + "=" + dir;
              // 输出本次运行的命令以便排障
              cout << "\033[36;1m第" << i << "次运行的命令是：" << fio_cmd
                   << "\033[0m" << endl;
              run_cmd(fio_cmd);
              format(i);
              // 重置数据
              bw_int.clear();
              iops_int.clear();
            }
            fio_sum(name);
          }
          runReport();
        }
      }
    }
  }
}
// --- 4k随机读写结束 ---

直接编写crontab使用一行命令完成Proxmox-VE所有虚拟机的安全关机和依次开机

2024-09-12T09:14:48.000Z

# 依次关机
i=$(qm list)&&vmid=$(echo "$i" | awk '{if (NR>1) {print $1}}')&&for i in $vmid;do qm shutdown $i;done

#依次开机，间隔一分钟
i=$(qm list)&&vmid=$(echo "$i" | awk '{if (NR>1) {print $1}}')&&for i in $vmid;do qm start $i&&sleep 60s;done

记录qemu虚拟机网卡的一次坑

2024-06-26T11:18:05.000Z

qemu的虚拟机网卡推荐设置如下

关闭防火墙,使用VirtIO班虚拟化,Multiqueue根据vCPU数量填写,4核则是4,超过8核最大值只能是8

此处记录一个大坑

qemu虚拟机网卡的限速功能,会导致传输大量小包是延迟巨大,比如steam下载游戏,会导致延迟巨高,甚至飙升到300ms

本次大坑的发现过程相当曲折,粒子GO的用户在购买服务器后,steamcmd下载游戏时会延迟巨高,很卡,随后针对机房防火墙,交换机性能,线路问题,进行了全面排查后,了解到steam下载会使用小包传输以保障完整性,而虚拟机服务器正好需要进行限速,导致流量在宿主机转发了一遍再传到虚拟机,一旦遇到steam下载这种大量小包传输,便会导致延迟巨高

填坑办法

取消在宿主机设置虚拟机网卡限速,直接在虚拟机系统里做限速,以下是在Debian使用iproute2的tc进行限速的办法

# 初始化enp6s18,设置默认的根qdisc,然后删除
tc qdisc add dev enp6s18 root handle 1: fq_codel
tc qdisc del dev enp6s18 root
# 设置根队列规则
tc qdisc add dev enp6s18 root handle 1: htb default 10
# 创建一个类来限制上行带宽为30Mbps
tc class add dev enp6s18 parent 1: classid 1:1 htb rate 30mbit
# 创建过滤器将所有上行流量命中该类
tc filter add dev enp6s18 protocol ip parent 1: prio 1 u32 match ip src 0.0.0.0/0 flowid 1:1

# 查询enp6s18网卡规则
tc qdisc show dev enp6s18
# 查询enp6s18网卡类规则
tc class show dev enp6s18
# 查询enp6s18网卡过滤器
tc filter show dev enp6s18

# 一条龙梭哈
tc qdisc add dev enp6s18 root handle 1: fq_codel && tc qdisc del dev enp6s18 root && tc qdisc add dev enp6s18 root handle 1: htb default 10 && tc class add dev enp6s18 parent 1: classid 1:1 htb rate 30mbit && tc filter add dev enp6s18 protocol ip parent 1: prio 1 u32 match ip src 0.0.0.0/0 flowid 1:1

如何搭建具有GPGkey验证的可信任apt源

2024-06-21T09:13:04.000Z

本文将介绍如何搭建一个像docker-ce一样具有GPG key验证的源

普通的用deb [trusted=yes] http://url/ bookworm main添加的源在内网环境用还行，但若是在公网，就会存在没有验证，被篡改的风险，且具有GPG key验证的源也更专业

搭建自己的apt源后便可将自己的deb包上传到服务器，然后添加自己的apt源并导入GPG密钥

使用aptly管理apt仓库

# 创建一个aptly的工作地址
mkdir -p /mypath/apt
# 使用aptly创建仓库
# bookworm是debian 12的代号
# comment则是填仓库的描述
# hackerbs是我的仓库名，修改为你的即可
aptly repo create -distribution="bookworm" -comment="hackerbs.com's repository" hackerbs

# 运行该命令后会在用户目录下生成一个.aptly.conf配置文件，和.aptly的目录
# 建议编辑.aptly.conf配置文件，修改原
"rootDir": "/root/.aptly",
# 改为指定的，如我的/mypath/apt目录
"rootDir": "/mypath/apt",
# 重新运行
aptly repo create -distribution="bookworm" -comment="hackerbs.com's repository" hackerbs
# 现在指定的/mypath/apt下便会出现一个db文件夹
# 继续往仓库添加deb包
# add后面的hackerbs是上一步创建的仓库名，仓库名后面则是包的路径，跟部署无关，这里只是添加到仓库
aptly repo add hackerbs /deb/package/aptdownloader/aptdownloader_1.0.0-1_amd64.deb
# 添加完成后创建一个快照
# create后面的aptdownloader只是我的快照名称，repo后面接你的仓库名
aptly snapshot create aptdownloader from repo hackerbs
# 使用快照发布apt存储库
# snapshot后面跟快照名
aptly publish snapshot aptdownloader

至此，aptly发布存储库完成，/mypath/apt/public文件夹就是网站的文件夹，所以下文中nginx指向的便是该路径

以下是aptly命令的补充

aptly publish drop buster # 取消已发布的存储库，这里指定的名字不是存储库的名字而是distribution
aptly snapshot drop imlala_snapshot # 删除快照（如果当前快照正在对外服务，需要先取消快照对应的存储库发布后才能删除）
aptly snapshot show -with-packages imlala_snapshot # 显示某个快照内有多少个包
aptly snapshot list # 列出所有快照
aptly repo show -with-packages imlala # 显示某个存储库内有多少包
aptly repo list # 列出所有存储库
aptly repo remove imlala qbittorrent-nox_4.1.7.1_amd64 # 从存储库删除包
aptly serve # 启动自带的http服务器

使用docker创建一个nginx，以下是我的docker-compose.yaml文件

services:
    apt:
        image: nginx:latest
        container_name: apt
        restart: always
        ports:
        - 443:443
        volumes:
        - /mypath/html:/usr/share/nginx/html
        - /mypath/conf:/etc/nginx/conf.d

然后使用docker compose up -d启动这个nginx容器

进入到我的目录的conf中，新建一个apt.conf配置文件

server {
    listen 443;
    listen [::]:443;
    server_name mydomain;

    root /mypath/public;
    autoindex on;
    index index.html
    allow all;
}

然后使用docker exec apt nginx -t测试配置文件

继续使用docker exec apt nginx -s reload重载配置文件

此时nginx已经上线

配置GPG key

首先使用gpg --full-generate-key命令并按图所示创建gpg密钥

然后建议导出密钥用于备份

私钥绝对不要泄露

# 导出私钥，邮箱替换成你的，private.gpg也可以按你的习惯命名
gpg --export-secret-keys --armor 0@hackerbs.com > private.gpg

# 导出公钥，邮箱替换成你的，public.gpg也可以按你的习惯命名
gpg --export --armor 0@hackerbs.com > public.gpg

# 查看所有gpg key信息
 gpg --list-keys
# 我的输出如下
/root/.gnupg/pubring.kbx
------------------------
pub   rsa4096 2024-06-21 [SC]
      0380F37B181615738D90FF46C1763CF4CC699C74
uid           [ultimate] hackerbs (hackerbs.com) <0@hackerbs.com>
sub   rsa4096 2024-06-21 [E]
# 其中0380F37B181615738D90FF46C1763CF4CC699C74便是我的公钥，使用下面的命令进行导出
gpg --export --armor 0380F37B181615738D90FF46C1763CF4CC699C74 > hackerbs.asc

# 导出的公钥放到网站根目录以供下载
mv hackerbs.asc /mypath/public

因为apt-key被淘汰了，所以没有推荐用apt-key的方式，不过还是补充下

1 2	# 将公钥上传到keyserver.ubuntu.com gpg --keyserver keyserver.ubuntu.com --send-key 630D583FFE07EDA9B9531E029CA58840D67352EE

在https://keyserver.ubuntu.com/输入邮箱地址即可查询到公钥

客户端添加gpg密钥和源

# 以下是本站源的演示
# 其中hackerbs.asc名称可以更改，如myname.asc，后缀要保留
# 后面的连接就是上方为什么需要将asc放到网站根目录
# &&是表示执行成功后继续执行mv将asc密钥放到/etc/apt/trusted.gpg.d/目录下
# 后面的添加到sources.list就不用再讲解了
curl -o hackerbs.asc https://apt.ygeit.cn/hackerbs.asc && mv hackerbs.asc /etc/apt/trusted.gpg.d/
echo "deb https://apt.ygeit.cn bookworm main" >> /etc/apt/sources.list
apt update

补充

如果访问有问题，记得修改public的权限为755

1	chmod -R 755 /mypath/apt/public

记录用docker部署nextcloud及配套mariadb、redis和持久化存储

2024-06-13T08:45:32.000Z

使用docker compose便捷的部署nextcloud及其配套的mariadb和redis并实现数据持久存储在本地的办法

安装docker的教程在apt等各种源列表（持续更新），docker hub被禁，处理的办法在国内docker hub无法使用的解决办法

新的docker已经自带docker compose命令了，所以不需要再安装docker-compose，且需注意是docker空格compose而不是以前的-

docker compose基础命令如下：

# 指定配置文件并后台启动
docker compose -f 指定配置文件.yaml up -d

# 停止容器并删除容器
docker compose -f 指定配置文件.yaml down

nextcloud.yaml配置文件如下

services:
  db:
    image: mariadb:latest
    container_name: nextcloud-db
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: 设置你的数据库root密码
      MYSQL_DATABASE: 设置你的数据库名
      MYSQL_USER: 设置你的数据库用户名
      MYSQL_PASSWORD: 设置你的数据库用户密码
    volumes:
      - /mnt/nextcloud/db:/var/lib/mysql
      - 你的物理机路径:/var/lib/mysql # 这条是示例，该配置的作用是让数据库的所有文件持久存储到本地的该目录

  redis:
    image: redis:alpine
    container_name: nextcloud-redis
    restart: always

  app:
    image: nextcloud:latest
    container_name: nextcloud-app
    restart: always
    ports:
      - 80:80
    environment:
      MYSQL_HOST: db
      MYSQL_DATABASE: 你的数据库名
      MYSQL_USER: 你的数据库用户名
      MYSQL_PASSWORD: 你的数据库用户密码
      REDIS_HOST: redis
    volumes:
      - /mnt/nextcloud/data:/var/www/html
      - 你的服务器路径:/var/www/html # 这条是示例，该配置的作用是让nextcloud的所有文件持久存储到本地的该目录
    depends_on:
      - db
      - redis

crontab自动执行

# 每5分钟执行一次cron
*/5  *  *  *  * docker exec -u www-data nextcloud-app php -f /var/www/html/cron.php

# 每天0点down掉容器然后拉取nextcloud的更新，再启动，然后执行命令行更新
0 0 * * * docker compose -f /mnt/docker-compose.yaml down && docker pull nextcloud && docker compose -f /mnt/docker-compose.yaml up -d && docker exec -it -u 33 nextcloud-app php occ upgrade

记录一下我的Debian配置v2ray config.json

2024-06-13T08:41:09.000Z

配置内容如下

vim /etc/v2ray/config.json

{
  "log": {
    "access": "",
    "error": "",
    "loglevel": "warning"
  },
  "inbounds": [
    {
      "tag": "socks",
      "port": 10808,
      "listen": "127.0.0.1",
      "protocol": "socks",
      "sniffing": {
        "enabled": true,
        "destOverride": [
          "http",
          "tls"
        ],
        "routeOnly": false
      },
      "settings": {
        "auth": "noauth",
        "udp": true,
        "allowTransparent": false
      }
    }
  ],
  "outbounds": [
    {
      "tag": "proxy",
      "protocol": "shadowsocks",
      "settings": {
        "servers": [
          {
            "address": "你的服务器地址",
            "method": "加密方式",
            "ota": false,
            "password": "你的密码",
            "port": 服务器端口,
            "level": 1
          }
        ]
      },
      "streamSettings": {
        "network": "tcp"
      },
      "mux": {
        "enabled": false,
        "concurrency": -1
      }
    },
    {
      "tag": "direct",
      "protocol": "freedom",
      "settings": {}
    },
    {
      "tag": "block",
      "protocol": "blackhole",
      "settings": {
        "response": {
          "type": "http"
        }
      }
    }
  ]
}