creativity Hexo http://zncddh.cn/ All rights reserved 2026, creativity 学习记录与日常随笔 dream 2026-04-24T10:52:46.432Z creativity Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment

]]> http://zncddh.cn/2026/04/24/hello-world/ 2026-04-24T10:52:46.432Z Welcome to Hexo! This is your very first post. Check documentation]]> Hello World 2026-04-24T10:52:46.432Z creativity 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# Git 学习笔记

## 一、Git 是什么？

Git 是一个**版本控制工具**，主要用来管理代码的修改历史。

简单理解：

> Git 可以帮我们记录代码的每一次修改，并且可以在需要时回到之前的版本。

Git 常用于：

- 保存代码历史版本
- 回退错误修改
- 多人协作开发
- 创建分支开发新功能
- 将代码上传到 GitHub、GitLab、Gitee 等远程仓库

---

## 二、Git 的基本工作流程

Git 的日常使用流程可以概括为：

```text
工作区 -> 暂存区 -> 本地仓库 -> 远程仓库

对应命令：

1
2
3
git add .
git commit -m "提交说明"
git push

1. 工作区

工作区就是我们平时写代码、修改文件的地方。

例如：

1
2
3
index.html
style.css
main.js

这些文件所在的项目目录就是工作区。

2. 暂存区

暂存区用于临时保存准备提交的修改。

把文件加入暂存区：

1
git add 文件名

添加所有修改：

1
git add .

3. 本地仓库

本地仓库保存已经提交的版本记录。

提交代码：

1
git commit -m "提交说明"

4. 远程仓库

远程仓库一般指 GitHub、GitLab、Gitee 上的仓库。

推送到远程仓库：

1
git push

三、安装 Git

Windows

下载地址：

1
https://git-scm.com/

安装完成后，打开 Git Bash 或终端，输入：

1
git --version

如果能看到版本号，说明安装成功。

macOS

查看是否已安装：

1
git --version

使用 Homebrew 安装：

1
brew install git

Linux

Ubuntu / Debian：

1
2
sudo apt update
sudo apt install git

CentOS：

1
sudo yum install git

四、Git 初始配置

第一次使用 Git，需要配置用户名和邮箱。

1
2
git config --global user.name "你的名字"
git config --global user.email "你的邮箱"

查看配置：

1
git config --list

示例：

1
2
git config --global user.name "zhangsan"
git config --global user.email "zhangsan@example.com"

笔记

--global 表示全局配置，对当前电脑上的所有 Git 项目生效。

五、创建 Git 仓库

方式一：本地初始化仓库

进入项目目录：

1
cd my-project

初始化 Git：

1
git init

初始化后，项目中会生成一个隐藏目录：

1
.git

笔记

.git 文件夹保存了 Git 的版本信息，不要随便删除。

方式二：克隆远程仓库

从远程仓库下载代码：

1
git clone 仓库地址

示例：

1
git clone https://github.com/user/demo.git

进入项目：

1
cd demo

六、查看仓库状态

1
git status

这个命令非常常用，用来查看当前项目的状态。

常见状态：

状态含义
untracked新文件，还没有被 Git 管理
modified文件被修改了
staged文件已加入暂存区
clean没有需要提交的内容

学习重点

提交代码前，建议先执行：

1
git status

这样可以确认哪些文件被修改了。

七、添加文件到暂存区

添加单个文件：

1
git add index.html

添加多个文件：

1
git add index.html style.css

添加所有修改：

1
git add .

笔记

git add . 会把当前目录下所有修改都加入暂存区。

八、提交代码

提交暂存区的内容：

1
git commit -m "提交说明"

示例：

1
git commit -m "添加首页页面"

推荐写清楚提交内容：

1
2
3
git commit -m "新增登录功能"
git commit -m "修复按钮样式问题"
git commit -m "更新 README 文档"

笔记

提交说明不要随便写 aaa、test，最好说明这次提交做了什么。

九、查看提交历史

查看详细提交记录：

1
git log

简洁查看：

1
git log --oneline

示例：

1
2
a1b2c3d 添加首页页面
e4f5g6h 初始化项目

笔记

每一次提交都会生成一个 commit id，可以用来回退版本。

十、查看文件修改内容

查看工作区修改：

1
git diff

查看暂存区修改：

1
git diff --cached

使用场景

提交之前，可以先用 git diff 查看自己改了哪些内容。

十一、撤销修改

1. 撤销工作区修改

1
git restore 文件名

示例：

1
git restore index.html

旧写法：

1
git checkout -- index.html

注意

这个操作会丢弃当前文件的修改，需要谨慎使用。

2. 取消暂存

如果已经执行了 git add，但不想提交某个文件，可以取消暂存：

1
git restore --staged 文件名

示例：

1
git restore --staged index.html

旧写法：

1
git reset HEAD index.html

十二、删除文件

删除文件：

1
rm index.html

提交删除操作：

1
2
git add .
git commit -m "删除 index.html"

也可以使用 Git 命令删除：

1
2
git rm index.html
git commit -m "删除 index.html"

十三、分支管理

分支可以理解为一条独立的开发线。

常见分支：

分支说明
main / master主分支
dev开发分支
feature-login登录功能分支
bugfix修复 bug 分支

1. 查看分支

1
git branch

查看本地和远程分支：

1
git branch -a

2. 创建分支

1
git branch 分支名

示例：

1
git branch dev

3. 切换分支

1
git switch 分支名

示例：

1
git switch dev

旧写法：

1
git checkout dev

4. 创建并切换分支

1
git switch -c 分支名

示例：

1
git switch -c feature-login

旧写法：

1
git checkout -b feature-login

5. 合并分支

先切换到要合并到的目标分支：

1
git switch main

合并其他分支：

1
git merge feature-login

笔记

意思是：把 feature-login 分支的代码合并到 main 分支。

6. 删除分支

删除本地分支：

1
git branch -d 分支名

强制删除：

1
git branch -D 分支名

删除远程分支：

1
git push origin --delete 分支名

十四、远程仓库

远程仓库一般托管在：

  • GitHub
  • GitLab
  • Gitee
  • Bitbucket

1. 查看远程仓库

1
git remote -v

2. 添加远程仓库

1
git remote add origin 仓库地址

示例：

1
git remote add origin https://github.com/user/demo.git

3. 修改远程仓库地址

1
git remote set-url origin 新仓库地址

4. 删除远程仓库地址

1
git remote remove origin

十五、推送代码到远程仓库

第一次推送：

1
git push -u origin main

以后推送：

1
git push

如果主分支是 master：

1
git push -u origin master

笔记

-u 的作用是建立本地分支和远程分支的关联，以后可以直接使用 git push。

十六、拉取远程代码

拉取远程代码并合并：

1
git pull

这个命令相当于：

1
2
git fetch
git merge

只获取远程代码，不自动合并：

1
git fetch

十七、解决冲突

多人同时修改同一个文件时，可能会出现冲突。

冲突文件中可能会出现：

1
2
3
4
5
<<<<<<< HEAD
本地代码
=======
远程代码
>>>>>>> origin/main

需要手动修改成正确内容。

修改完成后：

1
2
git add .
git commit -m "解决合并冲突"

笔记

冲突不是错误，只是 Git 不知道应该保留哪一份代码，需要开发者手动判断。

十八、版本回退

1. 回退到上一个版本

1
git reset --hard HEAD^

2. 回退到指定版本

先查看提交记录：

1
git log --oneline

然后复制 commit id：

1
git reset --hard commit_id

示例：

1
git reset --hard a1b2c3d

注意

--hard 会丢弃当前工作区修改，使用前一定要确认。

十九、查看操作记录

如果误操作，可以查看 Git 操作历史：

1
git reflog

然后恢复到指定版本：

1
git reset --hard commit_id

笔记

git reflog 是 Git 的“后悔药”，可以找回很多误操作前的版本。

二十、.gitignore 文件

.gitignore 用来告诉 Git 哪些文件不需要提交。

常见内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 依赖目录
node_modules/

# 日志文件
*.log

# 系统文件
.DS_Store

# 环境变量文件
.env

# 构建目录
dist/
build/

# 编辑器配置
.vscode/
.idea/

常见使用场景

不应该提交到 Git 的文件：

  • 依赖包
  • 日志文件
  • 临时文件
  • 密码、密钥、环境变量文件
  • 编译打包后的文件

已经提交过的文件如何忽略？

如果文件已经被 Git 跟踪，再写入 .gitignore 不会立即生效。

需要先取消跟踪：

1
git rm -r --cached 文件或目录

示例：

1
2
git rm -r --cached node_modules
git commit -m "移除 node_modules 跟踪"

二十一、stash 临时保存修改

当你正在修改代码，但需要临时切换分支时，可以使用 stash。

保存当前修改：

1
git stash

查看 stash 列表：

1
git stash list

恢复最近一次保存：

1
git stash pop

恢复但不删除 stash：

1
git stash apply

删除 stash：

1
git stash drop

清空所有 stash：

1
git stash clear

笔记

stash 适合临时保存没有提交的修改。

二十二、标签 tag

标签一般用于标记项目版本。

例如：

1
2
3
v1.0.0
v1.1.0
v2.0.0

创建标签：

1
git tag v1.0.0

查看标签：

1
git tag

推送标签：

1
git push origin v1.0.0

推送所有标签：

1
git push origin --tags

删除本地标签：

1
git tag -d v1.0.0

删除远程标签：

1
git push origin --delete v1.0.0

二十三、常用 Git 命令总结

命令作用
git init初始化 Git 仓库
git clone克隆远程仓库
git status查看仓库状态
git add .添加所有修改到暂存区
git commit -m "说明"提交代码
git log --oneline查看提交历史
git branch查看分支
git switch 分支名切换分支
git switch -c 分支名创建并切换分支
git merge 分支名合并分支
git pull拉取远程代码
git push推送代码
git remote -v查看远程仓库
git stash临时保存修改
git reset --hard回退版本
git reflog查看操作记录

二十四、常见问题笔记

1. git push 失败怎么办？

可能是远程仓库有新代码，本地没有同步。

解决：

1
2
git pull
git push

如果出现冲突，需要先解决冲突。

2. 怎么查看当前在哪个分支？

1
git branch

带 * 的就是当前分支。

3. 提交说明写错了怎么办？

修改最近一次提交说明：

1
git commit --amend -m "新的提交说明"

4. 文件 add 错了怎么办？

1
git restore --staged 文件名

5. 怎么把本地分支推送到远程？

1
git push -u origin 分支名

二十五、推荐提交规范

提交信息建议使用统一格式：

1
类型: 提交说明

常见类型：

类型说明
feat新功能
fix修复 bug
docs文档修改
style样式修改
refactor代码重构
test测试相关
chore工具、依赖、构建等杂项

示例：

1
2
3
4
git commit -m "feat: 新增用户登录功能"
git commit -m "fix: 修复登录按钮样式问题"
git commit -m "docs: 更新 Git 教程"
git commit -m "style: 调整首页布局"

二十六、完整操作示例

新建项目：

1
2
3
mkdir demo
cd demo
git init

创建 README 文件：

1
echo "# Demo 项目" > README.md

查看状态：

1
git status

添加文件：

1
git add .

提交代码：

1
git commit -m "初始化项目"

添加远程仓库：

1
git remote add origin https://github.com/user/demo.git

设置主分支名称：

1
git branch -M main

推送代码：

1
git push -u origin main

二十七、学习路线

建议按照下面的顺序学习 Git：

第一阶段：基础操作

重点掌握：

1
2
3
4
git init
git status
git add .
git commit -m "说明"

第二阶段：远程仓库

重点掌握：

1
2
3
4
git remote
git push
git pull
git clone

第三阶段：分支管理

重点掌握：

1
2
3
git branch
git switch
git merge

第四阶段：问题处理

重点掌握：

1
2
3
4
git restore
git reset
git stash
git reflog

二十八、Git 日常开发流程

个人项目常用流程

1
2
3
4
git status
git add .
git commit -m "提交说明"
git push

团队项目常用流程

1
2
3
4
5
6
7
8
git pull
git switch -c feature-login

# 修改代码

git add .
git commit -m "feat: 新增登录功能"
git push -u origin feature-login

然后在 GitHub / GitLab / Gitee 上创建 Pull Request 或 Merge Request。

二十九、重点记忆

Git 最核心的几个命令：

1
2
3
4
5
git status
git add .
git commit -m "提交说明"
git push
git pull

Git 最核心的流程：

1
修改文件 -> 添加到暂存区 -> 提交到本地仓库 -> 推送到远程仓库

Git 最重要的思想：

每一次 commit 都是一个可以回到的版本节点。

三十、总结

Git 是开发中非常重要的工具。刚开始学习时，不需要一次性掌握所有命令，先熟悉最常用的流程即可。

日常开发最常用的命令是：

1
2
3
4
5
git status
git add .
git commit -m "提交说明"
git pull
git push

掌握这些命令后，再逐步学习分支、合并、冲突、回退和 stash，就可以应对大多数开发场景。

1

]]> http://zncddh.cn/2026/04/24/git%E5%AD%A6%E4%B9%A0%E8%BF%87%E7%A8%8B/ 2026-04-24T00:37:35.000Z 
1
2

    
    git学习过程
    2026-04-24T10:52:46.432Z
  
  
    
      creativity
    
    
    
    
    
    
    
      Docker + Nginx + Hexo 最终速查版命令清单
一、项目结构
1
2
3
4
5
6
~/docker-learn/
├── hello-docker/      # Docker/Nginx 基础练习
├── my-site/           # 最早练习用的静态网页目录
├── nginx-conf/        # 最早练习用的 Nginx 配置
├── hexo-blog/         # Hexo 博客项目（开发 + 生产构建）
└── hexo-nginx/        # 挂载式 Nginx 发布（开发式发布）
二、开发环境：Hexo 本地预览
目录：
1
cd ~/docker-learn/hexo-blog
启动开发环境：
1
docker compose up -d
查看状态：
1
docker compose ps
查看日志：
1
docker compose logs --tail 50
进入运行中的 Hexo 容器：
1
docker compose exec hexo bash
浏览器访问：
1
http://localhost:4000
停止开发环境：
1
docker compose down
三、Hexo 常用命令
1. 新建文章
1
docker compose exec hexo hexo new post "文章标题"
或者一次性容器方式：
1
docker compose run --rm hexo bash -lc "hexo new post '文章标题'"
2. 重新生成静态文件
1
docker compose run --rm hexo bash -lc "hexo clean && hexo generate"
3. 查看文章目录
1
ls source/_posts
4. 查看生成结果
1
2
ls public
find public -maxdepth 2 -type f | head
四、开发式发布：Nginx 挂载 public 目录
目录：
1
cd ~/docker-learn/hexo-nginx
启动挂载式发布环境：
1
docker compose up -d
查看状态：
1
docker compose ps
查看日志：
1
docker compose logs --tail 50
进入 Nginx 容器检查静态文件：
1
2
docker exec -it hexo-nginx ls -la /usr/share/nginx/html
docker exec -it hexo-nginx ls -la /usr/share/nginx/html/index.html
浏览器访问：
1
http://localhost:8081
停止挂载式发布环境：
1
docker compose down
五、生产环境：多阶段构建镜像
目录：
1
cd ~/docker-learn/hexo-blog
1. 手动构建生产镜像
1
docker build -f Dockerfile.prod -t hexo-prod .
查看镜像：
1
docker images | grep hexo-prod
2. 手动启动生产容器
1
docker run --rm -d -p 8082:80 --name hexo-prod-test hexo-prod
查看运行状态：
1
docker ps
查看日志：
1
docker logs --tail 50 hexo-prod-test
检查容器内静态文件：
1
docker exec -it hexo-prod-test ls -la /usr/share/nginx/html | head
浏览器访问：
1
http://localhost:8082
删除测试容器：
1
docker rm -f hexo-prod-test
六、生产环境：Compose 管理
目录：
1
cd ~/docker-learn/hexo-blog
1. 启动生产环境
1
docker compose -f docker-compose.prod.yml up -d --build
2. 查看状态
1
docker compose -f docker-compose.prod.yml ps
3. 查看日志
1
docker compose -f docker-compose.prod.yml logs --tail 50
4. 停止生产环境
1
docker compose -f docker-compose.prod.yml down
5. 强制重建生产环境
1
docker compose -f docker-compose.prod.yml up -d --build --force-recreate
浏览器访问：
1
http://localhost:8082
七、日常完整工作流
场景 1：写文章并本地预览
1
2
cd ~/docker-learn/hexo-blog
docker compose up -d
访问：
1
http://localhost:4000
场景 2：改完文章后生成静态文件
1
2
cd ~/docker-learn/hexo-blog
docker compose run --rm hexo bash -lc "hexo clean && hexo generate"
场景 3：查看挂载式发布结果
1
2
cd ~/docker-learn/hexo-nginx
docker compose up -d
访问：
1
http://localhost:8081
场景 4：更新生产环境
1
2
cd ~/docker-learn/hexo-blog
docker compose -f docker-compose.prod.yml up -d --build
访问：
1
http://localhost:8082
八、最常用排错命令
1. 看容器是否在运行
1
2
3
docker ps
docker compose ps
docker compose -f docker-compose.prod.yml ps
2. 看日志
1
2
3
docker logs 容器名
docker compose logs --tail 50
docker compose -f docker-compose.prod.yml logs --tail 50
3. 进入容器
1
2
docker exec -it 容器名 bash
docker compose exec hexo bash
4. 看端口占用
1
docker ps
重点看类似：
1
2
3
0.0.0.0:4000->4000/tcp
0.0.0.0:8081->80/tcp
0.0.0.0:8082->80/tcp
5. 如果报端口冲突
删除旧容器：
1
docker rm -f 容器名
6. 检查挂载目录是否正确
宿主机查看：
1
2
ls -la ~/docker-learn/hexo-blog/public
ls -la ~/docker-learn/hexo-blog/public/index.html
容器里查看：
1
2
docker exec -it hexo-nginx ls -la /usr/share/nginx/html
docker exec -it hexo-nginx ls -la /usr/share/nginx/html/index.html
7. 检查 Nginx 配置语法
1
docker exec -it my-nginx nginx -t
8. 重载 Nginx 配置
1
docker exec -it my-nginx nginx -s reload
九、当前几个地址的意义
开发预览
1
http://localhost:4000
用途：
  • 写文章时本地预览
  • Hexo 开发环境
挂载式发布
1
http://localhost:8081
用途：
  • Nginx 直接挂载 public/
  • 开发式发布验证
生产式发布
1
http://localhost:8082
用途：
  • 多阶段构建后的生产镜像
  • 更接近真实部署
十、当前几个核心文件的作用
hexo-blog/docker-compose.yml
开发环境 compose 文件
hexo-blog/Dockerfile
开发镜像 Dockerfile（my-hexo）
hexo-blog/Dockerfile.prod
生产镜像多阶段构建文件
hexo-blog/docker-compose.prod.yml
生产环境 compose 文件
hexo-nginx/docker-compose.yml
挂载式 Nginx 发布配置
十一、几个关键概念一句话版
Docker
负责管理环境、镜像、容器。
Hexo
负责把 Markdown 文章生成成静态网页。
Nginx
负责把静态网页提供给浏览器访问。
bind mount
把宿主机目录直接映射进容器。
named volume
让 Docker 管理某个数据目录。
Dockerfile
定义“镜像怎么构建”。
multi-stage build
第一阶段构建，第二阶段运行，适合生产环境。
十二、一句话总总结
Hexo 生成网页，Nginx 提供网页，Docker 管理运行环境。
]]>
    
    http://zncddh.cn/2026/04/23/all/
    
    2026-04-23T03:33:45.000Z
    
      
    
    
    
    
    
      Docker、Nginx 与 Hexo 学习总结
这篇文章记录了我从零开始学习 Docker、Nginx 和 Hexo 的过程。
一、我先学会了 Docker 的基础概念
一开始，我先理解了 Docker 里最重要的两个概念：
  • 镜像（image）是模板
  • 容器（container）是镜像运行出来的实例
我练习了这些常用命令：
1
2
3
4
5
6
7
8
docker images
docker ps
docker ps -a
docker run hello-world
docker run -it ubuntu bash
docker exec -it my-ubuntu bash
docker stop my-ubuntu
docker rm my-ubuntu
通过这些练习，我搞明白了：
  • docker ps 看的是正在运行的容器
  • docker ps -a 看的是所有容器
  • 容器停止后不会自动消失
  • 删除容器和停止容器不是一回事
二、我理解了容器的运行方式
我先运行了 hello-world 容器，确认 Docker 环境正常。
然后我又运行了 Ubuntu 容器，进入容器内部执行命令，确认容器里也有自己的文件系统和操作环境。
我学到了：
  • docker run 是新建并启动容器
  • docker exec 是进入一个已经运行中的容器
  • exit 在不同场景下效果不同
例如：
  • 如果是 docker run -it ubuntu bash 进入的，退出后容器通常就停止
  • 如果是 docker exec -it my-ubuntu bash 进入的，退出后后台容器仍然继续运行
三、我学会了端口映射
接着我运行了一个 Nginx 容器：
1
docker run -d --name my-nginx -p 8080:80 nginx
这里最关键的是：
1
-p 8080:80
它表示：
  • 宿主机的 8080 端口
  • 映射到容器里的 80 端口
这样我就在浏览器里通过 http://localhost:8080 访问到了 Nginx 欢迎页。
这一步让我真正理解了 Web 服务在 Docker 里是怎么暴露给外部访问的。
四、我学会了 Nginx 提供静态页面
进入 Nginx 容器后，我找到了默认网页目录：
1
/usr/share/nginx/html
我还看到了默认首页文件：
1
/usr/share/nginx/html/index.html
然后我直接修改了这个首页文件，刷新浏览器后，页面内容立刻发生变化。
这让我明白：
Nginx 的核心作用，就是把目录里的文件返回给浏览器。
五、我学会了挂载目录
接下来我没有继续在容器里手动改文件，而是改成在 WSL 里创建网站目录，再挂载给 Nginx。
例如：
1
-v ~/docker-learn/my-site:/usr/share/nginx/html:ro
这表示：
  • 左边是 WSL 里的目录
  • 右边是容器里的目录
  • :ro 表示只读挂载
这样做之后，我在 WSL 里改 index.html，浏览器里的页面也会立刻更新。
这一点非常重要，因为后面博客、配置文件、项目目录，都会用这种方式管理。
六、我学会了挂载 Nginx 配置文件
除了挂载网页目录，我还学会了挂载配置文件。
例如把 WSL 里的 default.conf 挂载到：
1
/etc/nginx/conf.d/default.conf
这样我就可以在宿主机直接修改 Nginx 配置，而不是每次进容器手改。
我还写了一个最基础的配置：
1
2
3
4
5
6
7
8
9
10
11
server {
    listen 80;
    server_name localhost;

    root /usr/share/nginx/html;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}
通过这个配置，我理解了几个很重要的概念：
  • listen：监听哪个端口
  • root：网站根目录
  • index：默认首页文件
  • location：请求路径如何处理
七、我学会了看日志和检查配置
为了更像真实环境，我还练习了这些命令：
1
2
3
docker logs my-nginx
docker exec -it my-nginx nginx -t
docker exec -it my-nginx nginx -s reload
这几步让我明白：
  • 网页打不开时，要先看日志
  • 改配置后，先用 nginx -t 检查语法
  • 配置没问题后，再用 nginx -s reload 重载服务
我还配置了一个 /test 路径：
1
2
3
4
location /test {
    return 200 'hello from /test';
    add_header Content-Type text/plain;
}
然后成功访问了：
1
http://localhost:8080/test
这让我理解了 Nginx 的路由配置是怎么生效的。
八、我学会了使用 Docker Compose
手敲 docker run 很方便学习，但实际项目更适合用 docker-compose.yml 管理。
我后面把 Nginx 服务改成了 Compose 方式启动，例如：
1
2
3
4
5
6
7
8
9
services:
  nginx:
    image: nginx
    container_name: my-nginx
    ports:
      - "8080:80"
    volumes:
      - /home/yah/docker-learn/my-site:/usr/share/nginx/html:ro
      - /home/yah/docker-learn/nginx-conf/default.conf:/etc/nginx/conf.d/default.conf:ro
然后我学会了：
1
2
3
4
docker compose up -d
docker compose ps
docker compose logs
docker compose down
这让我理解了：
  • Compose 可以把复杂命令写进配置文件
  • 更适合管理完整项目
  • 后面多服务协作时会非常方便
九、我开始学习 Hexo
在学完 Docker 和 Nginx 基础后，我开始引入 Hexo。
我先用 Node 容器初始化了 Hexo 项目，在容器里执行了：
1
2
3
npm install -g hexo-cli
hexo init .
npm install
初始化后，我看到了这些目录和文件：
  • _config.yml
  • source/
  • themes/
  • scaffolds/
  • package.json
这一步让我明白：
Hexo 本质上是一个静态博客生成器。
十、我理解了 Hexo 的 public 目录
接着我执行了：
1
2
hexo clean
hexo generate
生成之后，我看到了 public/ 目录，里面有：
  • index.html
  • archives/
  • css/
  • js/
这让我理解了：
  • source/ 是博客源内容
  • public/ 是生成出来的网站成品
也就是说，Hexo 并不是必须长期在线运行，它最重要的作用其实是：
把博客内容生成成静态网页文件。
十一、我学会了用 Docker 跑 Hexo 预览
为了能在浏览器里看博客，我又用 Docker 跑了 Hexo 预览服务，并且做了端口映射：
1
2
3
4
5
6
docker run --rm -it \
  -p 4000:4000 \
  -v $(pwd):/app \
  -w /app \
  node:20-bullseye \
  bash
然后在容器里执行：
1
npx hexo server --host 0.0.0.0
这样我就可以在浏览器访问：
1
http://localhost:4000
这一步让我明白：
  • Hexo 可以作为开发预览服务来用
  • 容器里跑的服务，要记得映射端口
  • --host 0.0.0.0 很重要，否则外部访问不到
十二、我把 Hexo 和 Nginx 串起来了
最后，我学会了把 Hexo 和 Nginx 结合起来：
  • Hexo 负责生成 public/
  • Nginx 负责托管 public/
我写了一个新的 docker-compose.yml，让 Nginx 直接挂载：
1
/home/yah/docker-learn/hexo-blog/public
然后通过 Nginx 发布 Hexo 生成的博客页面。
这让我真正理解了静态博客的典型部署思路：
  1. 写文章
  2. Hexo 生成静态文件
  3. Nginx 托管静态文件
  4. 浏览器访问网站
十三、这次学习我最大的收获
通过这次从零实践，我不只是搭了一个博客，更重要的是建立了下面这套完整理解：
  • Docker 解决环境运行问题
  • Nginx 解决网页访问问题
  • Hexo 解决静态博客生成问题
它们三者的关系可以总结成一句话：
Hexo 生成网页，Nginx 提供网页，Docker 管理运行环境。
十四、下一步计划
接下来我准备继续学习这些内容：
  • Hexo 主题配置
  • 标签、分类、归档页面
  • Dockerfile 的写法
  • Compose 管多个服务
  • Nginx 更复杂的配置
  • 把博客真正部署到服务器
结语
这次学习路线让我第一次把 Docker、Nginx 和静态博客真正串起来。
以前这些概念看起来很散，但实际做完以后就清楚了：
  • Docker 不是只会背命令
  • Nginx 不是只会装和开
  • Hexo 也不只是写文章工具
它们组合起来，正好构成了一套很典型的现代开发和部署练习项目。
补充一句：这是生产镜像更新测试。
]]>
    
    http://zncddh.cn/2026/04/20/my-second-post/
    
    2026-04-20T07:00:00.000Z
    
      Docker、Nginx]]>
    
    Docker、Nginx 与 Hexo 学习总结
    2026-04-24T10:52:46.432Z