杂烩饭

使用 Easytier-web 管理 easytier 节点

2026-04-23T00:11:18.000Z

普通的使用方式之前写过一篇文章：开源组网工具-easytier

但是试想一下如果你有 100 个 easytier 节点，现在想批量修改一个配置，那是比较痛苦的事情。easytier-web 就是个管理控制台，可以统一在控制台管理所有节点的配置。

搭建 easytier-web 服务

官方提供的有两种服务，官方文档在：https://easytier.cn/guide/network/web-console.html

EasyTier 的 web 控制台有 2 个版本：

easytier-web（仅 web api 后端）
easytier-web-embed（web 前端 + web api 后端）

如果你只搭建 web api 后端的话，需要登录官方的前端，api 配置你的后端地址，不过都选择自建了，那就前后端一起部署吧。

我是用 docker 搭建的，但是官方的 docker 镜像写死了 entrypoint 是 easytier-core ，不能启动 easytier-web 服务，所以自己构建镜像。

dockerfile

避免镜像变大，我使用多阶段构建。

FROM alpine:latest AS downloader
ADD https://github.com/EasyTier/EasyTier/releases/download/v2.6.1/easytier-linux-x86_64-v2.6.1.zip /
RUN unzip /easytier-linux-x86_64-v2.6.1.zip && \
    mv /easytier-linux-x86_64 /easytier

FROM alpine:latest
COPY --from=downloader /easytier /easytier
WORKDIR /easytier

启动服务

docker run --name easytier-web -d \
    -e TZ=Asia/Shanghai \
    --network iuxt \
    -p 22020:22020/udp \
    -v ./data:/easytier/data \
    --restart=always \
    iuxt/easytier:2.6.1 \
    /easytier/easytier-web-embed \
    --db /easytier/data/et.db \
    --api-server-port 11211 \
    --api-host https://et.example.com \
    --config-server-port 22020 \
    --config-server-protocol udp

说明

我指定了 docker network ，是为了和 nginx 镜像放在同一个网络下，入口统一是 nginx，配置 tls 证书和 mtls 双向认证。
udp 22020 端口是分发配置的端口，映射到公网。
data 目录存储的是数据库，记录的是控制台账号密码以及机器的配置信息。
--api-server-port 11211 这个是指定的 web 控制台界面的端口。
--api-host https://et.example.com 这个是对外的控制台地址。

配置 nginx 入口

控制台我用了 nginx 反向代理，有两个好处：

可以配置 tls 证书，https 安全访问。
配置 mtls 双向认证，只有携带客户端证书才可以访问。

server {
    listen 443 ssl;
    server_name et.example.com;
    client_max_body_size 0;

    ssl_certificate         ssl/example.com.crt;
    ssl_certificate_key     ssl/example.com.key;
    ssl_protocols TLSv1.1 TLSv1.2 TLSv1.3;
    ssl_ciphers EECDH+CHACHA20:EECDH+CHACHA20-draft:EECDH+AES128:RSA+AES128:EECDH+AES256:RSA+AES256:EECDH+3DES:RSA+3DES:!MD5;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    add_header Strict-Transport-Security "max-age=31536000";
    error_page 497  https://$host$request_uri;

    ssl_client_certificate ssl/ca.crt;       # 配置 CA 证书，用于验证客户端证书的签发者
    ssl_verify_client on;                    # 启用客户端证书验证
    ssl_crl ssl/crl.pem;                     # 配置 CRL 文件路径，用于检查吊销的证书

    location / {
      proxy_set_header Host $http_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_cache_convert_head off;

      proxy_connect_timeout 300;
      proxy_http_version 1.1;
      proxy_set_header Connection "";
      chunked_transfer_encoding off;

      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";

      proxy_pass http://easytier-web:11211;
    }
}

客户端接入

客户端启动的时候，只需要指定参数即可接入。

docker run --name easytier-core -d \
    --network host \
    -e TZ=Asia/Shanghai \
    -v /etc/machine-id:/etc/machine-id \
    --privileged \
    --restart=always \
    easytier/easytier:v2.6.1 \
    -w udp://et.example.com:22020/yourusername

说明：

挂载了/etc/machine-id，控制台上的 machine id 是根据这个生成的，为了避免容器重新创建的时候 id 发生变化，所以挂载此文件，或者手动指定 machine id ，增加参数：--machine-id 。
-w udp://et.example.com:22020/yourusername 这里是控制台的配置下发地址，和你的控制台上注册的用户名。

控制台设置

第一步先注册、登录控制台。
接入了节点后，在控制台可以看到节点的信息：

点击设置按钮，create network，配置好后点击保存即可。后续可以在控制台修改配置，无须更新节点。

ingress-nginx 去除指定context path

2026-02-21T13:52:27.000Z

比如我想去掉 url 中的 /a

curl test.example.com/a/b/xxx/xxx

# 实际请求到后端的路径：
/b/xxx/xxx

方法一、使用 Nginx 配置片段

1
2
3

location /a/b/ {
  proxy_pass http://a.default/b/;
}

但是这种方式需要修改 ingress nginx 开启支持 nginx 配置的功能，详情见 ingress-nginx 使用自定义的nginx配置

方法二、使用 ingress nginx 原生配置

需要去除 context path 的路径，创建专门的 ingress，比如：

kind: Ingress
apiVersion: networking.k8s.io/v1
metadata:
  name: a
  namespace: default
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: 'true'
spec:
  ingressClassName: private-nginx
  rules:
    - host: test.example.com
      http:
        paths:
          - path: /
            pathType: ImplementationSpecific
            backend:
              service:
                name: a
                port:
                  number: 80

---
kind: Ingress
apiVersion: networking.k8s.io/v1
metadata:
  name: b
  namespace: default
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: 'true'
    nginx.ingress.kubernetes.io/rewrite-target: /b/$2
spec:
  ingressClassName: private-nginx
  rules:
    - host: test.example.com
      http:
        paths:
          - path: /a/b(/|$)(.*)
            pathType: ImplementationSpecific
            backend:
              service:
                name: b
                port: 
                  number: 80

在macOS上使用MusicPlayer2听本地音乐

2026-02-21T13:40:15.000Z

我的环境：
OS：macOS Tahoe & macOS Sequoia
CrossOver 版本：26.0
MusicPlayer2 版本：2.78

在 macOS 上没有找到我想要的本地音乐播放软件，倒是 Windows 上有个开源的播放器很不错: MusicPlayer2官方地址，由于是 Windows 应用程序，想要在 macOS 上使用，我用的是 CrossOver 来运行，凑合使用，就是 CPU 使用率有亿点高。

配置软件

MusicPlayer2 文件我放在了 iCloud Drive 里，这样多个 Mac 电脑可以同步配置、播放记录等。

创建容器

我创建的是 Windows 11 容器。

安装运行库

按照 MusicPlayer2 的要求，需要安装 Microsoft Visual C++ 运行库到 CrossOver 的容器里，当然也可以将需要的 dll 文件放在软件目录下。

创建图标

在这里选择程序路径，然后将指令保存到面板

备注：删除图标

CrossOver 设计的有问题，创建图标没给删除的方式，经过研究，删除图标需要到：~/Applications/CrossOver/ 把对应的文件删除即可。

CrossOver 配置

为了显示最佳化，我做了如下改动：
图形：D3DMetal
开启高分辨率模式

窗口大小调整问题

默认情况下不能调整窗口大小，只能最大化和最小化，需要修改 Wine 配置 Graphics ，取消勾选允许窗口管理器装饰窗口。

MusicPlayer2 配置

歌词字体设置霞鹜文楷常规
标题栏自绘标题栏（wine 自带标题栏太难看了）
界面设置为界面 12（这个界面不带系统默认的列表，默认列表搜索有 bug）

最终展示界面

Kubernetes 1.34 + RHEL10 + Cilium + kube-vip 高可用集群部署

2026-01-10T15:19:23.000Z

适用场景：
裸机 / 虚拟机环境
无云厂商 LB
追求 eBPF + 原生路由的高性能网络

环境介绍

主机名	IP	安装组件
master1	10.0.0.11	etcd、apiserver、controller-manager、scheduler、kubelet、containerd、kubeadm、kube-vip
master2	10.0.0.12	etcd、apiserver、controller-manager、scheduler、kubelet、containerd、kubeadm、kube-vip
master3	10.0.0.13	etcd、apiserver、controller-manager、scheduler、kubelet、containerd、kubeadm、kube-vip

基础环境

操作系统：CentOS Stream 10
Kubernetes：v1.34.5
容器运行时：containerd
CNI：Cilium
高可用方式：kube-vip（ARP 模式）

准备工作（所有节点）

关闭防火墙与 SELinux

sudo systemctl disable --now firewalld
setenforce 0
sed -i "s/^SELINUX=.*/SELINUX=disabled/g" /etc/selinux/config

# 验证，结果为0
getenforce

配置主机名

1	hostnamectl set-hostname master1

配置 hosts

cat >> /etc/hosts <<EOF
10.0.0.11 master1
10.0.0.12 master2
10.0.0.13 master3
EOF

关闭 Swap

swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab

# 验证, swap为0
free -h

时间同步

dnf install -y chrony
systemctl enable --now chronyd

# 验证，查看时间状态
timedatectl status

内核参数与模块

yum install -y kernel-modules-extra

cat > /etc/modules-load.d/k8s.conf <<EOF
overlay
br_netfilter
EOF

modprobe overlay
modprobe br_netfilter

cat > /etc/sysctl.d/99-kubernetes-cri.conf <<EOF
net.bridge.bridge-nf-call-iptables  = 1
net.ipv4.ip_forward                 = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF

sysctl -p

# RHEL 10 测试要重启 net.ipv4.ip_forward 才能生效, 或者临时修改一下
echo 1 > /proc/sys/net/ipv4/ip_forward

启用 cgroup v2

CentOS Stream 10 / RHEL 10 / Rocky Linux 10 / AlmaLinux 10 默认已经启用了 cgroup v2

安装 Containerd（所有节点）

# 卸载旧版本Docker
sudo yum remove docker \
        docker-client \
        docker-client-latest \
        docker-common \
        docker-latest \
        docker-latest-logrotate \
        docker-logrotate \
        docker-engine

# 安装docker仓库
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 安装containerd
sudo yum install containerd.io -y

启用 SystemdCgroup

systemctl stop containerd

mkdir -p /etc/containerd
containerd config default > /etc/containerd/config.toml
sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
systemctl enable --now containerd

# 验证
sudo ctr version

安装 Kubernetes 组件（所有节点）

配置 yum 源

cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.34/rpm/
enabled=1
gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.34/rpm/repodata/repomd.xml.key
exclude=kubelet kubeadm kubectl cri-tools kubernetes-cni
EOF

cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.34/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.34/rpm/repodata/repomd.xml.key
exclude=kubelet kubeadm kubectl cri-tools kubernetes-cni
EOF

安装

# 查看可用的版本
yum list kubelet kubeadm kubectl --showduplicates --disableexcludes=kubernetes

yum install -y kubelet-1.34.5 kubeadm-1.34.5 kubectl-1.34.5 --disableexcludes=kubernetes

systemctl enable --now kubelet

配置 crictl

1	crictl config --set runtime-endpoint=unix:///run/containerd/containerd.sock

初始化 Kubernetes（首个 Master）

创建集群

# 也可以先拉取镜像
# kubeadm config images pull --kubernetes-version 1.34.5
# --skip-phases=addon/kube-proxy 是为了 Cilium 网络插件，如果用flannel，不用加这个参数

ip addr add 10.0.0.10/24 dev ens160

sudo kubeadm init \
  --control-plane-endpoint "10.0.0.10:6443" \
  --kubernetes-version 1.34.5 \
  --upload-certs \
  --service-cidr=10.96.0.0/12 \
  --pod-network-cidr=10.244.0.0/16 \
  --skip-phases=addon/kube-proxy

配置 kubectl

1
2
3

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

安装 Cilium（首个 master）

安装 cilium-cli

dnf install tar -y

CILIUM_CLI_VERSION=$(curl -s https://raw.githubusercontent.com/cilium/cilium-cli/main/stable.txt)
CLI_ARCH=amd64

if [ "$(uname -m)" = "aarch64" ]; then CLI_ARCH=arm64; fi
curl -L --fail --remote-name-all https://github.com/cilium/cilium-cli/releases/download/${CILIUM_CLI_VERSION}/cilium-linux-${CLI_ARCH}.tar.gz{,.sha256sum}
sha256sum --check cilium-linux-${CLI_ARCH}.tar.gz.sha256sum
sudo tar xzvfC cilium-linux-${CLI_ARCH}.tar.gz /usr/local/bin
rm cilium-linux-${CLI_ARCH}.tar.gz{,.sha256sum}

cilium install \
  --set kubeProxyReplacement=true \
  --set ipam.mode=cluster-pool \
  --set routingMode=native \
  --set ipam.operator.clusterPoolIPv4PodCIDRList=10.244.0.0/16 \
  --set ipam.operator.clusterPoolIPv4MaskSize=24 \
  --set ipv4NativeRoutingCIDR=10.244.0.0/16 \
  --set autoDirectNodeRoutes=true \
  --set bpf.masquerade=true

cilium install \
  --set kubeProxyReplacement=true \
  --set tunnel=vxlan \
  --set ipam.mode=cluster-pool \
  --set ipam.operator.clusterPoolIPv4PodCIDRList=10.244.0.0/16 \
  --set ipam.operator.clusterPoolIPv4MaskSize=24 \
  --set bpf.masquerade=true

检查状态

cilium status --wait


    /¯¯\
 /¯¯\__/¯¯\    Cilium:             OK
 \__/¯¯\__/    Operator:           OK
 /¯¯\__/¯¯\    Envoy DaemonSet:    OK
 \__/¯¯\__/    Hubble Relay:       disabled
    \__/       ClusterMesh:        disabled

DaemonSet              cilium                   Desired: 1, Ready: 1/1, Available: 1/1
DaemonSet              cilium-envoy             Desired: 1, Ready: 1/1, Available: 1/1
Deployment             cilium-operator          Desired: 1, Ready: 1/1, Available: 1/1
Containers:            cilium                   Running: 1
                       cilium-envoy             Running: 1
                       cilium-operator          Running: 1
                       clustermesh-apiserver    
                       hubble-relay             
Cluster Pods:          2/2 managed by Cilium
Helm chart version:    1.18.3
Image versions         cilium             quay.io/cilium/cilium:v1.18.3@sha256:5649db451c88d928ea585514746d50d91e6210801b300c897283ea319d68de15: 1
                       cilium-envoy       quay.io/cilium/cilium-envoy:v1.34.10-1761014632-c360e8557eb41011dfb5210f8fb53fed6c0b3222@sha256:ca76eb4e9812d114c7f43215a742c00b8bf41200992af0d21b5561d46156fd15: 1
                       cilium-operator    quay.io/cilium/operator-generic:v1.18.3@sha256:b5a0138e1a38e4437c5215257ff4e35373619501f4877dbaf92c89ecfad81797: 1

部署 kube-vip（首个 master）

export VIP=10.0.0.10
export INTERFACE=ens160
kubectl apply -f https://kube-vip.io/manifests/rbac.yaml

ip addr del 10.0.0.10/24 dev ens160

ctr image pull docker.io/plndr/kube-vip:v1.0.3
ctr run --rm --net-host docker.io/plndr/kube-vip:v1.0.3 kube-vip /kube-vip manifest pod \
  --interface $INTERFACE \
  --address $VIP \
  --controlplane \
  --services \
  --arp \
  --leaderElection \
  | tee /etc/kubernetes/manifests/kube-vip.yaml
  
# 验证，如果有 kube-vip-master1 就说明成功了
kubectl get pod -n kube-system

其余节点加入集群

生成 token

# 这条命令生成加入命令
kubeadm token create --print-join-command --ttl 30m

# 这条命令会生成一个key
kubeadm init phase upload-certs --upload-certs

增加 Master 节点

# 发送 kube-vip 配置文件到其他 Master 节点
cd /etc/kubernetes/manifests
scp kube-vip.yaml 10.0.0.12:$PWD
scp kube-vip.yaml 10.0.0.13:$PWD

# 参考上一步的生成token的结果
kubeadm join 10.0.0.10:6443 --token  --discovery-token-ca-cert-hash sha256:<hash> --control-plane --certificate-key 

# 验证 ETCD 状态
kubectl exec -it -n kube-system etcd-master1 -- etcdctl --endpoints 127.0.0.1:2379 --cacert /etc/kubernetes/pki/etcd/ca.crt --cert /etc/kubernetes/pki/etcd/server.crt --key /etc/kubernetes/pki/etcd/server.key member list

增加 Node 节点

1 2	# 参考上面生成token步骤的输出结果 kubeadm join 10.0.0.10:6443 --token --discovery-token-ca-cert-hash sha256:<hash>

验证部署

1
2
3

kubectl create deployment testdp --image=nginx:1.23.2
kubectl expose deployment testdp --port=80 --type=NodePort
kubectl get pods,svc

浏览器访问：

1
2
3

http://10.0.0.11:NodePort
http://10.0.0.12:NodePort
http://10.0.0.13:NodePort

使用腾讯云CLS收集TKE（k8s）业务日志

2026-01-07T13:23:56.000Z

使用 CLS 来采集业务日志的好处有

运维方便，不用费劲搭建 ELK 系统，传统的 filebeat -> kafka -> logstash -> ElasticSearch 架构复杂
费用便宜（和 ES、kafka 这一套相比）
不用担心告警等（如 ES 磁盘使用率等）

开启采集

在集群管理界面，点击日志新增采集配置：

然后选择日志源、元数据等，点击下一步，配置日志解析方式。

如果是纯 json 日志，就配置成 json 格式解析。业务日志是 Spring Boot，并且包含多行日志，所以选择多行 - 完全正则模式来匹配。

点击完成后就完成了日志采集。

多行正则模式匹配

假设业务日志格式为：

2026-01-07 20:58:29.335  INFO [tsp-agent,517f1bd4b38282b2,e66be3ada6f121cf,true] [XNIO-1 task-7] c.ingeek.nub.webmvc.filter.PrintFilter   [145]: 响应
 ResponseHeader: 
    Transfer-Encoding: chunked
    Connection: keep-alive
    Date: Wed, 07 Jan 2026 12:58:29 GMT
    Content-Type: application/json
 Body: 
    {"code":0,"message":"成功","data":{"nkUserId":"158c440b431d482a8a738f82caf2f638","nkUserTicket":"2bb5003769864887a90f615a7381d253","expiresAt":1767790769}}

那么我们需要的日志字段有（按日志顺序）：

2026-01-07 20:58:29.335 日志时间
INFO 日志级别
[服务名，TraceId， SpanId, 不知道是什么字段]
[XNIO-1 task-7] XNIO：是 XNIO 框架的线程池 task-7：线程池中的第 7 个工作线程
c.ingeek.nub.webmvc.filter.PrintFilter 哪个类打印出来的
[145] 上面的 java 类的第 145 行打印的日志
冒号 : 后面的是日志原文了，多行的

根据这个，写一个正则，然后点击提取验证。

1	(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3})\s+(\w+)\s+\[([^,\]]),([^,\]]),([^,\]]),[^,\]]\]\s+\[[^\]]+\]\s+([^\s[]+)\s\[\d+\]:\s(.*)

需要的字段，用括号 () 包起来，点击提取验证，下面就会有示例：

给提取到的日志起个 Key 名

然后到 CLS 日志 -> 检索分析里面，可以看到日志字段都成功解析了。

Ingress Nginx 访问日志采集

比如想采集 ingress-nginx 的访问日志，需要先配置 ingress controller 的日志输出格式（Nginx 同理）。然后再进行采集，日志解析格式为 json 即可。

容器调试工具之BusyBox

2025-12-14T13:57:28.000Z

很早之前我在上学的时候给安卓手机刷机，root 后还可以安装了个号称 Linux 瑞士军刀的 App，不过没搞懂有什么用，不过记住了这个特别的名字 – BusyBox

BusyBox 是什么

BusyBox 是一款超轻量级的 Linux 工具集，也被称为 “Linux 瑞士军刀”—— 它把数百个常用的 Linux 命令（如 ls、cat、ps、telnet、unzip 等）打包进一个单一的可执行文件，体积仅 1-2MB，且支持静态编译，是嵌入式 Linux、精简系统、应急运维场景的 “神器”。

下载地址

官方编译好的可执行文件：https://busybox.net/downloads/binaries/1.35.0-x86_64-linux-musl/，可以下载主文件 busybox，也可以下载单个命令使用。

BusyBox 使用方法

包含的命令

BusyBox v1.35.0 (2022-01-17 19:57:02 CET) multi-call binary.
BusyBox is copyrighted by many authors between 1998-2015.
Licensed under GPLv2. See source distribution for detailed
copyright notices.

Usage: busybox [function [arguments]...]
   or: busybox --list[-full]
   or: busybox --show SCRIPT
   or: busybox --install [-s] [DIR]
   or: function [arguments]...

BusyBox is a multi-call binary that combines many common Unix
utilities into a single executable.  Most people will create a
link to busybox for each function they wish to use and BusyBox
will act like whatever it was invoked as.

Currently defined functions:
[, [[, acpid, add-shell, addgroup, adduser, adjtimex, ar, arch, arp, arping, ascii, ash, awk, base32, base64, basename, bc, blkdiscard, blkid, blockdev, bootchartd,
brctl, bunzip2, bzcat, bzip2, cal, cat, chat, chattr, chgrp, chmod, chown, chpasswd, chpst, chroot, chrt, chvt, cksum, clear, cmp, comm, conspy, cp, cpio, crc32, crond,
crontab, cryptpw, cttyhack, cut, date, dc, dd, deallocvt, delgroup, deluser, depmod, devmem, df, dhcprelay, diff, dirname, dmesg, dnsd, dnsdomainname, dos2unix, dpkg,
dpkg-deb, du, dumpkmap, dumpleases, echo, ed, egrep, eject, env, envdir, envuidgid, expand, expr, factor, fakeidentd, fallocate, false, fatattr, fbset, fbsplash,
fdflush, fdformat, fdisk, fgconsole, fgrep, find, findfs, flash_eraseall, flash_lock, flash_unlock, flashcp, flock, fold, free, freeramdisk, fsck, fsck.minix, fsfreeze,
fstrim, fsync, ftpd, ftpget, ftpput, fuser, getopt, getty, grep, groups, gunzip, gzip, halt, hd, hdparm, head, hexdump, hexedit, hostid, hostname, httpd, hush, hwclock,
i2cdump, i2cget, i2cset, i2ctransfer, id, ifconfig, ifenslave, ifplugd, inetd, init, inotifyd, insmod, install, ionice, iostat, ip, ipaddr, ipcalc, ipcrm, ipcs, iplink,
ipneigh, iproute, iprule, iptunnel, kbd_mode, kill, killall, killall5, klogd, last, less, link, linux32, linux64, linuxrc, ln, loadfont, loadkmap, logger, login,
logname, losetup, lpd, lpq, lpr, ls, lsattr, lsmod, lsof, lspci, lsscsi, lsusb, lzcat, lzma, lzop, lzopcat, makedevs, makemime, man, md5sum, mdev, mesg, microcom, mim,
mkdir, mkdosfs, mke2fs, mkfifo, mkfs.ext2, mkfs.minix, mkfs.reiser, mkfs.vfat, mknod, mkpasswd, mkswap, mktemp, modinfo, modprobe, more, mount, mountpoint, mpstat, mt,
mv, nameif, nbd-client, nc, netstat, nice, nl, nmeter, nohup, nologin, nproc, nsenter, nslookup, ntpd, nuke, od, openvt, partprobe, passwd, paste, patch, pgrep, pidof,
ping, ping6, pipe_progress, pivot_root, pkill, pmap, popmaildir, poweroff, powertop, printenv, printf, ps, pscan, pstree, pwd, pwdx, raidautorun, rdate, rdev, readlink,
readprofile, realpath, reboot, reformime, remove-shell, renice, reset, resize, resume, rev, rm, rmdir, rmmod, route, rpm, rpm2cpio, rtcwake, run-init, run-parts,
runlevel, runsv, runsvdir, rx, script, scriptreplay, sed, sendmail, seq, setarch, setconsole, setfattr, setfont, setkeycodes, setlogcons, setpriv, setserial, setsid,
setuidgid, sh, sha1sum, sha256sum, sha3sum, sha512sum, showkey, shred, shuf, slattach, sleep, smemcap, softlimit, sort, split, ssl_client, start-stop-daemon, stat,
strings, stty, su, sulogin, sum, sv, svc, svlogd, svok, swapoff, swapon, switch_root, sync, sysctl, syslogd, tac, tail, tar, taskset, tc, tcpsvd, tee, telnet, telnetd,
test, tftp, tftpd, time, timeout, top, touch, tr, traceroute, traceroute6, true, truncate, ts, tty, ttysize, tunctl, tune2fs, ubiattach, ubidetach, ubimkvol, ubirename,
ubirmvol, ubirsvol, ubiupdatevol, udhcpc, udhcpc6, udhcpd, udpsvd, uevent, umount, uname, uncompress, unexpand, uniq, unix2dos, unlink, unlzma, unlzop, unshare, unxz,
unzip, uptime, users, usleep, uudecode, uuencode, vconfig, vi, vlock, volname, w, wall, watch, watchdog, wc, wget, which, who, whoami, whois, xargs, xxd, xz, xzcat, yes,
zcat, zcip

如何使用

直接使用

# 从我的镜像仓库下载
curl -OL https://s3.babudiu.com/src/linux/bin/busybox && chmod +x busybox

# zip 解压 jar 包
./busybox unzip app.jar

# ps查看进程
./busybox ps aux

# df查看磁盘
./busybox df -h

# ping测试网络
./busybox ping -c 4 baidu.com

简化使用

如果想像原生命令一样直接用 busybox 自带的命令，可创建软链接：

ln -s busybox ps
ln -s busybox df
ln -s busybox /usr/local/bin/ping

# 之后直接调用
./ps aux
./df -h
ping baidu.com

为什么适合在容器环境下使用

镜像安全问题，容易被各种安全团队扫描到漏洞进行整改，需要尽量少安装各种包。
镜像体积大小问题。
有些容器的基础镜像停止维护（比如老掉牙的 jdk8,基础的操作系统镜像也比较老，想要安装个包很折腾）

无Docker环境进行容器镜像操作

2025-11-16T11:52:09.000Z

找了有两个开源项目比较不错，都可以完成镜像的迁移。

crpy 的使用

crpy 使用 python 开发，有本地缓存，拉取和推送镜像速度比较快。使用体验比较接近 docker。
开源地址： https://github.com/bvanelli/crpy

安装

1 2	# 也可以安装到虚拟环境 pip install crpy

认证

1	crpy login registry.cn-hangzhou.aliyuncs.com -u -p

认证信息存储在：~/.crpy/config.json

拉取镜像

1	crpy pull nginx:1.29 nginx_1.29.tar

缓存数据存储在：~/.crpy/blobs

推送镜像

1	crpy push nginx_1.29.tar registry.cn-hangzhou.aliyuncs.com/iuxt/nginx:1.29

crane 的使用

这个工具是 Golang 写的，支持 Windows，单文件直接运行，比较方便，支持指定架构。

https://github.com/google/go-containerregistry/blob/main/cmd/crane/README.md

安装

在：https://github.com/google/go-containerregistry/releases 下载二进制文件即可。

认证

1	crane auth login registry.cn-hangzhou.aliyuncs.com -u -p

认证信息存储在：~/.docker/config.json

拉取镜像

1 2	# --platform linux/arm64 可以指定拉取特定架构的镜像 crane pull --platform linux/arm64 nginx:1.27 nginx_1.27.tar

推送镜像

1	crane push ./nginx_1.27.tar registry.cn-hangzhou.aliyuncs.com/iuxt/nginx:1.27

同步镜像

同步镜像会根据两个仓库的镜像摘要来确定是否同步对应的层，如果指定的层目标已存在是不会进行同步的，同步会更高效。

1	crane copy --platform linux/amd64 nginx:1.27 registry.cn-hangzhou.aliyuncs.com/iuxt/nginx:1.27

查看仓库里有哪些 tag

1	crane ls registry.cn-hangzhou.aliyuncs.com/iuxt/nginx

使用kubeadm部署一套高可用k8s集群1.34 for Ubuntu

2025-10-29T01:42:58.000Z

基于 ubuntu 使用 kubeadm 搭建集群， centos部署文档, 有疑问的地方可以看官方文档

准备机器

我的机器详情如下, 配置至少为 4C4G

hostname	IP	作用
master1	10.0.0.11	k8s master 节点
master2	10.0.0.12	k8s master 节点
master3	10.0.0.13	k8s master 节点
worker1	10.0.0.21	k8s worker 节点
worker2	10.0.0.22	k8s worker 节点

每台机器都做域名解析，或者绑定 hosts(可选但建议)

vim /etc/hosts

10.0.0.11 master1
10.0.0.12 master2
10.0.0.13 master3

基础环境配置

基础环境是不管 master 还是 worker 都需要的环境

禁用 swap
确保每个节点上 MAC 地址和 product_uuid 的唯一性 sudo cat /sys/class/dmi/id/product_uuid
修改 hostname
允许 iptables 检查桥接流量
关闭防火墙

1	sudo systemctl disable --now ufw

安装 runtime

先决条件

cat <<EOF | sudo tee /etc/modules-load.d/containerd.conf
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

# 设置必需的 sysctl 参数，这些参数在重新启动后仍然存在。
cat <<EOF | sudo tee /etc/sysctl.d/99-kubernetes-cri.conf
net.bridge.bridge-nf-call-iptables  = 1
net.ipv4.ip_forward                 = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF

# 应用 sysctl 参数而无需重新启动
sudo sysctl --system

安装

# 安装依赖
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg lsb-release

# 信任密钥
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 添加仓库
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安装containerd
sudo apt update
sudo apt install -y containerd.io

配置

生成默认配置

1 2	sudo mkdir -p /etc/containerd containerd config default \| sudo tee /etc/containerd/config.toml

结合 runc 使用 systemd cgroup 驱动，在 /etc/containerd/config.toml 中设置

# 结合 runc 使用 systemd cgroup 驱动，在 `/etc/containerd/config.toml` 中设置
sed -i 's#SystemdCgroup = .*#SystemdCgroup = true#g' /etc/containerd/config.toml

# 修改 pause容器 镜像，不能拉取官方镜像的可以使用阿里云镜像源
# sed -i 's#sandbox_image = .*#sandbox_image = "registry.aliyuncs.com/google_containers/pause:3.9"#g' /etc/containerd/config.toml
sed -i 's#sandbox_image = .*#sandbox_image = "registry.k8s.io/pause:3.10.1"#g' /etc/containerd/config.toml

sudo systemctl restart containerd

crictl 配置

之前使用 docker 的时候，docker 给我们做了很多好用的工具，现在用了 containerd，管理容器我们用 cri 管理工具 crictl，创建配置文件

cat > /etc/crictl.yaml <<-'EOF'
runtime-endpoint: unix:///run/containerd/containerd.sock
debug: false
EOF

安装 Docker

1	curl -fsSL get.docker.com \| bash

配置 Doker

sudo mkdir /etc/docker
cat <
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF

sudo systemctl enable --now docker

安装 kubeadm、kubelet 和 kubectl

这一步需要科学上网, 不能科学上网的可以看看国内的源。

更新 apt 包索引并安装使用 Kubernetes apt 仓库所需要的包：

1 2	sudo apt update sudo apt-get install -y apt-transport-https ca-certificates curl gpg

下载 Google Cloud 公开签名秘钥与添加 Kubernetes apt 仓库：

官方版本变更较快，详情查看官方文档https://kubernetes.io/zh-cn/docs/setup/production-environment/tools/kubeadm/install-kubeadm/

更新 apt 包索引，安装 kubelet、kubeadm 和 kubectl，并锁定其版本：

curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.34/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.34/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

sudo apt update

# 查看可用的版本号
sudo apt-cache madison kubeadm
sudo apt install -y kubeadm=1.34.5-1.1 kubelet=1.34.5-1.1 kubectl=1.34.5-1.1

# 锁定版本，不随 apt upgrade 更新
sudo apt-mark hold kubelet kubeadm kubectl
sudo systemctl enable --now kubelet

准备高可用方案

高可用方案有很多种，其他方案请参考 Kubernetes之master高可用方案

这里使用每台节点部署 nginx 反代来实现高可用，这种方式需要所有节点都安装负载均衡 (包括 master 和 worker )

mkdir -p /etc/kube-lb/{conf,logs,sbin}

curl -L -C - https://s3.babudiu.com/src/linux/bin/kube-lb -o /etc/kube-lb/sbin/kube-lb
chmod +x /etc/kube-lb/sbin/kube-lb


cat > /etc/kube-lb/conf/kube-lb.conf <<'EOF'
user root;
worker_processes 1;

error_log  /etc/kube-lb/logs/error.log warn;

events {
    worker_connections  3000;
}

stream {
    upstream backend {
        server 10.0.0.11:6443    max_fails=2 fail_timeout=3s;
        server 10.0.0.12:6443    max_fails=2 fail_timeout=3s;
        server 10.0.0.13:6443    max_fails=2 fail_timeout=3s;
    }

    server {
        listen 127.0.0.1:8443;
        proxy_connect_timeout 1s;
        proxy_pass backend;
    }
}
EOF

cat > /etc/systemd/system/kube-lb.service <<'EOF'
[Unit]
Description=l4 nginx proxy for kube-apiservers
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=forking
ExecStartPre=/etc/kube-lb/sbin/kube-lb -c /etc/kube-lb/conf/kube-lb.conf -p /etc/kube-lb -t
ExecStart=/etc/kube-lb/sbin/kube-lb -c /etc/kube-lb/conf/kube-lb.conf -p /etc/kube-lb
ExecReload=/etc/kube-lb/sbin/kube-lb -c /etc/kube-lb/conf/kube-lb.conf -p /etc/kube-lb -s reload
PrivateTmp=true
Restart=always
RestartSec=15
StartLimitInterval=0
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF


# 启动服务
systemctl enable --now kube-lb

kube-lb 其实就是自己编译的 Nginx，精简了 http 模块，只开启了 stream 模块用作 4 层转发，详细参数如下：

1
2
3

nginx version: nginx/1.24.0
built by gcc 4.8.5 20150623 (Red Hat 4.8.5-44) (GCC)
configure arguments: --with-stream --without-http --without-http_uwsgi_module --without-http_scgi_module --without-http_fastcgi_module

创建集群

kubeadm init

在 init 之前先将镜像拉取到本地（可选步骤）

1	kubeadm config images pull --kubernetes-version 1.34.5

其中会拉下来一个 pause 镜像，尽量再修改一下 containerd 里面配置的 pause 镜像，版本保持一致。

在 k8s-master0 上执行

sudo kubeadm init \
--kubernetes-version 1.34.5 \
--control-plane-endpoint "127.0.0.1:8443" \
--upload-certs \
--service-cidr=10.96.0.0/12 \
--pod-network-cidr=10.244.0.0/16

在 init 之前先将镜像拉取到本地（可选步骤）

1	kubeadm config images pull --kubernetes-version 1.34.5 --image-repository registry.cn-hangzhou.aliyuncs.com/google_containers

在 k8s-master0 上执行

sudo kubeadm init \
--kubernetes-version 1.34.5 \
--control-plane-endpoint "127.0.0.1:8443" \
--image-repository registry.cn-hangzhou.aliyuncs.com/google_containers \
--upload-certs \
--service-cidr=10.96.0.0/12 \
--pod-network-cidr=10.244.0.0/16

也可以用 kubeadm config print init-defaults > init.yaml 生成 kubeadm 的配置，并用
kubeadm init --config=init.yaml 来创建集群。

安装网络插件

1	kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

待补充

常见问题

kubeadm 部署的集群常见问题汇总

正在运行的Docker容器增加端口映射

2025-09-26T16:39:30.000Z

为什么有这个需求

假设有如下情况：

这个服务很重要，很多服务在连，停服不知道会有什么影响。
服务是运行在 docker 里的，但是 docker 启动命令找不到了。
想给 docker 容器临时增加一个端口映射。

方法一、使用工具反向代理

这个方法性能不如上面的 iptables 规则，比如可以用 nginx 的 stream 四层代理，或者用 socat 一条命令搞定。

查看容器的 IP 地址

1	docker inspect postgres

在结果中找到 NetworkSettings -> Networks -> <你的网络名称> -> IPAddress

# 安装 socat
sudo apt-get install socat  # Ubuntu/Debian

# 创建端口转发，172.18.0.2 是容器的IP
socat TCP-LISTEN:5432,fork TCP:172.18.0.2:5432

方法二、参照 Docker 原生的方式

docker 的 -p 命令来进行端口映射，本质上也是维护了一套 iptables 规则来实现的，docker-proxy 会维护 docker 需要的 iptables 规则，执行 iptables-save 可以查看所有的规则 (iptables-save 并不会真的 save，想保存 iptables 规则还需要额外的操作)。

获取容器的 IP 地址

1	docker inspect postgres

在结果中找到 NetworkSettings -> Networks -> <你的网络名称> -> IPAddress

查看 docker 的虚拟网卡

docker 的一个 bridge 网卡就对应了 linux 机器上的一个网卡，要新增端口映射，需要知道你的容器连接的虚拟网卡是什么。

比如我想让 Postgres 的 5432 端口映射到外网，先查看 Postgres 的容器信息。

1	docker inspect postgres

在结果中找到 NetworkSettings -> Networks -> <你的网络名称> -> Gateway ，记录一下网关的 IP

ip addr

可以知道网卡的名称是 br-342eceae259f

配置 iptables 规则

比如我的容器 IP：172.18.0.2
Docker 虚拟网卡：br-342eceae259f
要映射的端口：5432

1
2

iptables -A DOCKER-USER -o br-342eceae259f ! -i br-342eceae259f -d 172.18.0.2/32 -m tcp -p tcp --dport 5432 -j ACCEPT
iptables -t nat -A DOCKER ! -i br-342eceae259f -p tcp -m tcp --dport 5432 -j DNAT --to-destination 172.18.0.2:5432

不需要做 SNAT，因为 Docker 默认已经做了 SNAT 了。

方法三、传统的 iptables 规则

#!/bin/bash

IP=10.0.0.21
PORT=8000
CONTAINER_IP=172.17.0.2
CONTAINER_PORT=80

# 这个是DNAT，到本机的流量，重写目的地址为容器
iptables -t nat -A PREROUTING -4 -p tcp -d ${IP} --dport ${PORT} -j DNAT --to-destination ${CONTAINER_IP}:${CONTAINER_PORT}

# 这个是为了本机也可以通过访问自己的IP和端口来访问
iptables -t nat -A OUTPUT -4 -p tcp -d ${IP} --dport ${PORT} -j DNAT --to-destination ${CONTAINER_IP}:${CONTAINER_PORT}

# 注意这两条，需要将规则插到最上面，或者加入到DOCKER-USER链，配合下面的图理解
iptables -I FORWARD -p tcp -d ${CONTAINER_IP} --dport ${CONTAINER_PORT} -j ACCEPT
iptables -I FORWARD -p tcp -s ${CONTAINER_IP} --sport ${CONTAINER_PORT} -j ACCEPT

# 这个是SNAT规则，数据包回包
iptables -t nat -A POSTROUTING -4 -p tcp -d ${CONTAINER_IP} --dport ${CONTAINER_PORT} -j SNAT --to-source ${IP}

如果规则不加，或加在了 DOCKER-USER 的下面，会兜兜转转，最后匹配到了 DROP

知道了原理后，那么还有一种方法：删除这个 DROP（不要这么做）

1	# iptables -D DOCKER ! -i docker0 -o docker0 -j DROP

轻量级组网工具WireGuard

2025-09-04T14:35:52.000Z

要先打开服务器的内核转发：net.ipv4.ip_forward = 1
假设 WireGuard 自身的虚拟网段是 10.8.0.0/24, 给服务器分配的 IP 是：10.8.0.1，服务器的公网 IP 是：124.221.31.148

服务器基础配置

# Ubuntu安装 WireGuard
sudo apt-get install -y wireguard

# CentOS 安装 WireGuard
sudo yum install -y wireguard-tools

# 开启内核转发
echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf
sysctl -p

# 配置目录创建
mkdir -p /etc/wireguard
cd /etc/wireguard
umask 077

生成公私钥对

先生成一些公私钥对，服务器需要 1 个，每个客户端 1 个。

# 生成服务器公私钥
wg genkey > server_privatekey
wg pubkey < server_privatekey > server_publickey

# Client1 的公私钥和预共享密钥
wg genkey > client1_privatekey
wg pubkey < client1_privatekey > client1_publickey
wg genpsk > client1_preSharedKey

# Client2 的公私钥和预共享密钥
wg genkey > client2_privatekey
wg pubkey < client2_privatekey > client2_publickey
wg genpsk > client2_preSharedKey

那么服务器的配置文件 wg0.conf:

echo "
# Server
[Interface]
PrivateKey = $(cat server_privatekey)
Address = 10.8.0.1/24
ListenPort = 51820
MTU = 1420
PreUp =
PostUp = iptables -t nat -A POSTROUTING -s 10.8.0.0/24 -o eth0 -j MASQUERADE
PostUp = iptables -A INPUT -p udp -m udp --dport 51820 -j ACCEPT
PostUp = iptables -A FORWARD -i %i -j ACCEPT
PostUp = iptables -A FORWARD -o %i -j ACCEPT
PreDown =
PostDown = iptables -t nat -D POSTROUTING -s 10.8.0.0/24 -o eth0 -j MASQUERADE
PostDown = iptables -D INPUT -p udp -m udp --dport 51820 -j ACCEPT
PostDown = iptables -D FORWARD -i %i -j ACCEPT
PostDown = iptables -D FORWARD -o %i -j ACCEPT

# Client 1
[Peer]
PublicKey = $(cat client1_publickey)
PresharedKey = $(cat client1_preSharedKey)
AllowedIPs = 10.8.0.2/32, 192.168.1.0/24

# Client 2
[Peer]
PublicKey = $(cat client2_publickey)
PresharedKey = $(cat client2_preSharedKey)
AllowedIPs = 10.8.0.3/32" > wg0.conf

AllowedIPs 表示这些 IP/段，发送到这个 Peer 上。

设置开机自启动：

1	systemctl enable --now wg-quick@wg0

Client 1 配置

echo "
[Interface]
PrivateKey = $(cat client1_privatekey)
Address = 10.8.0.2/24
DNS = 1.1.1.1
MTU = 1420

[Peer]
PublicKey = $(cat server_publickey)
PresharedKey = $(cat client1_preSharedKey)
AllowedIPs = 10.8.0.0/24
PersistentKeepalive = 0
Endpoint = 124.221.31.148:51820 " > client1.conf

AllowedIPs 表示这些 IP/段，发送到这个 Peer 上。
Endpoint 是这个 Peer 的入口，这里配置的就是服务器的端口。

Client 2 配置

echo "
[Interface]
PrivateKey = $(cat client2_privatekey)
Address = 10.8.0.3/24
DNS = 1.1.1.1
MTU = 1420

[Peer]
PublicKey = $(cat server_publickey)
PresharedKey = $(cat client2_preSharedKey)
AllowedIPs = 10.8.0.0/24
PersistentKeepalive = 0
Endpoint = 124.221.31.148:51820 " > client2.conf

常用操作

# 启动WireGuard
wg-quick up wg0

# 停止WireGuard
wg-quick down wg0

# 查看状态
wg

# 重启WireGuard
wg-quick down wg0 && wg-quick up wg0 && wg

wg-quick 可以自动创建网卡

实际案例

从 client1 可以直接访问 client2 的虚拟 IP：根据 AllowIPs 配置，client1 的所有流量都会转发给 server，server 接收到请求 10.8.0.3 的流量，根据 server 的 AllowIPs 配置，转发给了 client2，回包同理。

如果想打通两个内网，需要将对方的内网 IP 段添加到 AllowIPs 列表里。并且在内网机器上添加路由。

名称	说明
机器 A IP	10.0.1.3/24
机器 B IP	10.0.2.3/24

机器 A

# /etc/wireguard/wg0.conf on Server A
[Interface]
Address = 10.200.200.1/24
ListenPort = 51820
PrivateKey = 
# Enable IP forwarding
PostUp = iptables -A FORWARD -i %i -j ACCEPT; iptables -A FORWARD -o %i -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i %i -j ACCEPT; iptables -D FORWARD -o %i -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

[Peer]
# Server B
PublicKey = 
AllowedIPs = 10.200.200.2/32, 10.0.2.0/24 # 关键：包含对端内网网段
Endpoint = 10.0.2.3:51820
PersistentKeepalive = 25

如果机器 A 是内网的网关，那么它就已经是默认路由了。否则机器 A 局域网内的其他机器需要手动添加一条路由规则：

# Linux
sudo ip route add 10.0.2.0/24 via 10.0.2.3

# Windows (以管理员身份运行 PowerShell)
route add 10.0.2.0 mask 255.255.255.0 10.0.2.3

机器 B

和 A 同理。

在Kubernetes中部署一个单节点Elasticsearch

2025-08-13T02:10:31.000Z

Elasticsearch 有自己的高可用集群机制，不建议再用 k8s 管理
适用于临时使用一下、或者测试使用

数据存储问题

为了测试使用，我也没有用 pvc 来管理数据，而是选择了 hostpath，那么为了重启也可以正常访问数据，需要将 es 固定在一个节点上。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: elasticsearch
  labels:
    app: elasticsearch
spec:
  replicas: 1
  selector:
    matchLabels:
      app: elasticsearch
  template:
    metadata:
      labels:
        app: elasticsearch
    spec:
      nodeSelector:
        kubernetes.io/hostname: iuxt
      containers:
      - name: elasticsearch
        image: sls-registry.cn-hangzhou.cr.aliyuncs.com/kproxy/elasticsearch:7.17.26
        env:
          - name: discovery.type
            value: single-node
          - name: ELASTIC_USERNAME
            value: elastic
          - name: ELASTIC_PASSWORD
            value: "jjxkjkdgkdjgkkdjgk"
          - name: ES_JAVA_OPTS
            value: "-Xms1G -Xmx1G"
          - name: xpack.security.enabled
            value: "true"
        ports:
        - containerPort: 9200
          name: http
        - containerPort: 9300
          name: transport
        volumeMounts:
        - name: data
          mountPath: /usr/share/elasticsearch/data
      volumes:
      - name: data
        hostPath:
          path: /data/elasticsearch
          type: DirectoryOrCreate

这里我使用 nodeSelector 指定了一个标签来选择节点。

问题

日志停留在：Created elasticsearch keystore in /usr/share/elasticsearch/config/elasticsearch.keystore
然后自动重启

到主机的 /data/elasticsearch 目录查看，是空的

这种情况是没有权限写入，用 pvc 没有这个问题，直接挂载 hostpath 就会有权限问题，因为 es 这个容器不是使用 root 运行的进程，而是用的 uid:1000 这个用户来运行的。

解决方法是：使用 init container 来修复目录权限，init container 太适合来做这个事情了

apiVersion: apps/v1
kind: Deployment
metadata:
  name: elasticsearch
  labels:
    app: elasticsearch
spec:
  replicas: 1
  selector:
    matchLabels:
      app: elasticsearch
  template:
    metadata:
      labels:
        app: elasticsearch
    spec:
      nodeSelector:
        kubernetes.io/hostname: iuxt
      initContainers:
      - name: fix-permissions
        image: busybox
        command: ["sh", "-c", "chown -R 1000:1000 /usr/share/elasticsearch/data"]
        volumeMounts:
        - name: data
          mountPath: /usr/share/elasticsearch/data
      containers:
      - name: elasticsearch
        image: sls-registry.cn-hangzhou.cr.aliyuncs.com/kproxy/elasticsearch:7.17.26
        env:
          - name: discovery.type
            value: single-node
          - name: ELASTIC_USERNAME
            value: elastic
          - name: ELASTIC_PASSWORD
            value: "jjxkjkdgkdjgkkdjgk"
          - name: ES_JAVA_OPTS
            value: "-Xms1G -Xmx1G"
          - name: xpack.security.enabled
            value: "true"
        ports:
        - containerPort: 9200
          name: http
        - containerPort: 9300
          name: transport
        volumeMounts:
        - name: data
          mountPath: /usr/share/elasticsearch/data
      volumes:
      - name: data
        hostPath:
          path: /data/elasticsearch
          type: DirectoryOrCreate

这样就解决了权限问题：

部署 kibana

---
kind: Deployment
apiVersion: apps/v1
metadata:
  namespace: default
  labels:
    app: kibana
  name: kibana
spec:
  replicas: 1
  selector:
    matchLabels:
      app: kibana
  template:
    metadata:
      labels:
        app: kibana
    spec:
      containers:
      - name: kibana
        image: sls-registry.cn-hangzhou.cr.aliyuncs.com/kproxy/kibana:7.17.26
        ports:
          - containerPort: 5601
            protocol: TCP
        volumeMounts:
          - name: kibana-config
            mountPath: /usr/share/kibana/config
        resources:
          limits:
            memory: "4Gi"
            cpu: "2"
          requests: 
            memory: "2Gi"
            cpu: "2"
      volumes:
      - name: kibana-config
        configMap:
          name: kibana-config
          items:
            - key: kibana.yml
              path: kibana.yml
---
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: default
  name: kibana-config
data:
  kibana.yml: |
    server.port: 5601
    server.host: "0.0.0.0"
    elasticsearch.hosts: ["http://elasticsearch:9200"]
    elasticsearch.requestTimeout: 3600000
    elasticsearch.shardTimeout: 3600000
    i18n.locale: "zh-CN"
    elasticsearch.username: "elastic"
    elasticsearch.password: "jjxkjkdgkdjgkkdjgk"
---
kind: Service
apiVersion: v1
metadata:
  labels:
    app: kibana
  name: kibana-service
  namespace: default
spec:
  ports:
    - port: 5601
      targetPort: 5601
  selector:
    app: kibana
  type: ClusterIP

---
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  namespace: default
  name: kibana
  annotations:
    kubernetes.io/ingress.class: "nginx"
    nginx.ingress.kubernetes.io/ssl-redirect: "false" #关闭SSL跳转

spec:
  tls:
  - hosts:
    - kibana.xxxx.com
    secretName: xxxx-com
  rules:
  - host: kibana.xxxx.com
    http:
      paths:
      - backend:
          serviceName: kibana-service
          servicePort: 5601
        path: /

使用openssl制作自签名双向认证(mTLS)证书

2025-07-17T23:58:24.000Z

可以直接使用我制作好的工具，支持自签名 HTTPS 证书和双向认证证书，纯 shell 脚本，支持 Docker 使用，一键生成证书：https://github.com/iuxt/my_cert

双向认证用途是什么：双向认证就是客户端需要携带证书来请求服务器，证书校验通过了才会正常返回。比如说我有个网站只有自己访问，就可以配置双向认证，自己电脑安装一下证书就可以访问，还可以通过吊销证书的方式来禁止对应的人访问网站。

CA 证书

生成 CA 私钥

1	openssl genrsa -out ca.key 4096

生成一个 ca.key 文件

生成 CA 证书

1	openssl req -utf8 -new -x509 -days 3650 -key ca.key -out ca.crt -subj '/C=CN/ST=Shanghai/L=Pudong/O=iuxt/OU=张理坤/CN=www.i.com/emailAddress=iuxt@qq.com'

1	openssl req -utf8 -new -x509 -days 3650 -key ca.key -out ca.crt

需要交互式输入:

提示	含义	输入内容
Country Name	国家	CN
State or Province Name	省	Shanghai
Locality Name	市	留空
Organization Name	组织名,公司名	iuxt
Organizational Unit Name	团体名	留空
Common Name	你的名字或域名	zhanglikun
Email Address	电子邮箱	iuxt@qq.com

就可以生成 ca.crt 文件, 这个文件需要加入到客户端的 受信任的根证书颁发机构

制作双向认证客户端证书

我是在 Ubuntu 24.04 系统下操作。不同系统可能会有差别。

生成证书吊销列表

准备一份 openssl.cnf 配置文件

[ ca ]
default_ca = CA_default

[ CA_default ]
# 根目录设置为自定义路径
dir = ./ca

# 默认算法
default_md = sha256

# CA 的数据库文件
database = $dir/index.txt
# 证书的序列号文件
serial = $dir/serial
# 新证书的默认有效期
default_days = 365
# 吊销证书的理由
crl_reason = unspecified
# 默认的证书颁发策略
policy = policy_anything

# CRL 选项
crlnumber = $dir/crlnumber
default_crl_days = 30
crl_extensions = crl_ext

[ policy_anything ]
# 配置任何策略
countryName = optional
stateOrProvinceName = optional
organizationName = optional
organizationalUnitName = optional
commonName = supplied
emailAddress = optional

[ crl_ext ]
# CRL 的扩展配置
authorityKeyIdentifier = keyid:always

吊销指定证书

其他的证书都是 ca 签发的, 不管是 nginx 用的 server 证书,还是双向认证用到的 client 证书, 吊销证书后需要重新生成 crl 文件

touch ca/index.txt

# crlnumber初始化，第一次给个初始值即可，后面不需要修改，每次重新生成crl的时候会自增。
[ ! -f ca/crlnumber ] && echo "01" > ca/crlnumber

# 吊销指定证书
openssl ca  -config openssl.cnf -cert ca/ca.crt  -keyfile  ca/ca.key  -revoke ssl/i.com.crt

# 吊销完成后，重新生成吊销列表，建议定期重新生成 CRL 文件，并在 Nginx 上 reload 配置
openssl ca -config openssl.cnf  -cert ca/ca.crt  -keyfile  ca/ca.key  -gencrl -out ca/crl.pem

服务端 nginx 配置

server {
  listen 80;
  listen [::]:80;
  listen 443 ssl;
  listen [::]:443 ssl;
  ssl_certificate   ssl/i.com.crt;
  ssl_certificate_key ssl/i.com.key;
  ssl_session_timeout 5m;
  ssl_ciphers HIGH:!aNULL:!MD5;
  ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
  ssl_prefer_server_ciphers on;
  server_name i.com;

  ssl_client_certificate ssl/ca.crt;       # 配置 CA 证书，用于验证客户端证书的签发者
  ssl_verify_client on;                    # 启用客户端证书验证
  ssl_crl ssl/crl.pem;                     # 配置 CRL 文件路径，用于检查吊销的证书

  client_max_body_size 1024m;

  location / {
          default_type text/plain;
          return 200 "hello";
  }
}

配置客户端 client 证书

证书生成方式和上面一样，p12 格式包含私钥和证书（iPhone 想导入的话，必须设置密码。）

1	openssl pkcs12 -export -in zhangsan.crt -inkey zhangsan.key -out zhangsan.p12

Windows 系统

双击导入，存储位置选择个人

访问对应网站的时候浏览器会提示让选择证书

这是证书被吊销的样子：

iPhone 手机

先在文件里点击一下 p12 文件

然后到 VPN 与设备管理里

选择已下载的描述文件，进行安装。

二级 CA

可选使用二级 CA 证书，如果业务量比较大的情况下，可以使用二级 CA，这样如果二级 CA 出现私钥泄露，可以通过根 CA 吊销二级 CA 证书 (通过此二级 CA 签发的证书都会失效)。使用二级 CA 签发证书需要注意：

签发二级 CA 的时候需要执行证书扩展信息为 CA (basicConstraints=CA:TRUE)
在 Nginx 等配置认证证书的时候，需要配置证书链，即二级 CA 和根 CA 这两个证书合并到一个文件里。

下面是一个一键生成各种证书脚本：

#!/bin/bash
set -e

WORKDIR=mtls_certs
mkdir -p $WORKDIR
cd $WORKDIR

echo "[1/6] 生成 Root CA..."
openssl genrsa -out rootCA.key 4096
openssl req -x509 -new -nodes -key rootCA.key -sha256 -days 3650 \
  -subj "/C=CN/ST=Beijing/O=MyOrg/CN=MyRootCA" \
  -out rootCA.crt

echo "[2/6] 生成二级 Sub CA..."
openssl genrsa -out subCA.key 4096
openssl req -new -key subCA.key \
  -subj "/C=CN/ST=Beijing/O=MyOrg/CN=MySubCA" \
  -out subCA.csr

openssl x509 -req -in subCA.csr -CA rootCA.crt -CAkey rootCA.key -CAcreateserial \
  -out subCA.crt -days 1825 -sha256 -extfile <(printf "basicConstraints=CA:TRUE,pathlen:0\nkeyUsage=critical,keyCertSign,cRLSign")

echo "[3/6] 生成 Client Key & CSR..."
openssl genrsa -out client.key 2048
openssl req -new -key client.key \
  -subj "/C=CN/ST=Beijing/O=MyOrg/CN=mtls-client" \
  -out client.csr

echo "[4/6] 用 Sub CA 签发 Client Cert..."
openssl x509 -req -in client.csr -CA subCA.crt -CAkey subCA.key -CAcreateserial \
  -out client.crt -days 825 -sha256

echo "[5/6] 生成证书链 (SubCA + RootCA)..."
cat subCA.crt rootCA.crt > ca-chain.crt

echo "[6/6] 生成 PFX (可用于浏览器/工具)"
openssl pkcs12 -export -out client.pfx -inkey client.key -in client.crt -certfile ca-chain.crt -password pass:123456

echo "✅ 证书生成完成 (目录: $WORKDIR)"
ls -l

其他

验证证书

# openssl 验证证书关系
openssl verify -CAfile ca-chain.crt client.crt

# curl测试
curl --cert client.crt --key client.key https://test.babudiu.com

Windows 删除个人证书

win + r 运行，输入 certmgr.msc 进入证书管理器。或者在开始菜单搜索 管理用户证书 进入。找到证书，右键删除即可。

iPhone 删除证书

删除描述文件即可。

minio自建对象存储

2025-07-04T07:02:18.000Z

单域名方式部署

单域名就是把 minio 的 api 接口和 web 管理控制台放在一个域名下，比如：

管理控制台：https://minio.xxx.com/ui/
API 接口：https://minio.xxx.com

docker 部署

这里我指定了 network，我的 nginx 也是用的这个 network，可以直接用容器名字来访问

docker run --name minio -d \
    --env-file=.env \
    --network iuxt \
    -v ./data:/data \
    -v ./config:/root/.mc \
    minio/minio:RELEASE.2025-04-22T22-12-26Z server --console-address ":9001" /data

.env 配置

MINIO_ROOT_USER=username
MINIO_ROOT_PASSWORD=password
MINIO_SERVER_URL=https://minio.xxx.com
MINIO_BROWSER_REDIRECT_URL=https://minio.xxx.com/ui/
MC_CONFIG_DIR=/root/.mc

nginx 配置

server {
    listen 80;
    listen 443 ssl;
    server_name minio.xxx.com;
    client_max_body_size 0;

    ssl_certificate         ssl/xxx.com.crt;
    ssl_certificate_key     ssl/xxx.com.key;
    ssl_protocols TLSv1.1 TLSv1.2 TLSv1.3;
    ssl_ciphers EECDH+CHACHA20:EECDH+CHACHA20-draft:EECDH+AES128:RSA+AES128:EECDH+AES256:RSA+AES256:EECDH+3DES:RSA+3DES:!MD5;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    add_header Strict-Transport-Security "max-age=31536000";
    error_page 497  https://$host$request_uri;

    # API endpoint
    location / {
        proxy_set_header Host $http_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://minio:9000;
    }

    # Console endpoint
    location /ui/ {
        rewrite ^/ui/(.*) /$1 break;
        proxy_set_header Host $http_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://minio:9001;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

独立 web 控制台方式部署

可以将 web 控制台独立出来，考虑到安全性，web 控制台不需要开放到公网，可以将控制台独立域名。比如：

管理控制台：https://s3-admin.example.com
API 接口：https://s3.example.com

docker 部署

这里我指定了 network，我的 nginx 也是用的这个 network，可以直接用容器名字来访问

docker run --name minio -d \
    --env-file=.env \
    --network iuxt \
    -v ./data:/data \
    -v ./config:/root/.mc \
    minio/minio:RELEASE.2025-04-22T22-12-26Z server --console-address ":9001" /data

.env 配置

MINIO_ROOT_USER=username
MINIO_ROOT_PASSWORD=password
MINIO_SERVER_URL=https://s3.example.com
MINIO_BROWSER_REDIRECT_URL=https://s3-admin.example.com
MC_CONFIG_DIR=/root/.mc

nginx 配置

我给控制台开了双向认证，如果不需要，删除掉这三行配置。ssl_client_certificate ssl/ca.crt; ssl_verify_client on; ssl_crl ssl/crl.pem;

```conf
server {
    listen 80;
    listen 443 ssl;
    server_name s3.example.com;

    ssl_certificate         ssl/example.com.crt;
    ssl_certificate_key     ssl/example.com.key;
    ssl_protocols TLSv1.1 TLSv1.2 TLSv1.3;
    ssl_ciphers EECDH+CHACHA20:EECDH+CHACHA20-draft:EECDH+AES128:RSA+AES128:EECDH+AES256:RSA+AES256:EECDH+3DES:RSA+3DES:!MD5;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    error_page 497  https://$host$request_uri;

    ignore_invalid_headers off;
    client_max_body_size 0;
    proxy_buffering off;
    proxy_request_buffering off;

    location / {
      proxy_set_header Host $http_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_cache_convert_head off;

      proxy_connect_timeout 300;
      proxy_http_version 1.1;
      proxy_set_header Connection "";
      chunked_transfer_encoding off;

      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";

      proxy_pass http://minio:9000;
    }
}

server {
    listen 80;
    listen 443 ssl;
    server_name s3-admin.example.com;
    client_max_body_size 0;

    ssl_certificate         ssl/example.com.crt;
    ssl_certificate_key     ssl/example.com.key;
    ssl_protocols TLSv1.1 TLSv1.2 TLSv1.3;
    ssl_ciphers EECDH+CHACHA20:EECDH+CHACHA20-draft:EECDH+AES128:RSA+AES128:EECDH+AES256:RSA+AES256:EECDH+3DES:RSA+3DES:!MD5;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    add_header Strict-Transport-Security "max-age=31536000";
    error_page 497  https://$host$request_uri;

    ssl_client_certificate ssl/ca.crt;       # 配置 CA 证书，用于验证客户端证书的签发者
    ssl_verify_client on;                    # 启用客户端证书验证
    ssl_crl ssl/crl.pem;                     # 配置 CRL 文件路径，用于检查吊销的证书

    location / {
      proxy_set_header Host $http_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_cache_convert_head off;

      proxy_connect_timeout 300;
      proxy_http_version 1.1;
      proxy_set_header Connection "";
      chunked_transfer_encoding off;

      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";

      proxy_pass http://minio:9001;
    }
}

mc 命令创建 apikey

在 RELEASE.2025-04-22T22-12-26Z 这个版本之后 minio 把控制台的管理功能给砍了，顺便还送了你一个每次打开都会弹出的通知。可以继续使用 RELEASE.2025-04-22T22-12-26Z 这个版本。如果你不幸更新了版本，你需要使用 mc 命令来创建 API key。

# 增加节点管理，命名为minio
mc alias set minio http://127.0.0.1:9000  

# 创建用户 
mc admin user add minio  

# 分配权限
mc admin policy attach minio readwrite --user=

使用 CURL 操作对象存储

公共存储桶（无须认证）

# 上传文件
# test 为 bucket 名字
curl -T "./1.txt" https://s3.example.com/test/

# 下载文件
curl -OL https://s3.example.com/test/1.txt

私有存储桶

上传文件

#!/bin/bash
ACCESS_KEY="minio_ACCESS_KEY"
SECRET_KEY="minio_SECRET_KEY"
BUCKET_NAME="test"
FILE_NAME="./1.txt"
OBJECT_NAME="1.txt"
MINIO_URL="s3.example.com"

# 生成签名
DATE_VALUE="$(date -R)"
SIGNATURE="$(echo -en "PUT\n\n\n${DATE_VALUE}\n/${BUCKET_NAME}/${OBJECT_NAME}" | openssl sha1 -hmac "${SECRET_KEY}" -binary | base64)"

# 上传文件
curl -X PUT --upload-file "${FILE_NAME}" \
   --header "Date: ${DATE_VALUE}" \
   --header "Authorization: AWS ${ACCESS_KEY}:${SIGNATURE}" \
   "${MINIO_URL}/${BUCKET_NAME}/${OBJECT_NAME}"

下载文件

#!/bin/bash
ACCESS_KEY="minio_ACCESS_KEY"
SECRET_KEY="minio_SECRET_KEY"
BUCKET_NAME="test"
FILE_NAME="./1.txt"
OBJECT_NAME="1.txt"
MINIO_URL="s3.example.com"

# 生成签名
DATE_VALUE="$(date -R)"
SIGNATURE="$(echo -en "GET\n\n\n${DATE_VALUE}\n/${BUCKET_NAME}/${OBJECT_NAME}" | openssl sha1 -hmac "${SECRET_KEY}" -binary | base64)"

# 上传文件
curl -X GET -OL \
   --header "Date: ${DATE_VALUE}" \
   --header "Authorization: AWS ${ACCESS_KEY}:${SIGNATURE}" \
   "${MINIO_URL}/${BUCKET_NAME}/${OBJECT_NAME}"

ingress-nginx 使用自定义的nginx配置

2025-06-26T06:49:30.000Z

新版 ingress 增强了安全性, 它认为用户自己写的 nginx 配置文件不安全，所以又加了限制。（允许自定义 nginx 配置有一定安全风险，酌情修改！）我的 ingress 版本是： 1.12.2

比如有个需求，Spring Boot 写的程序有个 /actuator 路径，安全审查不通过，如果是个 nginx 可以通过：

1
2
3

location /actuator {
    return 404;
}

来直接让它返回 404

configmap

apiVersion: v1
data:
  allow-snippet-annotations: "true"
  annotations-risk-level: Critical
kind: ConfigMap
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/instance: public-ingress-nginx
    app.kubernetes.io/name: public-ingress-nginx
    app.kubernetes.io/part-of: public-ingress-nginx
    app.kubernetes.io/version: 1.12.2
  name: public-ingress-nginx-controller
  namespace: public-ingress-nginx

加上这两个配置：
allow-snippet-annotations
annotations-risk-level

风险等级，在这里可以查到：
https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations-risk/

ingress 配置

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  annotations:
    nginx.ingress.kubernetes.io/cors-allow-headers: '*'
    nginx.ingress.kubernetes.io/cors-allow-methods: '*'
    nginx.ingress.kubernetes.io/cors-allow-origin: '*'
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
    nginx.ingress.kubernetes.io/server-snippet: |
      location /actuator {
        return 404;
      }
  name: mtls
  namespace: vos
spec:
  ingressClassName: public-nginx
  rules:
  - host: a.com
    http:
      paths:
      - backend:
          service:
            name: gateway
            port:
              number: 80
        path: /
        pathType: ImplementationSpecific
  tls:
  - hosts:
    - a.com
    secretName: a-com

server-snippet 作用于 server 块
configuration-snippet 作用于 location 块

注意：

1	nginx.ingress.kubernetes.io/use-regex: 'true'

当启用 use-regex 时，所有路径都会被当作正则表达式处理，会影响到匹配。

P12格式证书与PEM格式转换

2025-06-24T10:23:52.000Z

P12 证书是整合了公钥和私钥的，还可以给 P12 证书设置密码。

P12 转换为 PEM

# 提取证书
openssl pkcs12 -in 1.p12  -clcerts -nokeys -out certificate.crt

# 提取加密的私钥
openssl pkcs12 -in 1.p12 -nocerts -out private_key.key

# 提取未加密的私钥
openssl pkcs12 -in 1.p12 -nocerts -nodes -out private_key.key

这种是加密的 PEM 私钥

1
2
3

-----BEGIN ENCRYPTED PRIVATE KEY-----
...
-----END ENCRYPTED PRIVATE KEY-----

也可以将加密的 PEM 私钥转换成未加密的 PEM 私钥

1	openssl rsa -in encrypt.key -out nopassword.key

未加密的 PEM 私钥长这样

1
2
3

-----BEGIN PRIVATE KEY-----
...
-----END PRIVATE KEY-----

PEM 公钥和私钥转换成 P12

1	openssl pkcs12 -export -out certificate.p12 -inkey privateKey.key -in certificate.crt

使用blackbox-exporter做域名监控

2025-06-17T09:16:58.000Z

blackbox 创建模块

对应的 blackbox exporter 的配置文件：

modules:
  http_2xx:
    prober: http
    timeout: 5s
    http:
      valid_http_versions: ["HTTP/1.1", "HTTP/2"]
      valid_status_codes: [200]
      method: GET
      preferred_ip_protocol: "ip4"
  http_post_2xx:
    prober: http
    timeout: 5s
    http:
      valid_http_versions: ["HTTP/1.1", "HTTP/2"]
      method: POST
      preferred_ip_protocol: "ip4"
  tcp_connect:
    prober: tcp
    timeout: 2s
  icmp:
    prober: icmp
    timeout: 2s
    icmp:
      preferred_ip_protocol: "ip4"
  http_accept_404:
    prober: http
    timeout: 10s
    http:
      valid_status_codes: [200, 201, 204, 404]  # 404 也被视为正常
      method: GET
      preferred_ip_protocol: "ip4"
      no_follow_redirects: false

其中：

http_2xx： get 请求 200 认为是正常的
http_post_2xx： post 请求 200 认为是正常的
tcp_connect：测试端口是不是通的
icmp：能否 ping 通
http_accept_404： get 请求，404 也认为是正常的

配置 Prometheus

HTTP 监控只有 200 是正常请求

- job_name: 'http_get'
  metrics_path: /probe
  params:
    module: [http_2xx]
  static_configs:
    - targets: ['https://test.com']
      labels:
        app: 生产环境域名
    - targets: ['http://1.1.1.1:8888']
      labels:
        app: 测试IP地址
  relabel_configs:
    - source_labels: [__address__]
      target_label: __param_target
    - target_label: __address__
      replacement: blackbox-exporter.monitor.svc:9115
    - source_labels: [__param_target]
      target_label: instance

HTTP 监控 2xx 和 404 都认为是正常请求

- job_name: 'http_get_with_404'
  metrics_path: /probe
  params:
    module: [http_accept_404]
  static_configs:
    - targets: ['https://test.com']
      labels:
        app: 生产环境域名
    - targets: ['http://1.1.1.1:8888']
      labels:
        app: 测试IP地址
  relabel_configs:
    - source_labels: [__address__]
      target_label: __param_target
    - target_label: __address__
      replacement: blackbox-exporter.monitor.svc:9115
    - source_labels: [__param_target]
      target_label: instance

TCP 端口监控

- job_name: port
  honor_timestamps: true
  params:
    module:
    - tcp_connect
  scrape_interval: 10s
  scrape_timeout: 10s
  metrics_path: /probe
  scheme: http
  follow_redirects: true
  static_configs:
    - targets: ['1.1.1.1:8662']
      labels:
        app: 密码机-1
    - targets: ['2.2.2.2:8662']
      labels:
        app: 密码机-2
  relabel_configs:
  - source_labels: [__address__]
    separator: ;
    regex: (.*)
    target_label: __param_target
    replacement: $1
    action: replace
  - source_labels: [__param_target]
    separator: ;
    regex: (.*)
    target_label: addr
    replacement: $1
    action: replace
  - source_labels: [__param_target]
    separator: ;
    regex: (.+):(.*)
    target_label: port
    replacement: $2
    action: replace
  - separator: ;
    regex: (.*)
    target_label: __address__
    replacement: blackbox-exporter:9115
    action: replace

验证

1	curl "http://blackbox-exporter.monitor:9115/probe?target=http://a.test.com&module=http_accept_404"

PromQL 常用查询

# 查询证书到期时间
(probe_ssl_earliest_cert_expiry{project="project1",env="prod"} - time()) / 60 / 60 / 24

# 查询接口通不通
probe_success{project="project1",env="prod"}

# 查询接口延迟，包括 tcp监控 http监控
probe_duration_seconds{project="project1",env="prod"}

记一次MySQL字符集转换导致的故障

2025-06-09T10:34:38.000Z

业务报错如下：

经过排查为 MySQL 字符集 utf8 ，当插入 emoji 表情包的时候，就会报错。

用 python 查看这是个什么：
b'\xF0\x9F\x90\x92'.decode('utf-8')

尝试将表转换成 utf8mb4 字符集

1	ALTER TABLE vehicle_user_role CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;

结果导致数据库 CPU 飙升

于是进行回滚操作：

1	ALTER TABLE vehicle_user_role CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;

结果报错：

1	ERROR 1366 (HY000): Incorrect string value: '\xF0\x9F\x90\x92"}' for column 'EXT' at row 333582

原因是执行完这段时间已经有 emoji 数据写入到数据库了，找到这条数据：

1	SELECT * FROM vehicle_user_role WHERE HEX(`EXT`) LIKE '%F09F9092%' LIMIT 1;

清理不正确的数据：

1	UPDATE vehicle_user_role SET EXT = NULL WHERE ROLE_ID = 'df169ce2c1dd4574b014cb184b970f8e';

再次转换：

1	ALTER TABLE vehicle_user_role CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;

这个时候数据库还原成原始的样子。

转换了表的字符集导致跨表查询的时候索引失效了，正确处理方式：不改表只转换字段的字符集：

1	ALTER TABLE vehicle_user_role MODIFY COLUMN EXT varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;

使用双向认证增加git仓库安全性

2025-06-04T01:56:12.000Z

双向认证是用户需要提供证书来访问服务器，没有证书的用户不允许访问服务器，并且在服务端可以实现吊销指定用户的证书来实现禁止用户访问。配置 https 双向认证会影响到使用 https 协议拉取和推送代码，以及 git lfs 的正常使用 (lfs 使用 https 协议)，ssh 协议使用代码仓库不受影响。

配置双向认证

我是用的自签名证书，自签名证书的文档可以查看制作和使用自签名证书或者我的开源项目：https://github.com/iuxt/my_cert.git

服务器上的 nginx 上配置

server {
    listen 443 ssl;
    server_name example.com;

    ssl_certificate /path/to/your/server.crt;
    ssl_certificate_key /path/to/your/server.key;

    ssl_client_certificate /path/to/your/ca.crt;        # 配置 CA 证书，用于验证客户端证书的签发者
    ssl_verify_client on;                               # 启用客户端证书验证
    ssl_crl /path/to/your/crl.pem;                      # 配置 CRL 文件路径，用于检查吊销的证书

    location / {
        root /var/www/html;
        index index.html;
    }
}

配置好之后，打开网页会提示：

操作系统信任 CA 证书

Windows

Windows 将证书导入到系统的个人分类下。

macOS

macOS– 待补充。

Linux

Debian 系 Linux：

1 2	sudo cp cacert.crt /usr/local/share/ca-certificates/ sudo update-ca-certificates

RedHat 系 Linux：

1 2	sudo cp cacert.crt /etc/pki/ca-trust/source/anchors/ sudo update-ca-trust

信任完成后，浏览器重启后再次打开 git 网页：
选择证书，点击确定，就可以正常打开页面了。

Git 客户端配置

上面的配置，浏览器已经可以正常携带证书来访问指定的服务了，但是 git 客户端还不行，需要对 git 仓库进行配置。

1
2
3

# 需要全局配置，增加 --global 参数。会写入到 ~/.gitconfig 中。
git config http.sslCert C:\Users\iuxt\OneDrive\keys\manage.crt
git config http.sslkey C:\Users\iuxt\OneDrive\keys\manage.key

Prometheus自动监控K8S集群中的service

2025-05-13T08:42:59.000Z

定义

部署在 Kubernetes 上的 Prometheus 是有自动发现机制的，可以自动监控 service 通不通、监控 ingress 上的域名通不通等等。

HTTP Get 监控

service 的 HTTP Get 监控

- job_name: 'service_http_get'

  # service 需要添加注解
  # prometheus.io/http_get_path: /actuator/info
  # prometheus.io/http_get: "true"
  # prometheus.io/http_get_port: "8080"

  metrics_path: /probe
  params:
    module: [http_2xx]
  kubernetes_sd_configs:
  - role: service
  relabel_configs:
  - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_http_get]
    action: keep
    regex: true

  - source_labels: [__address__, __meta_kubernetes_service_annotation_prometheus_io_http_get_port, __meta_kubernetes_service_annotation_prometheus_io_http_get_path]
    action: replace
    # 正则解释：
    # 第一组([^:]+) - 匹配地址部分（直到冒号或结尾）
    # (:[0-9]+)? - 可选匹配端口部分
    # ;([0-9]+) - 匹配注解中的端口
    # ;(/.*)? - 匹配注解中的路径（可选）
    regex: ([^:]+)(:[0-9]+)?;([0-9]+);(/.*)?
    replacement: http://$1:$3$4
    target_label: __param_target

  - target_label: __address__
    replacement: blackbox-exporter.monitor.svc:9115

  - source_labels: [__param_target]
    target_label: instance

  # 额外添加标签
  - action: labelmap
    regex: __meta_kubernetes_service_label_(.+)

  - source_labels: [__meta_kubernetes_namespace]
    target_label: namespace

  - source_labels: [__meta_kubernetes_service_name]
    target_label: service_name

  - source_labels: [__meta_kubernetes_service_name]
    target_label: app

ingress 的 HTTP Get 监控


- job_name: 'ingress_http_get'

  # ingress 需要添加注解才可被自动发现
  # prometheus.io/http_get_path: /actuator/info
  # prometheus.io/http_get: "true"

  metrics_path: /probe
  params:
    module: [http_2xx]
  kubernetes_sd_configs:
  - role: ingress
  relabel_configs:

  - source_labels: [__meta_kubernetes_ingress_annotation_kubernetes_io_http_get]
    action: keep
    regex: true

  - source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_annotation_kubernetes_io_http_get_path]
    target_label: __param_target
    regex: (.+);(.+);(.*)
    replacement: ${1}://${2}${3}

  - target_label: __address__
    replacement: blackbox-exporter.monitor.svc:9115

  - source_labels: [__param_target]
    target_label: instance

  # 额外添加标签
  - action: labelmap
    regex: __meta_kubernetes_ingress_label_(.+)

  - source_labels: [__meta_kubernetes_namespace]
    target_label: kubernetes_namespace

  - source_labels: [__meta_kubernetes_ingress_name]
    target_label: kubernetes_name
  - source_labels: [__meta_kubernetes_ingress_name]
    target_label: app

收集业务 Metrics

比如有的业务会暴露出 metrics，比如 Prometheus 的各种 exporter，一个一个接入比较麻烦，也可以利用 service 自动发现的形式接入 Prometheus


- job_name: 'service_endpoints_metrics'
  # service 需要添加元数据 通常需要有 /metrics 接口返回 prometheus 数据格式
  # prometheus.io/path: /metrics
  # prometheus.io/port: "8080"
  # prometheus.io/scrape: "true"

  kubernetes_sd_configs:
  - role: endpoints
  relabel_configs:
  - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scrape]
    action: keep
    regex: true
  - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_scheme]
    action: replace
    target_label: __scheme__
    regex: (https?)
  - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_path]
    action: replace
    target_label: __metrics_path__
    regex: (.+)
  - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_env]
    action: replace
    target_label: env
  - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_dept]
    action: replace
    target_label: dept
  - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_app]
    action: replace
    target_label: app
  - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_project]
    action: replace
    target_label: project
  - source_labels: [__address__, __meta_kubernetes_service_annotation_prometheus_io_port]
    action: replace
    target_label: __address__
    regex: ([^:]+)(?::\d+)?;(\d+)
    replacement: $1:$2
  - action: labelmap
    regex: __meta_kubernetes_service_label_(.+)

    
  # 新增标签
  - source_labels: [__meta_kubernetes_namespace]
    action: replace
    target_label: kubernetes_namespace
  - source_labels: [__meta_kubernetes_service_name]
    action: replace
    target_label: kubernetes_service_name
  - source_labels: [__meta_kubernetes_pod_host_ip]
    action: replace
    target_label: node_ip
  - source_labels: [__meta_kubernetes_pod_name]
    action: replace
    target_label: pod_name

在需要接入监控的 service 上配置注解即可实现自动接入，注解如下：

kind: Service
apiVersion: v1
metadata:
  name: ops-kafka-exporter
  namespace: kafka-exporter
  annotations:
    prometheus.io/scrape: 'true'
    prometheus.io/path: /metrics
    prometheus.io/port: '9308'
    prometheus.io/project: ops
    prometheus.io/app: ops-kafka
    prometheus.io/dept: ep
    prometheus.io/env: prod
spec:
  ports:
    - protocol: TCP
      port: 9308
      targetPort: 9308
  selector:
    app: ops-kafka-exporter
  type: ClusterIP

Grafana 查询SQL 自定义变量

2025-05-06T08:04:22.000Z

比如一个 dashboard 里面有很多通用的数据，不想每个 panel 面板都手动修改一遍，可以定义个全局的变量，所有面板都调用这个变量，后续需要修改的时候，直接改变量即可。

面板设置里添加变量

这里添加好了之后，先打开 show on dashboard 显示

然后选择自己需要的数据，保存的时候，勾选 update default variable values 保存当前选择的值

最后再把变量隐藏起来。

在查询的时候调用变量

SELECT
    `desc` AS '说明',
    CONVERT_TZ(time, '+08:00', '+00:00') AS '最近日期',
    vin,
    value AS '发生数量'
FROM
    granfana.metric
WHERE
    metric_name = 'active_fail'
    AND vin IN (${users})
ORDER BY
    最近日期 DESC

如何调试

点击面板设置上的 Query inspector 查询里可以看到原始的数据。