![在这里插入图片描述](/static/img/images/00071.png)






深入理解 Linux 中的 `mv` 命令：移动文件和文件夹的艺术

在日常使用 Linux 的过程中，`mv`（move）命令是我们经常会用到的一个命令，它不仅可以用来移动文件和文件夹，还可以用于重命名。尽管 `mv` 看似简单，但在实际使用中，我们可以通过一些技巧使其更为强大和灵活。本篇博客将深入探讨 `mv` 命令的各种用法，并分享一些实用的小技巧，帮助你更高效地管理文件。

### 一、基本语法

`mv` 命令的基本语法如下：

```bash
mv [选项] 源文件 目标路径
```

其中，`源文件` 是你想要移动或重命名的文件或文件夹，`目标路径` 是你希望将其移动到的目的地。

### 二、基本用法

1. **移动文件：**

   ```bash
   mv filename.txt /home/user/documents/
   ```

   这条命令将 `filename.txt` 文件从当前目录移动到 `/home/user/documents/` 目录下。

2. **移动并重命名文件：**

   ```bash
   mv filename.txt /home/user/documents/newname.txt
   ```

   这条命令不仅移动了文件，还将文件重命名为 `newname.txt`。

3. **移动文件夹：**

   ```bash
   mv foldername /home/user/documents/
   ```

   这条命令将文件夹 `foldername` 及其内容移动到 `/home/user/documents/` 目录下。

### 三、使用 `mv` 移动所有文件但排除特定文件或文件夹

有时候，我们可能需要移动一个目录中的所有文件和文件夹，但希望排除某些特定的文件或文件夹。假设你要移动所有文件和文件夹，但排除 `.git` 文件夹，可以使用以下方法：

```bash
shopt -s extglob
mv !( .git ) /path/to/destination/
```

#### **命令解释：**

- `shopt -s extglob`：这是一个 Bash 内建命令，用于启用扩展模式匹配（extglob）。

- `mv !( .git ) /path/to/destination/`：在这个命令中，`!( .git )` 是一个模式匹配表达式，表示匹配除了 `.git` 文件夹之外的所有文件和文件夹。

这个命令会将当前目录下所有的文件和文件夹（除了 `.git`）移动到指定的目的地 `/path/to/destination/`。

### 四、其他常用选项

1. **覆盖提示：** 默认情况下，`mv` 会直接覆盖目标路径中的同名文件。如果你希望在覆盖文件之前得到提示，可以使用 `-i` 选项。

   ```bash
   mv -i filename.txt /home/user/documents/
   ```

2. **强制覆盖：** 如果你希望在移动文件时强制覆盖目标路径中的文件，可以使用 `-f` 选项。

   ```bash
   mv -f filename.txt /home/user/documents/
   ```

3. **显示移动过程：** 使用 `-v` 选项可以显示移动过程，便于调试。

   ```bash
   mv -v filename.txt /home/user/documents/
   ```

### 五、总结

通过本文的介绍，我们可以看到 `mv` 命令不仅仅是一个简单的移动工具，通过一些小技巧和选项，我们可以灵活地处理文件和文件夹的移动与重命名任务。特别是在需要排除特定文件或文件夹的情况下，使用扩展的模式匹配可以极大地方便操作。掌握这些技能，将有助于你更高效地管理 Linux 系统中的文件。

【运维】深入理解 Linux 中的 `mv` 命令，使用 `mv` 移动所有文件但排除特定文件或文件夹

![在这里插入图片描述](/static/img/images/00072.png)





# 报错信息

```go
able of handling various complex tasks. Please report the progress of this project to the team members.
 > ===========================
  0%|                                                                                                                                         | 0/7 [00:00<?, ?it/s]
Traceback (most recent call last):
  File "/ssd/xd/tts/MeloTTS/x01.py", line 37, in <module>
    model.tts_to_file(text, speaker_ids['EN-US'], output_path, speed=speed)
  File "/ssd/xd/tts/MeloTTS/melo/api.py", line 100, in tts_to_file
    bert, ja_bert, phones, tones, lang_ids = utils.get_text_for_tts_infer(t, language, self.hps, device, self.symbol_to_id)
  File "/ssd/xd/tts/MeloTTS/melo/utils.py", line 23, in get_text_for_tts_infer
    norm_text, phone, tone, word2ph = clean_text(text, language_str)
  File "/ssd/xd/tts/MeloTTS/melo/text/cleaner.py", line 12, in clean_text
    phones, tones, word2ph = language_module.g2p(norm_text)
  File "/ssd/xd/tts/MeloTTS/melo/text/english.py", line 242, in g2p
    phone_list = list(filter(lambda p: p != " ", _g2p(w)))
  File "/ssd/xd/miniconda3/envs/melotts/lib/python3.10/site-packages/g2p_en/g2p.py", line 162, in __call__
    tokens = pos_tag(words)  # tuples of (word, tag)
  File "/ssd/xd/miniconda3/envs/melotts/lib/python3.10/site-packages/nltk/tag/__init__.py", line 165, in pos_tag
    tagger = _get_tagger(lang)
  File "/ssd/xd/miniconda3/envs/melotts/lib/python3.10/site-packages/nltk/tag/__init__.py", line 107, in _get_tagger
    tagger = PerceptronTagger()
  File "/ssd/xd/miniconda3/envs/melotts/lib/python3.10/site-packages/nltk/tag/perceptron.py", line 183, in __init__
    self.load_from_json(lang)
  File "/ssd/xd/miniconda3/envs/melotts/lib/python3.10/site-packages/nltk/tag/perceptron.py", line 273, in load_from_json
    loc = find(f"taggers/averaged_perceptron_tagger_{lang}/")
  File "/ssd/xd/miniconda3/envs/melotts/lib/python3.10/site-packages/nltk/data.py", line 582, in find
    raise LookupError(resource_not_found)
LookupError:
**********************************************************************
  Resource averaged_perceptron_tagger_eng not found.
  Please use the NLTK Downloader to obtain the resource:
  >>> import nltk
  >>> nltk.download('averaged_perceptron_tagger_eng')
  For more information see: https://www.nltk.org/data.html
  Attempted to load taggers/averaged_perceptron_tagger_eng/
  Searched in:
    - '/home/xd/nltk_data'
    - '/ssd/xd/miniconda3/envs/melotts/nltk_data'
    - '/ssd/xd/miniconda3/envs/melotts/share/nltk_data'
    - '/ssd/xd/miniconda3/envs/melotts/lib/nltk_data'
    - '/usr/share/nltk_data'
    - '/usr/local/share/nltk_data'
    - '/usr/lib/nltk_data'
    - '/usr/local/lib/nltk_data'
    - '/home/xd/nltk_data'
***************************************************************
```

# 解决

python代码前加这几句，开魔法执行，会下载好对应包，就不会报错了。
```go
import nltk
nltk.data.path.append('/home/xd/nltk_data')  # 添加路径
nltk.download('averaged_perceptron_tagger_eng')
```

要有魔法才行，路径可以改为自己喜欢的，python能找到的。比如显示在这些地方找，那就选一个。

![在这里插入图片描述](/static/img/images/00073.png)

【运维】报错Resource averaged_perceptron_tagger_eng not found.

一直要求输入密码，很烦人：





![在这里插入图片描述](/static/img/images/00079.png)

如何免密连接？

1 重新打开gateway，来到这个界面点新建连接：

![在这里插入图片描述](/static/img/images/00080.png)

2 点这里设置：

![在这里插入图片描述](/static/img/images/00081.png)

3 在这一页，你可以改你的所有配置，只要设置为password并且保存密码，就可以一直爽：

![在这里插入图片描述](/static/img/images/00082.png)

【运维】JetBrains Gateway (Pycharm) SSH免密连接，改为免密连接

![在这里插入图片描述](/static/img/images/00083.png)





## 深入了解 `grep` 命令：全面指南

`grep` 是 Linux/Unix 系统中的一款非常强大的命令行工具，用于在文本中搜索特定的模式或字符串。无论是日常任务还是复杂的文本处理，`grep` 都能帮助你高效地找到所需的信息。在这篇博客中，我们将详细介绍 `grep` 的基本用法、常用选项以及一些高级技巧和实际应用场景。

### 基本用法

`grep` 的最基本用法如下：

```bash
grep 'pattern' filename
```

- **pattern**：你要搜索的字符串或正则表达式。

- **filename**：要在其中搜索的文件名。

#### 示例：查找文件 `sample.txt` 中包含 `hello` 的行

```bash
grep 'hello' sample.txt
```

这个命令将搜索 `sample.txt` 中所有包含 `hello` 字符串的行，并将匹配的行输出到终端。

### 选项和常用参数

`grep` 提供了多种选项，帮助用户更灵活地进行搜索。下面是一些常用的参数及其示例。

#### 1. 忽略大小写：`-i`

```bash
grep -i 'hello' sample.txt
```

此命令忽略大小写，找到所有形式的 `hello`（如 `HELLO`、`Hello` 等）。

#### 2. 显示行号：`-n`

```bash
grep -n 'hello' sample.txt
```

此命令会显示匹配行的行号，方便定位。

#### 3. 递归搜索：`-r`

```bash
grep -r 'hello' /path/to/directory
```

递归搜索指定目录下的所有文件，查找包含 `hello` 的行。

#### 4. 只显示匹配的行：`-o`

```bash
grep -o 'hello' sample.txt
```

只显示匹配的字符串，而不是整行内容。

#### 5. 显示匹配行的上下文：`-C`

```bash
grep -C 3 'hello' sample.txt
```

显示匹配行以及上下各三行的内容，以便了解匹配所在的上下文。

#### 6. 匹配整个单词：`-w`

```bash
grep -w 'hello' sample.txt
```

只匹配完整的单词，如 `hello`，而不会匹配 `helloworld`。

#### 7. 统计匹配的行数：`-c`

```bash
grep -c 'hello' sample.txt
```

统计文件中包含 `hello` 的行数。

### 使用正则表达式

`grep` 支持正则表达式，使其在处理复杂的文本匹配时更加得心应手。

#### 匹配以某字符串开头的行

```bash
grep '^hello' sample.txt
```

匹配以 `hello` 开头的行。

#### 匹配以某字符串结尾的行

```bash
grep 'hello$' sample.txt
```

匹配以 `hello` 结尾的行。

#### 匹配任意字符

```bash
grep 'h.llo' sample.txt
```

匹配 `h` 和 `llo` 之间有一个任意字符的行，如 `hello` 或 `hallo`。

### 实际应用场景

`grep` 的应用非常广泛，从搜索日志文件到查找特定的代码片段，以下是一些常见的使用场景。

#### 1. 查找日志文件中的错误信息

假设你有一个日志文件 `logfile.txt`，你希望找到所有包含 `error` 的行，并且忽略大小写，显示行号并提供上下文信息：

```bash
grep -inC 2 'error' logfile.txt
```

#### 2. 搜索特定文件类型

你可以通过 `grep` 在特定类型的文件中搜索。例如，要在一个目录及其子目录中的所有 `.py` 文件中搜索包含字符串 "reg_model.pt" 的文件：

```bash
grep -r --include="*.py" 'reg_model.pt' /path/to/directory
```

#### 3. 查找代码中的 `TODO` 注释

如果你想在项目中找到所有标记为 `TODO` 的注释：

```bash
grep -r --include="*.py" 'TODO' /home/user/projects
```

#### 4. 排除特定文件或目录

在递归搜索时，排除某些不相关的文件或目录可能会更有效率：

```bash
grep -r --exclude="*.log" 'failure' /var/logs
```

### 其他实用例子

#### 查找并高亮显示匹配项

你可以使用 `--color` 参数来高亮显示匹配到的内容：

```bash
grep --color 'pattern' filename.txt
```

#### 查找空行

查找文件中所有的空行（即没有任何字符的行）：

```bash
grep '^$' filename.txt
```

#### 查找不包含某个字符串的行

使用 `-v` 参数查找不包含特定字符串的行：

```bash
grep -v 'error' logfile.txt
```

### 总结

`grep` 是一个功能强大且灵活的工具，广泛应用于文本处理和日志分析。通过熟练掌握其各种选项和正则表达式，你可以更高效地处理日常任务。在工作中，`grep` 可以帮助你快速定位问题，提升工作效率。

无论你是新手还是经验丰富的开发者，`grep` 都是你工具箱中不可或缺的利器。通过不断实践和应用，你会发现 `grep` 的强大之处，并逐渐掌握它的高级用法。

【运维】深入了解 grep 命令，如何优雅地使用 grep 命令

### Linux 内核简介





Linux 内核是操作系统中最核心的部分，负责管理计算机的硬件资源，包括处理器、内存和外围设备。它为上层的应用程序提供了必要的系统服务，比如进程管理、文件系统控制和网络通信等。Linux 内核是一个开源项目，由 Linus Torvalds 在 1991 年首次发布，现在由全球的开发者共同开发和维护。

### 如何查看 Ubuntu 当前的内核版本

在 Ubuntu 系统中，查看当前正在使用的内核版本非常简单。你只需要打开终端（Terminal）并输入以下命令：

```bash
uname -r
```

这个命令会返回一个版本号，它表示了你的系统正在运行的内核版本。例如，输出 `5.4.0-42-generic` 表示你正在使用的是 5.4.0 版本的 Linux 内核。

### 如何更新 Linux 内核

更新 Ubuntu 的 Linux 内核可以通过几种方法实现，最常用的是使用系统自带的包管理工具。以下是通过命令行更新内核的步骤：

1. 首先，打开一个终端窗口。

2. 输入以下命令以更新你的包列表：

   ```bash
   sudo apt update
   ```

3. 接下来，可以安装推荐的内核更新：

   ```bash
   sudo apt full-upgrade
   ```

   或者，如果你知道特定的内核版本号，你可以直接安装：

   ```bash
   sudo apt install linux-image-你的内核版本-generic
   ```

### 更新内核的影响

更新 Linux 内核有其重要性，也带来一些影响，值得用户注意：

1. **性能提升**：新版本的内核通常包含了性能优化，能更有效地管理硬件资源，提升系统整体性能。

2. **安全性增强**：内核更新往往包括安全补丁，可以修复已知的安全漏洞，增强系统的安全性。

3. **支持更多硬件**：随着新硬件的发布，新版本的内核通常会加入对这些硬件的支持，如果你计划升级硬件，更新内核可能是必需的。

4. **可能的不兼容**：尽管不常见，新内核可能与某些旧的软件或驱动不兼容。因此，在更新内核之前，建议备份重要数据。

### 结语

理解 Linux 内核及其更新过程对于任何使用 Linux 系统的用户来说都是非常重要的。通过保持内核的更新，用户可以享受到更好的性能，更高的安全性以及更广泛的硬件支持。然而，也应注意更新可能带来的风险，合理安排内核的更新时间和测试，以确保系统的稳定运行。

【运维】什么是Linux 内核？如何更新内核版本？

cli：





[https://github.com/hiddify/hiddify-core/releases](https://github.com/hiddify/hiddify-core/releases)

web：

[https://github.com/hiddify/hiddify-next/releases](https://github.com/hiddify/hiddify-next/releases)

### 如何使用 HiddifyCli 或 Hiddify 命令行

此应用程序是为无桌面环境（如服务器）开发的，并支持所有处理器。

#### 下载

要下载此应用程序，请访问[此处](#)并下载与您的处理器相关的文件。

#### 在 HiddifyCli 中执行配置或订阅链接

要使用它，应使用以下命令：

```bash
HiddifyCli run -c <config file or sublink> -h <HiddifyApp config file or URL>
```

要连接到特定配置，只需按如下所示运行上述命令：

```bash
HiddifyCli run -c <config file>
```

在此，将您的配置文件替换为 `<config file>`。

您还可以在应用程序中运行订阅链接：

```bash
HiddifyCli run -c <sublink>
```

在此，将您的订阅链接替换为 `<sublink>`。

#### 使用 HiddifyApp 设置在 HiddifyCli 中运行配置或订阅链接

为此，您必须首先提取与 HiddifyApp 相关的设置。

##### 提取 HiddifyApp 设置

首先，从 HiddifyApp 中提取相关设置。

##### 使用从 HiddifyApp 提取的设置在 HiddifyCli 中运行配置或订阅链接

此外，如果您想使用您的 HiddifyApp 设置，应使用以下命令：

```bash
HiddifyCli run -c <config file or sublink> -h <HiddifyApp config file>
```

在此，将您的配置文件或订阅链接替换为 `<config file or sublink>`，并将从上一步骤中提取的 HiddifyApp 配置文件替换为 `<HiddifyApp config file>`。

您还可以使用 HiddifyApp 中的设置链接替代配置文件，链接放在 Github 上：

```bash
HiddifyCli run -c <config file or sublink> -h <HiddifyApp config URL>
```

在此，将您的配置文件或订阅链接替换为 `<config file or sublink>`，并将 HiddifyApp 中设置的链接替换为 `<HiddifyApp config URL>`。

联网工具hiddify

要在Linux中批量解压这些`.tar.gz`文件，你可以使用`tar`命令配合`find`或者`bash`的通配符功能。这里是一个简单的步骤来解压所有这些`.tar.gz`文件：





### 方法 1: 使用 `find` 命令

```sh
find . -type f -name "*.tar.gz" -exec tar -xzvf {} \;
```

这个命令的意思是从当前目录开始查找所有的`.tar.gz`文件，并且使用`-exec`选项来执行`tar`命令对每个找到的文件进行解压。

### 方法 2: 使用 `bash` 通配符

如果你在`bash` shell下，可以直接使用通配符：

```sh
for file in *.tar.gz; do tar -xzvf "$file"; done
```

这个命令会循环遍历当前目录下的所有`.tar.gz`文件并解压它们。

### 方法 3: 使用 `xargs`

另一种方法是使用`xargs`命令来处理`find`命令的结果：

```sh
find . -type f -name "*.tar.gz" | xargs -I{} tar -xzvf {}
```

### 注意事项:

1. **解压路径**: 如果你希望将文件解压到特定的目录，可以在`tar`命令中指定 `-C` 参数来设置目标目录。例如：`tar -C /path/to/extract -xzvf {}`。

2. **权限问题**: 如果遇到权限问题，你可能需要使用`sudo`或者以具有足够权限的用户身份运行这些命令。

3. **错误处理**: 如果某个文件出现问题，上述命令可能会停止执行。你可以加入错误处理逻辑来忽略有问题的文件，或者记录错误信息。

【运维】Linux如何批量解压文件夹下的很多个`.tar.gz`文件

报错了：





```css
      /opt/conda/compiler_compat/ld: /usr/lib/x86_64-linux-gnu/openmpi/lib/libmpi.so: undefined reference to `MPIR_being_debugged'
      /opt/conda/compiler_compat/ld: /usr/lib/x86_64-linux-gnu/openmpi/lib/libmpi.so: undefined reference to `opal_list_t_class'
      collect2: error: ld returned 1 exit status
      failure.
      removing: _configtest.c _configtest.o
      error: Cannot link MPI programs. Check your configuration!!!
      [end of output]
  note: This error originates from a subprocess, and is likely not a problem with pip.
  ERROR: Failed building wheel for mpi4py
  Building wheel for tensorrt-cu12 (setup.py) ... done
  Created wheel for tensorrt-cu12: filename=tensorrt_cu12-10.2.0-py2.py3-none-any.whl size=17574 sha256=d924df0128987463ef9ba57021f9baa5e692769b77be8c442c906deaf5cab4f1
  Stored in directory: /root/.cache/pip/wheels/07/6b/5c/ec3d9f9d7c1cb0aa86da43b6833df01994927fba4092df6f55
Successfully built tensorrt tensorrt-cu12
Failed to build mpi4py
ERROR: Could not build wheels for mpi4py, which is required to install pyproject.toml-based projects
```

解决：

`mpi4py` 是一个用于 Python 与 MPI（Message Passing Interface）进行交互的库。安装 `mpi4py` 失败并提示 `Could not build wheels for mpi4py` 通常是因为缺少一些构建工具或者依赖项。以下是一些解决办法：

### 1. 安装构建工具

首先，确保你有必要的构建工具。你可以尝试安装以下包：

```bash
sudo apt-get update
sudo apt-get install -y build-essential python3-dev libopenmpi-dev
```

### 2. 使用 `pip` 安装 `mpi4py`

如果你已经安装了上述工具，可以尝试再次安装 `mpi4py`：

```bash
pip install mpi4py
```

### 3. 安装 `mpi4py` 的特定版本

有时候特定版本可能更容易安装：

```bash
pip install mpi4py==3.0.3
```

### 4. 使用 `conda` 安装

如果你使用 Anaconda 或 Miniconda，可以尝试通过 `conda` 安装，这通常更简单：

```bash
conda install -c conda-forge mpi4py
```

### 5. 检查 Python 和 pip 的版本

确保你使用的是兼容的 Python 和 `pip` 版本。有时候旧版本的 Python 或 `pip` 会导致安装失败。

### 6. 手动编译

如果以上方法都失败，你可以尝试手动编译 `mpi4py`。从官方仓库克隆源码并编译：

```bash
git clone https://github.com/mpi4py/mpi4py.git
cd mpi4py
python setup.py build
python setup.py install
```

### 7. 详细日志

如果以上方法仍然无法解决问题，可以查看详细的错误日志，找出具体缺失的依赖或错误原因：

```bash
pip install mpi4py --verbose
```

这会提供更多详细信息，帮助你定位问题。

希望这些方法能帮助你解决安装 `mpi4py` 时遇到的问题。如果仍有问题，请提供详细的错误日志信息，以便进一步诊断。

ERROR: Could not build wheels for mpi4py, which is required to install pyproject.toml-based projects

# 前言





内存溢出后，服务器可能就打不开了，死机了。所以设置个程序监测内存占用状态，超出95%后，直接关掉那个最占用内存的进程。

# 增加守护进程

在Ubuntu上设置一个守护进程来监控内存使用情况，并在内存超过90%时终止内存占用最多的进程，可以通过编写一个shell脚本和使用`systemd`来实现。以下是详细的步骤和代码示例：

### 1. 编写监控脚本

创建一个脚本文件，例如`monitor_memory.sh`，其内容如下：

我在`/root`中创建了。

```bash
#!/bin/bash
# 设置内存阈值为95%
MEMORY_THRESHOLD=95
while true; do
  # 获取总内存和已用内存
  TOTAL_MEM=$(free | grep Mem | awk '{print $2}')
  USED_MEM=$(free | grep Mem | awk '{print $3}')
  # 计算已用内存的百分比
  MEMORY_USAGE=$(($USED_MEM * 100 / $TOTAL_MEM))
  # 如果内存使用超过阈值，找到并终止占用内存最多的进程
  if [ $MEMORY_USAGE -gt $MEMORY_THRESHOLD ]; then
    echo "Memory usage is at $MEMORY_USAGE%, which is above the threshold of $MEMORY_THRESHOLD%."
    TOP_PROCESS_INFO=$(ps -eo pid,comm,%mem,user --sort=-%mem | head -n 2 | tail -n 1)
    TOP_PROCESS_PID=$(echo $TOP_PROCESS_INFO | awk '{print $1}')
    TOP_PROCESS_USER=$(echo $TOP_PROCESS_INFO | awk '{print $4}')
    TOP_PROCESS_MEM=$(echo $TOP_PROCESS_INFO | awk '{print $3}')
    echo "Killing process $TOP_PROCESS_PID, owned by $TOP_PROCESS_USER, which is using $TOP_PROCESS_MEM% of memory."
    kill -9 $TOP_PROCESS_PID
  fi
  # 每隔60秒检查一次
  sleep 60
done
```

确保脚本具有可执行权限：

```bash
chmod +x monitor_memory.sh
```

### 2. 创建 systemd 服务文件

在`/etc/systemd/system/`目录下创建一个服务文件，例如`memory_monitor.service`，其内容如下：

```ini
[Unit]
Description=Memory Monitor Service
After=network.target
[Service]
Type=simple
ExecStart=/root/monitor_memory.sh
Restart=on-failure
[Install]
WantedBy=multi-user.target
```

请将`/path/to/your/monitor_memory.sh`替换为实际的脚本路径。

### 3. 启动并启用服务

重新加载`systemd`，启动并启用服务：

```bash
sudo systemctl daemon-reload
sudo systemctl start memory_monitor.service
sudo systemctl enable memory_monitor.service
```

### 4. 验证服务是否运行

使用以下命令检查服务状态：

```bash
sudo systemctl status memory_monitor.service
```

如果一切正常，服务应该会显示为“active (running)”。

### 注意事项

1. 这种方法会强制终止占用内存最多的进程，可能导致数据丢失或服务中断。请谨慎使用。

2. 可根据需要调整脚本的检查频率和阈值。

3. 可以在脚本中添加日志记录以便后续分析。

通过上述步骤，你就可以在Ubuntu上设置一个守护进程来监控内存使用情况，并在内存超过95%时终止占用最多的进程。

![在这里插入图片描述](/static/img/images/02837.png)

# 如何修改守护进程

比如要将监控频率从每60秒一次改为每10秒一次，同时更新和重启服务，你需要进行以下修改和操作：

### 1. 修改监控脚本

编辑之前创建的 `monitor_memory.sh` 脚本，将 `sleep` 时间从 `60` 秒改为 `10` 秒：

```bash
#!/bin/bash
# 设置内存阈值为95%
MEMORY_THRESHOLD=95
while true; do
  # 获取总内存和已用内存
  TOTAL_MEM=$(free | grep Mem | awk '{print $2}')
  USED_MEM=$(free | grep Mem | awk '{print $3}')
  # 计算已用内存的百分比
  MEMORY_USAGE=$(($USED_MEM * 100 / $TOTAL_MEM))
  # 如果内存使用超过阈值，找到并终止占用内存最多的进程
  if [ $MEMORY_USAGE -gt $MEMORY_THRESHOLD ]; then
    echo "Memory usage is at $MEMORY_USAGE%, which is above the threshold of $MEMORY_THRESHOLD%."
    TOP_PROCESS_INFO=$(ps -eo pid,comm,%mem,user --sort=-%mem | head -n 2 | tail -n 1)
    TOP_PROCESS_PID=$(echo $TOP_PROCESS_INFO | awk '{print $1}')
    TOP_PROCESS_USER=$(echo $TOP_PROCESS_INFO | awk '{print $4}')
    TOP_PROCESS_MEM=$(echo $TOP_PROCESS_INFO | awk '{print $3}')
    echo "Killing process $TOP_PROCESS_PID, owned by $TOP_PROCESS_USER, which is using $TOP_PROCESS_MEM% of memory."
    kill -9 $TOP_PROCESS_PID
  fi
  # 每隔10秒检查一次
  sleep 10
done
```

保存并关闭文件。

### 2. 重新加载并重启服务

执行以下命令重新加载 `systemd`，然后重启并启用服务：

```bash
sudo systemctl daemon-reload
sudo systemctl restart memory_monitor.service
```

### 3. 验证服务是否运行

使用以下命令检查服务状态：

```bash
sudo systemctl status memory_monitor.service
```

如果服务正常运行，它将显示为“active (running)”。

### 总结

通过以上步骤，你将监控频率改为每10秒检查一次，并重启了服务。这样，守护进程将每10秒检查一次内存使用情况，并在内存超过阈值时终止占用最多的进程。


# 如何设置一个日志文件来查看信息

为了查看脚本中 `echo` 命令打印的日志信息，可以将其输出重定向到一个日志文件。可以在 `monitor_memory.sh` 脚本中添加日志记录，并确保 `systemd` 服务配置正确处理日志输出。以下是详细步骤：

### 1. 修改监控脚本以记录日志

编辑 `monitor_memory.sh` 脚本，添加日志记录功能。可以使用 `logger` 命令将信息写入系统日志，也可以将日志输出重定向到一个专用的日志文件。以下是两种方法：

#### 方法一：使用 `logger` 命令记录日志

将 `echo` 命令替换为 `logger` 命令，将信息写入系统日志：

```bash
#!/bin/bash
# 设置内存阈值为95%
MEMORY_THRESHOLD=95
while true; do
  # 获取总内存和已用内存
  TOTAL_MEM=$(free | grep Mem | awk '{print $2}')
  USED_MEM=$(free | grep Mem | awk '{print $3}')
  # 计算已用内存的百分比
  MEMORY_USAGE=$(($USED_MEM * 100 / $TOTAL_MEM))
  # 如果内存使用超过阈值，找到并终止占用内存最多的进程
  if [ $MEMORY_USAGE -gt $MEMORY_THRESHOLD ]; then
    logger "Memory usage is at $MEMORY_USAGE%, which is above the threshold of $MEMORY_THRESHOLD%."
    TOP_PROCESS_INFO=$(ps -eo pid,comm,%mem,user --sort=-%mem | head -n 2 | tail -n 1)
    TOP_PROCESS_PID=$(echo $TOP_PROCESS_INFO | awk '{print $1}')
    TOP_PROCESS_USER=$(echo $TOP_PROCESS_INFO | awk '{print $4}')
    TOP_PROCESS_MEM=$(echo $TOP_PROCESS_INFO | awk '{print $3}')
    logger "Killing process $TOP_PROCESS_PID, owned by $TOP_PROCESS_USER, which is using $TOP_PROCESS_MEM% of memory."
    kill -9 $TOP_PROCESS_PID
  fi
  # 每隔10秒检查一次
  sleep 10
done
```

#### 方法二：将日志重定向到文件

将所有输出重定向到一个日志文件，例如 `/var/log/memory_monitor.log`：

```bash
#!/bin/bash
# 设置内存阈值为95%
MEMORY_THRESHOLD=95
LOG_FILE="/var/log/memory_monitor.log"
while true; do
  # 获取总内存和已用内存
  TOTAL_MEM=$(free | grep Mem | awk '{print $2}')
  USED_MEM=$(free | grep Mem | awk '{print $3}')
  # 计算已用内存的百分比
  MEMORY_USAGE=$(($USED_MEM * 100 / $TOTAL_MEM))
  # 如果内存使用超过阈值，找到并终止占用内存最多的进程
  if [ $MEMORY_USAGE -gt $MEMORY_THRESHOLD ]; then
    echo "$(date): Memory usage is at $MEMORY_USAGE%, which is above the threshold of $MEMORY_THRESHOLD%." >> $LOG_FILE
    TOP_PROCESS_INFO=$(ps -eo pid,comm,%mem,user --sort=-%mem | head -n 2 | tail -n 1)
    TOP_PROCESS_PID=$(echo $TOP_PROCESS_INFO | awk '{print $1}')
    TOP_PROCESS_USER=$(echo $TOP_PROCESS_INFO | awk '{print $4}')
    TOP_PROCESS_MEM=$(echo $TOP_PROCESS_INFO | awk '{print $3}')
    echo "$(date): Killing process $TOP_PROCESS_PID, owned by $TOP_PROCESS_USER, which is using $TOP_PROCESS_MEM% of memory." >> $LOG_FILE
    kill -9 $TOP_PROCESS_PID
  fi
  # 每隔10秒检查一次
  sleep 10
done
```

确保日志文件具有写入权限：

```bash
sudo touch /var/log/memory_monitor.log
sudo chmod 666 /var/log/memory_monitor.log
```

### 2. 修改 systemd 服务文件（如果使用日志文件）

如果选择将日志输出重定向到文件，则需要确保 `systemd` 服务能够正确处理这些输出。在 `/etc/systemd/system/memory_monitor.service` 文件中，添加 `StandardOutput` 和 `StandardError` 选项：

```ini
[Unit]
Description=Memory Monitor Service
After=network.target
[Service]
Type=simple
ExecStart=/root/monitor_memory.sh
StandardOutput=append:/var/log/memory_monitor.log
StandardError=append:/var/log/memory_monitor.log
Restart=on-failure
[Install]
WantedBy=multi-user.target
```

### 3. 重新加载并重启服务

执行以下命令重新加载 `systemd`，然后重启并启用服务：

```bash
sudo systemctl daemon-reload
sudo systemctl restart memory_monitor.service
```

### 4. 查看日志

根据你选择的日志记录方法，查看日志信息：

#### 查看系统日志（如果使用 `logger` 命令）

使用 `journalctl` 查看日志：

```bash
sudo journalctl -u memory_monitor.service
```

#### 查看日志文件（如果将日志重定向到文件）

使用 `cat` 或 `tail` 命令查看日志文件：

```bash
cat /var/log/memory_monitor.log
# 或
tail -f /var/log/memory_monitor.log
```

通过以上步骤，你可以在监控脚本中记录日志，并使用 `systemd` 服务来管理和查看这些日志。


# 服务脚本含义

这个 `systemd` 服务单元文件定义了一个名为 `memory_monitor.service` 的服务，该服务运行一个用于监控内存使用情况的脚本。以下是各部分的详细解释：

### `[Unit]` 部分

- `Description=Memory Monitor Service`：描述该服务的功能，这里是“内存监控服务”。

- `After=network.target`：指定该服务应该在 `network.target` 之后启动。这意味着网络服务启动后才会启动该服务。

### `[Service]` 部分

- `Type=simple`：指定服务类型为 `simple`，表示 `ExecStart` 选项启动的进程不会派生其他子进程，且不会进入后台。`systemd` 会认为该服务的主进程就是 `ExecStart` 启动的进程。

- `ExecStart=/root/monitor_memory.sh`：指定服务启动时执行的命令，即运行 `/root/monitor_memory.sh` 脚本。

- `StandardOutput=append:/var/log/memory_monitor.log`：将标准输出（即脚本中 `echo` 或其他标准输出的内容）追加到 `/var/log/memory_monitor.log` 文件中。

- `StandardError=append:/var/log/memory_monitor.log`：将标准错误输出（即脚本中错误信息的输出）追加到 `/var/log/memory_monitor.log` 文件中。

- `Restart=on-failure`：如果服务因为非零退出状态失败，则自动重启服务。这有助于确保服务在意外故障时重新启动。

### `[Install]` 部分

- `WantedBy=multi-user.target`：指定该服务应该在多用户目标下启动。`multi-user.target` 是一个常用的系统运行级别，类似于传统的运行级别 3（多用户模式，不带图形界面）。



# 总结全文【直接用这个即可】

在Ubuntu上设置一个守护进程来监控内存使用情况，并在内存超过90%时终止内存占用最多的进程，可以通过编写一个shell脚本和使用`systemd`来实现。以下是详细的步骤和代码示例：

### 1. 编写监控脚本

创建一个脚本文件，例如`monitor_memory.sh`，其内容如下：

我在`vim /root/monitor_memory.sh`中创建了。

```bash
#!/bin/bash
# 设置内存阈值为95%
MEMORY_THRESHOLD=95
while true; do
  # 获取总内存和已用内存
  TOTAL_MEM=$(free | grep Mem | awk '{print $2}')
  USED_MEM=$(free | grep Mem | awk '{print $3}')
  # 计算已用内存的百分比
  MEMORY_USAGE=$(($USED_MEM * 100 / $TOTAL_MEM))
  # 如果内存使用超过阈值，找到并终止占用内存最多的进程
  if [ $MEMORY_USAGE -gt $MEMORY_THRESHOLD ]; then
    logger "Memory usage is at $MEMORY_USAGE%, which is above the threshold of $MEMORY_THRESHOLD%."
    TOP_PROCESS_INFO=$(ps -eo pid,comm,%mem,user --sort=-%mem | head -n 2 | tail -n 1)
    TOP_PROCESS_PID=$(echo $TOP_PROCESS_INFO | awk '{print $1}')
    TOP_PROCESS_USER=$(echo $TOP_PROCESS_INFO | awk '{print $4}')
    TOP_PROCESS_MEM=$(echo $TOP_PROCESS_INFO | awk '{print $3}')
    logger "Killing process $TOP_PROCESS_PID, owned by $TOP_PROCESS_USER, which is using $TOP_PROCESS_MEM% of memory."
    kill -9 $TOP_PROCESS_PID
  fi
  # 每隔10秒检查一次
  sleep 10
done
```

确保脚本具有可执行权限：

```bash
chmod +x monitor_memory.sh
```

### 2. 创建 systemd 服务文件

在`/etc/systemd/system/`目录下创建一个服务文件，例如`memory_monitor.service`，其内容如下：

```ini
[Unit]
Description=Memory Monitor Service
After=network.target
[Service]
Type=simple
ExecStart=/root/monitor_memory.sh
StandardOutput=append:/var/log/memory_monitor.log
StandardError=append:/var/log/memory_monitor.log
Restart=on-failure
[Install]
WantedBy=multi-user.target
```

请将`/root/monitor_memory.sh`替换为实际的脚本路径。

### 3. 启动并启用服务

重新加载`systemd`，启动并启用服务：

```bash
sudo systemctl daemon-reload
sudo systemctl start memory_monitor.service
sudo systemctl enable memory_monitor.service
```

### 4. 验证服务是否运行

使用以下命令检查服务状态：

```bash
sudo systemctl status memory_monitor.service
```

如果一切正常，服务应该会显示为“active (running)”。


### 5. 使用 `journalctl` 查看日志

```bash
sudo journalctl -u memory_monitor.service
```

【运维】如何在Ubuntu中设置一个内存守护进程来确保内存不会溢出

要分析根目录(`/`)使用了这么多空间，您可以使用以下几种方法来找出具体的占用情况：





### 1. 使用 `du` 命令

`du` 命令可以显示目录或文件的磁盘使用情况。

运行以下命令来找出根目录下的哪些目录占用了大量空间：

```bash
sudo du -h --max-depth=1 / | sort -hr
```

这将显示根目录下每个一级子目录的大小，并按大小降序排列。

### 2. 使用 `ncdu` 命令

`ncdu` 是一个交互式的磁盘使用情况分析工具，可以更加直观地查看目录的使用情况。

首先，安装 `ncdu`：

```bash
sudo apt install ncdu
```

然后，运行 `ncdu` 分析根目录：

```bash
sudo ncdu /
```

### 3. 检查特定目录

通常，大量空间被日志文件、缓存、虚拟机镜像、Docker 镜像等占用。您可以逐个检查以下目录：

- `/var/log`: 系统日志

- `/var/cache`: 系统缓存

- `/home`: 用户目录（如果有多个用户）

- `/usr`: 软件包安装目录

- `/tmp`: 临时文件

以下是一些命令来检查这些目录：

```bash
sudo du -sh /var/log
sudo du -sh /var/cache
sudo du -sh /home
sudo du -sh /usr
sudo du -sh /tmp
```

### 4. 删除不需要的文件

在找到占用大量空间的文件或目录后，您可以考虑删除不再需要的文件或清理一些缓存。例如：

- 清理 APT 缓存：

  ```bash
  sudo apt-get clean
  sudo apt-get autoremove
  ```

- 删除旧的日志文件：

  ```bash
  sudo rm /var/log/*.gz
  ```

- 清理 Docker 镜像和容器：

  ```bash
  docker system prune -a
  ```

通过以上方法，您应该能够找出根目录中占用大量空间的文件或目录，并进行适当的清理以释放空间。