<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:atom="http://www.w3.org/2005/Atom"
>
<channel>
<title><![CDATA[小曦窝]]></title> 
<atom:link href="https://m.hanshao.top/rss.php" rel="self" type="application/rss+xml" />
<description><![CDATA[云笔记]]></description>
<link>https://m.hanshao.top/</link>
<language>zh-cn</language>

<item>
    <title>Nginx综合服务2（平滑升级：反向代理+ssl证书）</title>
    <link>https://m.hanshao.top/?post=37</link>
    <description><![CDATA[<p>一、需求</p>
<p>使用一个nginx作为统一访问入口，作为代理服务器。（源码编译）</p>
<ol>
<li>使⽤nginx01作为访问⼊⼝，将所有的虚拟主机放到nginx01</li>
<li>web01上放两个web业务，⼀个user，⼀个api</li>
<li>web02上放⼀个web业务，www</li>
<li>www域名需要⽀持https</li>
</ol>
<p>二、架构图</p>
<p><a href="/content/uploadfile/202611/d2b51795086176.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51795086176.png" alt="image.png"></a></p>
<p>nginx01：192.168.134.130</p>
<p>web01：192.168.134.131</p>
<p>web02：192.168.134.132</p>
<p>三、配置思路</p>
<p>先给nginx01源码编译安装nginx</p>
<p>然后再给web01、02用yum安装</p>
<p>接着配置文件即可</p>
<p>四、具体步骤</p>
<p>准备操作：同步时间、改机器名</p>
<pre class="language-markup"><code>#三台机器都写
date
timedatectl set-timezone Asia/Shanghai
ntpdate ntp1.aliyun.com

#在nginx01机器写
hostnamectl set-hostname nginx01
bash

#在web01机器写
hostnamectl set-hostname web01
bash

#在web02机器写
hostnamectl set-hostname web02
bash</code></pre>
<p>步骤一：在nginx01机器源码编译安装nginx</p>
<pre class="language-markup"><code>yum -y install pcre pcre-devel gcc gcc-c++ zlib zlib-devel openssl openssl-devel make lrzsz wget curl 

tar xf nginx-1.26.3.tar.gz
cd /root/nginx-1.26.3
./configure --prefix=/usr/local/nginx --with-http_ssl_module
make -j$(nproc)
make install

/usr/local/nginx/sbin/nginx</code></pre>
<p>步骤二：在web01、02机器yum安装nginx</p>
<pre class="language-markup"><code>yum -y install nginx</code></pre>
<p>步骤三：配置nginx01</p>
<pre class="language-markup"><code>[root@nginx01 ~]# cd /usr/local/nginx/conf/
[root@nginx01 conf]# egrep -v "#|^$" nginx.conf
[root@nginx01 conf]# cp nginx.conf nginx.conf.bak
[root@nginx01 conf]# egrep -v "#|^$" nginx.conf.bak &gt; nginx.conf
[root@nginx01 conf]# vim nginx.conf

...
worker_processes  1;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;
    include /usr/local/nginx/conf/vhosts/*.conf;
#    server {
#        listen       80;
#        server_name  localhost;
#        location / {
#            root   html;
#            index  index.html index.htm;
#        }
#        error_page   500 502 503 504  /50x.html;
#        location = /50x.html {
#            root   html;
#        }
#    }
}

...
</code></pre>
<pre class="language-markup"><code>[root@nginx01 ~]# mkdir /usr/local/nginx/conf/vhosts
[root@nginx01 ~]# cd /usr/local/nginx/conf/vhosts/
[root@nginx01 vhosts]# touch user.docker123.cn.conf
[root@nginx01 vhosts]# vim user.docker123.cn.conf 

...
upstream user {
        server 192.168.134.131:80;
}
server {
        listen       80;
        server_name  user.docker123.cn;
        access_log /usr/local/nginx/logs/user.docker123.cn_access.log;
        error_log /usr/local/nginx/logs/user.docker123.cn_error.log;
        location / {
                proxy_set_header Host $host;
                proxy_set_header X_Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header X-Forwarded-Proto $scheme;

                proxy_pass http://user;
        }
}  
...

[root@nginx01 vhosts]# /usr/local/nginx/sbin/nginx -t
[root@nginx01 vhosts]# /usr/local/nginx/sbin/nginx -s reload
[root@nginx01 vhosts]# cp user.docker123.cn.conf api.docker123.cn.conf
[root@nginx01 vhosts]# vim api.docker123.cn.conf 

...
upstream api {
        server 192.168.134.131:80;
}
server {
        listen       80;
        server_name  api.docker123.cn;
        access_log /usr/local/nginx/logs/api.docker123.cn_access.log;
        error_log /usr/local/nginx/logs/api.docker123.cn_error.log;
        location / {
                proxy_set_header Host $host;
                proxy_set_header X_Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header X-Forwarded-Proto $scheme;

                proxy_pass http://api;
        }
}  
...

[root@nginx01 vhosts]# /usr/local/nginx/sbin/nginx -t
[root@nginx01 vhosts]# /usr/local/nginx/sbin/nginx -s reload
[root@nginx01 vhosts]# cp user.docker123.cn.conf www.docker123.cn.conf
[root@nginx01 vhosts]# vim www.docker123.cn.conf 

...
upstream www {
        server 192.168.134.132:80;
}
server {
        listen       80;
        server_name  www.docker123.cn;
        access_log /usr/local/nginx/logs/www.docker123.cn_access.log;
        error_log /usr/local/nginx/logs/www.docker123.cn_error.log;
        location / {
                proxy_set_header Host $host;
                proxy_set_header X_Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header X-Forwarded-Proto $scheme;

                proxy_pass http://www;
        }
}
...</code></pre>
<p>步骤四：在web01中配置</p>
<pre class="language-markup"><code>[root@web01 nginx]# cd /etc/nginx/conf.d/
[root@web01 conf.d]# vim user.docker123.cn.conf

...
server {
        listen 80;
        server_name user.docker123.cn;
        index index.html;
        root /data/nginx/user;
        access_log /var/log/nginx/user.docker123.cn_access.log;      
        error_log /var/log/nginx/user.docker123.cn_error.log;
}
...

[root@web01 conf.d]# cp user.docker123.cn.conf api.docker123.cn.conf
[root@web01 conf.d]# vim api.docker123.cn.conf

...
server {
        listen 80;
        server_name api.docker123.cn;
        index index.html;
        root /data/nginx/api;
        access_log /var/log/nginx/api.docker123.cn_access.log;      
        error_log /var/log/nginx/api.docker123.cn_error.log;
}
...

[root@web01 nginx]# cd /var/log/nginx/
[root@web01 nginx]# ll
[root@web01 nginx]# nginx -t
[root@web01 nginx]# nginx</code></pre>
<p>步骤五：用nginx01测试web01</p>
<pre class="language-markup"><code>[root@nginx01 vhosts]# curl 192.168.134.131
[root@nginx01 vhosts]# vim /etc/hosts

#在nginx01的hosts文件中加入两句
...
192.168.134.131 user.docker123.cn
192.168.134.131 api.docker123.cn
...</code></pre>
<p>然后开始测试</p>
<pre class="language-markup"><code>[root@nginx01 vhosts]# curl user.docker123.cn
[root@nginx01 vhosts]# curl api.docker123.cn
</code></pre>
<p>步骤六：开始配置web02</p>
<pre class="language-markup"><code>[root@web02 ~]# cd /etc/nginx/conf.d/
[root@web02 conf.d]# ls
[root@web02 conf.d]# vim www.docker123.cn.conf

...
server {
        listen 80;
        server_name www.docker123.cn;
        index index.html;
        root /data/nginx/www;
        access_log /var/log/nginx/www.docker123.cn_access.log; 
        error_log /var/log/nginx/www.docker123.cn_error.log;
}

...

[root@web02 conf.d]# mkdir -p /data/nginx/www
[root@web02 conf.d]# cd /data/nginx/www/
[root@web02 www]# echo "www" &gt; index.html
[root@web02 www]# nginx</code></pre>
<p>步骤七：在nginx01中加上ssl</p>
<pre class="language-markup"><code>[root@nginx01 ~]# cd /usr/local/nginx
[root@nginx01 nginx]# mkdir ssl
[root@nginx01 nginx]# cd ssl

#上传SSL证书
[root@nginx01 ssl]# rz

[root@nginx01 ssl]# ll
#解压证书压缩包
[root@nginx01 ssl]# unzip 28613728_www.docker123.cn_nginx.zip 
[root@nginx01 ssl]# ll
</code></pre>
<pre class="language-markup"><code>[root@nginx01 ssl]# cd /usr/local/nginx/conf/vhosts/
[root@nginx01 vhosts]# vim www.docker123.cn.conf 

#对比修改里面的文件（在最后加上那一大段）
...
upstream www {
        server 192.168.134.132:80;
}
server {
        listen       80;
        server_name  www.docker123.cn;
        access_log /usr/local/nginx/logs/www.docker123.cn_access.log;
        error_log /usr/local/nginx/logs/www.docker123.cn_error.log;
        location / {
                proxy_set_header Host $host;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header X-Forwarded-Proto $scheme;

                proxy_pass http://www;
        }
server {
    #SSL 默认访问端口号为 443
    listen 443 ssl;
    #请填写绑定证书的域名
    server_name www.docker123.cn;  #注意填写自己的域名
    #请填写证书文件的相对路径或绝对路径
    ssl_certificate /usr/local/nginx/ssl/www.docker123.cn.pem;
    #请填写私钥文件的相对路径或绝对路径
    ssl_certificate_key /usr/local/nginx/ssl/www.docker123.cn.key;
    ssl_session_timeout 5m;
    #请按照以下协议配置
    ssl_protocols TLSv1.2 TLSv1.3;
    #请按照以下套件配置，配置加密套件，写法遵循 openssl 标准。
    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
    ssl_prefer_server_ciphers on;
    location / {
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_pass http://www;
    }
}
...

[root@nginx01 vhosts]# /usr/local/nginx/sbin/nginx -s reload
</code></pre>
<p>步骤八：nginx01配置hosts测试</p>
<pre class="language-markup"><code>[root@nginx01 vhosts]# cat /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6

192.168.134.131 user.docker123.cn
192.168.134.131 api.docker123.cn
192.168.134.132 www.docker123.cn</code></pre>
<pre class="language-markup"><code>curl api.docker123.cn
curl user.docker123.cn
curl www.docker123.cn</code></pre>
<p>步骤九：物理机测试</p>
<p><a href="/content/uploadfile/202611/d2b51795101099.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51795101099.png" alt="image.png"></a></p>
<p>五、排错思路</p>
<p>Telnet 测试主机端⼝是否可以通信<br>Ping 测试域名解析的ip地址<br>Curl 可以模拟web浏览器测试web服务，访问内容<br>Nslookup dig测试解析</p>]]></description>
    <pubDate>Thu, 19 Nov 2026 15:54:47 +0800</pubDate>
    <dc:creator>小曦窝</dc:creator>
    <guid>https://m.hanshao.top/?post=37</guid>
</item>
<item>
    <title>DNS内⽹案例</title>
    <link>https://m.hanshao.top/?post=34</link>
    <description><![CDATA[<h1>一、需求</h1>
<p>公司内⽹部署了两套内部系统，员⼯在公司内部通过浏览器访问，外部不能访问呢。在内部需要通过内⽹DNS将域名解析到内⽹Web服务器IP。</p>
<h1>二、架构图</h1>
<p><a href="/content/uploadfile/202611/3a1f1794924739.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/3a1f1794924739.png" alt="屏幕截图 2026-11-17 220627副本.png"></a></p>
<h3>机器规划：</h3>
<p>192.168.134.131&mdash;&mdash;HR系统</p>
<p>192.168.134.132&mdash;&mdash;caiwu系统</p>
<p>192.168.134.133&mdash;&mdash;DNS服务器</p>
<p>192.168.134.130&mdash;&mdash;NFS系统</p>
<h1>三、配置思路</h1>
<p>步骤1：先部署DNS服务器</p>
<p>步骤2：搭建两个nginx，将对应的⻚⾯部署到对应的⽬录</p>
<p>步骤3：搭建共享服务器，创建lvm逻辑卷，逻辑卷⼤⼩为50G，挂载到/share⽬录</p>
<ul>
<li>hr系统：/share/hr，访问内容为HRsystem</li>
<li>财务系统：/share/caiwu,访问的内容分别为 caiwusystem</li>
</ul>
<p>步骤4：将两个⽬录分别挂载到两个web服务器</p>
<p>步骤5：在dns服务器添加dns解析记录</p>
<p>步骤6：给客⼾端主机配置dns服务器地址，告知解析服务器的ip地址。</p>
<h1>四、具体步骤</h1>
<p>步骤1：搭建并配置bind服务器作为内⽹dns解析</p>
<p>在192.168.134.133&mdash;&mdash;DNS服务器中配置：</p>
<pre class="language-markup"><code>yum -y install bind*

systemctl enable named.service
systemctl start named.service

netstat -lnptu | grep named
</code></pre>
<pre class="language-markup"><code>vim /etc/named.conf

...
options {
    listen-on port 53 { 192.168.134.133; };
    listen-on-v6 port 53 { ::1; };
    directory       "/var/named";
    dump-file       "/var/named/data/cache_dump.db";
    statistics-file "/var/named/data/named_stats.txt";
    memstatistics-file "/var/named/data/named_mem_stats.txt";
    recursing-file  "/var/named/data/named.recursing";
    secroots-file   "/var/named/data/named.secroots";
    allow-query     { any; };
    forwarders{ 223.5.5.5;114.114.114.114; };      # 转发本地位置记录请求

    # 关闭DNS安全
    dnssec-enable no;
    dnssec-validation no;
...

# 语法检测
named-checkconf /etc/named.conf</code></pre>
<pre class="language-markup"><code>vim /etc/named.rfc1912.zones

...
zone "docker123.cn" IN {
        type master;
        file "data/docker123.cn.zone";
};</code></pre>
<pre class="language-markup"><code>vim /var/named/data/docker123.cn.zone

...
$TTL 1D
@       IN SOA  dns.docker123.cn. dns.www.docker123.cn. (
                                        20190201      ; serial
                                        1D      ; refresh
                                        1H      ; retry
                                        1W      ; expire
                                        3H )    ; minimum
@                       IN      NS      dns.docker123.cn.
dns.docker123.cn.           IN      A       192.168.134.133
hr.docker123.cn.        IN      A       192.168.134.131
caiwu.docker123.cn.      IN      A       192.168.134.132
</code></pre>
<pre class="language-markup"><code>named-checkconf /etc/named.conf
systemctl restart named</code></pre>
<p>步骤2：搭建web服务，写⼊对应的内容</p>
<p>在192.168.134.131&mdash;&mdash;HR系统配置：</p>
<pre class="language-markup"><code>yum install nginx -y
cd /usr/share/nginx/html/ 
rm -rf * 
echo "hr" &gt; index.html</code></pre>
<p>在192.168.134.132&mdash;&mdash;caiwu系统中配置：</p>
<pre class="language-markup"><code>yum install nginx -y
cd /usr/share/nginx/html/ 
rm -rf * 
echo "caiwu" &gt; index.html</code></pre>
<p>接着在物理机配置dns为192.168.134.133</p>
<p>步骤3：测试</p>
<pre class="language-markup"><code>ping hr.docker123.cn 
ping caiwu.docker123.cn 

curl hr.docker123.cn 
curl caiwu.docker123.cn </code></pre>
<hr>
<p>下面的在192.168.134.130&mdash;&mdash;NFS系统中配置：<br>步骤4：NFS服务器挂载三快20G的盘，创建逻辑卷，空间为50G</p>
<pre class="language-markup"><code># 创建物理卷
pvcreate /dev/sdb /dev/sdc /dev/sdd

# 创建卷组
vgcreate vg0 /dev/sdb /dev/sdc /dev/sdd 

# 创建逻辑卷，为50G
lvcreate -L 50G -n lv0 vg0

# 格式化⽂件系统
 mkfs.xfs /dev/vg0/lv0

# 创建⽬录并挂载
 mkdir /share &amp;&amp; mount /dev/vg0/lv0 /share

# 添加⾃动挂载逻辑卷
 tail -n1 /etc/mtab &gt;&gt; /etc/fstab</code></pre>
<p>步骤5：搭建nfs并创建共享⽬录</p>
<pre class="language-markup"><code># 安装nfs服务，所有需要nfs的机器都需要安装，但是除了server其他的不需要启动
yum install nfs-utils -y

# 启动nfs服务
systemctl start nfs-server
systemctl enable nfs-server

# 查看监听端口
netstat -nlpt | grep rpcbind

# 创建共享⽬录
mkdir -p /share/hr
mkdir -p /share/caiwu

# 配置共享⽬录
 vim /etc/exports

...
/data/share/hr 192.168.134.0/24(rw,sync,no_root_squash)
/data/share/caiwu 192.168.134.0/24(rw,sync,no_root_squash)

# 刷新配置
exportfs -a</code></pre>
<hr>
<p>下面的命令在192.168.134.131&mdash;&mdash;HR系统和192.168.134.132&mdash;&mdash;caiwu系统中配置：</p>
<p>步骤6：web机器挂载nfs</p>
<pre class="language-markup"><code>mount -t nfs 192.168.134.130:/data/share/hr /usr/share/nginx/html/
mount -t nfs 192.168.134.130:/data/share/caiwu /usr/share/nginx/html/</code></pre>
<h1>五、排错思路</h1>
<p>Ping</p>
<p>Nslookup</p>
<p>Curl</p>
<p>Telnet</p>]]></description>
    <pubDate>Tue, 17 Nov 2026 22:01:35 +0800</pubDate>
    <dc:creator>小曦窝</dc:creator>
    <guid>https://m.hanshao.top/?post=34</guid>
</item>
<item>
    <title>中间件nginx入门</title>
    <link>https://m.hanshao.top/?post=33</link>
    <description><![CDATA[<h1>一、开发语言及框架概述</h1>
<h3>1、前端语言与框架</h3>
<p>- 基础：HTML、CSS、JavaScript/TypeScript。<br>- 框架：React、Vue、Angular；构建工具 Vite/Webpack；跨端方案 React Native、Flutter、小程序框架</p>
<h3>2、后端语言与框架</h3>
<p>- Java：Spring Boot / Spring Cloud，企业级主流。<br>- Go：Gin、Echo，高并发、云原生友好。<br>- Python：Django、Flask、FastAPI，快速开发与数据场景。<br>- PHP：Laravel，中小型 Web 常用。<br>- Node.js：Express、NestJS，前后端同栈。</p>
<h3>3、数据库与中间件</h3>
<p>- 关系型：MySQL、PostgreSQL、Oracle。<br>- NoSQL：Redis（缓存）、MongoDB（文档）、Elasticsearch（搜索）、HBase/Cassandra（宽表）。<br>- 消息队列：Kafka、RabbitMQ、RocketMQ。<br>- 其他中间件：Nginx（反向代理/负载均衡）、Tomcat、注册中心（Nacos/Consul）、网关（Kong/APISIX）。</p>
<h3>4、中间件概述</h3>
<h4>1、什么是中间件</h4>
<p>中间件（Middleware）是位于操作系统和应用程序之间的软件层，它为分布式系统提供通信、数据管理和应用程序集成等服务。中间件的主要作用包括：<br>- 提供程序的运行环境<br>- 简化复杂系统的开发<br>- 连接不同的系统组件<br>- 处理应用程序间的通信，充当消息的传递管道</p>
<p><a href="/content/uploadfile/202611/d2b51794920044.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794920044.png" alt="image.png"></a></p>
<h4>2、中间件的类型</h4>
<p>- 消息中间件：RabbitMQ, Kafka<br>- web中间件：Tomcat, &nbsp;Nginx,Springboot<br>- 数据库中间件：ODBC, JDBC</p>
<h4>3、语言与框架选型原则</h4>
<p>- 业务匹配：性能、并发、开发效率、生态成熟度。<br>- 团队能力：现有技术储备与维护成本。<br>- 社区与长期支持：活跃度、文档、安全更新。<br>- 可运维性：部署复杂度、监控生态、排障工具链。<br>- 成本：人力、服务器资源、许可费用。</p>
<h1>二、web 概述</h1>
<h3>1、Web 的基本概念</h3>
<p>Web 是基于 HTTP 协议、通过浏览器访问资源的信息系统。核心要素：URL（定位资源）、HTTP（传输协议）、HTML（内容载体）、浏览器/服务器（两端）。<br>访问web时，一般使用域名来访问。</p>
<p><a href="/content/uploadfile/202611/d2b51794920143.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794920143.png" alt="image.png"></a></p>
<h3>2、Web 工作原理</h3>
<p>1. 浏览器解析 URL，DNS 解析域名得到 IP。<br>2. 建立 TCP 连接（HTTPS 还需 TLS 握手）。<br>3. 发送 HTTP 请求（方法、路径、头、体）。<br>4. 服务器处理（Web 服务器 &rarr; 应用 &rarr; 数据库），返回响应（状态码、头、体）。<br>5. 浏览器渲染页面，加载静态资源，可能发起后续请求。</p>
<p><a href="/content/uploadfile/202611/d2b51794920170.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794920170.png" alt="image.png"></a></p>
<p><br>客户端浏览器 &nbsp; &gt; web服务器 &gt; 代码 &nbsp;&gt; 数据库</p>
<h3>3、HTTP 与 HTTPS 协议</h3>
<p>- HTTP：无状态应用层协议，方法 GET/POST/PUT/DELETE 等，状态码 2xx/3xx/4xx/5xx。<br>- HTTPS：HTTP over TLS，加密传输、身份认证、完整性保护；依赖证书体系（CA）。<br>- 关键差异：端口 80 vs 443；明文 vs 加密。</p>
<h3>4、web基础知识</h3>
<p>用一个登录场景的例子，用于输入用户名密码之后，不会直接传输用户名+密码，而是以固定的格式将数据传递到后端。</p>
<h4>1、HTTP报文格式</h4>
<p>1、请求包格式</p>
<p><a href="/content/uploadfile/202611/d2b51794920290.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794920290.png" alt="image.png"></a></p>
<p>2、回应包格式</p>
<p><a href="/content/uploadfile/202611/d2b51794920317.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794920317.png" alt="image.png"></a></p>
<h4>2、请求方法</h4>
<p>- GET：一般用户请求页面<br>- POST：用户登录场景，提交<br>- PUT：上传图片<br>- DELETE：删除</p>
<h4>3、URL/URI</h4>
<p><a href="/content/uploadfile/202611/d2b51794920348.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794920348.png" alt="image.png"></a></p>
<p>- URL: 泛指域名<br>- URI：资源路径</p>
<h4>4、状态码</h4>
<p>服务端响应后，每个响应包都会有对应的状态码，可以通过状态码来判断网站目前的状态。<br>- 1xx：信息响应<br>- 2xx：成功响应（200 OK）<br>- 3xx：重定向（301, 302）&nbsp;<br>- 4xx：客户端错误（404 Not Found） 401 &nbsp;403 &nbsp;404<br>- 5xx：服务器错误（500 Internal Server Error） &nbsp;500 &nbsp;502 &nbsp;503 &nbsp;504</p>
<h4>5、常见 Web 服务器介绍</h4>
<p>- Nginx：高并发、反向代理、静态资源、负载均衡。<br>- Apache HTTP Server：模块丰富、.htaccess、传统生态。<br>- Tomcat：Java Servlet 容器，常与 Nginx 搭配。<br>- IIS：Windows 生态。</p>
<h1>三、Nginx 概述</h1>
<h3>1、Nginx 简介与发展历史</h3>
<p>Nginx 由 Igor Sysoev 于 2002 年前后开发，2004 年首次公开发布，初衷是解决 C10K 问题（单机万级并发连接）。现由 F5 支持，分为开源版与 Nginx Plus 商业版。广泛用于反向代理、负载均衡、静态资源服务和 API 网关场景。</p>
<h3>2、Nginx 与 Apache 对比</h3>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 33.3205%;"><col style="width: 33.3205%;"><col style="width: 33.3205%;"></colgroup>
<tbody>
<tr>
<td>维度</td>
<td>Nginx</td>
<td>Apache</td>
</tr>
<tr>
<td>并发模型</td>
<td>事件驱动、异步非阻塞</td>
<td>多进程/多线程（prefork/worker）</td>
</tr>
<tr>
<td>高并发表现</td>
<td>优秀，连接数高时资源占用低</td>
<td>连接数高时内存/进程开销大</td>
</tr>
<tr>
<td>配置方式</td>
<td>集中式配置文件</td>
<td>配置文件 + .htaccess分数</td>
</tr>
<tr>
<td>动态内容</td>
<td>常作为反向代理交给后端</td>
<td>可内嵌模块直接处理（如mod_php）</td>
</tr>
<tr>
<td>生态</td>
<td>反向代理/负载均衡强</td>
<td>模块丰富，传统虚拟机生态成熟</td>
</tr>
</tbody>
</table>
<h3>3、Nginx 典型应用场景</h3>
<p>- 静态资源服务器：图片、JS/CSS、下载。<br>- 反向代理：隐藏后端、统一入口。<br>- 负载均衡：多后端分发。<br>- API 网关/入口层：限流、鉴权、路由。<br>- HTTPS 终结：证书卸载。<br>- 缓存加速：proxy_cache。<br>- 动静分离：静态走 Nginx，动态转发后端。</p>
<h3>4、Nginx 进程模型</h3>
<p>- Master 进程：读取配置、管理 Worker、平滑重载/升级，不直接处理请求。<br>- Worker 进程：实际处理连接，数量通常设为 CPU 核心数；每个 Worker 基于 epoll（Linux） 等事件驱动模型，单进程可处理大量并发连接。<br>- 请求处理流程：Master 启动 &rarr; Worker 监听端口 &rarr; 接收连接 &rarr; 解析 HTTP &rarr; 按配置匹配 location &rarr; 静态返回或代理转发 &rarr; 记录日志。</p>
<h1>四、Nginx 安装及配置</h1>
<h3>1、官方版本介绍</h3>
<p>官网下载：http://nginx.org/en/download.html<br>Nginx官网提供了三个类型的版本:<br>- Mainline version：Mainline 是 Nginx 目前主力在做的版本，可以说是开发版<br>- Stable version：最新稳定版，生产环境上建议使用的版本（通常使用下载这个版本）<br>- Legacy versions：遗留的老版本的稳定版</p>
<h3>2、Yum 安装 Nginx</h3>
<pre class="language-markup"><code>yum -y install nginx</code></pre>
<h3>3、源码编译安装 Nginx</h3>
<h4>1、安装步骤</h4>
<p>步骤1：安装依赖</p>
<pre class="language-markup"><code>yum -y install pcre pcre-devel gcc gcc-c++ zlib zlib-devel openssl openssl-devel make lrzsz wget curl </code></pre>
<p>步骤2：编译安装部署</p>
<pre class="language-markup"><code>tar xf nginx-1.26.3.tar.gz
cd /root/nginx-1.26.3
./configure --prefix=/usr/local/nginx
make -j$(nproc)
make install</code></pre>
<h4>2、维护命令</h4>
<pre class="language-markup"><code># 查看 nginx 版本号
nginx -v

# 产看 nginx 的进程
ps -ef | grep nginx

# 启动 nginx
nginx

# 查看语法是是否正确
nginx -t

# 停止 nginx，无论进程是否在工作，都直接停止进程
nginx -s stop

# 从容停止 nginx，需要进程完成当前工作后再停止
nginx -s quit

# 比较野蛮的，直接杀死nginx进程
killall nginx
kill pid

# 重新加载 nginx，最常用，只刷新配置文件，不重启主进程
nginx -s reload

# 开机启动nginx
vim /etc/rc.d/rc.local
...
/usr/local/nginx/sbin/nginx

# 添加权限
chmod a+x /etc/rc.d/rc.local</code></pre>
<h3>4、Nginx 目录结构说明</h3>
<p>- 配置文件目录：conf<br>- 网页根目录：html<br>- 日志目录: logs<br>- 可执行文件：sbin/nginx</p>
<h3>5、Nginx 主配置文件详解</h3>
<p>nginx 的主配置文件 nginx.conf 包含以下几个部分：</p>
<p>-&nbsp;<strong>全局块</strong>：全局块是 nginx.conf 的第一部分，用于配置全局参数，如 user、worker_processes、error_log、pid 等。<br>- <strong>events 块</strong>：events 块是 nginx.conf 的第二部分，用于配置事件模块参数，如 worker_connections、use、multi_accept 等。<br>- <strong>http 块</strong>：http 块是 nginx.conf 的第三部分，用于配置 HTTP 模块参数，如 server、upstream、location 等。<br>- <strong>server 块</strong>：server 块是 http 块的子块，用于配置虚拟主机参数，如 listen、server_name、root、index、access_log、error_log 等。<br>-<strong> location 块</strong>：location 块是 server 块的子块，用于匹配 URL 路径参数，如 root、index、proxy_pass、fastcgi_pass、try_files、rewrite 等。<br>- <strong>upstream 块</strong>：upstream 块是 http 块的子块，用于配置负载均衡参数，如 server、weight、max_fails、fail_timeout 等。<br>- <strong>include 块</strong>：include 块用于包含其他配置文件，可以将多个配置文件合并为一个,方便管理，防止主配置过于臃肿。</p>
<h3>6、将前端项目部署到nginx服务</h3>
<p><a href="/content/uploadfile/202611/d2b51794921612.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794921612.png" alt="image.png"></a></p>
<pre class="language-markup"><code>vim /usr/local/nginx/conf/nginx.conf
...
root html;
...</code></pre>
<h1>五、Nginx 虚拟主机及基本维护</h1>
<h3>1、什么是虚拟主机</h3>
<p>所谓虚拟主机，就是可以在一个nginx服务运行多个域名服务，nginx为统一访问入口，通过不同域名、不同端口、或者不同ip来区分不同的服务，其中，以基于域名的虚拟主机最为常用。</p>
<p><a href="/content/uploadfile/202611/d2b51794921759.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794921759.png" alt="image.png"></a></p>
<p>include 模块</p>
<p>include 指令用于主配置文件nginx.conf中指定包含其他扩展配置文件，从而简化nginx主配置文件，让其配置文件更加具有可配置性和可读性。</p>
<p>&nbsp;</p>
<p>现在主配置文件的http模块中添加一个 include 指令</p>
<pre class="language-markup"><code>vim nginx.conf
http {
...
    include /usr/local/nginx/conf/vhosts/*.conf;
...
}</code></pre>
<p>在 vhosts 目录中创建虚拟主机</p>
<pre class="language-markup"><code>cd /usr/local/nginx/conf/vhosts/
vim bbb.itstyle.net.conf
server {
    listen 80;
    server_name bbb.itstyle.net;
    index index.html;
    root /var/www/bbb;
    access_log /usr/local/nginx/logs/bbb.itstyle.net.com.access.log;
    error_log /usr/local/nginx/logs/bbb.itstyle.net.com.error.log;
}</code></pre>
<h3>2、虚拟主机类型</h3>
<p>- 基于域名<br>- 基于端口<br>- 基于ip</p>
<h3>3、基于域名的虚拟主机</h3>
<p>通过在一个nginx部署多个域名，通过不同的域名来访问到不同的内容</p>
<pre class="language-markup"><code>vim aaa.docker123.cn.conf
server {
        listen 80;
        server_name aaa.docker123.cn;
        index index.html;
        root /data/www/aaa;
        access_log /usr/local/nginx/logs/aaa.docker123.cn_access.log;
        error_log /usr/local/nginx/logs/aaa.docker123.cn_error.log;
}

mkdir /data/www/aaa/
echo "&lt;h1&gt;aaa&lt;/h1&gt;" &gt; index.html
</code></pre>
<h3>4、基于ip的虚拟主机</h3>
<p>需要在几个机器配置多个ip地址，基本不用</p>
<h3>5、基于端口的虚拟主机</h3>
<pre class="language-markup"><code>http {
...
    server {
        listen 81;
        server_name  192.168.9.11;
        root /var/www/81;
        index index.html;
        access_log /var/log/nginx/example.com.access.log;
        error_log /var/log/nginx/example.com.error.log;
    }

        server {
        listen 82;
        server_name  192.168.9.11;
        root /var/www/82;
        index index.html;
        access_log /var/log/nginx/example.com.access.log;
        error_log /var/log/nginx/example.com.error.log;
    }
...
}
</code></pre>
<h3>6、认识 location 模块</h3>
<p>location 是 Nginx 配置中最核心的指令之一，它的主要作用是根据请求的 URI 来匹配并定义如何处理该请求。<br>简单来说，它就像一个 "请求路由器" ，当用户访问不同的网址路径时，location 块决定了 Nginx 应该返回静态文件、转发给后端应用服务器、还是执行其他操作。<br>核心功能：根据请求的 URL 路径（如 /, /api/, /images/）进行匹配，将不同请求分发到不同的处理逻辑。<br>- <strong>静态文件服务</strong><br>最常见的用途是直接返回服务器上的静态文件（HTML、CSS、JS、图片等），无需经过后端应用。<br>- <strong>反向代理转发</strong><br>将匹配到的请求转发给后端服务器（如 Tomcat、Node.js、Python 应用等），实现负载均衡和应用分离。<br>- <strong>访问控制与安全</strong><br>可以针对特定路径设置访问限制（IP 白名单、密码认证等）。<br>-<strong> 重定向与重写</strong><br>实现 URL 重写、强制 HTTPS、添加或修改请求头等。</p>
<p>看以下静态资源定义场景。</p>
<h3>7、静态资源路径定义</h3>
<p>在 Nginx 配置中，alias 和 root 都用于指定访问文件的路径，这两者的用法区别在于对URI的处理方法不同。<br># 如果访问访问/i/目录里面的文件时，ningx会自动去/data/nginx/aaa/i/目录找文件，一般来说，使用root的话，会去匹配文件。</p>
<pre class="language-markup"><code>server {
        listen 80;
        server_name aaa.docker123.cn;
        access_log /usr/local/nginx/logs/aaa.docker123.cn_access.log;
        error_log /usr/local/nginx/logs/aaa.docker123.cn_error.log;
        location /i/{
                index index.html;
                root /data/nginx/aaa/;
        }
}

mkdir -p /data/nginx/aaa/i
echo "&lt;h1&gt;root&lt;/h1&gt;" &gt; i/index.html

# 使用alias，在访问/i/目录里面的文件时，ningx会自动去/data/www/aaa 目录找文件。
server {
        listen 80;
        server_name aaa.docker123.cn;
        access_log /usr/local/nginx/logs/aaa.docker123.cn_access.log;
        error_log /usr/local/nginx/logs/aaa.docker123.cn_error.log;
        location /i/{
                index index.html;
                alias /data/www/aaa/;
        }
}
echo "&lt;h1&gt;alias &lt;/h1&gt;" &gt; index.html</code></pre>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>]]></description>
    <pubDate>Tue, 17 Nov 2026 20:30:41 +0800</pubDate>
    <dc:creator>小曦窝</dc:creator>
    <guid>https://m.hanshao.top/?post=33</guid>
</item>
<item>
    <title>Nginx综合服务1</title>
    <link>https://m.hanshao.top/?post=32</link>
    <description><![CDATA[<h1>一、需求</h1>
<p>公司内⽹部署了两套内部系统，员⼯在公司内部通过浏览器访问，外部不能访问。</p>
<p>将多个域名服务器部署到同⼀个nginx服务中，使⽤nginx虚拟主机实现。</p>
<p>www.zzh.top 192.168.134.130 访问内容：&lt;h1&gt;www&lt;/h1&gt;</p>
<p>caiwu.zzh.top 192.168.134.130 访问内容：&lt;h1&gt;caiwu&lt;/h1&gt;</p>
<p>api.zzh.top 192.168.134.130 访问内容：&lt;h1&gt;api&lt;/h1&gt;</p>
<h1>二、架构图</h1>
<p><img src="/content/uploadfile/202611/45581794900778.png" alt="屏幕截图 2026-11-17 153011副本.png"></p>
<h1>三、配置思路</h1>
<p>1、源码编译nginx<br>2、备份主配置⽂件<br>3、将主配置⽂件简化<br>4、在主配置⽂件删除server端，添加⼀个include端<br>5、创建include段定义的路径，让主配置⽂件识别以conf结尾的配置⽂件，将server段放到这个路径<br>并识别<br>6、检查语法 &amp;&amp; 重载配置<br>7、创建域名对应的代码资源路径，并写⼊对应的内容<br>8、在hosts⽂件添加解析，将多个域名解析到⼀个nginx中。</p>
<h1>四、具体步骤</h1>
<p>步骤一：安装依赖</p>
<pre class="language-markup"><code>yum -y install pcre pcre-devel gcc gcc-c++ zlib zlib-devel openssl openssl-devel make lrzsz wget curl </code></pre>
<p>步骤二：源码编译安装nginx</p>
<pre class="language-markup"><code>[root@localhost ~]# tar xf nginx-1.26.3.tar.gz
[root@localhost ~]# cd /root/nginx-1.26.3
[root@localhost nginx-1.26.3]# ./configure --prefix=/usr/local/nginx
[root@localhost nginx-1.26.3]# make -j$(nproc)
[root@localhost nginx-1.26.3]# make install
</code></pre>
<p>步骤三：设置开机自启与添加权限</p>
<pre class="language-markup"><code>vim /etc/rc.d/rc.local

...
/usr/local/nginx/sbin/nginx
...

vim /etc/rc.d/rc.local        #添加权限

#重启
reboot
</code></pre>
<p>步骤四：简化配置文件</p>
<pre class="language-markup"><code>[root@localhost ~]# cd /usr/local/nginx/conf
[root@localhost conf]# cp nginx.conf nginx.conf.bak
[root@localhost conf]# egrep -v "#|^$" nginx.conf.bak &gt; nginx.conf</code></pre>
<p>步骤五：在nginx.conf下加入include /usr/local/nginx/conf/hosts/*.conf;这行</p>
<pre class="language-markup"><code>[root@localhost conf]#vim nginx.conf

...
worker_processes  1;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;
    include /usr/local/nginx/conf/hosts/*.conf;
}
...</code></pre>
<p>步骤六：创建虚拟主机的目录</p>
<pre class="language-markup"><code>[root@localhost conf]# mkdir /usr/local/nginx/conf/hosts/ </code></pre>
<p>步骤七：在 虚拟主机的路径，添加对应的域名服务，以 .conf 结尾</p>
<pre class="language-markup"><code>[root@localhost conf]# cd /usr/local/nginx/conf/hosts/

[root@localhost hosts]# echo "" &gt; www.conf
[root@localhost hosts]# vim www.conf
    server {
        listen       80;
        server_name  www.zzh.top;
        location / {
            root   /data/nginx/www;
            index  index.html index.htm;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }

[root@localhost hosts]# echo "" &gt; caiwu.conf
[root@localhost hosts]# vim caiwu.conf
    server {
        listen       80;
        server_name  caiwu.zzh.top;
        location / {
            root   /data/nginx/caiwu;
            index  index.html index.htm;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }

[root@localhost hosts]# echo "" &gt; api.conf
[root@localhost hosts]# vim api.conf
    server {
        listen       80;
        server_name  api.zzh.top;
        location / {
            root   /data/nginx/api;
            index  index.html index.htm;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
</code></pre>
<p>步骤八：创建域名对应的代码路径</p>
<pre class="language-markup"><code>[root@localhost conf]# mkdir -p  /data/nginx/www
[root@localhost conf]# mkdir -p /data/nginx/caiwu
[root@localhost conf]# mkdir -p /data/nginx/api</code></pre>
<p>步骤九：回到/usr/local/nginx/conf/nginx.conf使用vim修改删除</p>
<pre class="language-markup"><code>#因为已经有include /usr/local/nginx/conf/hosts/*.conf;所以直接删除下面的这段

    server {
        listen       80;
        server_name  localhost;
        location / {
            root   html;
            index  index.html index.htm;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
</code></pre>
<p>步骤十：写入网页文件</p>
<pre class="language-markup"><code>[root@localhost nginx]# echo "www" &gt; /data/nginx/www/index.html
[root@localhost nginx]# echo "caiwu" &gt; /data/nginx/caiwu/index.html
[root@localhost nginx]# echo "api" &gt; /data/nginx/api/index.html</code></pre>
<p>再加一句重启服务</p>
<pre class="language-markup"><code>[root@localhost nginx]# /usr/local/nginx/sbin/nginx -s reload
</code></pre>
<p>步骤十一：打开本机电脑的hosts文件，加上ip与域名</p>
<p><a href="/content/uploadfile/202611/d2b51794901800.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794901800.png" alt="image.png"></a></p>
<h1>五、排错方法</h1>
<p>主要看是否创建目录：</p>
<p>1、</p>
<p>/data/nginx/www</p>
<p>/data/nginx/caiwu</p>
<p>/data/nginx/api</p>
<p>2、在/usr/local/nginx/conf/hosts/中是否创建文件</p>
<ul>
<li>www.conf</li>
<li>caiwu.conf</li>
<li>api.conf</li>
</ul>
<p>3、源码编译的nginx尽量写绝对路径</p>
<p>4、排错语句和重启服务</p>
<p>/usr/local/nginx/sbin/nginx -t</p>
<p>/usr/local/nginx/sbin/nginx -s reload</p>]]></description>
    <pubDate>Tue, 17 Nov 2026 11:45:35 +0800</pubDate>
    <dc:creator>小曦窝</dc:creator>
    <guid>https://m.hanshao.top/?post=32</guid>
</item>
<item>
    <title>web综合（nginx与DNS）</title>
    <link>https://m.hanshao.top/?post=30</link>
    <description><![CDATA[<h1>一、apache与nginx</h1>
<p>做任何服务之前需要先查机器时间是否一致</p>
<pre class="language-markup"><code>查看时间：
date
时间同步：
timedatectl set-timezone Asia/Shanghai  # 设置时区
ntpdate ntp1.aliyun.com  # 同步时间</code></pre>
<h2>1、apache安装与使⽤</h2>
<p>安装：</p>
<pre class="language-markup"><code># 2. 安装 Apache
yum install httpd -y

# 3. 启动并设置开机自启
systemctl start httpd
systemctl enable httpd

# 4. 验证状态
systemctl status httpd

# 查看监听端口
netstat -lnpt | grep 80</code></pre>
<p>状态维护：</p>
<pre class="language-markup"><code># 重启
systemctl restart httpd

# 重载配置 (不中断服务)
systemctl reload httpd

# 检查配置语法
apachectl configtest

查看版本
httpd -v</code></pre>
<p>yum安装apache代码位置：<span style="background-color: #f8cac6; color: #000000;">/usr/share/httpd/noindex</span></p>
<h2>2、nginx安装与使用</h2>
<h3>1、yum安装与维护</h3>
<p>安装</p>
<pre class="language-markup"><code># 1. 安装
yum install nginx -y

# 2. 启动并开机自启
systemctl start nginx
systemctl enable nginx</code></pre>
<p>状态维护</p>
<pre class="language-markup"><code># 测试配置语法
nginx -t

# 重载配置
systemctl reload nginx

# 重启
systemctl restart nginx</code></pre>
<p>代码默认路径：<span style="background-color: #f8cac6; color: #000000;">/usr/share/nginx/html/</span></p>
<h3>2、源码编译安装与维护</h3>
<p>安装</p>
<pre class="language-markup"><code>yum install -y gcc gcc-c++ make pcre-devel zlib-devel openssl-devel

# 1. 下载解压
cd /usr/local/src
wget https://nginx.org/download/nginx-1.24.0.tar.gz
tar zxvf nginx-1.24.0.tar.gz
cd nginx-1.24.0

# 2. 配置编译参数
./configure --prefix=/usr/local/nginx

# 3. 编译安装
make -j$(nproc) &amp;&amp; make install

# 启动
/usr/local/nginx/sbin/nginx

# 测试
curl -I http://127.0.0.1</code></pre>
<p>状态维护</p>
<pre class="language-markup"><code># 测试配置
/usr/local/nginx/sbin/nginx -t

# 重载
/usr/local/nginx/sbin/nginx -s reload

# 停止
/usr/local/nginx/sbin/nginx -s stop

# 查看编译参数
/usr/local/nginx/sbin/nginx -V</code></pre>
<p>代码默认路径：<span style="background-color: #f8cac6; color: #000000;">/usr/loca/nginx/html</span></p>
<h1>二、DNS域名系统与BIND服务</h1>
<h2>1、bind服务安装及配置</h2>
<h3>1、bind服务安装</h3>
<p>步骤1：基础环境配置</p>
<pre class="language-markup"><code>#查看时间：
date
# 同步时间
yum -y install ntpdate
# 同步时区
timedatectl set-timezone Asia/Shanghai
ntpdate ntp1.aliyun.com

# 关闭防火墙
systemctl stop firewalld
setenforce 0</code></pre>
<p>步骤2：安装</p>
<pre class="language-markup"><code>yum -y install bind*
rpm -qa | grep ^bind

# 启动named
systemctl enable named.service
systemctl start named.service

# 查看监听端口
netstat -lnptu | grep named</code></pre>
<h3>2、配置⽂件介绍</h3>
<table style="border-collapse: collapse; display: table; width: 100%; height: 138.4px;" border="1"><colgroup><col style="width: 49.9784%;"><col style="width: 49.9784%;"></colgroup>
<tbody>
<tr style="height: 34.6px;">
<td>⽂件/⽬录</td>
<td>作⽤</td>
</tr>
<tr style="height: 34.6px;">
<td>/etc/named.conf</td>
<td>主配置⽂件，定义全局选项、⽇志、根区域及包含其他⽂件</td>
</tr>
<tr style="height: 34.6px;">
<td>/etc/named.rfc1912.zones</td>
<td>定义主域名及对应的数据⽂件，⼀般在/var/named/data下</td>
</tr>
<tr style="height: 34.6px;">
<td>/var/named/data/</td>
<td>存放数据解析⽂件</td>
</tr>
</tbody>
</table>
<h2>2、web服务+dns内⽹解析案例</h2>
<h3>1、应⽤场景与实际需求</h3>
<p>公司内⽹部署了⼀套HR⼈⼒资源平台（Web应⽤），员⼯通过浏览器访问hr.docker123.cn 进⾏考勤打卡、请假申请、薪资查询等操作。由于是内⽹系统，不对外⽹暴露，需要通过内⽹DNS将域名解析到内⽹Web服务器IP。</p>
<p><strong>实际需求</strong></p>
<ul>
<li>内网用户通过域名 hr.docker123.cn 访问 HR 系统，而非记IP</li>
<li>同一域名在办公区、机房、vlan 等不同网段都能正确解析</li>
<li>DNS 解析要稳定，避免因 DNS 故障导致全员无法访问 HR 系统</li>
<li>后续可扩展：新增 oa.docker123.cn、wiki.docker123.cn 等内网域名</li>
</ul>
<h3>2、架构图</h3>
<p><a href="/content/uploadfile/202611/d2b51794463552.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794463552.png" alt="image.png"></a></p>
<h3>3、环境规划</h3>
<ul>
<li>HR系统：192.168.134.130</li>
<li>OA系统：192.168.134.131</li>
<li>DNS服务器：192.168.134.133</li>
<li>客⼾端：本机</li>
</ul>
<h3>4、配置思路</h3>
<ol>
<li>&nbsp;安装DNS服务</li>
<li>主配置⽂件修改</li>
<li>添加主域名</li>
<li>配置域名解析</li>
<li>在客⼾端配置DNS服务器地址</li>
<li>客⼾端测试解析</li>
</ol>
<h3>5、配置步骤</h3>
<p>步骤1：修改主配置⽂件</p>
<pre class="language-markup"><code>vim /etc/named.conf

...
options {
    listen-on port 53 { 192.168.134.133; };
    listen-on-v6 port 53 { ::1; };
    directory       "/var/named";
    dump-file       "/var/named/data/cache_dump.db";
    statistics-file "/var/named/data/named_stats.txt";
    memstatistics-file "/var/named/data/named_mem_stats.txt";
    recursing-file  "/var/named/data/named.recursing";
    secroots-file   "/var/named/data/named.secroots";
    allow-query     { any; };
    forwarders{ 223.5.5.5;114.114.114.114; };      # 转发本地位置记录请求

    # 关闭DNS安全
    dnssec-enable no;
    dnssec-validation no;
...

# 语法检测
named-checkconf /etc/named.conf</code></pre>
<p>步骤2：添加主域名，定义数据解析⽂件</p>
<pre class="language-markup"><code>vim /etc/named.rfc1912.zones

...
zone "docker123.cn" IN {
        type master;
        file "data/docker123.cn.zone";
};</code></pre>
<p>步骤3：添加解析⽂件</p>
<pre class="language-markup"><code>vim /var/named/data/docker123.cn.zone

...
$TTL 1D
@       IN SOA  dns.docker123.cn. dns.www.docker123.cn. (
                                        20190201      ; serial
                                        1D      ; refresh
                                        1H      ; retry
                                        1W      ; expire
                                        3H )    ; minimum
@                       IN      NS      dns.docker123.cn.
dns.docker123.cn.           IN      A       192.168.134.133
hr.docker123.cn.        IN      A       192.168.134.130
oa.docker123.cn.        IN      A       192.168.134.131
wiki.docker123.cn.      IN      A       192.168.134.132
</code></pre>
<p>步骤4：检查语法并重启</p>
<pre class="language-markup"><code>named-checkconf /etc/named.conf
systemctl restart named</code></pre>
<h3>6、排错思路</h3>
<pre class="language-markup"><code>1、ping:
    1、测试主机在线(不准确)
    2、测试网络质量延迟
    3、可以返回域名对应的ip地址
2、telnet：测试主机的端口是否可以访问。(最准确) web mysql
3、ps-ef: 查看进程是否存在
4、netstat -lnpt: 查看监听端口。
5、tail -f 动态查看日志
6、解析域名对应的ip:
    1、windows: nslookup
    2、linux : dig</code></pre>
<h1>三、NFS共享⽂件服务</h1>
<h3>1、多台web共享代码</h3>
<p>步骤1：安装配置NFS</p>
<pre class="language-markup"><code># 安装nfs服务，所有需要nfs的机器都需要安装，但是除了server其他的不需要启动
yum install nfs-utils -y

# 启动nfs服务
systemctl start nfs-server
systemctl enable nfs-server

# 查看监听端口
netstat -nlpt | grep rpcbind</code></pre>
<p>步骤2：配置远程⽬录共享</p>
<pre class="language-markup"><code>vim /etc/exports

...
/data/share/www 192.168.134.0/24(rw,sync,no_root_squash)

# 创建共享目录
mkdir /data/share/www -p

# 刷新配置
exportfs -a</code></pre>
<p>步骤2：挂载使⽤</p>
<pre class="language-markup"><code># 安装支持工具包
yum -y install nfs-utils

# 查看服务端暴露
showmount -e 192.168.134.133
Export list for 192.168.134.133:
/data/share/www 192.168.134.0/24

# 安装一个web服务测试共享
yum -y install epel-release
yum -y install nginx

# 挂载使用
mount -t nfs 192.168.134.133:/data/share/www /usr/share/nginx/html/</code></pre>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p>&nbsp;</p>]]></description>
    <pubDate>Thu, 12 Nov 2026 12:03:33 +0800</pubDate>
    <dc:creator>小曦窝</dc:creator>
    <guid>https://m.hanshao.top/?post=30</guid>
</item>
<item>
    <title>Linux服务管理命令</title>
    <link>https://m.hanshao.top/?post=29</link>
    <description><![CDATA[<h2>一、systemd服务概述</h2>
<p>systemd 是Linux系统的初始化系统和服务管理器，在CentOS7及以上版本中取代了传统的SysVinit，成为PID1（所有进程的祖先），其他所有的进程都可以说是systemd的⼦进程或者说是孙⼦进程。</p>
<p>在centos7之前的版本，都是通过init进程做初始化及初始⽗进程，相对与init，systemd有以下优势：</p>
<ul>
<li>并⾏启动：服务可并发启动，加快开机速度</li>
<li>按需启动：通过socket激活，⽤时才拉起</li>
<li>依赖管理：明确的依赖关系，避免启动顺序混乱</li>
<li>统⼀⽇志：journald集中收集⽇志</li>
<li>资源控制：基于cgroup限制CPU/内存</li>
<li>服务⾃愈：可配置崩溃⾃动重启</li>
</ul>
<h2>二、systemctl命令介绍</h2>
<p>systemctl 是systemd的核⼼命令⾏⼯具，⽤于管理服务、单元、系统状态。</p>
<p>基本语法：</p>
<pre class="language-markup"><code>systemctl [⼦命令] [单元名称] </code></pre>
<p>systemctl start nginx 等同于 systemctl start nginx.service，默认操作 .service 类型。</p>
<p>命令分类：</p>
<pre class="language-markup"><code>类别          常用命令
服务生命周期  start / stop / restart / reload / status
开机自启      enable / disable / is-enabled
查看单元      list-units / list-unit-files / list-dependencies
系统状态      poweroff / reboot / suspend / get-default
日志          journalctl (配套工具)</code></pre>
<h2>三、system核心管理</h2>
<p>systemd 以 &ldquo;单元 (Unit) &rdquo; 为单位管理系统的各种资源。常见的单元类型包括：.service (服务)、.socket (套接字)、.target (目标/运行级别)、.timer (定时器) 等。</p>
<p>服务⽣命周期管理</p>
<pre class="language-markup"><code>命令                            作用
systemctl start nginx           启动服务
systemctl stop nginx            停止服务
systemctl restart nginx         重启服务 (PID 会变化)
systemctl reload nginx          热重载配置 (PID 不变，需服务本身支持)
systemctl status nginx          查看服务状态 (是否 active、是否 enabled、最近日志)
systemctl is-active nginx       仅检查是否正在运行
systemctl is-enabled nginx      仅检查是否开机自启</code></pre>
<p>restart 与 reload 的区别：restart 会先停后起，服务短暂中断；reload 只重新加载配置⽂件，不中断服务（如Nginx的reload）。</p>
<h2>四、服务开机自启</h2>
<p>设置与取消</p>
<pre class="language-markup"><code>systemctl enable nginx          # 设置开机自启
systemctl disable nginx         # 取消开机自启
systemctl enable --now nginx    # 设置自启并立即启动</code></pre>
<p>注意：<br>enable 只配置⾃启，不会⽴即启动服务。需要⽴即运⾏请配合start 或使⽤--now 。</p>
<pre class="language-markup"><code>systemctl is-enabled nginx                    # 返回 enabled 或 disabled
systemctl list-unit-files --type=service | grep enabled    # 列出所有已启用的服务</code></pre>
<p>⾃启原理：enable会在对应的target（通常是multi-user.target）的.wants⽬录中创建⼀个指向该服务单元的符号链接。系统启动时，systemd会加载multi-user.target，从⽽拉起所有链接的服务。</p>
<h2>五、服务日志查看</h2>
<p>systemd使⽤journald统⼀收集⽇志，通过journalctl查看。服务⽇志默认写⼊journal，⽆需⼿动配置。</p>
<pre class="language-markup"><code>命令                                作用
journalctl -u nginx                 查看 nginx 服务的日志
journalctl -u nginx -f              实时跟踪日志（类似 tail -f）
journalctl -u nginx -b              只看本次启动以来的日志
journalctl -u nginx -p err          只看错误级别的日志
journalctl -u nginx --since "1 hour ago"  查看最近1小时的日志
journalctl -u nginx --since today   查看今天的日</code></pre>
<h2>六、⾃定义systemd服务单元</h2>
<p>当需要让⼀个程序随系统启动、崩溃后⾃动重启、被systemd统⼀管理时，可以创建⾃定义.service<br>⽂件。</p>
<h3>1、最⼩可⽤模板</h3>
<p>创建/etc/systemd/system/myapp.service：</p>
<pre class="language-markup"><code>[Unit]
Description=My Application
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=appuser
WorkingDirectory=/opt/myapp
ExecStart=/opt/myapp/start.sh
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target</code></pre>
<h3>2、单元文件位置</h3>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.8798%;"><col style="width: 49.8798%;"></colgroup>
<tbody>
<tr>
<td>路径</td>
<td>用途</td>
</tr>
<tr>
<td>/usr/lib/systemd/system/</td>
<td>软件包安装的默认位置</td>
</tr>
<tr>
<td>/etc/systemd/system/</td>
<td>管理员⾃定义/覆盖位置，优先级更⾼</td>
</tr>
</tbody>
</table>
<h3>3、配置文件详解</h3>
<p>[Unit]段：描述与依赖</p>
<pre class="language-markup"><code>指令            说明
Description     服务描述
After           排序依赖，在指定单元之后启动
Before          在指定单元之前启动
Wants           弱依赖，被依赖单元失败时本服务仍启动
Requires        强依赖，被依赖单元失败则本服务也不启动</code></pre>
<p>[Service]段：启动⽅式与⾏为</p>
<pre class="language-markup"><code>指令                          说明
Type                          进程类型：simple（默认，前台）、forking（传统 daemon）、notify（主动通知就绪）、oneshot（执行一次）
ExecStart                     启动命令（必须绝对路径）
ExecStop / ExecReload         停止 / 重载命令（可选）
Restart                       重启策略：no / on-failure / always
RestartSec                    重启前等待秒数
User / Group                  运行用户 / 组
WorkingDirectory              工作目录
Environment                   环境变量</code></pre>
<p>[Install]段：开机⾃启配置</p>
<pre class="language-markup"><code>指令                          说明
WantedBy=multi-user.target    必须写，enable 时创建链接实现自启</code></pre>
<h3>4、添加到服务管理</h3>
<pre class="language-markup"><code># 1. 重新加载 systemd 配置 (修改/新增单元文件后必须执行)
systemctl daemon-reload

# 2. 启用并立即启动
systemctl enable --now myapp.service

# 3. 验证
systemctl status myapp.service</code></pre>
<p>&nbsp;</p>]]></description>
    <pubDate>Tue, 10 Nov 2026 16:53:06 +0800</pubDate>
    <dc:creator>小曦窝</dc:creator>
    <guid>https://m.hanshao.top/?post=29</guid>
</item>
<item>
    <title>Linux进程管理</title>
    <link>https://m.hanshao.top/?post=28</link>
    <description><![CDATA[<h2>一、什么是进程</h2>
<p>进程是正在运⾏的程序实例。程序是存储在磁盘上的静态⽂件，进程则是它被加载到内存、由CPU执⾏时的动态实体。</p>
<p>每个进程都有：</p>
<ul>
<li>PID：进程ID，唯⼀标识</li>
<li>PPID：⽗进程ID</li>
<li>UID/GID：所属⽤⼾和组</li>
<li>状态：运⾏、睡眠、停⽌、僵⼫等</li>
<li>资源：内存、打开的⽂件、CPU时间等</li>
</ul>
<p>进程之间通常形成⽗⼦关系：系统启动时由systemd ，PID1创建第⼀个⽤⼾空间进程，之后所有进程都由此派⽣。</p>
<p>通过pid可以管理进程的⾏为。</p>
<h2>二、认识初始化进程</h2>
<p>进程1是所有⽤⼾态进程的祖先，是整个系统进程树的根节点。</p>
<ul>
<li>CentOS 7 的变化：在 CentOS 5/6 中，PID 1 是 init 进程；但从 CentOS 7 开始，PID 1 由 systemd 取代。</li>
<li>作用：它是内核启动后运行的第一个用户态程序。所有其他的系统服务和用户进程，最终都由它（直接或间接）启动和收养。</li>
<li>同样不可杀：如果进程 1 终止，内核会认为系统已无法继续运行，从而触发 Kernel Panic（内核恐慌），导致系统崩溃或重启。</li>
</ul>
<h2>三、进程管理流程</h2>
<p>进程管理主要包括：查看进程(监控资源)&rarr;控制进程(启动/暂停/终⽌)&rarr;调整优先级&rarr;后台/前台切换。</p>
<h2>四、进程信号</h2>
<p>操作系统可以通过预定义的信号向进程发送指令，控制进程的⾏为。</p>
<p>常用信号：</p>
<pre class="language-markup"><code>信号       编号    含义             默认动作
SIGHUP     1       挂起/重载配置    终止
SIGINT     2       中断 (Ctrl+C)    终止
SIGKILL    9       强制杀死         终止 (不可捕获)
SIGTERM    15      优雅终止         终止 (可捕获) 默认
SIGSTOP    19      暂停             停止 (不可捕获)
SIGCONT    18      继续运行         继续
SIGUSR1/2  10/12   用户自定义       终止</code></pre>
<p>发送信号：</p>
<pre class="language-markup"><code>kill -15 PID                 # 发送 SIGTERM
kill -9 PID                  # 发送 SIGKILL
pkill -HUP nginx             # 按名称发送信号
killall -9 python            # 杀死所有同名进程</code></pre>
<p>原则：优先⽤SIGTERM（15）让进程优雅退出；⽆响应时再⽤SIGKILL（9）。</p>
<h2>五、查看进程</h2>
<p>相关的命令包括：</p>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.8798%;"><col style="width: 49.8798%;"></colgroup>
<tbody>
<tr>
<td>命令</td>
<td>用途</td>
</tr>
<tr>
<td>ps aux</td>
<td>查看所有进程快照</td>
</tr>
<tr>
<td>top</td>
<td>实时动态查看</td>
</tr>
<tr>
<td>pgrep -a 名称</td>
<td>按名称查PID</td>
</tr>
<tr>
<td>pidof 名称</td>
<td>差PID</td>
</tr>
<tr>
<td>pstree -p</td>
<td>树状显示进程关系</td>
</tr>
<tr>
<td>lsof -p PID</td>
<td>查看进程打开的文件</td>
</tr>
</tbody>
</table>
<h3>1、ps命令</h3>
<p>作⽤：查看当前系统进程的快照（静态，执⾏那⼀刻的状态）。</p>
<p>常⽤参数组合：</p>
<pre class="language-markup"><code>命令                            说明
ps aux                          BSD 风格，显示所有进程的详细信息（用户、CPU、内存等）
ps -ef                          System V 风格，显示所有进程及父子关系（PPID）
ps -ef | grep nginx             过滤查找特定进程
ps -u username                  查看指定用户的进程
ps -p PID                       查看指定 PID 的进程
ps -eo pid,ppid,cmd,%cpu,%mem   自定义输出列</code></pre>
<p>示例：</p>
<pre class="language-markup"><code>ps aux | grep sshd
ps -ef --forest          #树状显示父子进程</code></pre>
<p>输出列含义（aux）：</p>
<ul>
<li>USER：进程所属用户</li>
<li>PID：进程ID</li>
<li>%CPU / %MEM：CPU/内存占用</li>
<li>STAT：进程状态</li>
<li>COMMAND：启动命令</li>
</ul>
<h3>2、top命令</h3>
<p>作⽤：实时动态查看系统资源占⽤和进程状态（默认每3秒刷新）。</p>
<p>常⽤交互快捷键（运⾏中按）：</p>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.8798%;"><col style="width: 49.8798%;"></colgroup>
<tbody>
<tr>
<td>按键</td>
<td>功能</td>
</tr>
<tr>
<td>P</td>
<td>按CPU使用率排序（默认）</td>
</tr>
<tr>
<td>M</td>
<td>按内存使用率排序</td>
</tr>
<tr>
<td>1</td>
<td>展开/收起每个CPU核心的使用情况</td>
</tr>
<tr>
<td>T</td>
<td>按运行时间排序</td>
</tr>
<tr>
<td>k</td>
<td>杀掉指定PID的进程</td>
</tr>
<tr>
<td>u</td>
<td>过滤指定用户的进程</td>
</tr>
<tr>
<td>q</td>
<td>退出</td>
</tr>
</tbody>
</table>
<p>常⽤启动参数：</p>
<pre class="language-markup"><code>top -d 1                    # 每 1 秒刷新
top -p 1234                 # 只监控 PID 1234
top -u root                 # 只看 root 用户的进程
top -b -n 1                 # 批处理模式输出一次 (适合脚本/日志)</code></pre>
<p>top的输出分为上下两部分：上半部分是统计信息区（5~6⾏），下半部分是进程列表区（表头+每⾏⼀个进程）。</p>
<h3>3、pstree命令</h3>
<p>作用：以树状结构显⽰进程的⽗⼦关系，直观展⽰进程派⽣层次。</p>
<p>常用参数：</p>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.8798%;"><col style="width: 49.8798%;"></colgroup>
<tbody>
<tr>
<td>命令</td>
<td>说明</td>
</tr>
<tr>
<td>pstree</td>
<td>以树状显示所有进程</td>
</tr>
<tr>
<td>pstree -p</td>
<td>同时显示每个进程的PID</td>
</tr>
<tr>
<td>pstree -u</td>
<td>显示进程所属用户（用户变化时标注）</td>
</tr>
<tr>
<td>pstree -a</td>
<td>显示完整命令行参数</td>
</tr>
<tr>
<td>pstree username</td>
<td>只看某用户的进程树</td>
</tr>
<tr>
<td>pstree PID</td>
<td>以某进程为根显示子树</td>
</tr>
</tbody>
</table>
<p>⽰例：</p>
<pre class="language-markup"><code>pstree -p | grep sshd
pstree -p 1             # 从 init/systemd 开始看整棵树</code></pre>
<p>输出⽰例：</p>
<pre class="language-markup"><code>systemd(1)─┬─sshd(1024)───sshd(2048)───bash(2050)───pstree(2100)
           ├─nginx(1100)─┬─nginx(1101)
           │              └─nginx(1102)
           └─cron(1200)</code></pre>
<h3>4、lsof命令</h3>
<p>作用：ListOpenFiles，列出进程打开的⽂件。Linux中"⼀切皆⽂件"，所以它也能查看⽹络连接、端⼝、设备等。</p>
<p>常用参数：</p>
<pre class="language-markup"><code>命令                        说明
lsof                        列出所有打开的文件（量大，慎用）
lsof -p PID                 查看指定进程打开的文件
lsof -u username            查看指定用户打开的文件
lsof /path/file             查看谁打开了某个文件
lsof -i                     列出所有网络连接
lsof -i :80                 查看占用 80 端口的进程
lsof -i tcp                 只看 TCP 连接
lsof -i @192.168.1.1        查看与某 IP 的连接
lsof +D /dir                递归查看目录下被打开的文件
lsof -c nginx               查看指定命令名打开的进程</code></pre>
<p>示例：</p>
<pre class="language-markup"><code>lsof -i :22                     # 谁占用了 22 端口
lsof -p 1234                    # PID 1234 打开的所有文件
lsof /var/log/syslog            # 哪个进程在用这个日志文件
lsof -u root -i                 # root 用户的所有网络连接</code></pre>
<p>典型用途：</p>
<ul>
<li>排查端口被占用（lsof -i :端口）</li>
<li>定位&ldquo;文件被占用无法删除/卸载&rdquo;的问题</li>
<li>查看进程打开的文件描述符，排查句柄泄露</li>
</ul>
<h2>六、top命令详解</h2>
<h3>1、整体示例</h3>
<p><a href="/content/uploadfile/202611/d2b51794299073.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794299073.png" alt="image.png"></a></p>
<h3>2、系统概况</h3>
<pre class="language-markup"><code>top - 14:32:05 up 10 days,  3:21,  2 users,  load average: 0.15, 0.10, 0.05</code></pre>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.8798%;"><col style="width: 49.8798%;"></colgroup>
<tbody>
<tr>
<td>字段</td>
<td>含义</td>
</tr>
<tr>
<td>top</td>
<td>命令名</td>
</tr>
<tr>
<td>14:32:05</td>
<td>当前系统时间</td>
</tr>
<tr>
<td>up 10 days, 3:21</td>
<td>系统已经运行时长（开机到现在）</td>
</tr>
<tr>
<td>2 users</td>
<td>当前登录用户数</td>
</tr>
<tr>
<td>load average: 0.15, 0.10, 0.05</td>
<td><span style="background-color: #f1c40f; color: #000000;">系统负载：过去1、5、15分钟的平均值</span></td>
</tr>
</tbody>
</table>
<p>关于load average：</p>
<ul>
<li>表示处于可运行（R）和不可中断睡眠（D）状态的进程平均数</li>
<li>判断标准：与CPU核心数比较
<ul>
<li>1核机器，load=1.0表示满载</li>
<li>4核机器，load&lt;4.0都算正常</li>
</ul>
</li>
<li>若1分钟值远大于15分钟值&rarr;负载在上升；反之在下降</li>
</ul>
<h3>3、进程统计</h3>
<pre class="language-markup"><code>Tasks: 128 total,   1 running, 127 sleeping,   0 stopped,   0 zombie</code></pre>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.8798%;"><col style="width: 49.8798%;"></colgroup>
<tbody>
<tr>
<td>字段</td>
<td>含义</td>
</tr>
<tr>
<td>128 total</td>
<td>进程总数</td>
</tr>
<tr>
<td>1 running</td>
<td>正在运行（R状态）的进程数</td>
</tr>
<tr>
<td>127 sleeping</td>
<td>睡眠（S/D状态）的进程数</td>
</tr>
<tr>
<td>0 stopped</td>
<td>已停止（T状态，被暂停）的进程数</td>
</tr>
<tr>
<td>0 zombie</td>
<td>僵尸（Z状态）进程数</td>
</tr>
</tbody>
</table>
<p>僵⼫进程：⼦进程已结束但⽗进程未回收其资源。少量正常，⼤量则需排查⽗进程。<br>stopped：被Ctrl+Z&nbsp;或 kill -STOP&nbsp;暂停的进程。</p>
<h3>4、CPU使用率</h3>
<pre class="language-markup"><code>%Cpu(s):  1.3 us,  0.7 sy,  0.0 ni, 97.7 id,  0.3 wa,  0.0 hi,  0.0 si,  0.0 st</code></pre>
<pre class="language-markup"><code>字段   含义       说明
us     user       用户态进程占用 CPU（不含 nice）
sy     system     内核态占用 CPU（系统调用）
ni     nice       改变过优先级的用户进程占用
id     idle       空闲 CPU 百分比
wa     iowait     等待 IO 完成的时间占比 ⚠️
hi     hardirq    硬中断处理占用
si     softirq    软中断处理占用
st     steal      被虚拟机/宿主机"偷走"的时间（云服务器重要指标）</code></pre>
<p>关键解读：</p>
<p>&bull; us 高 &rarr; 应用本身耗 CPU（代码问题）。<br>&bull; sy 高 &rarr; 系统调用/内核繁忙（可能是IO、上下文切换过多）。<br>&bull; wa 高 &rarr; 磁盘IO 瓶颈（进程在等磁盘）。<br>&bull; st 高 &rarr; 虚拟机被宿主机抢占资源（云主机性能差常见原因）。<br>&bull; id 高 &rarr; 系统空闲，正常。</p>
<p>按数字键&nbsp;1&nbsp;可展开显⽰每个CPU核⼼的独⽴数据。</p>
<h3>5、物理内存</h3>
<pre class="language-markup"><code>MiB Mem :   7982.5 total,    512.3 free,   2048.7 used,   5421.5 buff/cache</code></pre>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.8798%;"><col style="width: 49.8798%;"></colgroup>
<tbody>
<tr>
<td>字段</td>
<td>含义</td>
</tr>
<tr>
<td>total</td>
<td>物理内存总量</td>
</tr>
<tr>
<td>free</td>
<td>完全空闲的内存</td>
</tr>
<tr>
<td>used</td>
<td>已使用内存（total - free - buff/cache）</td>
</tr>
<tr>
<td>buff/cache</td>
<td>内核缓冲+页缓存（用于加速磁盘读写，可被回收）</td>
</tr>
</tbody>
</table>
<p>⚠注意：free⼩不代表内存不⾜！Linux会尽量⽤空闲内存做缓存（buff/cache）。真正要看的是第5⾏的avail Mem</p>
<h3>6、swap与可用内存</h3>
<pre class="language-markup"><code>MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   5500.2 avail Mem</code></pre>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.8798%;"><col style="width: 49.8798%;"></colgroup>
<tbody>
<tr>
<td>字段</td>
<td>含义</td>
</tr>
<tr>
<td>total</td>
<td>交换分区总量</td>
</tr>
<tr>
<td>free</td>
<td>空闲swap</td>
</tr>
<tr>
<td>used</td>
<td>已用swap</td>
</tr>
<tr>
<td>avail Mem</td>
<td>真正可用的内存（free+可回收的buff/cache）⭐</td>
</tr>
</tbody>
</table>
<p>判断内存是否紧张，看avail Mem和swap的used：</p>
<p>avail Mem 充足&rarr;内存正常</p>
<p>swap used持续增长&rarr;内存不足，开始用磁盘当内存，性能会急剧下降</p>
<h3>7、进程列表区</h3>
<pre class="language-markup"><code>  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 1234 root      20   0 2563212  51234  12345 S   1.3   0.6  10:23.45 nginx</code></pre>
<pre class="language-markup"><code>列名      含义          详解
PID       进程 ID       唯一标识
USER      进程属主      启动该进程的用户
PR        优先级        Priority，内核调度优先级，值越小越优先，默认 20
NI        nice 值       -20 (最高) ~ 19 (最低)，默认 0，影响 PR
VIRT      虚拟内存      Virt，进程申请的总地址空间，不是占用的物理内存空间 (含未实际分配的)
RES       常驻内存      Resident，进程实际占用的物理内存 (不含 swap) ，排查内存看这个
SHR       共享内存      Shared，与其他进程共享的内存 (如动态库)
S         进程状态      见下方状态码表
%CPU      CPU 使用率    单个进程占用 CPU 百分比
%MEM      内存使用率    RES / 总物理内存
TIME+     累计 CPU 时间  进程启动以来占用的 CPU 总时长 (精确到 0.01s)
COMMAND   命令名        启动该进程的命令 (按 c 可切换显示完整命令行)</code></pre>
<p>进程状态码（S列）</p>
<pre class="language-markup"><code>状态        字母    含义
Running     R       正在运行或可运行
Sleeping    S       可中断睡眠 (等待事件，最常见)
Disk sleep  D       不可中断睡眠 (等 IO，杀不掉) ⚠️
Stopped     T       被暂停/停止
Zombie      Z       僵尸进程
Dead        X       已死
高优先级    &lt;       nice 值为负
低优先级    N       nice 值为正
多线程      l       多线程进程 (小写 L)
前台进程组  +       位于前台进程组</code></pre>
<h3>8、VIRT/RES/SHR的区别</h3>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 33.3534%;"><col style="width: 33.3534%;"><col style="width: 33.3534%;"></colgroup>
<tbody>
<tr>
<td>字段</td>
<td>含义</td>
<td>是否真实占用物理内存</td>
</tr>
<tr>
<td>VIRT</td>
<td>虚拟地址空间总量</td>
<td>不是</td>
</tr>
<tr>
<td>RES</td>
<td>实际驻留物理内存</td>
<td>是（排查内存看这个）</td>
</tr>
<tr>
<td>SHR</td>
<td>其中共享的部分</td>
<td>部分可享</td>
</tr>
</tbody>
</table>
<p>排查内存泄漏看RES，⽽不是VIRT（VIRT往往很⼤但虚⾼）。</p>
<p>9、为什么要详细了解top输出</p>
<p>如果部署在机器的服务器发⽣了响应慢或者访问不了的情况，除了服务本⾝的问题，也有可能是机器本⾝的性能问题。要学会通过这些输出指标来判断是哪⾥出了问题。</p>
<pre class="language-markup"><code>现象                  可能原因            关注字段
系统卡顿，load 高但 CPU 空闲   IO 瓶颈            wa 高
应用响应慢，us 高       代码耗 CPU          %CPU 高的进程
内存告急              内存泄漏/不足       avail Mem 小、swap used 增长
云主机性能忽高忽低     资源被抢占          st 高
系统调用频繁          上下文切换多        sy 高</code></pre>
<h2>七、控制进程</h2>
<pre class="language-markup"><code>命令             说明
kill PID         发送 SIGTERM(15)，优雅退出（默认）
kill -9 PID      发送 SIGKILL(9)，强制杀死（不可捕获）
kill -l          列出所有信号
pkill 名称       按名称杀进程
killall 名称     杀掉所有同名进程
pkill -u 用户名  杀掉某用户所有进程</code></pre>
<pre class="language-markup"><code># 线查看进程的pid
ps -ef | grep nginx

# 杀死进程
kill 1234                   # 优雅终止
kill -9 1234                # 强制杀死
pkill -f "python app.py"    # 按完整命令行匹配杀
killall nginx</code></pre>
<h2>八、前台与后台进程管理</h2>
<h3>1、什么是前/后台进程</h3>
<p>前台进程：当前终端（terminal）中运⾏，占⽤终端输⼊输出的进程</p>
<ul>
<li>特点：
<ul>
<li>⽤⼾可以直接与其交互（输⼊命令、查看输出）</li>
<li>会阻塞终端，⽆法执⾏其他命令</li>
<li>例如：直接运⾏vim 、top 、ping 等命令</li>
</ul>
</li>
</ul>
<p>后台进程：在后台运行，不占用终端输入输出的进程</p>
<ul>
<li>定义：在后台运行，不占用终端输入输出的进程</li>
<li>特点：
<ul>
<li>用户无法直接交互，但可用继续使用终端</li>
<li>通常⽤于耗时任务</li>
<li>例如： ./script.sh &amp;</li>
</ul>
</li>
</ul>
<p>相关命令：</p>
<pre class="language-markup"><code>命令      作用
&amp;         启动时直接后台运行
Ctrl+Z    挂起当前前台进程
bg        将挂起进程转入后台继续运行
fg        将后台进程调回前台
jobs      查看作业列表
nohup     忽略挂起信号运行
disown    从作业表中移除，脱离 shell</code></pre>
<h3>2、前后台进程调度</h3>
<p>步骤1：准备⼀个测试脚本</p>
<pre class="language-markup"><code>[root@ops ~]# cat qiantai.sh
#!/bin/bash
# 演示前台进程可被 Ctrl+C 中断

echo "=========================================="
echo "前台进程中断演示"
echo "进程 PID: $$"
echo "=========================================="

echo ""

# 捕获 SIGINT，演示信号处理
trap 'echo ""; echo "[捕获到 Ctrl+C] 收到 SIGINT 信号，正在清理..."; exit 0' INT

echo "我是一个前台进程，正在无限循环运行"
echo "请按 Ctrl+C 尝试中断我"
echo ""

count=0
while true; do
    count=$((count + 1))
    echo "运行中... 第 $count 次循环 (PID: $$)"
    sleep 1
done</code></pre>
<p>步骤2：添加⼀个执⾏权限并执⾏</p>
<pre class="language-markup"><code>chmod +x qiantai.sh
./qiantai.sh
# 按 Ctrl+C 观察中断效果</code></pre>
<p>步骤3：将程序调度到后台</p>
<pre class="language-markup"><code>ctrl + z 挂起
[1]+  Stopped                 sh qiantai.sh

# 查看挂起的任务
[root@localhost ~]# jobs -l
[1]+  1459 Stopped             sh qiantai.sh

# 把任务放到后台
[root@localhost ~]# bg %1

# 把后台任务放到前台
[root@localhost ~]# fg %1</code></pre>
<p>步骤4：直接把任务放到后台运⾏</p>
<pre class="language-markup"><code>sh qiantai.sh &amp; </code></pre>
<h3>3、忽略SIGHUP信号</h3>
<p>当⽤⼾关闭终端或退出登录时，后台进程会收到SIGHUP⽽被杀死。若希望进程持续运⾏（如⻓时间任务、服务），就需要忽略该信号。</p>
<pre class="language-markup"><code># 2&gt;&amp;1 是把输出重定向为空

nohup sh qiantai.sh &gt; output.log 2&gt;&amp;1 &amp; </code></pre>
<h2>九、机器性能排查速查表</h2>
<pre class="language-markup"><code>现象                          可能原因            关注字段
系统卡顿，load 高但 CPU 空闲   IO 瓶颈            wa 高
应用响应慢，us 高              代码耗 CPU         %CPU 高的进程
内存告急                      内存泄漏/不足      avail Mem 小、swap used 增长
云主机性能忽高忽低             资源被抢占         st 高
进程杀不死                    等 IO / 僵尸       状态 D / Z
系统调用频繁                  上下文切换多       sy 高</code></pre>
<p>&nbsp;</p>]]></description>
    <pubDate>Tue, 10 Nov 2026 16:05:01 +0800</pubDate>
    <dc:creator>小曦窝</dc:creator>
    <guid>https://m.hanshao.top/?post=28</guid>
</item>
<item>
    <title>系统引导流程系统拯救</title>
    <link>https://m.hanshao.top/?post=27</link>
    <description><![CDATA[<h2>&nbsp;</h2>
<h2>一、Linux系统开机流程</h2>
<p><img src="/content/uploadfile/202611/d2b51794294183.png" alt="image.png"></p>
<pre class="language-markup"><code>阶段   名称              作用
1      加电自检 (POST)   BIOS 检测 CPU、内存、硬盘等硬件
2      BIOS 引导         按启动顺序找到可引导设备
3      MBR 引导          读取硬盘第 0 扇区 (446 字节引导代码)
4      GRUB 引导         加载 GRUB，显示菜单，加载内核
5      加载内核          内核解压、初始化硬件驱动
6      initramfs         临时根文件系统，加载必要驱动挂载真正根分区
7      init/systemd      PID 1 进程，启动系统服务
8      登录              进入登录界面或命令行</code></pre>
<p>①加电自检 (POST)<br>&bull; 主板通电后，BIOS/UEFI 固件运行。<br>&bull; 检测 CPU、内存、硬盘、键盘等关键硬件。<br>&bull; 自检通过后，按启动顺序 (Boot Order) 寻找可引导设备（硬盘、U盘、光驱、网络）。</p>
<p>②BIOS 引导阶段<br>&bull; BIOS 读取启动设备的第一个扇区 (512 字节)，即 MBR。<br>&bull; 检查末尾两字节是否为 55 AA (魔数)，确认是引导扇区。<br>&bull; 将控制权交给 MBR 中的引导代码。</p>
<p>③MBR 引导阶段<br>&bull; MBR 前 446 字节是引导加载程序代码。<br>&bull; 它负责找到并加载 GRUB 第二阶段 (通常在 /boot 分区)。</p>
<p>④GRUB 引导阶段<br>&bull; GRUB2 分多个阶段：<br>&nbsp; &nbsp; ◦ boot.img (MBR 中) &rarr; core.img (MBR 后空隙) &rarr; /boot/grub2/ 下的模块。<br>&bull; 显示启动菜单 (可选择内核、数据模式等)。<br>&bull; 读取 /boot/grub2/grub.cfg 配置文件。<br>&bull; 加载选定的内核 (vmlinuz) 和 initramfs 到内存。</p>
<p>⑤加载内核<br>&bull; 内核解压自身，初始化内存管理、进程调度、驱动等。<br>&bull; 挂载 initramfs (临时根文件系统) 作为初始根。</p>
<p>⑥initramfs 阶段<br>&bull; 一个大型临时文件系统，包含加载真正根分区所需的驱动 (如 RAID、LVM、加密)。<br>&bull; 加载驱动后，挂载真正的根文件系统 /。<br>&bull; 切换到真正的根，启动 /sbin/init。</p>
<p>⑦init / systemd 阶段<br>&bull; 传统 SysVinit: 读取 /etc/inittab，按运行级别启动服务。<br>&bull; 现代 systemd: PID1，读取 /etc/systemd/system/default.target，并行启动服务。</p>
<p>&bull;运行级别对应关系：</p>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 33.3534%;"><col style="width: 33.3534%;"><col style="width: 33.3534%;"></colgroup>
<tbody>
<tr>
<td>运行级别</td>
<td>systemd target</td>
<td>含义</td>
</tr>
<tr>
<td>0</td>
<td>poweroff.target</td>
<td>关机</td>
</tr>
<tr>
<td>1</td>
<td>rescue.target</td>
<td>单用户</td>
</tr>
<tr>
<td>3</td>
<td>multi-user.target</td>
<td>多用户命令行</td>
</tr>
<tr>
<td>5</td>
<td>graphical.target</td>
<td>图形界面</td>
</tr>
<tr>
<td>6</td>
<td>reboot.target</td>
<td>重启</td>
</tr>
</tbody>
</table>
<p>⑧登录阶段</p>
<p>&bull;启动getty/显⽰管理器，提供登录界⾯。<br>&bull;⽤⼾登录后启动shell和⽤⼾环境</p>
<h2>二、认识MBR分区</h2>
<h3>1、认识MBR</h3>
<p>MBR（MasterBootRecord，主引导记录）是硬盘第⼀个扇区（512字节），位于0 柱⾯ 0&nbsp;磁头1&nbsp;扇区。它是传统BIOS启动⽅式的核⼼。</p>
<h3>2、MBR结构</h3>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 24.9399%;"><col style="width: 24.9399%;"><col style="width: 24.9399%;"><col style="width: 24.9399%;"></colgroup>
<tbody>
<tr>
<td>区域</td>
<td>偏移</td>
<td>大小</td>
<td>作用</td>
</tr>
<tr>
<td>引导代码</td>
<td>0x000</td>
<td>446字节</td>
<td>引导加载程序（如GRUB stage1）</td>
</tr>
<tr>
<td>分区表</td>
<td>0x1BE</td>
<td>64字节</td>
<td>4个分区表项，每项16字节</td>
</tr>
<tr>
<td>结束标志</td>
<td>0x1FE</td>
<td>2字节</td>
<td>固定为55 AA</td>
</tr>
</tbody>
</table>
<pre class="language-markup"><code>+---------------------------------------+
|    引导代码 (446 字节)    |  0x000 ~ 0x1BD
+---------------------------------------+
|    分区表项 1 (16 字节)   |  0x1BE
|    分区表项 2 (16 字节)   |
|    分区表项 3 (16 字节)   |
|    分区表项 4 (16 字节)   |
+---------------------------------------+
|    结束标志 55 AA (2 字节) |  0x1FE
+---------------------------------------+</code></pre>
<h3>3、MBR的限制</h3>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.8798%;"><col style="width: 49.8798%;"></colgroup>
<tbody>
<tr>
<td>限制</td>
<td>说明</td>
</tr>
<tr>
<td>最多4个主分区</td>
<td>分区表只有4项</td>
</tr>
<tr>
<td>最大2TB磁盘</td>
<td>用32位LBA寻址，2^32 &times; 512B=2TB</td>
</tr>
<tr>
<td>无备份</td>
<td>分区表仅一份，损坏即丢失</td>
</tr>
<tr>
<td>无校验</td>
<td>没有CRC校验，容易出错</td>
</tr>
</tbody>
</table>
<p>扩展分区解决⽅案：<br>&bull;当需要超过4个分区时，⽤⼀个扩展分区代替主分区。<br>&bull;扩展分区内可再划分多个逻辑分区。<br>&bull;结构：3主分区+1扩展分区（内含N个逻辑分区）。</p>
<h2>三、mbr分区拯救</h2>
<p><img src="/content/uploadfile/202611/d2b51794295577.png" alt="image.png"></p>
<p>如果MBR引导记录损坏，那么操作系统将⽆法正常启动，所以，我们要需要提前备份引导记录，在MBR损坏时，使⽤引导记录恢复。</p>
<p>步骤1：备份引导记录，在第⼀个扇区的前512个字节</p>
<pre class="language-markup"><code># 格式化一块数据盘，然后挂载到 /mnt 下
mount /dev/sdb1 /mnt/

# 将sda里面的前512字节移动到mnt下
dd if=/dev/sda of=/mnt/sda.mbr.bak count=1 bs=512

# 输出规范的十六进制和 ASCII码 查看前512字节
hexdump -C -n512 /dev/sda

# 输出规范的十六进制和ASCII码 查看备份的引导记录
hexdump -C /mnt/sda.mbr.bak</code></pre>
<p>步骤2：模拟损坏mbr分区</p>
<pre class="language-markup"><code>dd if=/dev/zero of=/dev/sda count=1 bs=512

#重启
reboot</code></pre>
<p>步骤3：重启之后进⼊到这个⻚⾯，选择第三项(处理重⼤故障)</p>
<p><img src="/content/uploadfile/202611/d2b51794295960.png" alt="image.png"></p>
<p>步骤4：选择第⼆项(拯救)</p>
<p><img src="/content/uploadfile/202611/d2b51794295974.png" alt="image.png"></p>
<p>步骤5：选择第⼀项，进⼊到shell</p>
<p><img src="/content/uploadfile/202611/d2b51794295994.png" alt="image.png"></p>
<p>步骤6：将备份的mbr进到导⼊到/dev/sda的前512字节，重启</p>
<p><img src="/content/uploadfile/202611/d2b51794296014.png" alt="image.png"></p>
<h2>四、root密码破解</h2>
<p>步骤1：在系统启动出现下图界⾯时，快速按上下键，选择第⼀项，然后输⼊字⺟⼩写 "e"，进⼊引导菜单的编辑模式</p>
<p><img src="/content/uploadfile/202611/d2b51794296051.png" alt="image.png"></p>
<p>步骤2：找到Linux16这⼀⾏，在最后添加init=/bin/sh，告诉系统进⼊到单⽤⼾模式</p>
<p><img src="/content/uploadfile/202611/d2b51794296077.png" alt="image.png"></p>
<p>步骤3：再按CTRL+X键，启动系统，开始运⾏，之后会出现下图</p>
<p><img src="/content/uploadfile/202611/d2b51794296089.png" alt="image.png"></p>
<p>步骤4：然后输⼊"mount-oremount,rw/"指令，再回⻋，该命令表⽰⽤读写⽅式重新挂载特定⽬录，这⾥是根⽬录（/），再输⼊"passwd"进⾏密码的修改,会输⼊两次密码，第⼀次新密码，第⼆次重新输⼊密码</p>
<p><img src="/content/uploadfile/202611/d2b51794296110.png" alt="image.png"></p>
<p>步骤5：更新password⽂件会导致SELinux安全上下⽂⽂件错误，以下命令在下次系统引导前重新标记所有⽂件: touch/.autorelabel。最后输⼊"exec/sbin/init"命令，回⻋,该命令表⽰让它正常启动</p>
<p><img src="/content/uploadfile/202611/d2b51794296130.png" alt="image.png"></p>
<p>操作步骤：</p>
<ul>
<li>开机出现centoslinux界⾯时按⼩写字⺟e</li>
<li>输⼊init=/bin/sh</li>
<li>ctrl + x</li>
<li>mount-oremount,rw/</li>
<li>passwd</li>
<li>touch /.autorelabel</li>
<li>exec /sbin/init</li>
</ul>]]></description>
    <pubDate>Tue, 10 Nov 2026 14:58:22 +0800</pubDate>
    <dc:creator>小曦窝</dc:creator>
    <guid>https://m.hanshao.top/?post=27</guid>
</item>
<item>
    <title>Linux计划任务管理</title>
    <link>https://m.hanshao.top/?post=26</link>
    <description><![CDATA[<h2>一、为什么需要计划任务</h2>
<p>核⼼⽬的：让重复性、定时性的⼯作⾃动化，⽆需⼈⼯值守。</p>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.9412%;"><col style="width: 49.9412%;"></colgroup>
<tbody>
<tr>
<td>典型场景</td>
<td>说明</td>
</tr>
<tr>
<td>定时备份</td>
<td>每天凌晨备份数据库/文件</td>
</tr>
<tr>
<td>日志清理</td>
<td>定期清理过期日志，防止磁盘写满</td>
</tr>
<tr>
<td>数据同步</td>
<td>定时同步数据到远程服务器</td>
</tr>
<tr>
<td>监控巡检</td>
<td>定期检查服务器状态、发送报告</td>
</tr>
<tr>
<td>报表生成</td>
<td>每天生成统计报表并发邮件</td>
</tr>
<tr>
<td>证书续期</td>
<td>定期更新SSL证书</td>
</tr>
<tr>
<td>系统维护</td>
<td>定时更新缓存、清理临时文件</td>
</tr>
</tbody>
</table>
<p>Linux提供两类计划任务：</p>
<table style="border-collapse: collapse; display: table; width: 100%; height: 138.4px;" border="1"><colgroup><col style="width: 33.3534%;"><col style="width: 33.3534%;"><col style="width: 33.3534%;"></colgroup>
<tbody>
<tr style="height: 34.6px;">
<td>类型</td>
<td>工具</td>
<td>特点</td>
</tr>
<tr style="height: 34.6px;">
<td>一次性任务</td>
<td>at</td>
<td>只执行一次，指定未来某个时间点</td>
</tr>
<tr style="height: 34.6px;">
<td>周期性任务</td>
<td>cron</td>
<td>按固定周期重复执行</td>
</tr>
<tr style="height: 34.6px;">
<td>现代定时器</td>
<td>systemd timer</td>
<td>systemd提供的定时机制，功能更强</td>
</tr>
</tbody>
</table>
<h2>二、一次性任务</h2>
<p>作⽤：在未来某个时间点执⾏⼀次任务，执⾏完就结束。</p>
<pre class="language-markup"><code>yum install -y at
systemctl start atd      #启动atd服务
systemctl enable atd     #开机自启
systemctl status atd     #查看状态</code></pre>
<p>常用命令：</p>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.8798%;"><col style="width: 49.8798%;"></colgroup>
<tbody>
<tr>
<td>命令</td>
<td>说明</td>
</tr>
<tr>
<td>at 时间</td>
<td>交互式创建一次性任务（Ctrl+D结束输入）</td>
</tr>
<tr>
<td>at -f 脚本文件 时间</td>
<td>从文件读取任务</td>
</tr>
<tr>
<td>at -l 或 atq</td>
<td>列出待执行任务</td>
</tr>
<tr>
<td>at -d 编号 或 atrm 编号</td>
<td>删除指定任务</td>
</tr>
<tr>
<td>at -c 编号</td>
<td>查看任务详细内容</td>
</tr>
<tr>
<td>batch</td>
<td>系统空闲时执行（负载低于0.8时）</td>
</tr>
</tbody>
</table>
<p>语法格式：</p>
<pre class="language-markup"><code>at 15:30
at&gt; echo "hello" &gt;&gt; /tmp/test.log
at&gt; &lt;Ctrl+D&gt;

# 查看有什么任务
atq
at -l

# 查看具体任务，4为编号
at -c 4

# 删除任务
at -d 4</code></pre>
<p>时间格式（灵活多样）：</p>
<pre class="language-markup"><code># 今天 15:30 (若已过则明天)
at 15:30

# 明天 15:30
at 15:30 tomorrow

# 指定日期
at 15:30 2026-10-10

# 5 分钟后
at now + 5 minutes

# 2 小时后
at now + 2 hours

# 下周上午 10 点
at 10:00 AM next week

# 午夜
at midnight

# 下午 4 点
at teatime</code></pre>
<h2>三、周期性任务</h2>
<p>cron 是Linux中最常⽤的周期性任务调度⼯具，由⼀个名为crond的守护进程驱动，该进程每分钟检查⼀次所有⽤⼾的任务表，判断是否有需要执⾏的任务。</p>
<p>与at 的⼀次性任务不同，crontab 中的任务会按照预设的时间规则反复执⾏。</p>
<p>核心命令：</p>
<table style="border-collapse: collapse; display: table; width: 100%;" border="1"><colgroup><col style="width: 49.8798%;"><col style="width: 49.8798%;"></colgroup>
<tbody>
<tr>
<td>命令</td>
<td>作用</td>
</tr>
<tr>
<td>crontab -e</td>
<td>编辑当前用户的定时任务表</td>
</tr>
<tr>
<td>crontab -l</td>
<td>列出当前用户的所有任务</td>
</tr>
<tr>
<td>crontab -r</td>
<td>删除当前用户的所有任务（慎用）</td>
</tr>
<tr>
<td>crontab -e -u username</td>
<td>编辑指定用户的任务（需root权限）</td>
</tr>
</tbody>
</table>
<h2>四、crontab时间语法</h2>
<p>crontab每行任务的格式为5共和时间字段+命令，字段之间用空格分隔</p>
<pre class="language-markup"><code>* * * * * command_to_execute
│ │ │ │ │
│ │ │ │ └── 星期 (0-7, 0和7都代表周日)
│ │ │ └──── 月份 (1-12)
│ │ └────── 日期 (1-31)
│ └──────── 小时 (0-23)
└────────── 分钟 (0-59)</code></pre>
<p>特殊符号：</p>
<pre class="language-markup"><code>符号   含义          示例
*      任意值        * * * * * = 每分钟
,      枚举多个值    1,15,30 * * * * = 1分、15分、30分
-      范围          0 9-17 * * * = 9点到17点整
/      步长/间隔     */5 * * * * = 每5分钟</code></pre>
<p>常⽤⽰例：</p>
<pre class="language-markup"><code>表达式            含义
*/15 * * * *      每 15 分钟
0 2 * * *         每天凌晨 2:00
0 9 * * 1         每周一 9:00
0 0 1 * *         每月 1 日 0:00
0 8-18 * * 1-5    工作日 8:00-18:00 每小时</code></pre>
<p>特殊关键字：</p>
<pre class="language-markup"><code>关键字      等价写法        含义
@reboot     &mdash;               系统启动时执行一次
@daily      0 0 * * *       每天
@hourly     0 * * * *       每小时
@weekly     0 0 * * 0       每周
@monthly    0 0 1 * *       每月</code></pre>
<h2>五、任务日志查看</h2>
<p>cron⽇志只记录任务是否被调度，不记录脚本执⾏结果（成败需在脚本内⾃⾏输出）。</p>
<p>不同发⾏版的⽇志位置：</p>
<pre class="language-markup"><code>发行版          默认路径               查看方式
CentOS/RHEL     /var/log/cron          cat /var/log/cron 或 tail -f /var/log/cron
Ubuntu/Debian   混在 /var/log/syslog 中  grep CRON /var/log/syslog</code></pre>
<p>⾃定义任务⽇志（最推荐）：</p>
<p>在crontab任务中重定向输出，直接记录脚本的运⾏结果：</p>
<pre class="language-markup"><code>*/5 * * * * /path/to/script.sh &gt;&gt; /var/log/my_task.log 2&gt;&amp;1</code></pre>
<p>&gt;&gt;追加写⼊，2&gt;&amp;1&nbsp;将错误输出合并到同⼀⽂件。</p>
<p>定义定时任务的路径：</p>
<pre class="language-markup"><code>位置                      类型      格式特点                      适用场景
crontab -e                用户级    5 时间字段 + 命令             当前用户的个人任务
/var/spool/cron/用户名    用户级    同上（不直接编辑）            crontab -e 的实际存储文件
/etc/crontab              系统级    6 字段（多一个用户）          系统管理员统一定义
/etc/cron.d/              系统级    6 字段（多一个用户）          软件包/服务安装任务（推荐）
/etc/cron.hourly/         目录级    放可执行脚本                  每小时运行
/etc/cron.daily/          目录级    放可执行脚本                  每天运行
/etc/cron.weekly/         目录级    放可执行脚本                  每周运行
/etc/cron.monthly/        目录级    放可执行脚本                  每月运行
/etc/anacrontab           系统级    补跑机制                      关机期间错过的任务（RHEL 系）
systemd timer             系统级    .timer 单元                   现代 systemd 系统</code></pre>
<h2>六、常见计划任务案例</h2>
<h3>1、文件备份类</h3>
<pre class="language-markup"><code># 每天凌晨 2 点备份网站目录
0 2 * * * tar -czf /backup/web_$(date +\%Y\%m\%d).tar.gz /var/www/html &gt;&gt; /var/log/backup.log 2&gt;&amp;1

# 每周日 3 点备份数据库
0 3 * * 0 mysqldump -u root -p'密码' mydb | gzip &gt; /backup/db_$(date +\%Y\%m\%d).sql.gz</code></pre>
<p>注意：crontab中&nbsp;% 有特殊含义（表⽰换⾏），必须转义为&nbsp;\% ，否则会被截断。</p>
<p>更推荐的做法&mdash;&mdash;把逻辑写进脚本，crontab只调⽤：</p>
<pre class="language-markup"><code>vim /opt/scripts/backup_web.sh
#!/bin/bash
DATE=$(date +%Y%m%d)
tar -czf /backup/web_${DATE}.tar.gz /var/www/html
find /backup -name "web_*.tar.gz" -mtime +7 -delete    # 只保留 7 天

crontab -e
...
0 2 * * * /opt/scripts/backup_web.sh &gt;&gt; /var/log/backup.log 2&gt;&amp;1</code></pre>
<h3>2、日志清理类</h3>
<pre class="language-markup"><code># 每天凌晨清理 7 天前的日志
0 0 * * * find /var/log/myapp -name "*.log" -mtime +7 -delete

# 每小时清理超过 1G 的大日志 (清空而非删除)
0 * * * * find /var/log -name "*.log" -size +1G -exec truncate -s 0 {} \;</code></pre>
<p>⽤&nbsp;truncate -s 0 清空⽽不是删除，避免程序句柄失效导致磁盘空间不释放。</p>
<h3>3、系统监控类</h3>
<pre class="language-markup"><code># 每 5 分钟检测服务，挂了自动重启
vim /opt/scripts/check_nginx.sh
#!/bin/bash
if ! systemctl is-active --quiet nginx; then
    systemctl restart nginx
    echo "$(date) nginx restarted" &gt;&gt; /var/log/nginx_restart.log
fi

crontab -e
*/5 * * * * /opt/scripts/check_nginx.sh

# 每 10 分钟记录系统负载
*/10 * * * * uptime &gt;&gt; /var/log/load.log</code></pre>
<h3>4、数据同步类</h3>
<pre class="language-markup"><code># 每 30 分钟同步文件到远程
*/30 * * * * rsync -avz --delete /data/ user@192.168.1.100:/backup/data/ &gt;&gt; /var/log/rsync.log 2&gt;&amp;1

# 每天 1 点同步到对象存储 (如 AWS S3)
0 1 * * * aws s3 sync /data s3://mybucket/data --delete &gt;&gt; /var/log/s3_sync.log 2&gt;&amp;1</code></pre>
<h3>5、定时⼀次性任务（at）</h3>
<pre class="language-markup"><code># 30 分钟后自动关机
echo "shutdown -h now" | at now + 30 minutes

# 今晚 23 点执行一次数据迁移
at 23:00
at&gt; /opt/scripts/migrate.sh
at&gt; &lt;Ctrl+D&gt;

# 明天早上 8 点发提醒
echo "echo '记得提交周报' | mail -s '提醒' me@example.com" | at 8:00 tomorrow</code></pre>
<h3>6、开机与重启类</h3>
<pre class="language-markup"><code># 系统启动后自动执行初始化脚本
@reboot /opt/scripts/init_service.sh &gt;&gt; /var/log/init.log 2&gt;&amp;1

# 每周一早上重启服务 (业务低峰期)
0 5 * * 1 systemctl restart myapp</code></pre>
<p>&nbsp;</p>]]></description>
    <pubDate>Tue, 10 Nov 2026 14:16:18 +0800</pubDate>
    <dc:creator>小曦窝</dc:creator>
    <guid>https://m.hanshao.top/?post=26</guid>
</item>
<item>
    <title>LVM逻辑卷管理</title>
    <link>https://m.hanshao.top/?post=25</link>
    <description><![CDATA[<p>LVM逻辑卷（LogicalVolumeManager，逻辑卷管理器）是Linux中⼀种在物理磁盘和⽂件系统之间增加抽象层的存储管理机制。</p>
<p><a href="/content/uploadfile/202611/d2b51794037068.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794037068.png" alt="image.png"></a></p>
<h2>一、逻辑卷的基本概念</h2>
<p>LVM由三层结构组成，从下到上依次是：</p>
<pre>&nbsp;</pre>
<p>1. 物理卷（PV，Physical Volume）</p>
<p>LVM 的最底层，是实际的物理存储单元，可以是一整块磁盘（如 /dev/sdb），也可以是一个分区<br>（如 /dev/sdb1）。使用前需用 pvcreate 初始化，初始化会在设备上写入 LVM 元数据。物理<br>卷被切分成固定大小的基本单元 PE（Physical Extent）。</p>
<p>2. 卷组（VG，Volume Group）</p>
<p>由一个或多个物理卷组成，是 LVM 的"存储池"。用 vgcreate 创建。卷组把各物理卷的 PE 统一管<br>理，形成可分配的空间。一个卷组可以包含多块磁盘，容量是它们之和。</p>
<p>3. 逻辑卷（LV，Logical Volume）</p>
<p>从卷组中划分出来的可用空间，是最终创建文件系统并挂载使用的对象。用 lvcreate 创建。逻辑<br>卷由卷组中的 PE 组成，大小可动态增减。逻辑卷上可像普通分区一样 mkfs、mount 使用。</p>
<p>PE（Physical Extent）：物理卷被划分的最小存储单元，默认 4MB。卷组按 PE 为单位分配空间给逻<br>辑卷。</p>
<p><a href="/content/uploadfile/202611/d2b51794037179.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794037179.png" alt="image.png"></a></p>
<p>三层关系总结：</p>
<pre class="language-markup"><code>物理磁盘/分区  &rarr;  物理卷 PV  &rarr;  卷组 VG  &rarr;  逻辑卷 LV  &rarr;  文件系统
/dev/sdb1        pvcreate        vgcreate        lvcreate        mkfs
</code></pre>
<p>常⽤命令对应：</p>
<pre class="language-markup"><code>| 功能   | 物理卷管理   | 卷组管理   | 逻辑卷管理   |
|--------|--------------|------------|--------------|
| 扫描   | pvscan       | vgscan     | lvscan       |
| 创建   | pvcreate     | vgcreate   | lvcreate     |
| 显示   | pvdisplay    | vgdisplay  | lvdisplay    |
| 删除   | pvremove     | vgremove   | lvremove     |
| 扩容   |              | vgextend   | lvextend     |
| 缩容   |              | vgreduce   | lvreduce     |
</code></pre>
<h2>二、配置与管理逻辑卷</h2>
<p>将三块磁盘使⽤lvm统⼀管理。测试演⽰，先将两块盘纳⼊逻辑卷管理，然后演⽰扩容添加最后⼀块盘</p>
<p>步骤1：添加硬盘</p>
<p><a href="/content/uploadfile/202611/d2b51794037375.png" target="_blank" rel="noopener"><img src="/content/uploadfile/202611/d2b51794037375.png" alt="image.png"></a></p>
<p>步骤2：查看硬盘</p>
<pre class="language-markup"><code>[root@localhost /]# fdisk -l</code></pre>
<p>步骤3：创建物理卷</p>
<pre class="language-markup"><code># 创建物理卷
[root@localhost ~]# pvcreate /dev/sdb /dev/sdc /dev/sdd
  Physical volume "/dev/sdb" successfully created.
  Physical volume "/dev/sdc" successfully created.
  Physical volume "/dev/sdd" successfully created.

# 查看物理卷
[root@localhost ~]# pvscan
  PV /dev/sda2   VG centos          lvm2 [&lt;19.00 GiB / 0    free]
  PV /dev/sdd                      lvm2 [20.00 GiB]
  PV /dev/sdc                      lvm2 [20.00 GiB]
  PV /dev/sdb                      lvm2 [20.00 GiB]
  Total: 4 [&lt;79.00 GiB] / in use: 1 [&lt;19.00 GiB] / in no VG: 3 [60.00 GiB]

# 删除物理卷
[root@localhost ~]# pvremove /dev/sdd
  Labels on physical volume "/dev/sdd" successfully wiped.
</code></pre>
<p>步骤4：创建卷组</p>
<pre class="language-markup"><code>[root@localhost ~]# vgcreate vg0 /dev/sdb /dev/sdc
  Volume group "vg0" successfully created

[root@localhost ~]# vgs
  VG      #PV #LV #SN Attr   VSize   VFree
  centos    1   2   0 wz--n- &lt;19.00g      0
  vg0       2   0   0 wz--n-  39.99g  39.99g

[root@localhost ~]# vgdisplay vg0
  --- Volume group ---
  VG Name               vg0
  System ID
  Format                lvm2
  Metadata Areas        2
  Metadata Sequence No  1
  VG Access             read/write
  VG Status             resizable
  MAX LV                0
  Cur LV                0
  Open LV               0
  Max PV                0
  Cur PV                2
  Act PV                2
  VG Size               39.99 GiB
  PE Size               4.00 MiB
  Total PE              10238
  Alloc PE / Size       0 / 0
  Free  PE / Size       10238 / 39.99 GiB
  VG UUID               9X8LAq-sYjC-bGg9-d9tr-HHvh-Txkd-GD0f8u
</code></pre>
<p>步骤5：创建逻辑卷</p>
<pre class="language-markup"><code># 从vg0卷组中拿出10G，添加到逻辑卷
[root@localhost ~]# lvcreate -L 10G -n lv0 vg0
  Logical volume "lv0" created.
</code></pre>
<p>步骤6：格式化⽂件系统为xfs格式</p>
<pre class="language-markup"><code># 格式化
mkfs.xfs /dev/vg0/lv0

# 查看文件系统类型
lsblk -f /dev/sdb
</code></pre>
<p>步骤7：创建⽬录并挂载并添加开机启动</p>
<pre class="language-markup"><code># 创建挂载点
mkdir /data1

# 挂载到 /data1
mount -t xfs /dev/vg0/lv0 /data1/
tail -n1 /etc/mtab

# 添加到开机启动
tail -n1 /etc/mtab &gt;&gt; /etc/fstab
</code></pre>
<h2>三、逻辑卷扩容缩容操作</h2>
<p>1、卷组扩容</p>
<pre class="language-markup"><code># 查看目前卷组空间
vgdisplay vg0

# 查看物理卷
pvscan

# 步骤1：创建物理卷
pvcreate /dev/sdd

# 步骤2：添加到现有的卷组
vgextend vg0 /dev/sdd

# 步骤3：查看卷组
vgdisplay vg0
</code></pre>
<p>2、逻辑卷扩容</p>
<pre class="language-markup"><code># 查看逻辑卷空间
lvdisplay /dev/vg0/lv0

# 目前是10G空间，扩容5G
lvextend -L +5G /dev/vg0/lv0

# 查看目前空间没有括起来
df -hT

# 如果文件系统是 xfs格式，使用 xfs_growfs 刷新文件系统
# 如果文件系统是 ext4格式，使用  resize2fs /dev/vg0/lv0
xfs_growfs /dev/vg0/lv0

# 查看磁盘
df -hT
</code></pre>
<h2>四、文件系统维护命令</h2>
<ul>
<li>查看磁盘与 inode 使用（df、du、lsblk、blkid）</li>
<li>磁盘分区（fdisk、gdisk、parted）</li>
<li>创建文件系统（mkfs）</li>
<li>挂载与卸载（mount、umount）</li>
<li>开机自动挂载（/etc/fstab）</li>
<li>文件系统检查与修复（fsck、xfs_repair）</li>
<li>查看与调整文件系统参数（dumpe2fs、tune2fs）</li>
<li>调整文件系统大小（resize2fs、xfs_growfs）</li>
<li>交换分区管理（swap）</li>
</ul>
<p>&nbsp;</p>
<p>&nbsp;</p>]]></description>
    <pubDate>Sat, 07 Nov 2026 15:36:59 +0800</pubDate>
    <dc:creator>小曦窝</dc:creator>
    <guid>https://m.hanshao.top/?post=25</guid>
</item>
</channel>
</rss>