NightFury

利用Acme脚本自动申请SSL证书

2024-07-05T08:09:11.000Z

在这篇博客中，我们将介绍如何在Linux服务器上使用 acme.sh 申请Let’s Encrypt证书，并配置自动续签任务。以下脚本将自动执行这些步骤，确保你的服务器能够使用免费的 SSL 证书并自动续签，完整代码开源在 szNightFury‘s Github。

前提条件

确保你有一个域名，并且能够修改其 DNS 记录。
确保你的服务器上已经安装了 Nginx（或其他Web服务器）。

脚本详解

1. 确保脚本以`root`身份运行

为了执行需要管理员权限的操作，脚本需要以root身份运行。如果当前用户不是root，脚本将退出并提示用户以root身份重新运行。

if [ "$EUID" -ne 0 ]; then
    echo "请以 root 身份运行此脚本。"
    exit 1
fi

2. 检查系统类型

脚本会检测当前操作系统类型，以便使用适当的软件包管理器安装所需的依赖项。

if [ -f /etc/os-release ]; then
    . /etc/os-release
    OS=$ID
else
    echo "无法确定操作系统类型，请手动检查。"
    exit 1
fi

3. 安装`socat`

socat是一个多功能的网络工具，用于建立独立的双向连接。脚本会检查是否已经安装了socat，如果没有，则根据操作系统类型进行安装。

if ! command -v socat &> /dev/null; then
    echo "socat 未安装，正在安装 socat..."
    if [ "$OS" == "debian" ] || [ "$OS" == "ubuntu" ]; then
        apt update
        apt install -y socat
    elif [ "$OS" == "centos" ]; then
        yum install -y socat
    else
        echo "不支持的操作系统。"
        exit 1
    fi
    if [ $? -ne 0 ]; then
        echo "socat 安装失败，请检查错误信息。"
        exit 1
    fi
else
    echo "socat 已安装。"
fi

4. 检查 Nginx 服务状态

脚本会检查 Nginx 服务是否正在运行，如果是，则停止服务以释放 80 端口（如有其他程序占用 80 端口，请修改下面代码）

nginx_status=$(systemctl is-active nginx)
if [ "$nginx_status" == "active" ]; then
    echo "nginx 服务正在运行，准备停止..."
    systemctl stop nginx
    if [ $? -ne 0 ]; then
        echo "停止 nginx 失败，请检查错误信息。"
        exit 1
    fi
else
    echo "nginx 服务未运行，无需停止。"
fi

5. 检查端口 80 是否被占用

脚本会检查端口 80 是否被占用，如果被占用，将提示用户并退出。

if lsof -i:80 &> /dev/null; then
    echo "端口 80 被占用，无法继续。"
    exit 1
fi

6. 安装 `acme.sh`

acme.sh 是一个纯 Unix Shell 脚本，用于从 Let’s Encrypt 申请 SSL 证书。脚本会检查是否已经安装了 acme.sh，如果没有，则进行安装。

if [ ! -d "$HOME/.acme.sh" ]; then
    echo "正在安装 acme.sh..."
    curl https://get.acme.sh | sh
    if [ $? -ne 0 ]; then
        echo "acme.sh 安装失败，请检查错误信息。"
        exit 1
    fi
else
    echo "acme.sh 已安装。"
fi

7. 设置默认 CA 为 Let’s Encrypt

echo "设置默认 CA 为 Let’s Encrypt..."
~/.acme.sh/acme.sh --set-default-ca --server letsencrypt

8. 获取用户输入的域名

脚本会提示用户输入主域名和附加域名。

read -p "请输入主域名: " main_domain
domains=($main_domain)
while true; do
    read -p "请输入附加域名（或按 Enter 键结束输入）: " additional_domain
    if [ -z "$additional_domain" ]; then
        break
    fi
    domains+=("$additional_domain")
done

9. 生成域名参数

根据用户输入的域名生成域名参数，用于申请证书。

domain_args=""
for domain in "${domains[@]}"; do
    domain_args="$domain_args -d $domain"
done

10. 申请测试证书

echo "申请测试证书..."
~/.acme.sh/acme.sh --issue $domain_args --standalone -k ec-256 --force --test
if [ $? -ne 0 ]; then
    echo "测试证书申请失败，请检查错误信息。"
    exit 1
fi

echo "删除测试证书..."
rm -rf "$HOME/.acme.sh/${main_domain}_ecc"

如果机子只有 IPV6，则还需要加个参数--listen-v6

11. 申请正式证书

echo "申请正式证书..."
~/.acme.sh/acme.sh --issue $domain_args --standalone -k ec-256 --force
if [ $? -ne 0 ]; then
    echo "正式证书申请失败，请检查错误信息。"
    exit 1
fi

同理，如果机子只有 IPV6，同样需要加个参数--listen-v6

12. 安装证书

echo "创建证书存储目录..."
mkdir -p /etc/cert

echo "安装证书..."
~/.acme.sh/acme.sh --installcert -d "$main_domain" --fullchainpath /etc/cert/fullchain.pem --keypath /etc/cert/privkey.pem --ecc --force
if [ $? -ne 0 ]; then
    echo "证书安装失败，请检查错误信息。"
    exit 1
fi

13. 重新启动 Nginx 服务

如果 Nginx 之前正在运行，脚本会重新启动 Nginx 服务。

if [ "$nginx_status" == "active" ]; then
    echo "重新启动 nginx 服务..."
    systemctl start nginx
    if [ $? -ne 0 ]; then
        echo "启动 nginx 失败，请检查错误信息。"
        exit 1
    fi
fi

14. 设置自动续签任务

为了确保证书在到期前自动续签，脚本会配置一个定时任务。

echo "设置自动续签任务..."
crontab -l | grep -v "acme.sh --cron" | crontab -
(crontab -l 2>/dev/null; echo "0 0 * * * ~/.acme.sh/acme.sh --cron --home ~/.acme.sh > /dev/null 2>&1") | crontab -
if [ $? -ne 0 ]; then
    echo "自动续签任务设置失败，请检查错误信息。"
    exit 1
fi

echo "证书申请、安装和自动续签任务设置完成。"

结论

通过这个脚本，你可以自动化从申请到安装以及配置自动续签 Let’s Encrypt 证书的整个过程。这将确保你的服务器始终使用有效的 SSL 证书，从而提高安全性。

Debian12部署Cloudreve云盘

2024-07-05T06:38:20.000Z

Cloudreve 是一款开源的网盘系统，支持多种存储后端，可以方便地搭建私人网盘。

VPS 环境：Debian 12

CloudReve 版本：3.8.3

步骤一：更新系统

首先，确保你的系统是最新的。运行以下命令更新软件包列表并升级所有已安装的软件包：

sudo apt update && sudo apt upgrade -y

步骤二：下载 Cloudreve

访问 Cloudreve的GitHub页面以获取最新版本的 Cloudreve。或者，你可以使用 curl 命令直接下载 3.8.3 版本（截止博客发表前的最新版本）：

curl -L -o cloudreve.zip https://github.com/cloudreve/Cloudreve/releases/download/3.8.3/cloudreve_3.8.3_linux_amd64.tar.gz

下载完成后，解压文件：

mkdir /opt/cloudreve
tar -xvzf cloudreve_3.8.3_linux_amd64.tar.gz -C /opt/cloudreve

步骤三：配置 Cloudreve

进入 Cloudreve 的目录，并赋予可执行权限：

cd /opt/cloudreve
chmod +x cloudreve

运行 Cloudreve 以生成默认配置文件：

./cloudreve # 初次启动会生成管理员账号和密码, 请妥善保存好, 后面可以进面板修改账号和密码

初次运行后，会生成一个名为 conf.ini 的配置文件，你可以根据需要修改此文件。以下是一个示例配置：

[System]
; 运行模式
Mode = master
; 监听端口
Listen = :5212
; 是否开启 Debug
Debug = false
; Session 密钥, 一般在首次启动时自动生成
SessionSecret = 23333
; Hash 加盐, 一般在首次启动时自动生成
HashIDSalt = something really hard to guss

; 实测只会生成上述上述五个配置, 下面的配置如有需要请自行选择

; 呈递客户端 IP 时使用的 Header
ProxyHeader = X-Forwarded-For

; SSL 相关
[SSL]
; SSL 监听端口
Listen = :443
; 证书路径
CertPath = C:\Users\i\Documents\fullchain.pem
; 私钥路径
KeyPath = C:\Users\i\Documents\privkey.pem

; 启用 Unix Socket 监听
[UnixSocket]
Listen = /run/cloudreve/cloudreve.sock
; 设置产生的 socket 文件的权限
Perm = 0666

; 数据库相关，如果你只想使用内置的 SQLite 数据库，这一部分直接删去即可
[Database]
; 数据库类型，目前支持 sqlite/mysql/mssql/postgres
Type = mysql
; MySQL 端口
Port = 3306
; 用户名
User = root
; 密码
Password = root
; 数据库地址
Host = 127.0.0.1
; 数据库名称
Name = v3
; 数据表前缀
TablePrefix = cd_
; 字符集
Charset = utf8mb4
; SQLite 数据库文件路径
DBFile = cloudreve.db
; 进程退出前安全关闭数据库连接的缓冲时间
GracePeriod = 30
; 使用 Unix Socket 连接到数据库
UnixSocket = false

; 从机模式下的配置
[Slave]
; 通信密钥
Secret = 1234567891234567123456789123456712345678912345671234567891234567
; 回调请求超时时间 (s)
CallbackTimeout = 20
; 签名有效期
SignatureTTL = 60

; 跨域配置
[CORS]
AllowOrigins = *
AllowMethods = OPTIONS,GET,POST
AllowHeaders = *
AllowCredentials = false
SameSite = Default
Secure = lse

; Redis 相关
[Redis]
Server = 127.0.0.1:6379
Password =
DB = 0

; 从机配置覆盖
[OptionOverwrite]
; 可直接使用 `设置名称 = 值` 的格式覆盖
max_worker_num = 50

步骤五：创建 systemd 服务

为了方便管理 Cloudreve，可以创建一个 systemd 服务。

创建一个名为 cloudreve.service 的文件：

nano /usr/lib/systemd/system/cloudreve.service

在文件中添加以下内容（将下文 PATH_TO_CLOUDREVE 更换为程序所在目录，本文即 /opt/cloudreve/）：

[Unit]
Description=Cloudreve
Documentation=https://docs.cloudreve.org
After=network.target
After=mysqld.service
Wants=network.target

[Service]
WorkingDirectory=/PATH_TO_CLOUDREVE
ExecStart=/PATH_TO_CLOUDREVE/cloudreve
Restart=on-abnormal
RestartSec=5s
KillMode=mixed

StandardOutput=null
StandardError=syslog

[Install]
WantedBy=multi-user.target

保存并退出后，重新加载 systemd 服务：

# 更新配置
systemctl daemon-reload

# 启动服务
systemctl start cloudreve

# 设置开机启动
systemctl enable cloudreve

步骤六：访问Cloudreve

Cloudreve 默认监听在 5212 端口。你可以通过访问 http://你的服务器IP:5212 来访问 Cloudreve。

初次登录时，用管理员账户登录，然后点击头像里的管理面板做进一步的个性化设置。

步骤七：配置Nginx反向代理（可选）

为了更加安全和便捷地访问 Cloudreve，可以使用Nginx配置反向代理并启用HTTPS。

在网站的 server 段添加以下内容（实际应用中推荐强制 https，然后在 443 端口反代 5212 端口）：

location / {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_redirect off;
    proxy_pass http://127.0.0.1:5212;

    # 如果不使用本地存储策略，可以注释掉
    client_max_body_size 20G; # 设置理论最大文件尺寸（这里即20 GB）
}

启用这个配置并重新加载Nginx：

systemctl restart nginx

至此，你应该可以通过你的域名访问 Cloudreve 云盘了。现在你可以开始使用这个强大的网盘系统来管理和分享你的文件了。如果你在配置过程中遇到任何问题，可以参考Cloudreve的文档获取更多帮助。

Debian12系统Hexo部署到VPS

2024-07-04T04:34:08.000Z

网上大部分教程都是将 Hexo 部署到 GitHub Pages 上面，本文主要介绍如何部署到 VPS。

VPS 环境：Debian 12

准备工作

网上流传的武功秘籍分为两种：

将 Hexo 项目上传到 VPS 上面后执行 hexo server，之后配置 Nginx 反向代理，让域名指向 http://localhost:4000。
将 Hexo 在本地通过 hexo generate 生成静态文件，在通过 hexo deploy 部署到 VPS 上面，使用 Nginx 直接做 Web 服务器。
相比第二种方式，第一种每次写博客与更新博客时候的操作会很繁琐。所以我们使用第二种方式进行部署，这样既可以将静态文件 deploy 到 VPS 上，也可以上传到 Github 上用作备份，操作性和安全性上都要胜于前者。
而对于第二种方式而言，常用的又有 git hook 和 rsync 两种自动部署解决方案。

本文主要介绍 git hook 部署过程。

Git Hooks 自动部署

部署原理

我们在本地编辑文本，然后使用 Git 远程部署到 VPS 的 Git 仓库。hexo d 命令实际上只 deploy 了本地的 public 文件夹，Git Hooks 实际上就是当 Git 仓库收到最新的 push 时，将 Git 仓库接受到的内容复制到 VPS 上的网站目录内。相当于完成了手动将 public 文件夹复制到 VPS 的网站根目录里。

安装配置 Git

安装 Git

通过 SSH 连接 VPS，执行：apt-get install git，完成后通过 git --version 查看 Git 版本，若显示版本信息则说明安装成功。

创建 git 用户

执行：adduser git，根据提示设置密码，其他信息可以一路空格。

赋予 git 用户 sudo 权限

安装 sudo：

apt update
apt install sudo

执行：

chmod 740 /etc/sudoers
nano /etc/sudoers

找到以下内容：

## User privilege specification
root ALL=(ALL:ALL) ALL
# 在 root ALL=(ALL:ALL) ALL 这一行下面添加
git ALL=(ALL:ALL) ALL

保存退出后，修改回文件权限：

chmod 440 /etc/sudoers

关闭 git 用户 shell 权限

我们也可以通过：

ssh git@VPS IP

ssh 连接服务器，登录到服务器上，对服务器进行各种操作，这通常很不安全，也不合适，我们只需要能对仓库操作就可以了，不需要更大的权限。

因此我们关闭 git 用户 shell 权限，执行：

nano /etc/passwd

将最后一行的 git:x:1001:1001:,,,:/home/git:/bin/bash 修改为 git:x:1001:1001:,,,:/home/git:/usr/bin/git-shell

这样，git 用户可以正常通过 ssh 使用 git，但无法登录 shell，因为我们为 git 用户指定的 git-shell 每次一登录就自动退出。

初始化 git 仓库

cd /home/git                # 切换到git用户目录
mkdir blog.git              # 创建git仓库文件夹，以blog.git为例
cd blog.git                 # 进入仓库目录
git init --bare             # 使用--bare参数初始化为裸仓库，这样创建的仓库不包含工作区

注意：裸仓库没有工作区，因为服务器上的 Git 仓库纯粹是为了共享，所以不让用户直接登录到服务器上去改工作区，并且服务器上的 Git 仓库通常都以 .git 结尾。

创建网站目录

cd /home/wwwroot/           # 切换目录
# 由于我想直接将博客放在/home/wwwroot/下，所以并没有创建blog目录
mkdir blog                  # 创建网站目录，以blog为例

配置 SSH

cd /home/git                # 切换到git用户目录
mkdir .ssh                  # 创建.ssh目录
cd .ssh
nano authorized_keys

然后将本地的公钥复制到 authorized_keys 文件里 (公钥即本地执行 cat ~/.ssh/id_rsa.pub （如 C:/Users/Your User Name/.ssh/id_rsa.pub）查看的内容)。

如果本地没有公钥，可以在本地用 ssh-keygen 命令生成一个新的 ssh 密钥对：

ssh-keygen -t rsa -C "your_email@example.com"

当系统提示输入文件名时，可以按 Enter 键使用默认路径（通常是~/.ssh/id_rsa），也可以指定一个新的路径。

Generating public/private rsa key pair.
Enter file in which to save the key (/home/username/.ssh/id_rsa): [Press Enter]

你可以选择为私钥设置一个密码短语，以增加额外的安全性，这里可以直接按 Enter 键跳过。

Enter passphrase (empty for no passphrase): [Type a passphrase or press Enter]
Enter same passphrase again: [Repeat the passphrase or press Enter]

生成完成后，系统会告诉你密钥对已经生成并存储在指定路径中。

Your identification has been saved in /home/username/.ssh/id_rsa.
Your public key has been saved in /home/username/.ssh/id_rsa.pub.
# Windows -> C:/Users/username/.ssh/id_rsa, C:/Users/username/.ssh/id_rsa.pub
The key fingerprint is:
SHA256:... your_email@example.com
The key's randomart image is:
+---[RSA 2048]----+
|    .==+.        |
|    =.o.         |
|   o  .          |
|  .  . o.        |
|   . oSo.o.      |
|  E .oBo= .      |
| .  .++.+ o      |
|  o+.o . o       |
|   +=o . .       |
+----[SHA256]-----+

注意：收集所有需要登录的用户的公钥，就是他们自己的 id_rsa.pub 文件，把所有公钥导入到 /home/git/.ssh/authorized_keys 文件里，一行一个。

通常这样配置后，hexo -d 部署就不需要输入密码了，而是通过证书校验身份。

用户组管理

查看 Nginx 运行用户：

cat /etc/nginx/nginx.conf | grep user

输出示例：

user www-data;

查看 Php-fpm 运行用户：

cat /etc/php/8.2/fpm/pool.d/www.conf | grep -E '^(user|group) ='

输出示例：

user = www-data
group = www-data

创建用户组 webgroup 并添加 git 和 www-data 到用户组：

groupadd webgroup
usermod -aG webgroup git
usermod -aG webgroup www-data

更改文件夹的组：

chgrp -R webgroup /home/wwwroot

更改文件和目录的所有者：

chown -R git:git /home/git
chown -R www-data:webgroup /home/wwwroot

设置文件夹和文件的权限：

chmod -R 770 /home/git
chmod -R 770 /home/wwwroot

设置 SGID 位，确保新创建的文件或文件夹自动继承该组：

# 只设置单层目录的方法
# chmod g+s /home/git
# chmod g+s /home/wwwroot

# 递归设置所有子目录的 SGID 位
find /home/git -type d -exec chmod g+s {} \;
find /home/wwwroot -type d -exec chmod g+s {} \;

安装配置 Nginx

由于我之前已经装过了 Nginx，可以参考前面的教程，以下nginx安装内容来源于网络，仅供参考。

安装 Nginx

执行：apt-get install nginx，若输入 nginx -V 可以看到 nginx 版本信息，则安装成功。

配置 nginx

执行：

cd /etc/nginx/sites-available   # 切换目录
cp default default.bak          # 备份默认配置
nano default                    # 修改配置

参考配置文件内容：

server {
    listen 80 default;              # 默认监听80端口
    root /home/wwwroot;             # 网站根目录
    server_name nightfury.top, www.nightfury.top;  # 网址
    access_log  /var/log/nginx/blog_access.log;
    error_log   /var/log/nginx/blog_error.log;
    error_page 404 =  /404.html;
    
    location ~* ^.+\.(ico|gif|jpg|jpeg|png)$ {
        root /home/wwwroot;
        access_log   off;
        expires      1d;
    }

    location ~* ^.+\.(css|js|txt|xml|swf|wav)$ {
        root /home/wwwroot;
        access_log   off;
        expires      10m;
    }

    location / {
        root /home/wwwroot;
        if (-f $request_filename) {
        rewrite ^/(.*)$  /$1 break;
        }
    }

    location /nginx_status {
        stub_status on;
        access_log off;
    }
}

保存退出后，启动 nginx：

systemctl start nginx

设置开机自动启动：

systemctl enable nginx

查看运行状态：

systemctl status nginx

显示 running 表示成功运行。

配置 Git Hooks

创建 post-receive 文件

root 用户下执行（或者 git 用户下执行，就不需要 sudo -u git）

cd /home/git/blog.git/hooks  # 切换到hooks目录下
sudo -u git nano post-receive

复制下面的内容到 post-receive 文件中：

#!/bin/bash
echo "post-receive hook is running..."

GIT_REPO=/home/git/blog.git
TMP_GIT_CLONE=/tmp/blog
PUBLIC_WWW=/home/wwwroot

rm -rf ${TMP_GIT_CLONE}
git clone $GIT_REPO $TMP_GIT_CLONE
# 如果想每次更新都删除掉原有所有内容则用下面这条命令
# rm -rf ${PUBLIC_WWW}/*
# 如果想每次更新都删除掉原有所有内容但排除掉一些文件（深度为1）则用下面这条命令（比如排除掉 .mp4 和 .png 文件）
find ${PUBLIC_WWW} -maxdepth 1 -mindepth 1 ! -name '.mp4' ! -name '*.png' -exec rm -rf {} +
cp -rf ${TMP_GIT_CLONE}/* ${PUBLIC_WWW}

为什么不直接将裸仓库克隆到 Web 根目录下呢？我之前也一直被这个问题困扰，感觉先克隆到 tmp 目录再拷贝到 Web 根目录是多此一举。后来我觉得可能是出于项目安全的考虑，在执行 cp 命令的时候，.git 作为隐藏目录不会被拷贝到 Web 根目录下，也就避免了将整个仓库历史暴露在 Web 服务中。

赋予可执行权限：

chmod +x post-receive

本地操作

尝试连接

在本地打开 Git Bash：

ssh git@VPS的ip

若默认端口不是 22，则需要在后面加上 -p 端口号：

ssh git@VPS的ip -p 2024

由于前面配置了证书，所以正常应该是不需要输入密码了，如果仍然需要输入密码，请检查 /home/git/.ssh 和 /home/git/.ssh/authorized_keys 的权限和所属用户/组是否正确，可以用如下命令查询 ssh 日志：

journalctl -u sshd -xe

ssh 连接成功后返回结果应该如下：

->ssh git@nightfury.top
->Linux XXX #1 SMP PREEMPT_DYNAMIC Debian XXX

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
fatal: Interactive git shell is not enabled.
hint: ~/git-shell-commands should exist and have read and execute access.
Connection to nightfury.top closed.

提示无法登录 shell 是正常的，因为我们在之前就为 git 用户指定了 git-shell 每次一登录就自动退出。

配置 Hexo

打开本地博客根目录下的_config.yml 文件，找到最后的 deploy 配置，修改为：

## Deployment

## Docs: https://hexo.io/docs/deployment.html

deploy:
  - type: git
    repo: git@github.com:szNightFury/szNightFury.github.io.git
    branch: master
  - type: git
    repo: git@nightfury.top:/home/git/blog.git
    branch: master

到此，Hexo 建站就全部配置部署完毕了。

Debian12配置Nginx1.22与Php8.2

2024-07-04T03:59:23.000Z

实验环境

操作系统：Debian 12
Nginx：1.22.1
Php：8.2.20
Php-fpm：php8.2-fpm

实验步骤

安装程序包与依赖

# 更新软件包列表
apt update

# 安装程序包
apt install nginx
apt install php php-fpm php-xml php-json php-curl php-mbstring

配置Nginx

# 查看 php-fpm 监听配置
nano /etc/php/8.2/fpm/pool.d/www.conf
# 41行取消注释：
listen = /run/php/php8.2-fpm.sock

nano /etc/nginx/conf.d/xxx.conf
# 在 index.html 前面加入 index.php
# 增加：
location ~ \.php$ {
	include snippets/fastcgi-php.conf;
	fastcgi_pass unix:/run/php/php8.2-fpm.sock;	# 注意路径与前面的监听配置一致
}

修改时区

# 查看当前时区
timedatectl
# 输出示例：
Local time: Tue 2024-07-03 14:00:00 UTC
Universal time: Tue 2024-07-03 14:00:00 UTC
RTC time: Tue 2024-07-03 14:00:00
Time zone: UTC (UTC, +0000)
System clock synchronized: yes
NTP service: active
RTC in local TZ: no

# 设置 PRC 时区
timedatectl set-timezone Asia/Shanghai
# 验证时区更改
timedatectl
# 输出示例：
Local time: Tue 2024-07-03 22:00:00 CST
Universal time: Tue 2024-07-03 14:00:00 UTC
RTC time: Tue 2024-07-03 14:00:00
Time zone: Asia/Shanghai (CST, +0800)
System clock synchronized: yes
NTP service: active
RTC in local TZ: no

# 配置 Php 时区
nano /etc/php/8.2/fpm/php.ini
# 979行增加
date.timezone = Asia/Shanghai

重启服务

service php8.2-fpm restart # systemctl restart php8.2-fpm
service nginx restart # systemctl restart nginx

调试步骤

# 检查 Nginx 访问日志
tail -f /var/log/nginx/access.log
# 查看 Php-fpm 错误日志
tail -f /var/log/php8.2-fpm.log

验收

编写任意 php 文件，比如说简单的有 index.php：

<h1>
    <span> Hello, this is test page </span>
</h1>

或者 php 探针：

<?php 
	phpinfo(); 
?>

访问该 php 地址，得到正确的返回结果。完结，Move On！

table

2023-09-11T02:46:06.000Z

refill	0	0	0	1	1	1									0	0	0	1	1	1
	refillPush	refillPush	refillPush	refillPush	refillPush	refillPush									refillPush	refillPush	refillPush	refillPush	refillPush	refillPush
							push	push	push												push	push	push
	refillOrPush	refillOrPush	refillOrPush	refillOrPush	refillOrPush	refillOrPush	refillOrPush	refillOrPush	refillOrPush						refillOrPush	refillOrPush	refillOrPush	refillOrPush	refillOrPush	refillOrPush	refillOrPush	refillOrPush	refillOrPush




refill		0	0	0	1	1	1
reuse								0	0	0	1	1	1	2	2	2
		refillPop	refillPop	refillPop	refillPop	refillPop	refillPop
		orPush，orPop做判断						reusePop	reusePop	reusePop	reusePop	reusePop	reusePop	reusePop	reusePop	reusePop
														pop	pop	pop
										reusePush	reusePush	reusePush	reusePush	reusePush	reusePush
		refillOrPop	refillOrPop	refillOrPop	refillOrPop	refillOrPop	refillOrPop							refillOrPop	refillOrPop	refillOrPop
							reuseOrPush	reuseOrPush	reuseOrPush	reuseOrPush	reuseOrPush	reuseOrPush	reuseOrPush	reuseOrPush	reuseOrPush
								reuseOrPop	reuseOrPop	reuseOrPop	reuseOrPop	reuseOrPop	reuseOrPop	reuseOrPop	reuseOrPop	reuseOrPop
	orPush	orPush	orPush	orPush	orPush	orPush	orPush	orPush	orPush	orPush	orPush	orPush	orPush	orPush	orPush	orPush
		orPop	orPop	orPop	orPop	orPop	orPop	orPop	orPop	orPop	orPop	orPop	orPop	orPop	orPop	orPop
								orPush，orPop做判断

A Low Power and Low Latency FPGA-Based Spiking Neural Network Accelerator

2023-09-10T07:36:45.000Z

A Low Power and Low Latency FPGA-Based Spiking Neural Network Accelerator

摘要

翻译自 ChatGPT：

脉冲神经网络（SNNs），被称为神经网络的第三代，因其生物合理性和类似大脑的特征而著名。最近的努力进一步展示了 SNN 在高速推断方面的潜力，通过设计具有时间或空间维度并行性的加速器。然而，由于硬件资源的限制，加速器设计必须利用片外内存来存储许多中间数据，这导致了高功耗和长延迟。本文侧重于层间数据流以提高算术效率。基于脉冲的离散特性，我们设计了一个卷积池化（CONVP）单元，将卷积层和池化层的处理合并，以减少延迟和资源利用率。此外，对于全连接层，我们应用了内部输出并行性和跨输出并行性来加速网络推理。我们通过在 Zynq XA7Z020 FPGA 上实现不同的 SNN 模型，并使用不同的数据集来展示我们提出的硬件架构的有效性。实验结果显示，我们的加速器在 MNIST 数据集上与 FPGA 实现相比，可以实现约 28 倍的推断速度提升，并在 DVSGesture 数据集上与 ASIC 设计相比，可以实现约 15 倍的推断速度提升，功耗较低。

设计方法

PC 端负责脉冲编码，通过 UART 协议输出给 PL 端；PL 端负责网络推理，对输入脉冲做 Line Buffer 做卷积（Adder Tree），输出结果再传回 PC 端进行验证，系统框图如图：
所谓的 CONVP 就是把 Conv 和 MaxPooling 融合（呃呃不就是很常见的多加个 buffer 吗，而且作者所做的似乎是 Valid Conv ），然后做了 Intra-Row Pooling 和 Inter-Row Pooling，说白了就是比如做 MP2 的时候，第一行先做 Intra-Row Pooling，每两个做一次 OR 操作再写入 Buffer，在第二行的时候则作 Inter-Row Pooling，本来是应该读出第一行的 pooling 结果然后接着做 OR 操作的，但作者似乎是偷懒多开了一行 Buffer 再一一做 OR 操作，如图：
卷积过程也有 Inter-Output Parallelism 和 Intra-Output Parallelism，其中 Intra-Output Parallelism 是把对某个神经元有贡献的权重（n bits）分成 k 个作为一组，即并行度为 k，经过 Ci / k 个 Clock 后就可以算完一个输出神经元的膜电势；Intra-Output Parallelism 没怎么理解，我估计是对上个 FC 层计算完的结果直接拿来做运算，而不需要存起来再被这层 FC 取出来作为 Input，如图：

实验与评估

在 Xilinx Zynq XA7Z020 FPGA 上进行了部署，Verilog 设计，8 bits 定点量化，100 MHz 时钟频率，性能对比如图：
其他也没啥好说的了，作者最后还对比了下 CONVP 和 CONV-POOLING 以及有无 Inter-Output Parallelism 和 Intra-Output Parallelism 的推理速率、资源使用率的差别，只能说增加了下工作量吧。

Efficient Hardware Acceleration of Sparsely Active Convolutional Spiking Neural Networks

2023-09-07T12:46:18.000Z

Efficient Hardware Acceleration of Sparsely Active Convolutional Spiking Neural Networks

摘要

翻译自 ChatGPT：

脉冲神经网络（SNNs）以事件驱动方式进行计算，以实现比标准神经网络更高效的计算。在 SNNs 中，神经元的输出不是编码为实值激活，而是编码为二进制脉冲序列。使用 SNNs 而不是传统神经网络的动机根植于脉冲处理的特殊计算方面，尤其是高度稀疏的脉冲。已经建立良好的卷积神经网络（CNNs）实现具有大型的处理元素（PEs）空间阵列，但在面对激活稀疏性时，它们的利用率仍然很低。我们提出了一种针对高度稀疏的卷积脉冲神经网络（CSNNs）进行优化的新型架构。所提出的架构包括一个与卷积内核大小相同的PE阵列以及一个智能脉冲队列，提供了高PE利用率。通过将特征图压缩成可以逐个脉冲处理的队列，确保了脉冲的持续流动。这种压缩是在运行时执行的，导致了一种自时序调度。这使得处理时间可以随着脉冲数量的增加而扩展。此外，引入了一种新颖的内存组织方案，用于使用多个小型并行的片上 RAM 高效存储和检索各个神经元的膜电位。每个 RAM 都与其 PE 硬连线，减少了开关电路。我们在 FPGA 上实现了所提出的架构，并与以前提出的 SNN 实现相比实现了显著的加速（约 10 倍），同时需要更少的硬件资源并保持更高的能源效率（约 15 倍）。

硬件架构

卷积和全连接分成了两个部分硬件实现，不够优雅（你猜为什么测试用例在做 FC 之前卷积核个数锐减到 10 个？），系统框图如图：
输出通道作为循环最外层，先对某一通道做所有时间步的推理，然后将这些通道的 Spike 存入 AER 的表中。一层一层做，没有层间流水化：

硬件实现

所谓的 Memory Interlacing，就是只做 3×3 卷积（这篇文章对于 3×3 卷积做了很多特定的设计，非常之不通用，详见后文），且这 9 个格的 Spike 可以并行写入到 9 个 RAM 里作为 AER 表格（深度未知，需要 fmapSize / 9 × ChannelOut？）。他的分块方式是这样的：对特征图 FMap 直接做 3×3 的分块，然后将分块内的 9 个元素编号后分别存在各自的 RAM 中，膜电势和权重也是分成 9 个部分，AER 表格存储方式如图：
卷积单元流程可以分为：计算地址 S1 → 读膜电势 S2 → 更新电势 S3 → 写膜电势 S4。
- 计算 Spike 所产生的 Active 邻域地址的时候，作者对于 9 个输出地址与输入地址都做了相应的映射（对于 3×3 卷积设计非常的特质化！！或许有些情况可以合并，懒得深究了），如图为输入地址为(0, 0)[5]（$s_{in}=5$）到邻域 $s_{in}=1$ 的映射公式与示例：
  
  除此之外，由于这 9 个卷积核到 9 个 PE 的映射取决于输入脉冲地址（比如从蓝框到紫框，最左上角从序号 1 变成了序号 6，但权重位置其实没有变），所以它还需要 9 个 9 选 1 的 Mux 来做膜电势更新。
- 更新电势的过程中考虑了上溢下溢的情况做了饱和操作，饱和操作对于 m-TTFS 而言影响不大，通过 check 符号位的变化可以实现上下溢的判断，好评。
- 卷积会遇到 S2 - S4，S3 - S4 的 Data Hazard，为了避免这样的数据冒险，作者对 S2 - S4 的数据冒险（S4 写的膜电势地址与 S2 读的膜电势地址一致）做了 Bypass（意味着 9 个 2 选 1 的 Mux），因为 S4 计算完的膜电势刚好可以对 S2 用，而对于 S3 - S4 的数据冒险则是采用了对 S2，S1 做了阻塞，从而使得转换成 S2 - S4 的数据冒险类型，但这样其实是会空一拍。不过作者也说明了由于他是 0 - 9 的顺序去做的，所以其实也很难有同样地址的 S3 - S4 数据冒险。
只支持 3×3 的 MaxPooling，垃圾。

实验与总结

给出了不同并行度时的吞吐速率和功耗，进一步计算能效比，这样可以选择出合适的并行度，不错的思路。
8 bits 量化大概用了 60 个 36K BRAM，16 bits 量化大概用了 111 个 36K BRAM（网络本身很小，28×28-32C3-32C3-P3-10C3-F10，对于 8 bits 量化而言按道理权重需要 10 个 18K 而已，膜电势就算所有都全存储起来也只需要 50 个 18K，你在这用了 60 个 36 K 在干啥啊？？），时钟频率跑到 333 MHz，但用的是 UltraScale+ ZU7EV，这个器件比 ZU5EV 大了一倍多，只能说还可以吧。
作者统计了下自己 PE 阵列的使用率，第二、三层都只有 50+ 的使用率，这依然不妨碍作者夸自己的 PE 使用率高。
性能对比：

结论

结论部分说自己的 neuron multiplexing 是为了降低膜电势的存储占用问题的？？？
通信作者是 IEEE Fellow，以及

dddd，哈哈。

StreamFifo

2023-08-18T09:38:12.000Z

StreamFifo

import spinal.core._
import spinal.lib._

import scala.language.postfixOps

trait StreamReuseFifoInterface[T <: Data]{
  def push          : Stream[T]
  def pop           : Stream[T]
  def pushOccupancy : UInt
  def popOccupancy  : UInt
}

object StreamReuseFifo{
  def apply[T <: Data](dataType: HardType[T],
                       depth: Int,
                       latency : Int = 2,
                       forFMax : Boolean = false) = {
    assert(latency >= 0 && latency <= 2)
    new StreamFifo(
      dataType,
      depth,
      withAsyncRead = latency < 2,
      withBypass = latency == 0,
      forFMax = forFMax
    )
  }
}

/**
 * Fully redesigned in release 1.8.2 allowing improved timing closure.
 * - latency of 0, 1, 2 cycles
 *
 * @param dataType
 * @param depth Number of element stored in the fifo, Note that if withAsyncRead==false, then one extra transaction can be stored
 * @param withAsyncRead Read the memory using asyncronous read port (ex distributed ram). If false, add 1 cycle latency
 * @param withBypass Bypass the push port to the pop port when the fifo is empty. If false, add 1 cycle latency
 *                   Only available if withAsyncRead == true
 * @param forFMax Tune the design to get the maximal clock frequency
 * @param useVec Use an Vec of register instead of a Mem to store the content
 *               Only available if withAsyncRead == true
 */
class StreamReuseFifo[T <: Data](val dataType: HardType[T],
                            val depth: Int,
                            val withAsyncRead : Boolean = false,
                            val withBypass : Boolean = false,
                            val allowExtraMsb : Boolean = true,
                            val forFMax : Boolean = false,
                            val useVec : Boolean = false) extends Component {
  require(depth >= 0)

  if(withBypass) require(withAsyncRead)
  if(useVec) require (withAsyncRead)

  val io = new Bundle with StreamReuseFifoInterface[T]{
    val push = slave Stream (dataType)
    val pop = master Stream (dataType)
    val flush = in Bool() default(False)
    val occupancy    = out UInt (log2Up(depth + 1) bits)
    val availability = out UInt (log2Up(depth + 1) bits)
    override def pushOccupancy = occupancy
    override def popOccupancy = occupancy
  }

  class CounterUpDownFmax(states : BigInt, init : BigInt) extends Area{
    val incr, decr = Bool()
    val value = Reg(UInt(log2Up(states) bits)) init(init)
    val plusOne = KeepAttribute(value + 1)
    val minusOne = KeepAttribute(value - 1)
    when(incr =/= decr){
      value := incr.mux(plusOne, minusOne)
    }
    when(io.flush) { value := init }
  }

  val withExtraMsb = allowExtraMsb && isPow2(depth)
  val bypass = (depth == 0) generate new Area {
    io.push >> io.pop
    io.occupancy := 0
    io.availability := 0
  }
  val oneStage = (depth == 1) generate new Area {
    val doFlush = CombInit(io.flush)
    val buffer = io.push.m2sPipe(flush = doFlush)
    io.pop << buffer
    io.occupancy := U(buffer.valid)
    io.availability := U(!buffer.valid)

    if(withBypass){
      when(!buffer.valid){
        io.pop.valid := io.push.valid
        io.pop.payload := io.push.payload
        doFlush setWhen(io.pop.ready)
        // 这里doFlush拉高是因为m2sPipe的rValid=RegNextWhen(self.valid, self.ready) init(False)
        // 而由于bypass的缘故, rValid不应该采样当前的self.valid, 因此doFlush拉高, rValid clearWhen(flush)
      }
    }
  }
  val logic = (depth > 1) generate new Area {
    val vec = useVec generate Vec(Reg(dataType), depth)
    val ram = !useVec generate Mem(dataType, depth)

    val ptr = new Area{
      val doPush, doPop = Bool()  // 这两个信号都是对内部Ram而言的,其中doPush就是io.push.fire,仅在bypass情况有所不同
      val full, empty = Bool()
      val push = Reg(UInt(log2Up(depth) + withExtraMsb.toInt bits)) init(0)
      val pop  = Reg(UInt(log2Up(depth) + withExtraMsb.toInt bits)) init(0)
      val occupancy = cloneOf(io.occupancy)
      val popOnIo = cloneOf(pop) // Used to track the global occupancy of the fifo (the extra buffer of !withAsyncRead)
      val wentUp = RegNextWhen(doPush, doPush =/= doPop) init(False) clearWhen (io.flush)
      // pop只是针对内部而言的, pop会在ram做pop操作后更改指针, 但pop操作到读结束还有latency, 因此用popOnIo记录读结束的指针

      val arb = new Area {
        // full是为了反压push的, pop相当于提前生成了读地址, 而popOnIo则是外部fire时的读地址
        // 因此full信号不用pop信号是因为他所指的指针可能并未真正的读(pop通常会比popOnIo多1)
        // empty是用于pop的valid信号的(准确来说是直接提供给addressGen), 但empty信号
        // 对外部并不暴露, 因此能否做pop操作只需要根据对内部的pop和push做判断即可
        val area = !forFMax generate {
          withExtraMsb match {
            case true => { //as we have extra MSB, we don't need the "wentUp"
              full := (push ^ popOnIo ^ depth) === 0  // full时push=popOnIo=depth
              empty := push === pop
            }
            case false => {
              full := push === popOnIo && wentUp
              empty := push === pop && !wentUp
            }
          }
        }

        val fmax = forFMax generate new Area {
          val counterWidth = log2Up(depth) + 1
          // empty对内部而言(为了pop)
          val emptyTracker = new CounterUpDownFmax(1 << counterWidth, 1 << (counterWidth - 1)) {
            incr := doPop
            decr := doPush
            empty := value.msb
          }
          // full对外部而言(为了push)
          val fullTracker = new CounterUpDownFmax(1 << counterWidth, (1 << (counterWidth - 1)) - depth) {
            incr := io.push.fire
            decr := io.pop.fire
            full := value.msb
          }
        }
      }


      when(doPush){
        push := push + 1
        if(!isPow2(depth)) when(push === depth - 1){ push := 0 }
      }
      when(doPop){
        pop := pop + 1
        if(!isPow2(depth)) when(pop === depth - 1){ pop := 0 }
      }

      when(io.flush){
        push := 0
        pop := 0
      }


      val forPow2 = (withExtraMsb && !forFMax) generate new Area{
        occupancy := push - popOnIo  //if no extra msb, could be U(full ## (push - popOnIo))
      }

      val notPow2 = (!withExtraMsb && !forFMax) generate new Area{
        val counter = Reg(UInt(log2Up(depth + 1) bits)) init(0)
        counter := counter + U(io.push.fire) - U(io.pop.fire)
        occupancy := counter

        when(io.flush) { counter := 0 }
      }
      val fmax = forFMax generate new CounterUpDownFmax(depth + 1, 0){
        incr := io.push.fire
        decr := io.pop.fire
        occupancy := value
      }
    }

    val push = new Area {
      io.push.ready := !ptr.full
      ptr.doPush := io.push.fire
      val onRam = !useVec generate new Area {
        val write = ram.writePort()
        write.valid := io.push.fire
        write.address := ptr.push.resized
        write.data := io.push.payload
      }
      val onVec = useVec generate new Area {
        when(io.push.fire){
          vec.write(ptr.push.resized, io.push.payload)
        }
      }
    }

    val pop = new Area{
      val addressGen = Stream(UInt(log2Up(depth) bits))
      addressGen.valid := !ptr.empty
      addressGen.payload := ptr.pop.resized
      ptr.doPop := addressGen.fire

      val sync = !withAsyncRead generate new Area{
        assert(!useVec)
        val readArbitration = addressGen.m2sPipe(flush = io.flush)   // valid和读地址打一拍
        val readPort = ram.readSyncPort   // 同样的是1 cycle delay
        readPort.cmd := addressGen.toFlowFire   // toFlowFire, 读的时候不需要ready
        io.pop << readArbitration.translateWith(readPort.rsp)   // valid打一拍后payload替换成读数据

        val popReg = RegNextWhen(ptr.pop, readArbitration.fire) init(0)
        ptr.popOnIo := popReg   // 读结束后采样pop指针
        when(io.flush){ popReg := 0 }
      }

      val async = withAsyncRead generate new Area{
        val readed = useVec match {
          case true => vec.read(addressGen.payload)
          case false => ram.readAsync(addressGen.payload)
        }
        io.pop << addressGen.translateWith(readed)
        ptr.popOnIo := ptr.pop

        if(withBypass){
          when(ptr.empty){
            io.pop.valid := io.push.valid
            io.pop.payload := io.push.payload
            ptr.doPush clearWhen(io.pop.ready)
          }
        }
      }
    }

    io.occupancy := ptr.occupancy
    if(!forFMax) io.availability := depth - ptr.occupancy
    val fmaxAvail = forFMax generate new CounterUpDownFmax(depth + 1, depth){
      incr := io.pop.fire
      decr := io.push.fire
      io.availability := value
    }
  }



  // check a condition against all valid payloads in the FIFO RAM
  def formalCheckRam(cond: T => Bool): Vec[Bool] = this rework new Composite(this){
    val condition = (0 until depth).map(x => cond(if (useVec) logic.vec(x) else logic.ram(x)))
    // create mask for all valid payloads in FIFO RAM
    // inclusive [popd_idx, push_idx) exclusive
    // assume FIFO RAM is full with valid payloads
    //           [ ...  push_idx ... ]
    //           [ ...  pop_idx  ... ]
    // mask      [ 1 1 1 1 1 1 1 1 1 ]
    val mask = Vec(True, depth)
    val push_idx = logic.ptr.push.resize(log2Up(depth))
    val pop_idx = logic.ptr.pop.resize(log2Up(depth))
    // pushMask(i)==0 indicates location i was popped
    val popMask = (~((U(1) << pop_idx) - 1)).asBits
    // pushMask(i)==1 indicates location i was pushed
    val pushMask = ((U(1) << push_idx) - 1).asBits
    // no wrap   [ ... popd_idx ... push_idx ... ]
    // popMask   [ 0 0 1 1 1 1  1 1 1 1 1 1 1 1 1]
    // pushpMask [ 1 1 1 1 1 1  1 1 0 0 0 0 0 0 0] &
    // mask      [ 0 0 1 1 1 1  1 1 0 0 0 0 0 0 0]
    when(pop_idx < push_idx) {
      mask.assignFromBits(pushMask & popMask)
      // wrapped   [ ... push_idx ... popd_idx ... ]
      // popMask   [ 0 0 0 0 0 0  0 0 1 1 1 1 1 1 1]
      // pushpMask [ 1 1 0 0 0 0  0 0 0 0 0 0 0 0 0] |
      // mask      [ 1 1 0 0 0 0  0 0 1 1 1 1 1 1 1]
    }.elsewhen(pop_idx > push_idx) {
      mask.assignFromBits(pushMask | popMask)
      // empty?
      //           [ ...  push_idx ... ]
      //           [ ...  pop_idx  ... ]
      // mask      [ 0 0 0 0 0 0 0 0 0 ]
    }.elsewhen(logic.ptr.empty) {
      mask := mask.getZero
    }
    val check = mask.zipWithIndex.map{case (x, id) => x & condition(id)}
    val vec = Vec(check)
  }.vec

  def formalCheckOutputStage(cond: T => Bool): Bool = this.rework {
    // only with sync RAM read, io.pop is directly connected to the m2sPipe() stage
    Bool(!withAsyncRead) & io.pop.valid & cond(io.pop.payload)
  }

  // verify this works, then we can simplify below
  //def formalCheck(cond: T => Bool): Vec[Bool] = this.rework {
  //  Vec(formalCheckOutputStage(cond) +: formalCheckRam(cond))
  //}

  def formalContains(word: T): Bool = this.rework {
    formalCheckRam(_ === word.pull()).reduce(_ || _) || formalCheckOutputStage(_ === word.pull())
  }
  def formalContains(cond: T => Bool): Bool = this.rework {
    formalCheckRam(cond).reduce(_ || _) || formalCheckOutputStage(cond)
  }

  def formalCount(word: T): UInt = this.rework {
    // occurance count in RAM and in m2sPipe()
    CountOne(formalCheckRam(_ === word.pull())) +^ U(formalCheckOutputStage(_ === word.pull()))
  }
  def formalCount(cond: T => Bool): UInt = this.rework {
    // occurance count in RAM and in m2sPipe()
    CountOne(formalCheckRam(cond)) +^ U(formalCheckOutputStage(cond))
  }

  def formalFullToEmpty() = this.rework {
    val was_full = RegInit(False) setWhen(!io.push.ready)
    cover(was_full && logic.ptr.empty)
  }
}

Memory Layout Analysis

2023-08-15T02:38:12.000Z

Memory Layout Analysis

Voltage Membrane

$$
Total=Co \times H_v \times W_v
$$
$$
Burst=H_k
$$

Kernel Weight

$$
Total=Co \times Ci \times H_k \times W_k
$$
$$
Burst=Ci \times S \times H_k \times W_k
$$

Mixed

$$
Parameter\ Unit =\frac{H_v \times W_v}{H_k \times W_k} + Ci
$$

Hexo部署到VPS

2023-08-14T07:17:08.000Z

网上大部分教程都是将 Hexo 部署到 GitHub Pages 上面，本文主要介绍如何部署到 VPS。

VPS 环境：Ubuntu 18.04。

准备工作

网上流传的武功秘籍分为两种：

将 Hexo 项目上传到 VPS 上面后执行 hexo server，之后配置 Nginx 反向代理，让域名指向 http://localhost:4000。
将 Hexo 在本地通过 hexo generate 生成静态文件，在通过 hexo deploy 部署到 VPS 上面，使用 Nginx 直接做 Web 服务器。
相比第二种方式，第一种每次写博客与更新博客时候的操作会很繁琐。所以我们使用第二种方式进行部署，这样既可以将静态文件 deploy 到 VPS 上，也可以上传到 Github 上用作备份，操作性和安全性上都要胜于前者。
而对于第二种方式而言，常用的又有 git hook 和 rsync 两种自动部署解决方案。

本文主要介绍 git hook 部署过程。

Git Hooks 自动部署

部署原理

安装配置 Git

安装 Git

通过 SSH 连接 VPS，执行：apt-get install git，完成后通过 git --version 查看 Git 版本，若显示版本信息则说明安装成功。

创建 git 用户

执行：adduser git，根据提示设置密码。

赋予 git 用户 sudo 权限

执行：

chmod 740 /etc/sudoers
vim /etc/sudoers

找到以下内容：

## User privilege specification
root ALL=(ALL:ALL) ALL
# 在 root ALL=(ALL:ALL) ALL 这一行下面添加
git ALL=(ALL:ALL) ALL

保存退出后，修改回文件权限：

chmod 440 /etc/sudoers

关闭 git 用户 shell 权限

我们也可以通过：

ssh git@VPS IP

ssh 连接服务器，登录到服务器上，对服务器进行各种操作，这通常很不安全，也不合适，我们只需要能对仓库操作就可以了，不需要更大的权限。

因此我们关闭 git 用户 shell 权限，执行：

vim /etc/passwd

将最后一行的 git:x:1001:1001:,,,:/home/git:/bin/bash 修改为 git:x:1001:1001:,,,:/home/git:/usr/bin/git-shell

这样，git 用户可以正常通过 ssh 使用 git，但无法登录 shell，因为我们为 git 用户指定的 git-shell 每次一登录就自动退出。

初始化 git 仓库

cd /home/git                //切换到git用户目录
mkdir blog.git              //创建git仓库文件夹，以blog.git为例
cd blog.git                 //进入仓库目录
git init --bare             //使用--bare参数初始化为裸仓库，这样创建的仓库不包含工作区

创建网站目录

cd /home/wwwroot/                //切换目录
# 由于我想直接将博客放在/home/wwwroot/下，所以并没有创建blog目录
mkdir blog                  //创建网站目录，以blog为例

配置 SSH

cd /home/git                //切换到git用户目录
mkdir .ssh                  //创建.ssh目录
cd .ssh
vim authorized_keys

然后将本地的公钥复制到 authorized_keys 文件里 (公钥即本地执行 cat ~/.ssh/id_rsa.pub 查看的内容)。

注意：收集所有需要登录的用户的公钥，就是他们自己的 id_rsa.pub 文件，把所有公钥导入到 /home/git/.ssh/authorized_keys 文件里，一行一个。

用户组管理

ll /home/git/
ll /home/wwwroot/

确保 blog.git、.ssh、blog 目录的用户组权限为 git:git，若不是，执行下列命令：

修改用户权限的命令：

# chown -R 用户名.组名 /目录
chown -R git.git /home/git/blog.git/
chown -R git.git /home/git/.ssh/
chown -R git.git /home/wwwroot/

安装配置 Nginx

由于我之前已经装过了nginx，nginx安装内容来源于网络，仅供参考。

安装 Nginx

执行：apt-get install nginx，若输入 nginx -V 可以看到 nginx 版本信息，则安装成功。

配置 nginx

执行：

cd /etc/nginx/sites-available   //切换目录
cp default default.bak          //备份默认配置
vim default                     //修改配置

参考配置文件内容：

server {
    listen 80 default;              #默认监听80端口
    root /home/wwwroot;             #网站根目录
    server_name nightfury.top, www.nightfury.top;  #网址
    access_log  /var/log/nginx/blog_access.log;
    error_log   /var/log/nginx/blog_error.log;
    error_page 404 =  /404.html;
    
    location ~* ^.+\.(ico|gif|jpg|jpeg|png)$ {
        root /home/wwwroot;
        access_log   off;
        expires      1d;
    }

    location ~* ^.+\.(css|js|txt|xml|swf|wav)$ {
        root /home/wwwroot;
        access_log   off;
        expires      10m;
    }

    location / {
        root /home/wwwroot;
        if (-f $request_filename) {
        rewrite ^/(.*)$  /$1 break;
        }
    }

    location /nginx_status {
        stub_status on;
        access_log off;
    }
}

保存退出后，启动 nginx：

systemctl start nginx

设置开机自动启动：

systemctl enable nginx

查看运行状态：

systemctl status nginx

显示 running 表示成功运行。

配置 Git Hooks

创建 post-receive 文件

git 用户下执行（这里我用 root 用户执行上述命令，然后更改了文件所有者为 git.git，就是chown -R git:git post-receive）：

cd /home/git/blog.git/hooks  //切换到hooks目录下
vim post-receive             //创建文件

复制下面的内容到 post-receive 文件中：

#!/bin/bash
echo "post-receive hook is running..."

GIT_REPO=/home/git/blog.git
TMP_GIT_CLONE=/tmp/blog
PUBLIC_WWW=/home/wwwroot

rm -rf ${TMP_GIT_CLONE}
git clone $GIT_REPO $TMP_GIT_CLONE
rm -rf ${PUBLIC_WWW}/*
cp -rf ${TMP_GIT_CLONE}/* ${PUBLIC_WWW}

赋予可执行权限：

chmod +x post-receive

本地操作

尝试连接

在本地打开 Git Bash：

ssh git@VPS的ip

若默认端口不是 22，则需要在后面加上 -p 端口号：

ssh git@VPS的ip -p 2022

返回结果应该如下：

->ssh git@nightfury.top
->Welcome to Ubuntu 18.04 LTS (GNU/Linux 4.14.129-bbrplus x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

 * Strictly confined Kubernetes makes edge and IoT secure. Learn how MicroK8s
   just raised the bar for easy, resilient and secure K8s cluster deployment.

   https://ubuntu.com/engage/secure-kubernetes-at-the-edge

 * Canonical Livepatch is available for installation.
   - Reduce system reboots and improve kernel security. Activate at:
     https://ubuntu.com/livepatch
Last login: Mon Aug 14 15:56:58 2023 from 159.226.177.100
fatal: Interactive git shell is not enabled.
hint: ~/git-shell-commands should exist and have read and execute access.
Connection to nightfury.top closed.

提示无法登录 shell 是正常的，因为我们在之前就为 git 用户指定了 git-shell 每次一登录就自动退出。

配置 Hexo

打开本地博客根目录下的_config.yml 文件，找到最后的 deploy 配置，修改为：

## Deployment

## Docs: https://hexo.io/docs/deployment.html

deploy:
  - type: git
    repo: git@github.com:szNightFury/szNightFury.github.io.git
    branch: master
  - type: git
    repo: git@nightfury.top:/home/git/blog.git
    branch: master

到此，Hexo 建站就全部配置部署完毕了。

Markdown图片配置

2023-08-13T12:38:10.000Z

Hexo中插入图片的方案

第一次使用 Hexo，对于 Markdown 中图片的处理不是很了解。由于 Markdown 中插入的图片多为本地或者网络链接的形式，而经过 Hexo 编译后，网页是不可能获取到本地图片，因此往往需要做额外的处理，经了解有以下几种方案：

使用网络链接。这需要网上资源有你需要的图片，或者使用图床等手动上传，但该方法由于图片掌握在他人手上并不稳定/安全，因此果断抛弃。
使用 base64 编码的方案。因为 Markdown 最后都会生成 html，因此可以将原本的 ![image](image_path) 这种写法改成 ![image](data:image/png:base64,...)这种写法，这种写法不需要将图片存在任何除了这个文件以外的其它地方。但是，图片的 base64 编码非常之长，直接插入文件中间会影响 Markdown 编写过程中的美观。不过其实也可以使用间接的方法，在需要插入图片的地方写 ![image][reference_name]，在其他地方（最好是文章末尾）写 [reference_name]:<base64>，但个人觉得这种方式还是不够优雅。
使用本地图片，同时上传至服务器。Hexo 本身提供了解决方案，需要配合 hexo-asset-img 一同食用，该方案比较优雅，只需将图片保存到本地（配合 Typora），然后一键三连即可（后文附上一键三连代码）

Hexo配置

如 Hexo 官方文档所说，我们首先对于 _config.yml 文件中的 post_asset_folder: false 改为 true，然后安装 hexo-asset-img（网上大多说是安装 hexo-asset-image，但据了解似乎不支持 Hexo5，已经弃用较久了，自己也尝试安装过，发现只有使用 {Picture Filename} 的形式才能在网页上正常显示，但在 Markdown 中却不行，需要使用 {Markdown Title}/{Picture Filename} 的形式才能在编写过程中显示出来，这很不优雅。而 hexo-asset-img 似乎是有个小伙对 hexo-asset-image 进行了魔改，看了下代码主要还是正则化等一些字符串处理，路径在 {Your Hexo Filepath}\node_modules\hexo-asset-img\index.js 中）

此时，通过 hexo n "{Markdown Title}" 会自动创建一个 Markdown 文件和相同名字的文件夹，这时只需要将 Markdown 中的图片存入对应的文件夹中，同时调用时使用 ![{Picture Name}]({Markdown Title}/{Picture Filename}) 即可。注意，由于设置了 post_asset_folder: true，原来的 front-matter 中封面图片的根路径将从根目录 .\source\ 变成 .\source\_posts\{Markdown Title}\，因此封面图片的路径直接使用 {Cover Filename} 即可。

Typora配置

打开 Typora，依次点击 文件 - 偏好设置 - 图像，设置插入图片时复制到指定路径，图片文件保存路径为 ./${filename} 即保存到与当前正在编辑的文件名相同的同级文件夹下，此时，无论是复制的本地图片还是截图的图片，可以直接粘贴进 Typora 中，Typora 将会自动把图片复制到指定位置，当然，可能还需要修改一下图片名以及图片文件名（如果是截图了话）

Hexo一键三连代码

将以下代码保存到 Hexo 根目录的 update.ps1 文件中，然后用管理员权限打开 powershell，执行 .\update.ps1 就会自动完成 清理 - 编译 - 上传 一键三连（当然前提是已经配置好了 hexo d 所需要的一些环境以及 git 帐号等信息填写）。

# 执行 hexo clean
Write-Host "Cleaning Hexo..."
hexo clean

# 执行 hexo g
Write-Host "Generating Hexo..."
hexo g

# 执行 hexo algolia（可选）
Write-Host "Running Hexo Algolia..."
hexo algolia

# 执行 hexo d
Write-Host "Deploying Hexo..."
hexo d

Write-Host "Done!"

Sbt缓存目录配置

2023-08-13T10:17:24.000Z

Sbt文件迁移

Sbt 原来的缓存路径为 C:\Users\{Your User Name}\AppData\Local，里面包含了 .sbt 和 .ivy2 文件夹，在这里我将其迁移至 D:\sbt 路径下

IntelliJ IDEA

打开 IntelliJ IDEA，依次点击 File - Settings - Build, Execution, Deployment - sbt，在 VM parameters 中输入：

-Dsbt.boot.directionary=D:\sbt\.sbt\boot
-Dsbt.global.base=D:\sbt\.sbt
-Dsbt.ivy.home=D:\sbt\.ivy2

至此，sbt 的缓存文件将会保存在 D 盘中，但由于当初安装 sbt 时似乎选择在了 C 盘，因此如有需要还可以对 sbt 进行迁移（似乎安装在了 C:\Users\{Your User Name}\AppData\Local\Coursier\cache\arc\https\github.com\sbt 中），等后面有时间了再处理吧。

m2sPipe与s2mPipe

2023-07-27T07:21:12.000Z

s2mPipe

关键点

self.ready为s2mPipe.ready打一拍，rValid和rData用于寄存输入valid和payload避免气泡。

开敲

如果有寄存数据，输出寄存数据；如果没有寄存数据，寄存数据 or 直接输出（视输出ready决定）

val rData = RegNextWhen(self.payload, self.fire & ~s2mPipe.fire)
val rValid = RegInit(False) setWhen(self.fire) clearWhen(s2mPipe.fire)
val rReady = RegInit(True) setWhen(s2mPipe.ready) clearWhen(~s2mPipe.ready | rValid)


self.ready := rReady
s2mPipe.valid := self.valid | rValid
s2mPipe.payload := Mux(rValid, rData, self.payload)

修正1：rData只有在rValid拉高时才用到，而rValid只有self.fire时才为高，因此

val rData = RegNextWhen(self.payload, self.fire)

修正2：rValid说明是否包含寄存数据，rValid为高时说明无法再接收新寄存数据，这要求self.ready拉低，因为只能寄存-消化-直通 or 寄存-消化-寄存-消化 or 直通，即有寄存数据后只能消化，不能消化的同时寄存（因为rValid在消化的时候拉低了，就算寄存了rValid也为低，这与前面说法相违背，或者说这种情况应该是m2sPipe，因为payload和valid有一拍延时)，因此实际上self.ready只在没有寄存数据的时候才能为高，即

self.ready := ~rValid

修正3：self.ready依赖于rValid，而rValid依赖self.fire，这形成了环路，存在问题. 实际上，rValid为高时，s2mPipe.valid为高，因此拉低条件s2mPipe.fire可以退化成s2mPipe.ready；而拉高条件self.fire & ~s2mPipe.ready是为了说明有数据寄存且没有消化，则原来的rValid为低，self.ready为高（self.ready := ~rValid)，因此拉高条件退化为self.valid & ~s2mPipe.ready，则

val rValid = RegInit(False) setWhen (self.valid) clearWhen(s2mPipe.ready)

修正4：rData的寄存条件self.fire较为严格，因为实际输出依赖rValid选择payload，而rValid是在self.valid时拉高，因此寄存条件self.fire = self.valid & self.ready可以退化为self.ready，则

val rData = RegNextWhen(self.payload, self.ready)

完整代码

val rData = RegNextWhen(self.payload, self.ready)
val rValid = RegInit(False) setWhen(self.valid) clearWhen(s2mPipe.ready)

self.ready := ~rValid
s2mPipe.valid := self.valid | rValid
s2mPipe.payload := Mux(rValid, rData, self.payload)

补充

s2mPipe() is ready to accept new data when the internal data register does not contain valid data.
The ready becomes valid when rData is free, thus when it does not contain valid data already.

m2sPipe

关键点

rValid和rData寄存输入valid和payload, self.ready处理气泡拼接。

开敲

val rData = RegNextWhen(self.payload, self.ready)
val rValid = RegNextWhen(self.valid, self.ready) init(False)

self.ready := m2sPipe.ready | ~m2sPipe.valid	// m2sPipe.isFree
m2sPipe.valid := rValid
m2sPipe.payload := rData

Php环境配置

2023-07-27T03:49:11.000Z

实验环境

操作系统：Ubuntu 18.04
Nginx：1.20.1
PHP：7.2.24
PHP-fpm：php7.2-fpm

实验步骤

安装程序包与依赖

# 更新软件包列表
apt update

# 安装程序包
apt install nginx
apt install php php-fpm php-xml php-json php-curl

# 安装常用依赖
sudo apt-get install php-json
sudo apt-get install php-curl
sudo apt-get install php-hash
sudo apt-get install php-openssl
sudo apt-get install php7.2-cgi

编辑fpm配置文件

sudo vim /etc/php/7.2/fpm/php.ini
# 提升安全性
# 修改参数如下：
# 778行 ;cgi.fix_fathinfo=1 更改为 cgi.fix_fathinfo=0

sudo vim /etc/php/7.2/fpm/pool.d/www.conf
# 配置连接数量
# 修改参数如下
#  36行 listen = 127.0.0.1:9000 
#  62行 listen.allowed_clients = 127.0.0.1
# 113行 pm.max_children = 50
# 139行 pm.max_requests = 500 
# 340行 request_terminate_timeout = 0 
# 344行 rlimit_files = 1024
# 以上部分，包括但不限于去除前面的";"

配置Nginx

sudo vim /etc/nginx/conf/nginx.conf # 富强后用/etc/nginx/conf/conf.d/xxx.conf
# 在index.html前面加入index.php
# 增加：
location ~ \.php$ {
    root           /home/wwwroot/;
    fastcgi_pass   127.0.0.1:9000;
    fastcgi_split_path_info  ^(.+\.php)(.*)$;
    fastcgi_param  SCRIPT_FILENAME $document_root$fastcgi_script_name;
    fastcgi_param  PATH_INFO $fastcgi_path_info;
    include        fastcgi_params; # include fastcgi.conf;
}

fastcgi_params 和 fastcgi.conf 的区别：

include fastcgi.conf： include fastcgi.conf; 通常用于包含 Nginx 默认提供的 FastCGI 配置参数文件。这个文件包含了一些通用的 FastCGI 参数设置，如 fastcgi_param、fastcgi_pass 等。这些参数适用于大多数 FastCGI 应用程序，包括 PHP、Python、Ruby 等。
include fastcgi_params： include fastcgi_params; 同样也是包含 FastCGI 配置参数的指令，但它通常比 fastcgi.conf 更加轻量级。fastcgi_params 文件包含了一些常见的 FastCGI 参数设置，同时避免了一些可能会引起安全问题的参数设置，如 SCRIPT_FILENAME、PATH_TRANSLATED 等。这使得 fastcgi_params 更适合用于共享主机环境或需要更严格安全设置的情况。

总的来说，两者的区别在于：

fastcgi.conf 可能包含更多的参数设置，适用于更多类型的 FastCGI 应用程序，但可能包含一些较为宽松的安全设置。
fastcgi_params 较为轻量，适用于较为安全和精简的配置需求，特别适合共享主机环境。

重启服务

sudo service php7.2-fpm restart # systemctl restart php7.2-fpm
sudo service nginx restart # systemctl restart nginx

验收

编写任意 php 文件，比如说简单的有 index.php：

<h1>
    <span> Hello, this is test page </span>
</h1>

或者 php 探针：

<?php 
	phpinfo(); 
?>

访问该 php 地址，得到正确的返回结果。完结，Move On！

Hello World

2023-07-27T01:44:02.894Z

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

$ hexo new "My New Post"

More info: Writing

Run server

$ hexo server

More info: Server

Generate static files

$ hexo generate

More info: Generating

Deploy to remote sites

$ hexo deploy

More info: Deployment

NightFury

利用Acme脚本自动申请SSL证书

前提条件

脚本详解

1. 确保脚本以root身份运行

2. 检查系统类型

3. 安装socat

4. 检查 Nginx 服务状态

5. 检查端口 80 是否被占用

6. 安装 acme.sh

7. 设置默认 CA 为 Let’s Encrypt

8. 获取用户输入的域名

9. 生成域名参数

10. 申请测试证书

11. 申请正式证书

12. 安装证书

13. 重新启动 Nginx 服务

14. 设置自动续签任务

结论

Debian12部署Cloudreve云盘

步骤一：更新系统

步骤二：下载 Cloudreve

步骤三：配置 Cloudreve

步骤五：创建 systemd 服务

步骤六：访问Cloudreve

步骤七：配置Nginx反向代理（可选）

Debian12系统Hexo部署到VPS

准备工作

Git Hooks 自动部署

部署原理

安装配置 Git

安装 Git

创建 git 用户

赋予 git 用户 sudo 权限

关闭 git 用户 shell 权限

初始化 git 仓库

创建网站目录

配置 SSH

用户组管理

安装配置 Nginx

安装 Nginx

配置 nginx

配置 Git Hooks

创建 post-receive 文件

本地操作

尝试连接

配置 Hexo

Debian12配置Nginx1.22与Php8.2

实验环境

实验步骤

安装程序包与依赖

配置Nginx

修改时区

重启服务

调试步骤

验收

table

A Low Power and Low Latency FPGA-Based Spiking Neural Network Accelerator

A Low Power and Low Latency FPGA-Based Spiking Neural Network Accelerator

摘要

相关工作

设计方法

实验与评估

Efficient Hardware Acceleration of Sparsely Active Convolutional Spiking Neural Networks

Efficient Hardware Acceleration of Sparsely Active Convolutional Spiking Neural Networks

摘要

相关工作

硬件架构

硬件实现

实验与总结

结论

StreamFifo

StreamFifo

Memory Layout Analysis

Memory Layout Analysis

Voltage Membrane

Kernel Weight

Mixed

Hexo部署到VPS

准备工作

1. 确保脚本以`root`身份运行

3. 安装`socat`

6. 安装 `acme.sh`