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
  ```

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

【运维】如何分析和清理 Linux 根目录的磁盘空间使用情况

### 在 Docker 容器中指定 UTF-8 编码：方法与技巧





在日常开发中，我们常常需要确保应用程序能正确处理各种字符编码，尤其是 UTF-8 编码。在 Docker 容器中运行应用程序时，正确设置字符编码尤为重要，因为容器通常是跨平台、跨地域部署的，字符编码问题可能导致不可预期的错误。本文将详细介绍如何在 Docker 容器中指定 UTF-8 编码，并讨论相关环境变量的作用和设置方法。

#### 一、通过 `docker run` 命令指定 UTF-8 编码

在运行 Docker 容器时，可以通过设置环境变量来指定容器内的字符编码为 UTF-8。使用 `-e` 选项可以在 `docker run` 命令中设置 `LANG` 和 `LC_ALL` 环境变量。

**示例命令：**

```bash
docker run -e LANG=C.UTF-8 -e LC_ALL=C.UTF-8 <image_name>
```

**步骤：**

1. **选择镜像**：确定你要运行的 Docker 镜像名称，例如 `my_app_image`。

2. **设置环境变量**：使用 `-e` 选项设置 `LANG` 和 `LC_ALL` 环境变量为 `C.UTF-8`。

3. **运行容器**：在 `docker run` 命令中添加这些选项：

    ```bash
    docker run -e LANG=C.UTF-8 -e LC_ALL=C.UTF-8 my_app_image
    ```

#### 二、Dockerfile 中设置 UTF-8 编码

如果你希望每次运行容器时都自动使用 UTF-8 编码，可以在 Dockerfile 中设置环境变量。

**示例 Dockerfile：**

```Dockerfile
FROM python:3.9-slim
# 设置环境变量以使用 UTF-8 编码
ENV LANG=C.UTF-8 LC_ALL=C.UTF-8
# 安装依赖包
COPY requirements.txt .
RUN pip install -r requirements.txt
# 复制应用程序代码
COPY . /app
WORKDIR /app
# 运行应用程序
CMD ["python", "app.py"]
```

**构建和运行镜像：**

1. **构建镜像：**

    ```bash
    docker build -t my_app_image .
    ```

2. **运行容器：**

    ```bash
    docker run my_app_image
    ```

通过这种方式，可以确保每次运行容器时都使用 UTF-8 编码。

#### 三、在已运行的容器中更改编码

如果你已经进入了正在运行的 Docker 容器，也可以临时改变字符编码为 UTF-8。

**步骤：**

1. **进入容器：**

    ```bash
    docker exec -it <container_id_or_name> /bin/bash
    ```

2. **设置环境变量：**

    ```bash
    export LANG=C.UTF-8
    export LC_ALL=C.UTF-8
    ```

3. **验证设置：**

    ```bash
    echo $LANG
    echo $LC_ALL
    ```

这将输出 `C.UTF-8`，确认环境变量已正确设置。

#### 四、使更改持久化

为了在每次进入容器时都生效，可以将这些命令添加到用户的 shell 配置文件中（例如 `.bashrc` 或 `.bash_profile`）。

**步骤：**

1. **编辑 `.bashrc` 文件：**

    ```bash
    nano ~/.bashrc
    ```

2. **添加环境变量设置：**

    ```bash
    export LANG=C.UTF-8
    export LC_ALL=C.UTF-8
    ```

3. **保存文件并退出编辑器。**

4. **重新加载 `.bashrc` 文件：**

    ```bash
    source ~/.bashrc
    ```

通过上述步骤，可以确保每次进入容器时都会自动设置字符编码为 UTF-8。

#### 五、环境变量解释

在 Linux 和类 Unix 系统中，`LANG` 和 `LC_ALL` 是环境变量，用于控制系统和应用程序的语言和区域设置。

- **`LANG`**：指定系统的默认语言和区域设置。如果没有为其他具体的 `LC_*` 变量（如 `LC_TIME`、`LC_NUMERIC` 等）设置值，系统将使用 `LANG` 的值作为默认设置。

    ```bash
    export LANG=en_US.UTF-8
    ```

- **`LC_ALL`**：覆盖所有其他语言和区域设置变量的值，具有最高优先级。

    ```bash
    export LC_ALL=en_US.UTF-8
    ```

在 Docker 容器中使用 `C.UTF-8` 是为了确保容器内的应用程序和命令行工具能够正确处理 UTF-8 编码的字符数据。

#### 总结

通过在 Docker 容器中正确设置 UTF-8 编码，可以确保应用程序在处理多语言数据时不出错。无论是通过 `docker run` 命令临时设置，还是在 Dockerfile 中永久设置，或者在运行容器后手动设置，都可以有效地解决字符编码问题。希望本文能够帮助你在 Docker 容器中更好地管理字符编码。如果有任何问题或进一步的需求，请随时联系。

---

【运维】在 Docker 容器中指定 UTF-8 编码：方法与技巧

你可以使用终端命令来直接设置取消登录密码和锁屏功能。以下是具体步骤：





### 取消登录密码

1. 打开终端。

2. 编辑 `/etc/gdm3/custom.conf` 文件：

    ```bash
    sudo nano /etc/gdm3/custom.conf
    ```

3. 在 `[daemon]` 部分下，添加或修改以下行：

    ```ini
    AutomaticLoginEnable = true
    AutomaticLogin = your_username
    ```

    将 `your_username` 替换为你的实际用户名。

4. 保存文件并退出编辑器（在 nano 中使用 `Ctrl+O` 保存，`Ctrl+X` 退出）。

5. 重启系统：

    ```bash
    sudo reboot
    ```

### 取消锁屏

1. 打开终端。

2. 使用以下命令关闭屏幕锁定：

    ```bash
    gsettings set org.gnome.desktop.screensaver lock-enabled false
    ```

3. 禁用空闲时间锁定：

    ```bash
    gsettings set org.gnome.desktop.session idle-delay 0
    ```

通过这些命令，你可以取消登录密码和锁屏功能。

在 Ubuntu 上取消登录密码和锁屏功能的简易指南

在 xterm 中输入 Python 代码时，如果遇到 Tab 键缩进混乱的问题，可以采取以下措施来解决：





### 1. 使用合适的文本编辑器

xterm 本身是一个终端模拟器，适合运行命令和简单的编辑任务，但不是一个理想的编写 Python 代码的环境。考虑使用以下文本编辑器，它们在处理缩进方面更可靠：

- **nano**: 一个简单且易用的终端文本编辑器，支持自动缩进。

- **vim**: 一个功能强大的文本编辑器，支持高级缩进和代码高亮。

- **emacs**: 一个高度可定制的编辑器，支持多种编程语言的扩展和插件。

- **Visual Studio Code**: 一个流行的图形化代码编辑器，支持丰富的插件和扩展。

### 2. 配置文本编辑器

#### nano【我成功了】

编辑 `.nanorc` 文件以启用自动缩进：
```sh
echo "set autoindent" >> ~/.nanorc
```

#### vim 【我成功了】

编辑 `.vimrc` 文件以启用自动缩进和设置合适的缩进级别：
```vim
set tabstop=4
set shiftwidth=4
set expandtab
set autoindent
set smartindent
nnoremap <F2> :set paste!<CR>
set clipboard=unnamedplus
```

这样设置后，vim进入文件后，按F2进入粘贴模式，然后按i进入插入，然后shift+insert插入内容即可。


**启用粘贴模式：**

   在 Vim 中，有一个粘贴模式可以防止粘贴时的自动缩进问题。你可以在粘贴代码前启用这个模式：

   ```vim
   :set paste
   ```

   粘贴完代码后，关闭粘贴模式：

   ```vim
   :set nopaste
   ```

   为了方便，你可以在 `.vimrc` 文件中添加快捷键来快速切换粘贴模式，例如：

   ```vim
   nnoremap <F2> :set paste!<CR>
   ```

   这样你可以通过按 `F2` 键来切换粘贴模式。






#### emacs

编辑 `.emacs` 文件以启用自动缩进和设置合适的缩进级别：
```emacs-lisp
(setq-default indent-tabs-mode nil) ; Use spaces instead of tabs
(setq-default tab-width 4) ; Set tab width to 4
(setq indent-line-function 'insert-tab)
```

### 3. 使用 IDE

如果可能，使用集成开发环境（IDE）来编写 Python 代码，例如：

- PyCharm

- VSCode

- Sublime Text

这些 IDE 提供了强大的代码编辑功能，包括自动缩进、代码补全和语法高亮等。

### 4. 确保一致的缩进风格

无论使用哪种工具，确保代码中的缩进风格一致。Python 对缩进非常敏感，建议使用空格而不是 Tab 来缩进。PEP 8（Python 的代码风格指南）推荐使用 4 个空格来缩进代码。

#### 将 Tab 替换为空格

许多编辑器可以自动将 Tab 替换为空格。下面是一些常见的设置：

- **VSCode**:

  打开设置 (`Ctrl + ,`) 并搜索 "insert spaces"，勾选 "Editor: Insert Spaces"。

  

- **Sublime Text**:

  打开设置并添加以下内容：

  ```json
  {
      "translate_tabs_to_spaces": true,
      "tab_size": 4
  }
  ```

### 总结

在 xterm 中编写 Python 代码时，最好使用适合编写代码的文本编辑器或 IDE，配置好缩进选项，并确保使用一致的缩进风格。这将极大地减少缩进混乱的问题，提高编码效率。

解决 xterm 中 Python 代码缩进混乱的问题，tmux中用Vim缩进混乱问题

我之前安装了xterm和新的Python，无法打开ubuntu自带的gnome-terminalle 。





终端应用崩溃：

试着通过其他方式打开终端，例如按下 Ctrl+Alt+T。

尝试使用其他终端模拟器，例如 xterm、konsole 或 gnome-terminal。可以通过 Alt+F2 然后输入 xterm 尝试打开xterm 。

**或者Ctrl+Alt+F5，进入命令登录，登录后安装xterm，然后使用xterm 。**

# 还原之前的终端【修改Python】

我之前修改了默认的Python，改回来就好了。

要将默认的Python版本切换回系统自带的版本，可以使用`update-alternatives`命令。假设你原本的系统默认Python版本是3.6，可以按照以下步骤操作：

1. **检查当前安装的Python版本：**

   首先，确保你已经安装了你希望切换回去的系统默认Python版本。例如，Python 3.6。

   ```bash
   sudo apt update
   sudo apt install python3.6
   ```

2. **为系统默认Python版本设置可替代项：**

   使用`update-alternatives`命令为Python 3.6创建可替代项。

   ```bash
   sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.6 1
   ```

3. **设置优先级和选择默认版本：**

   如果你已经为其他版本的Python设置了可替代项，可以通过以下命令查看和选择默认的Python版本：

   ```bash
   sudo update-alternatives --config python3
   ```

   系统会列出所有安装的Python版本，并提示你选择默认的版本。例如，你可能会看到类似这样的输出：

   ```
   There are 2 choices for the alternative python3 (providing /usr/bin/python3).
     Selection    Path                 Priority   Status
   ------------------------------------------------------------
     0            /usr/bin/python3.8    2         auto mode
     1            /usr/bin/python3.6    1         manual mode
     2            /usr/bin/python3.8    2         manual mode
   Press <enter> to keep the current choice[*], or type selection number: 
   ```

   输入你希望设置为默认版本的选择编号，例如`1`（对应Python 3.6）。

4. **验证更改：**

   确认默认Python版本已切换：

   ```bash
   python3 --version
   ```

   输出应显示你选择的Python版本，例如：

   ```
   Python 3.6.9
   ```

完成以上步骤后，系统应恢复使用默认的Python版本（例如Python 3.6），从而解决`gnome-tweaks`的导入错误问题。

# 还原之前的终端【重装gnome-terminal】

Ctrl+Alt+F5，进入命令登录后去重装gnome-terminal。

你可以尝试以下步骤来还原之前的终端：

1. **重装默认终端（例如 gnome-terminal）**：

   如果你使用的是 GNOME 桌面环境，可以尝试重新安装 `gnome-terminal`：

   ```sh
   sudo apt update
   sudo apt install --reinstall gnome-terminal
   ```

2. **设置默认终端**：

   确保 `gnome-terminal` 是你的默认终端。你可以使用 `update-alternatives` 来设置：

   ```sh
   sudo update-alternatives --config x-terminal-emulator
   ```

   这会显示一个列表，你可以选择 `gnome-terminal` 作为默认选项。

3. **检查桌面环境设置**：

   确保你的桌面环境的终端快捷方式指向正确的终端应用。对于 GNOME 桌面环境，可以通过 GNOME Tweak Tool 进行设置：

   ```sh
   sudo apt install gnome-tweaks
   gnome-tweaks
   ```

   然后在 Tweak Tool 中找到默认应用设置，确保默认终端是 `gnome-terminal`。

4. **恢复配置文件**：

   如果你修改过终端配置文件（例如 `.bashrc` 或 `.zshrc`），可以尝试恢复这些文件：

   ```sh
   mv ~/.bashrc_backup ~/.bashrc
   ```

5. **重启系统**：

   有时候简单的重启系统也能解决问题：

   ```sh
   sudo reboot
   ```

经过以上步骤，你的默认终端应该会恢复正常。

如何在Ubuntu 22.04中还原默认终端：解决无法打开终端的问题

要查看 Ubuntu 系统的版本，可以使用以下几种方法之一：





1. **通过命令行：**

   打开终端，然后输入以下命令：

   ```sh
   lsb_release -a
   ```

   这将显示类似以下的信息：

   ```
   No LSB modules are available.
   Distributor ID: Ubuntu
   Description:    Ubuntu 20.04.2 LTS
   Release:        20.04
   Codename:       focal
   ```

2. **通过 /etc/os-release 文件：**

   你可以查看 `/etc/os-release` 文件的内容，输入以下命令：

   ```sh
   cat /etc/os-release
   ```

   这将显示类似以下的信息：

   ```sh
   NAME="Ubuntu"
   VERSION="20.04.2 LTS (Focal Fossa)"
   ID=ubuntu
   ID_LIKE=debian
   PRETTY_NAME="Ubuntu 20.04.2 LTS"
   VERSION_ID="20.04"
   HOME_URL="https://www.ubuntu.com/"
   SUPPORT_URL="https://help.ubuntu.com/"
   BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
   PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
   VERSION_CODENAME=focal
   UBUNTU_CODENAME=focal
   ```

3. **通过 /etc/issue 文件：**

   你也可以查看 `/etc/issue` 文件的内容，输入以下命令：

   ```sh
   cat /etc/issue
   ```

   这将显示类似以下的信息：

   ```sh
   Ubuntu 20.04.2 LTS \n \l
   ```

这几种方法都可以帮助你查看 Ubuntu 的版本信息。