Doc Record | Blog

Mihomo SSH Config Alias Support

Sun, 07 Dec 2025 00:00:00 GMT

🔗 项目信息

Fork 仓库: https://github.com/iuin8/mihomo
分支: (请确保查看包含 ssh-config-alias 功能的分支, 例如: ssh_system_v1.19.17)
核心文件: adapter/outbound/ssh.go, adapter/outbound/ssh_system.go

📖 需求背景

在复杂的网络环境中，用户往往已经维护了一套完善的 SSH 配置文件 (~/.ssh/config)。这些配置可能包含：

ProxyJump (跳板机)：需要通过一台或多台跳板机才能访问目标内网服务器。
ProxyCommand：使用第三方认证工具（如 Cloudflare Access, AWS SSM）建立连接。
IdentityFile：针对不同主机使用不同的密钥文件。
Host 别名：使用简短的别名代替长 IP 或域名。

原有的 Mihomo SSH 适配器使用 Go 语言原生 SSH 库，无法直接利用这些系统级配置，导致用户必须把复杂的跳板逻辑手动转化为 Mihomo 的代理链（Dialer Proxy），配置繁琐且不支持部分高级指令（如特殊的 ProxyCommand）。

目标：让 Mihomo 可以直接”借用”系统 SSH 客户端的能力，只需填一个主机别名（如 my-server），剩下的认证、跳转全交给系统 SSH 处理。

✨ 功能特性

1. 完整 SSH Config 支持

通过调用系统 ssh 命令建立隧道，Mihomo 可以支持系统 SSH 客户端支持的所有指令：

✅ ProxyJump / JumpHost
✅ ProxyCommand (支持 cloudflared, nc 等)
✅ IdentityFile, User, Port 等自动读取
✅ Match, Include 等高级配置逻辑

2. 智能用户切换 (`sudo -u`)

Mihomo 通常以 root 权限运行（为了 TUN 模式等），而用户的 SSH 配置位于普通用户目录下。本功能实现了：

自动检测或指定实际用户。
使用 sudo -u <user> -i 切换身份执行 SSH。
-i 参数确保加载用户的完整登录环境（PATH），保证 cloudflared 等命令可被找到。

3. 零配置密钥

无需在 Mihomo 配置文件中填入私钥内容，它会自动读取 ~/.ssh/id_rsa 或配置中指定的 IdentityFile。

🚀 使用方式

参数说明

字段	说明
`type`	必须为 `ssh`
`server`	关键：填写 `~/.ssh/config` 中的 `Host` 别名
`port`	注意：填写目标服务内部监听端口（通常是 22）。 ⚠️ 不要填 `~/.ssh/config` 中的映射端口。
`use-ssh-config-alias`	设置为 `true` 开启此功能
`ssh-user`	指定本地执行 SSH 命令的用户名（你的 macOS/Linux 用户名）

配置示例

场景 1：基础跳板机 (ProxyJump)

SSH Config (~/.ssh/config):

Host bastion
  HostName 1.2.3.4
  User admin

Host internal-db
  HostName 10.0.0.5
  User root
  ProxyJump bastion  # 自动经过 bastion 跳转

Mihomo 配置:

proxies:
  - name: "Internal-DB-SSH"
    type: ssh
    server: "internal-db"      # 直接填别名
    port: 22                   # 目标内部 SSH 端口
    use-ssh-config-alias: true
    ssh-user: "your-username"  # 你的本地用户名

场景 2：Cloudflare Access (ProxyCommand)

SSH Config:

Host my-cf-server
  HostName ssh.example.com
  User root
  # 需要 cloudflared 命令在 PATH 中
  ProxyCommand cloudflared access ssh --hostname %h

Mihomo 配置:

proxies:
  - name: "CF-SSH"
    type: ssh
    server: "my-cf-server"
    port: 22
    use-ssh-config-alias: true
    ssh-user: "your-username"

🛠 原理简述

Mihomo 收到连接请求后，会在底层执行类似以下的命令：

sudo -u your-username -i ssh -W localhost:22 my-host-alias

这条命令会建立一个标准输入/输出到目标 SSH 端口的 TCP 隧道。Mihomo 随后在这个隧道上进行自己的 SSH 协议握手，建立代理连接。

SSH 远程端口转发配置指南：使用 socat 实现灵活的端口映射

Sat, 06 Dec 2025 00:00:00 GMT

概述

SSH 远程端口转发是一种强大的网络技术，允许您将远程服务器的端口转发到本地机器或其他目标地址。结合 socat 工具，您可以实现更灵活的端口映射和网络连接管理。

本文档详细介绍了如何配置和使用 SSH 远程端口转发，特别关注如何确保 socat 进程在 SSH 连接断开时自动终止，避免资源泄漏和端口占用问题。

配置详解

以下是完整的 SSH 配置文件示例：

Host fa.remote.intranet.company

&#x20; HostName 10.0.16.146

&#x20; User root

&#x20; IdentityFile \~/.ssh/id\_ed25519\_iu

&#x20; RemoteForward 9094 127.0.0.1:9093

&#x20; RemoteCommand bash -c "trap 'kill %%1' EXIT; socat TCP-LISTEN:9093,fork TCP:127.0.0.1:9094 & exec bash"

&#x20; ForwardAgent yes

&#x20; RequestTTY yes

配置项解析

1. 基本连接配置

Host fa.remote.intranet.company

&#x20; HostName 10.0.16.146

&#x20; User root

&#x20; IdentityFile \~/.ssh/id\_ed25519\_iu

Host：定义主机别名，方便后续引用
HostName：远程服务器的实际 IP 地址或域名
User：登录远程服务器使用的用户名
IdentityFile：指定用于身份验证的 SSH 密钥文件

2. 端口转发配置

RemoteForward 9094 127.0.0.1:9093

这是核心配置项，实现远程端口转发：

9094：远程服务器上监听的端口
127.0.0.1:9093：本地机器上的目标地址和端口

效果：远程服务器的 9094 端口收到的所有连接都会被转发到本地机器的 9093 端口。

3. 自动启动 socat

RemoteCommand bash -c "trap 'kill %%1' EXIT; socat TCP-LISTEN:9093,fork TCP:127.0.0.1:9094 & exec bash"

这个复杂的命令实现了以下功能：

bash -c "..."：在远程服务器上执行 bash 命令
trap 'kill %%1' EXIT：设置退出陷阱，当 shell 退出时终止 socat 进程
socat TCP-LISTEN:9093,fork TCP:127.0.0.1:9094：启动 socat 进行端口转发
- TCP-LISTEN:9093：在远程服务器的 9093 端口监听
- fork：为每个连接创建新的进程
- TCP:127.0.0.1:9094：转发到本地的 9094 端口
&：在后台运行 socat
exec bash：启动交互式 bash shell

4. 其他配置项

ForwardAgent yes

RequestTTY yes

ForwardAgent yes：启用 SSH 代理转发，允许在远程服务器上使用本地的 SSH 密钥
RequestTTY yes：强制分配伪终端，确保获得交互式 shell

工作原理

整个配置的工作流程如下：

SSH 连接建立：当您运行ssh fa.remote.intranet.company时，SSH 客户端会：

使用指定的密钥文件进行身份验证
在远程服务器上建立 9094 端口的转发
执行 RemoteCommand 中指定的命令

socat 启动：RemoteCommand 会：

设置退出陷阱
启动 socat 监听 9093 端口
启动交互式 bash shell

端口转发流程：

外部客户端 → 远程服务器:9093 → socat → 远程服务器:9094 → SSH转发 → 本地机器:9093

连接关闭：当您退出 bash shell 时：

trap 机制会捕获 EXIT 信号
终止 socat 进程
SSH 连接关闭
所有转发端口释放

使用方法

基本使用

编辑 SSH 配置文件

nano \~/.ssh/config

添加上述配置内容。

建立连接

ssh fa.remote.intranet.company

验证配置

在远程服务器上执行：

ss -tunlp | grep 9093

\# 应该显示socat在监听9093端口

ss -tunlp | grep 9094

\# 应该显示ssh在监听9094端口

测试端口转发

从另一台机器测试：

curl http://10.0.16.146:9093

后台运行

如果您希望在后台运行端口转发，可以使用：

ssh -fN fa.remote.intranet.company

-f：在后台运行
-N：不执行远程命令

故障排除

常见问题及解决方案

1. 端口占用错误

症状：

Address already in use

解决方案：

检查并终止占用端口的进程：

\# 在远程服务器上执行

ss -tunlp | grep 9093

kill -9 <进程ID>

或者修改配置使用其他端口。

2. 无法获得交互式 shell

症状：连接后直接退出或没有 bash 提示符

解决方案：

确保配置中包含：

RequestTTY yes

或者在命令行中使用：

ssh -t fa.remote.intranet.company

3. socat 在 SSH 断开后仍然运行

症状：

ps -ef | grep socat

\# 显示socat进程，父ID为1

解决方案：

手动终止进程：

pkill socat

或者修改 RemoteCommand 确保 trap 正确工作：

RemoteCommand bash -c "trap 'pkill socat' EXIT; socat TCP-LISTEN:9093,fork TCP:127.0.0.1:9094 & exec bash"

最佳实践

1. 使用不常用端口

避免使用常见服务端口（如 80、443、22 等），减少冲突风险。

2. 添加端口占用检查

修改 RemoteCommand，添加端口占用检查：

RemoteCommand bash -c "if ! ss -tunlp | grep -q 9093; then trap 'kill %%1' EXIT; socat TCP-LISTEN:9093,fork TCP:127.0.0.1:9094 & fi; exec bash"

3. 使用 autossh 保持连接

对于需要长期运行的转发，使用 autossh：

autossh -M 0 -o "ServerAliveInterval 30" -o "ServerAliveCountMax 3" fa.remote.intranet.company

4. 日志记录

添加日志记录以便故障排除：

RemoteCommand bash -c "trap 'kill %%1' EXIT; socat -d -d TCP-LISTEN:9093,fork TCP:127.0.0.1:9094 > /var/log/socat.log 2>&1 & exec bash"

高级配置

1. 多端口转发

您可以配置多个 RemoteForward：

RemoteForward 9094 127.0.0.1:9093

RemoteForward 9095 127.0.0.1:9094

RemoteForward 9096 192.168.1.100:80

2. 条件执行

根据本地环境变量决定是否启动转发：

Match exec "test -n \\"\$ENABLE\_FORWARD\\""

&#x20; RemoteForward 9094 127.0.0.1:9093

3. 使用环境变量

在 RemoteCommand 中使用环境变量：

RemoteCommand bash -c "PORT=\${PORT:-9093}; trap 'kill %%1' EXIT; socat TCP-LISTEN:\\\$PORT,fork TCP:127.0.0.1:9094 & exec bash"

然后在连接时设置变量：

PORT=9095 ssh fa.remote.intranet.company

总结

SSH 远程端口转发结合 socat 是一种强大的网络工具，能够实现灵活的端口映射和连接管理。通过本文档介绍的配置方法，您可以：

建立可靠的远程端口转发
确保 socat 进程在 SSH 连接断开时自动终止
获得完整的交互式 shell 体验
避免常见的端口冲突和资源泄漏问题

这种配置特别适用于需要从外部访问内部服务、构建安全隧道或实现复杂网络拓扑的场景。

更新时间：2025 年 12 月 6 日

版本：1.0

适用场景：SSH 端口转发、远程访问、网络隧道

（注：文档部分内容可能由 AI 生成）

Welcome

Wed, 26 Nov 2025 00:00:00 GMT

Welcome to my blog! This is a sample post to verify the blog functionality.

This blog is powered by Docusaurus.

(frps selfhost版)有没想过起个容器就能打通整个内网呢? 使用容器打通受限网络: frp+ssh组合镜像以及clash(mihomo)实现打通网络

Tue, 20 May 2025 00:00:00 GMT

使用容器打通受限网络: frp+ssh组合镜像以及clash(mihomo)实现打通任意环境所有内网服务(包括k8s)(web页面以及终端访问) 这里还有个需要提到的是, 因为我的科学上网环境是用的clash(mihomo)软件, 所以这里就用clash(mihomo)来实现打通各种内网这样我就可以只需要一个代理软件就行了

前言

开发过程中总是能遇到需要访问其他公司内网的情况, 一般常规方案都是由其他公司提供vpn访问, 或者jumpserver进行内网服务器连接.

这时, 一般就会遇到几个痛点: - 想要访问k8s中的容器服务, k8s内部域名svc.cluster.local无法直接使用 - 要装很多乱七八糟的vpn软件, 不同公司用的vpn可能就不一样, 有的vpn甚至像流氓软件一样, 有各种限制 - 有的公司不提供vpn或jumpserver, 只能去现场 - 家里网络和公司网络不互通的问题(在公司想访问家里的一些服务, 或在家想访问公司的一些服务等)

然而, 打通网络后, 都有哪些好处呢? - 自己本地电脑不在需要安转太多的vpn软件了 - 所能触碰到的每台内网服务器, 都能成为你在何时何地都能访问或当做跳板机的工具 - 内网才能打开的页面, 随时都能打开了 - 网页系统应用能用浏览器打开了 - nacos能用浏览器打开了 - 内网才能访问的服务器, 随时都能访问了 - 数据库能通过idea或者DBeaver可视化连接了

也就是说, 打通了网络, 也就打通了ssh访问, ssh能到达的地方, 都能将自己的本地电脑拉入到同一网络中进行互通操作

前提

需要有机会把容器起起来, 一般有以下几种方式, 选一个方便去操作的就行, 当容器起来之后, 网络就打通了, 虚拟机等过渡工具就可以删掉了, 不需要了 - 通过jumpserver页面登录 - 自己本身就安转了vpn - 找安装了vpn的同事 - 专门找台机用于安装各种乱七八糟的vpn也行 - 当然起个虚拟机去安转也行

编写docker-compose.yml(服务端)

这里的服务端, 就是你有公网IP的云服务器, 我这里用的是Debian, 你可以根据自己的情况, 选择合适的镜像

# vi /www/dev-jumpbox/server/docker-compose.yml
services:
  frps-ssh:
    image: registry.cn-hangzhou.aliyuncs.com/iuin/frps-ssh:tcpmux
    network_mode: host
    environment:
      - TZ="Asia/Shanghai"
      - auth_token="xxx"
      - bindPort=18000
      - tcpmuxHTTPConnectPort=12222
    restart: unless-stopped

# 构建镜像并启动容器
docker-compose up -d

编写docker-compose.yml(客户端)

共用端口的方式, 参考文章

PS: 自定义域名需要配合proxycommand代理使用ssh -o 'proxycommand socat - PROXY:x.x.x.x:%h:%p,proxyport=5002' test@machine-a.example.com

# vi /www/dev-jumpbox/client/docker-compose.yml
services:
  dev-jumpbox:
    image: registry.cn-hangzhou.aliyuncs.com/iuin/dev-jumpbox:tcpmux-v6.1.1
    container_name: dev-jumpbox
    environment:
      TZ: "Asia/Shanghai"
      serverAddr: '"55.44.33.33"'
      serverPort: 18000
      auth_token: '"jumpboxs-ssh"'
      client_name: '"jumpboxc-ssh-fa"'
      customDomains: '["fa.intranet.company"]'
    volumes:
      # 需要先创建这个文件, 不然会自动创建为文件夹
      - ./.ssh/authorized_keys:/root/.ssh/authorized_keys:ro
    restart: unless-stopped

不想要多配置个proxycommand的话, 用下面的方式会简单点, 但需要独占端口

services:
  dev-jumpbox:
    image: registry.cn-hangzhou.aliyuncs.com/iuin/dev-jumpbox:frpc-ssh-v6.1
    container_name: dev-jumpbox
    environment:
      TZ: "Asia/Shanghai"
      serverAddr: '"55.44.33.33"'
      client_title: proxies
      serverPort: 18000
      auth_token_line: auth.token = "jumpboxs-ssh"
      client_name: '"fa.intranet.company"'
      client_type: '"tcp"'
      localIP_proxies_line: localIP="127.0.0.1"
      localPort_proxies_line: localPort=22
      # 独占端口方式, 需要外网防火墙开放这个端口
      remotePort_proxies_tcp_line: remotePort=12202
    extra_hosts:
      - "container.host:host-gateway"
    volumes:
      # 需要先创建这个文件, 不然会自动创建为文件夹
      - ./.ssh/authorized_keys:/root/.ssh/authorized_keys:ro
    restart: unless-stopped

# 构建镜像并启动容器
docker-compose up -d

关于卷(volumes)的说明

这里的卷也可以不挂载, 也可以通过进入容器中执行命令去写入authorized_keys文件中, 不过容器重启后, 会丢失写入的内容

# 在本地电脑中执行, 打印公钥
cat ~/.ssh/id_ed25519.pub
# 复制打印的公钥内容, 需要写入到`./.ssh/authorized_keys`, 这个文件是需要挂载到容器中的文件
# 全路径: /www/dev-jumpbox/client/.ssh/authorized_keys(注意: 别跟宿主机的authorized_keys文件搞混了)
# 这里也可以由dev-jumpbox容器去管理ssh公私钥, 把宿主机生成好的公私钥, 挂载到容器中, 然后在容器中执行命令去写入authorized_keys文件中, 最后把私钥给到clash(mihomo)工具使用
# 如果clash用户想用自己的私钥的话, 那就在生成私钥的时候, 选择将公私钥生成到clash配置目录下, 然后在clash配置文件中, 引用自己的私钥文件即可(clash verge rev只支持读取根目录下的私钥文件)

# 在客户端宿主机或者容器中执行, 写入公钥到authorized_keys文件中
echo 'ssh-ed25519 xxxxx xxx' > ./.ssh/authorized_keys

第四步: 启动docker-compose, 测试容器以及上传进行

# 构建镜像并启动容器
docker-compose up -d

使用ssh远程连接下, 试试效果

# 上传公钥, 开启免密登录, 这一步也是顺便检查了是否能够正常通过内网穿透ssh到容器中
ssh-copy-id root@129.204.8.8 -p 12222 -i ~/.ssh/id_ed25519
# 然后, 通过ssh免密登录
ssh root@129.204.8.8 -p 12222

参考详情链接

到这就已经基本完成了在任何地方都能联通ssh了, 接下来的就是高级应用了, 配合clash(mihomo)工具, 实现网络流量代理到内容容器中

配合clash(mihomo)工具使用, 方便访问网页

这里, 我们借助clash(mihomo)工具, 通过ssh将流量代理转发到容器中, 实现像访问局域网一样访问容器那边的对应内网上的网页

clash(mihomo)的github地址

// 代理流量(script.js[这里用了全局脚本的方式, 兼容自己的原有的订阅, 不影响原有的订阅, 只做扩展])
function main(config, profileName) {
  const privateKeyContent = `-----BEGIN OPENSSH PRIVATE KEY-----
b3BlbnNzaC1rZxxxABAAAAMwAAA
QyNTUxOQAAAxxxAAAIgIqewcCKn
HAAAAAtxxxDYC8YhlRDIhM+GUeg
-----END OPENSSH PRIVATE KEY-----`;
  const extra = {
    proxies: [
      {
        name: "company_container",
        type: "ssh",
        server: "183.11.11.11",
        port: 11111,
        username: "root",
        // 用密钥的情况下, 这里需要把密钥复制到软件配置目录下的.ssh目录中, 才能正常使用
        // "private-key": "./.ssh/id_ed25519_iu"
        "private-key": privateKeyContent
      }
    ],
    proxyGroups: [
      {
        name: "company_g",
        type: "select",
        proxies: ["DIRECT", "company_container"]
      }
    ],
    rules: [
      "IP-CIDR,10.0.11.0/24,company_g",
      "DOMAIN-SUFFIX,company.com,company_g"
    ]
  };

  if (!Array.isArray(config.proxies)) config.proxies = [];
  for (const p of extra.proxies) {
    if (p && p.name && !config.proxies.some(x => x && x.name === p.name)) {
      config.proxies.unshift(p);
    }
  }

  if (!Array.isArray(config["proxy-groups"])) config["proxy-groups"] = [];
  for (const g of extra.proxyGroups) {
    let existing = config["proxy-groups"].find(x => x && x.name === g.name);
    if (!existing) {
      config["proxy-groups"].unshift({ name: g.name, type: g.type, proxies: Array.isArray(g.proxies) ? [...g.proxies] : [] });
    } else {
      if (!Array.isArray(existing.proxies)) existing.proxies = [];
      for (const pn of g.proxies || []) {
        if (!existing.proxies.includes(pn)) existing.proxies.unshift(pn);
      }
    }
  }

  if (!Array.isArray(config.rules)) config.rules = [];
  for (const r of extra.rules) {
    if (!config.rules.includes(r)) config.rules.unshift(r);
  }

  return config;
}

# 单独订阅配置(ssh.yml)
proxies:
  - name: company_container
    type: ssh
    server: 183.11.11.11
    port: 11111
    username: root
    # 用密钥的情况下, 这里需要把密钥复制到软件配置目录下的.ssh目录中, 才能正常使用
    # private-key: ./.ssh/id_ed25519_iu
    private-key: |
      -----BEGIN OPENSSH PRIVATE KEY-----
      b3BlbnNzaC1rZxxxABAAAAMwAAA
      QyNTUxOQAAAxxxAAAIgIqewcCKn
      HAAAAAtxxxDYC8YhlRDIhM+GUeg
      -----END OPENSSH PRIVATE KEY-----

proxy-groups:
  - name: company_g
    type: select
    proxies:
      - company_container

rules:
  - "IP-CIDR,10.0.11.0/24,company_g"
  - "DOMAIN-SUFFIX,company.com,company_g"

k8s中使用, 打通命名空间中的网络

## k8s等(有内部DNS功能的系统)用法

# 其他配置省略
rules:
  - "IP-CIDR,10.0.11.0/24,company_g"
  - "IP-CIDR,100.20.0.0/16,company_g"
  - "IP-CIDR,100.19.0.0/16,company_g"
  - "DOMAIN-SUFFIX,svc.cluster.local,company_g"
  - "DOMAIN-SUFFIX,company.com,company_g"

说明: 这里挂载了三个网段
- 其中, 第一个网段是需要代理其他正常流量的网段
- 第二和第三个网段, 则是命名空间中的容器使用的网段
  - 作用是, 让我们能通过k8s内部域名访问, k8s中容器提供的服务
    - 即通过svc.cluster.localk8s中内部域名访问

最后的话

到这就基本完成了我们的目标了, 能够正常像在一个局域网中一样, 访问网页以及连接数据库等了

要是有什么问题, 欢迎留言交流

更多内容
- 这篇文章对应的GitHub博客文档地址

(frps selfhost版)有没想过起个容器就能打通整个内网呢? 使用容器打通受限网络: frp+ssh组合镜像以及clash(mihomo)实现打通网络(full)

Tue, 20 May 2025 00:00:00 GMT

使用容器打通受限网络: frp+ssh组合镜像以及clash(mihomo)实现打通任意环境所有内网服务(包括k8s)(web页面以及终端访问) 这里还有个需要提到的是, 因为我的科学上网环境是用的clash(mihomo)软件, 所以这里就用clash(mihomo)来实现打通各种内网这样我就可以只需要一个代理软件就行了

前言

开发过程中总是能遇到需要访问其他公司内网的情况, 一般常规方案都是由其他公司提供vpn访问, 或者jumpserver进行内网服务器连接.

也就是说, 打通了网络, 也就打通了ssh访问, ssh能到达的地方, 都能将自己的本地电脑拉入到同一网络中进行互通操作

前提

第一步: 编写Dockerfile, 用于制作镜像

随便找台Linux系统, 或者自己电脑也行(就是麻烦点, 可能构建镜像时, 需要指定构建平台等), 我这里选择用x86架构的centos系统, 然后, 找个合适的目录, 例如: /www/container/frp-ssh

创建Dockerfile文件

# vim Dockerfile

FROM debian:trixie-slim

WORKDIR /www

# 安装必要的软件包
RUN apt-get update && \
    apt-get install -y openssh-server openssh-client curl wget locales gettext tini && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

# 生成并配置 locale
RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen && \
    locale-gen && \
    update-locale LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8

# 设置环境变量
ENV LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8 LANGUAGE=en_US.UTF-8

# 解压frp
COPY ./frp_0.62.1_linux_amd64.tar.gz ./frp_0.62.1_linux_amd64.tar.gz
RUN tar -xzf ./frp_0.62.1_linux_amd64.tar.gz && \
    mv frp_0.62.1_linux_amd64 frp

# 创建包装服务
RUN tee /www/frp/frpc.toml <<-'EOF'
serverAddr = ${serverAddr}
serverPort = ${serverPort}

[[${client_title}]]
name = ${client_name}
type = ${client_type}
${secretKey_stcp_line}
${localIP_proxies_line}
${localPort_proxies_line}
${serverName_visitors_line}
${bindAddr_visitors_line}
${bindPort_visitors_line}
${remotePort_proxies_tcp_line}
EOF

# 创建初始化脚本
RUN tee /entrypoint.sh <<-'EOF'
#!/bin/sh
# 替换环境变量的值
envsubst < /www/frp/frpc.toml > /tmp/frpc.toml.tmp && mv /tmp/frpc.toml.tmp /www/frp/frpc.toml

# 确保目录存在
[ ! -d "/var/run/sshd" ] && mkdir -p /var/run/sshd
# 启动 SSH（后台运行）
/usr/sbin/sshd -D &

# 启动 FRPC
/www/frp/frpc -c /www/frp/frpc.toml

# 保持容器运行
wait
EOF

RUN chmod +x /entrypoint.sh

# 暴露 SSH 端口
EXPOSE 22

# 使用 tini 作为 PID 1
ENTRYPOINT ["/usr/bin/tini", "--", "/entrypoint.sh"]

第二步: 编写docker-compose.yml, 方便构建和运行容器

# vim docker-compose.yml

services:
  dev-jumpbox:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: dev-jumpbox
    environment:
      TZ: "Asia/Shanghai"
      # 配置服务端的IP
      serverAddr: '"129.204.8.8"'
      client_title: proxies
      serverPort: 7000
      # 名称随便给, 不重复就行
      client_name: '"dev-jumpbox-6666"'
      client_type: '"tcp"'
      localIP_proxies_line: localIP="127.0.0.1"
      localPort_proxies_line: localPort=22
      # 配置云服务器中开放的端口, 随便开放一个都行, 用于远程连接ssh
      remotePort_proxies_tcp_line: remotePort=6666
    extra_hosts:
      - "me.host:host-gateway"
    restart: unless-stopped
    volumes:
      - ./.ssh/authorized_keys:/root/.ssh/authorized_keys

# 以上环境变量, 除了备注的内容, 其他的都可以保持不动就行

# authorized_keys的内容示例
# ssh-ed25519 xxxxx xxx

authorized_keys的内容示例

# 在本地电脑中执行, 打印公钥
cat ~/.ssh/id_ed25519.pub
# 复制打印的公钥内容, 需要写入到`./.ssh/authorized_keys`, 这个文件是需要挂载到容器中的文件

关于卷(volumes)的说明

这里的卷也可以不挂载, 也可以通过进入容器中执行命令去写入authorized_keys文件中

# 使用挂载券方式时, 这一步可省略
echo 'ssh-ed25519 xxxxx xxx' > /root/.ssh/authorized_keys

第三步: 需要一台有公网IP的云服务器(2c2g1m就差不多了, 我的镜像是Debian)

frp官网安装地址 frp官方GitHub下载地址

# 下载下来解压
tar -xzf ./frp_0.62.1_linux_amd64.tar.gz && mv frp_0.62.1_linux_amd64 frp
# 进入解压后的目录, 启动frp服务端, 设置开机自启
cd frp && systemctl start frps && systemctl enable frps

然后, 开放下端口, 例如: 开放端口:6666, 用于远程连接ssh

第四步: 启动docker-compose, 测试容器以及上传进行

# 构建镜像并启动容器
docker-compose up -d

使用ssh远程连接下, 试试效果

# 上传公钥, 开启免密登录, 这一步也是顺便检查了是否能够正常通过内网穿透ssh到容器中
ssh-copy-id root@129.204.8.8 -p 6666 -i ~/.ssh/id_ed25519
# 然后, 通过ssh免密登录
ssh root@129.204.8.8 -p 6666

到这就已经基本完成了在任何地方都能联通ssh了, 接下来的就是简化配置, 以及高级应用了

上传镜像到阿里云, 简化启动容器的配置

# 登录
docker login --username=xxx@qq.com registry.cn-hangzhou.aliyuncs.com
## 标记本地镜像并指向目标仓库（ip:port/image_name:tag，该格式为标记版本号）
docker tag dev-jumpbox registry.cn-hangzhou.aliyuncs.com/xxx/dev-jumpbox:frpc-ssh
## 推送镜像到仓库
docker push registry.cn-hangzhou.aliyuncs.com/xxx/dev-jumpbox:frpc-ssh

简化后的docker-compose配置

简化后, 就只需要docker-compose配置即可, 当然, 如果没有将authorized_keys配置整合到Dockerfile中的情况下, 还是需要挂载配置的

参考详情链接

services:
  dev-jumpbox:
    image: registry.cn-hangzhou.aliyuncs.com/iuin/dev-jumpbox:tcpmux-v6.1.1
    container_name: dev-jumpbox
    environment:
      TZ: "Asia/Shanghai"
      serverAddr: '"183.11.11.11"'
      serverPort: 11100
      auth_token: '"xx-jumpbox-ssh"'
      client_name: '"container.prod.xxx.customer"'
      customDomains: '["container.prod.xxx.customer"]'
    restart: unless-stopped

配合clash(mihomo)工具使用, 方便访问网页

这里, 我们借助clash(mihomo)工具, 通过ssh将流量代理转发到容器中, 实现像访问局域网一样访问容器那边的对应内网上的网页

clash(mihomo)的github地址

# 代理流量(script.js[这里用了全局脚本的方式, 兼容自己的原有的订阅, 不影响原有的订阅, 只做扩展])
function main(config, profileName) {
  const extra = {
    proxies: [
      {
        name: "company_container",
        type: "ssh",
        server: "183.11.11.11",
        port: 11111,
        username: "root",
        "private-key": "./.ssh/id_ed25519_iu"
      }
    ],
    proxyGroups: [
      {
        name: "company_g",
        type: "select",
        proxies: ["DIRECT", "company_container"]
      }
    ],
    rules: [
      "IP-CIDR,10.0.11.0/24,company_g",
      "DOMAIN-SUFFIX,company.com,company_g"
    ]
  };

  if (!Array.isArray(config.proxies)) config.proxies = [];
  for (const p of extra.proxies) {
    if (p && p.name && !config.proxies.some(x => x && x.name === p.name)) {
      config.proxies.unshift(p);
    }
  }

  if (!Array.isArray(config["proxy-groups"])) config["proxy-groups"] = [];
  for (const g of extra.proxyGroups) {
    let existing = config["proxy-groups"].find(x => x && x.name === g.name);
    if (!existing) {
      config["proxy-groups"].unshift({ name: g.name, type: g.type, proxies: Array.isArray(g.proxies) ? [...g.proxies] : [] });
    } else {
      if (!Array.isArray(existing.proxies)) existing.proxies = [];
      for (const pn of g.proxies || []) {
        if (!existing.proxies.includes(pn)) existing.proxies.unshift(pn);
      }
    }
  }

  if (!Array.isArray(config.rules)) config.rules = [];
  for (const r of extra.rules) {
    if (!config.rules.includes(r)) config.rules.unshift(r);
  }

  return config;
}

# 单独订阅配置(ssh.yml)
proxies:
  - name: company_container
    type: ssh
    server: 183.11.11.11
    port: 11111
    username: root
    private-key: ./.ssh/id_ed25519_iu

proxy-groups:
  - name: company_g
    type: select
    proxies:
      - company_container

rules:
  - "IP-CIDR,10.0.11.0/24,company_g"
  - "DOMAIN-SUFFIX,company.com,company_g"

k8s中使用, 打通命名空间中的网络

## k8s等(有内部DNS功能的系统)用法

# 其他配置省略
rules:
  - "IP-CIDR,10.0.11.0/24,company_g"
  - "IP-CIDR,100.20.0.0/16,company_g"
  - "IP-CIDR,100.19.0.0/16,company_g"
  - "DOMAIN-SUFFIX,svc.cluster.local,company_g"
  - "DOMAIN-SUFFIX,company.com,company_g"

说明: 这里挂载了三个网段
- 其中, 第一个网段是需要代理其他正常流量的网段
- 第二和第三个网段, 则是命名空间中的容器使用的网段
  - 作用是, 让我们能通过k8s内部域名访问, k8s中容器提供的服务
    - 即通过svc.cluster.localk8s中内部域名访问

最后的话

到这就基本完成了我们的目标了, 能够正常像在一个局域网中一样, 访问网页以及连接数据库等了

更多内容
- 这篇文章对应的GitHub博客文档地址

(frps selfhost版)有没想过起个容器就能打通整个内网呢? 使用容器打通受限网络: frp+ssh组合镜像以及sshuttle打通网络

Tue, 20 May 2025 00:00:00 GMT

使用容器打通受限网络: frp+ssh组合镜像以及sshuttle实现打通任意环境所有内网服务(包括k8s)(web页面以及终端访问)

前言

开发过程中总是能遇到需要访问其他公司内网的情况, 一般常规方案都是由其他公司提供vpn访问, 或者jumpserver进行内网服务器连接.

也就是说, 打通了网络, 也就打通了ssh访问, ssh能到达的地方, 都能将自己的本地电脑拉入到同一网络中进行互通操作

前提

第一步: 编写Dockerfile, 用于制作镜像

创建Dockerfile文件

# vim Dockerfile

FROM debian:trixie-slim

WORKDIR /www

# 安装必要的软件包
RUN apt-get update && \
    apt-get install -y openssh-server openssh-client curl wget locales gettext tini && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

# 生成并配置 locale
RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen && \
    locale-gen && \
    update-locale LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8

# 设置环境变量
ENV LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8 LANGUAGE=en_US.UTF-8

# 解压frp
COPY ./frp_0.62.1_linux_amd64.tar.gz ./frp_0.62.1_linux_amd64.tar.gz
RUN tar -xzf ./frp_0.62.1_linux_amd64.tar.gz && \
    mv frp_0.62.1_linux_amd64 frp

# 创建包装服务
RUN tee /www/frp/frpc.toml <<-'EOF'
serverAddr = ${serverAddr}
serverPort = ${serverPort}

[[${client_title}]]
name = ${client_name}
type = ${client_type}
${secretKey_stcp_line}
${localIP_proxies_line}
${localPort_proxies_line}
${serverName_visitors_line}
${bindAddr_visitors_line}
${bindPort_visitors_line}
${remotePort_proxies_tcp_line}
EOF

# 创建初始化脚本
RUN tee /entrypoint.sh <<-'EOF'
#!/bin/sh
# 替换环境变量的值
envsubst < /www/frp/frpc.toml > /tmp/frpc.toml.tmp && mv /tmp/frpc.toml.tmp /www/frp/frpc.toml

# 确保目录存在
[ ! -d "/var/run/sshd" ] && mkdir -p /var/run/sshd
# 启动 SSH（后台运行）
/usr/sbin/sshd -D &

# 启动 FRPC
/www/frp/frpc -c /www/frp/frpc.toml

# 保持容器运行
wait
EOF

RUN chmod +x /entrypoint.sh

# 暴露 SSH 端口
EXPOSE 22

# 使用 tini 作为 PID 1
ENTRYPOINT ["/usr/bin/tini", "--", "/entrypoint.sh"]

第二步: 编写docker-compose.yml, 方便构建和运行容器

# vim docker-compose.yml

services:
  dev-jumpbox:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: dev-jumpbox
    environment:
      TZ: "Asia/Shanghai"
      # 配置服务端的IP
      serverAddr: '"129.204.8.8"'
      client_title: proxies
      serverPort: 7000
      # 名称随便给, 不重复就行
      client_name: '"dev-jumpbox-6666"'
      client_type: '"tcp"'
      localIP_proxies_line: localIP="127.0.0.1"
      localPort_proxies_line: localPort=22
      # 配置云服务器中开放的端口, 随便开放一个都行, 用于远程连接ssh
      remotePort_proxies_tcp_line: remotePort=6666
    extra_hosts:
      - "me.host:host-gateway"
    restart: unless-stopped
    volumes:
      - ./.ssh/authorized_keys:/root/.ssh/authorized_keys

# 以上环境变量, 除了备注的内容, 其他的都可以保持不动就行

# authorized_keys的内容示例
# ssh-ed25519 xxxxx xxx

authorized_keys的内容示例

# 在本地电脑中执行, 打印公钥
cat ~/.ssh/id_ed25519.pub
# 复制打印的公钥内容, 需要写入到`./.ssh/authorized_keys`, 这个文件是需要挂载到容器中的文件

关于卷(volumes)的说明

这里的卷也可以不挂载, 也可以通过进入容器中执行命令去写入authorized_keys文件中

# 使用挂载券方式时, 这一步可省略
echo 'ssh-ed25519 xxxxx xxx' > /root/.ssh/authorized_keys

第三步: 需要一台有公网IP的云服务器(2c2g1m就差不多了, 我的镜像是Debian)

frp官网安装地址 frp官方GitHub下载地址

# 下载下来解压
tar -xzf ./frp_0.62.1_linux_amd64.tar.gz && mv frp_0.62.1_linux_amd64 frp
# 进入解压后的目录, 启动frp服务端, 设置开机自启
cd frp && systemctl start frps && systemctl enable frps

然后, 开放下端口, 例如: 开放端口:6666, 用于远程连接ssh

第四步: 启动docker-compose, 测试容器以及上传进行

# 构建镜像并启动容器
docker-compose up -d

使用ssh远程连接下, 试试效果

# vim ~/.ssh/config
Host frpc.internet.company
  HostName 129.204.8.8
  User root
  Port 6666
  IdentityFile ~/.ssh/id_ed25519

# 上传公钥, 开启免密登录, 这一步也是顺便检查了是否能够正常通过内网穿透ssh到容器中
ssh-copy-id frpc.internet.company -i ~/.ssh/id_ed25519
# 然后, 通过ssh免密登录
ssh frpc.internet.company

到这就已经基本完成了在任何地方都能联通ssh了, 接下来的就是简化配置, 以及高级应用了

上传镜像到阿里云, 简化启动容器的配置

# 登录
docker login --username=xxx@qq.com registry.cn-hangzhou.aliyuncs.com
## 标记本地镜像并指向目标仓库（ip:port/image_name:tag，该格式为标记版本号）
docker tag dev-jumpbox registry.cn-hangzhou.aliyuncs.com/xxx/dev-jumpbox:frpc-ssh
## 推送镜像到仓库
docker push registry.cn-hangzhou.aliyuncs.com/xxx/dev-jumpbox:frpc-ssh

简化后的docker-compose配置

简化后, 就只需要docker-compose配置即可, 当然, 如果没有将authorized_keys配置整合到Dockerfile中的情况下, 还是需要挂载配置的

services:
  dev-jumpbox:
    image: registry.cn-hangzhou.aliyuncs.com/iuin/dev-jumpbox:frpc-ssh-v5
    container_name: dev-jumpbox
    environment:
      TZ: "Asia/Shanghai"
      # 配置服务端的IP
      serverAddr: '"129.204.8.8"'
      client_title: proxies
      serverPort: 7000
      # 名称随便给, 不重复就行
      client_name: '"dev-jumpbox-6666"'
      client_type: '"tcp"'
      localIP_proxies_line: localIP="127.0.0.1"
      localPort_proxies_line: localPort=22
      # 配置云服务器中开放的端口, 随便开放一个都行, 用于远程连接ssh
      remotePort_proxies_tcp_line: remotePort=6666
    extra_hosts:
      - "me.host:host-gateway"
    restart: unless-stopped

配合sshuttle工具使用, 方便访问网页

这里, 我们借助sshuttle工具, 通过ssh将流量代理转发到容器中, 实现像访问局域网一样访问容器那边的对应内网上的网页

sshuttle的github地址

# 安装(macos)
brew install sshuttle
# 代理流量
sshuttle --dns --auto-hosts --auto-nets -D -r cpolar.internet.company 10.0.10.0/24

k8s中使用, 打通命名空间中的网络

## k8s等(有内部DNS功能的系统)用法
sshuttle --dns --auto-hosts --auto-nets -D -r cpolar.internet.company 10.0.10.0/24  100.20.0.0/16 100.19.0.0/16

说明: 这里挂载了三个网段
- 其中, 第一个网段是需要代理流量的网段
  - 例如, 在k8s中启动了这个容器, 用于打通命名空间内部网络
- 第二和第三个网段, 则是命名空间中的容器使用的网段
  - 作用是, 让我们能通过k8s内部域名访问, k8s中容器提供的服务
    - 即我们通过svc.cluster.localk8s中内部域名访问时
      - sshuttle —dns配置会将这个内部域名通过第一个网段去查询内部dns, 去获取内部IP, 然后本地电脑去访问这个IP
      - 最后, 正因为获取到的是k8s容器的内部IP, 所以第二和第三网段流量也需要代理

最后的话

到这就基本完成了我们的目标了, 能够正常像在一个局域网中一样, 访问网页以及连接数据库等了

下期目标
- 实现p2p连接
更多内容
- 这篇文章对应的博客文档
- 对应的GitHub仓库, 可以在这里找到相关的全部配置代码

想不到这么快就到说再见的时候了, 稍稍的期待一下吧, 下期再见👋

(免费版)有没想过起个容器就能打通整个内网呢? 使用容器打通受限网络: cpolar+ssh组合镜像以及sshuttle打通网络

Mon, 19 May 2025 00:00:00 GMT

使用容器打通受限网络: cpolar+ssh组合镜像以及sshuttle实现打通任意环境所有内网服务(包括k8s)(web页面以及终端访问)

前言

开发过程中总是能遇到需要访问其他公司内网的情况, 一般常规方案都是由其他公司提供vpn访问, 或者jumpserver进行内网服务器连接.

这时, 一般就会遇到几个痛点: - 想要访问k8s中的容器服务, k8s内部域名无法直接使用 - 要装很多乱七八糟的vpn软件, 不同公司用的vpn可能就不一样, 有的vpn甚至像流氓软件一样, 有各种限制 - 有的公司不提供vpn或jumpserver, 只能去现场 - 家里网络和公司网络不互通的问题(在公司想访问家里的一些服务, 或在家想访问公司的一些服务等)

也就是说, 打通了网络, 也就打通了ssh访问, ssh能到达的地方, 都能将自己的本地电脑拉入到同一网络中进行互通操作

前提

第一步: 编写Dockerfile, 用于制作镜像

随便找台Linux系统, 或者自己电脑也行(就是麻烦点, 可能构建镜像时, 需要指定构建平台等), 我这里选择用x86架构的centos系统, 然后, 找个合适的目录, 例如: /www/container/cpolar-ssh

创建Dockerfile文件

# vim Dockerfile
# 使用官方 CentOS 基础镜像(PS: latest版拉取openssh-server依赖报错)
# FROM centos:centos7.9.2009
FROM registry.cn-hangzhou.aliyuncs.com/iuin/centos:latest

# ENV https_proxy=http://192.168.0.121:7890 http_proxy=http://192.168.0.121:7890 all_proxy=socks5://192.168.0.121:7890

RUN sed -i s/mirror.centos.org/vault.centos.org/g /etc/yum.repos.d/*.repo && \
    sed -i s/^#.*baseurl=http/baseurl=http/g /etc/yum.repos.d/*.repo && \
    sed -i s/^mirrorlist=http/#mirrorlist=http/g /etc/yum.repos.d/*.repo && \
    yum install -y wget && \
    wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

# 安装必要的软件包
RUN yum update -y && yum install -y openssh-server openssh-clients passwd && yum clean all

# 设置 root 密码, 修改 SSH 配置文件允许密码登录和 root 登录
RUN echo "root:password" | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/g' /etc/ssh/sshd_config && \
    sed -i 's/#PasswordAuthentication no/PasswordAuthentication yes/g' /etc/ssh/sshd_config && \
    /usr/sbin/sshd-keygen

RUN curl -L https://www.cpolar.com/static/downloads/install-release-cpolar.sh | bash

COPY cpolar.yml /usr/local/etc/cpolar/cpolar.yml

# 开启服务后, /usr/sbin/init命令会自动帮忙启动服务
RUN systemctl enable cpolar.service


# 创建启动脚本
RUN tee /usr/local/bin/start-cpolar.sh <<-'EOF'
#!/bin/bash
cpolar authtoken ${CPOLAR_AUTH_TOKEN}
EOF

RUN chmod +x /usr/local/bin/start-cpolar.sh

# 创建包装服务
RUN tee /etc/systemd/system/cpolar-wrapper.service <<-'EOF'
[Unit]
Description=Cpolar Wrapper Service
# After=network.target
After=cpolar.service

[Service]
Type=simple
ExecStart=/usr/local/bin/start-cpolar.sh
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

# 启用包装服务
RUN systemctl enable cpolar-wrapper.service


# 暴露 SSH 端口
EXPOSE 22
# 启动ssh和cpolar服务
# ENTRYPOINT [ "/usr/sbin/init" ]


# 创建初始化脚本
RUN tee /usr/local/bin/init-container.sh <<-'EOF'
#!/bin/bash
# 替换环境变量的值
sed -i "s/\${CPOLAR_AUTH_TOKEN}/$CPOLAR_AUTH_TOKEN/g" /usr/local/bin/start-cpolar.sh
sed -i "s/\${CPOLAR_CONTANER_SSH_NAME}/${CPOLAR_CONTANER_SSH_NAME:-contaner_ssh}/g" /usr/local/etc/cpolar/cpolar.yml
# 启动 init
exec /usr/sbin/init
EOF

RUN chmod +x /usr/local/bin/init-container.sh

# 使用初始化脚本作为入口点
ENTRYPOINT ["/usr/local/bin/init-container.sh"]

第二步: 编写docker-compose.yml, 方便构建和运行容器

vim docker-compose.yml

services:
  cpolar-ssh:
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      - TZ="Asia/Shanghai"
      - CPOLAR_AUTH_TOKEN=xxx
      - CPOLAR_CONTANER_SSH_NAME=contaner_ssh_1
    restart: unless-stopped
    privileged: true
    volumes:
      - ./cpolar.yml:/usr/local/etc/cpolar/cpolar.yml

编写用于挂载的cpolar配置文件
- 这个也可以考虑写死到Dockerfile中, 通过环境变量的方式去更新变量
- 需要配置更多的隧道, 再把它给挂载出来, 这样能够简化下基础流程

vim cpolar.yml

tunnels:
  ${CPOLAR_CONTANER_SSH_NAME}:
    proto: tcp
    addr: "22"
    bind_tls: both
    start_type: enable

第三步: 启动docker-compose, 测试容器以及上传进行

调整上一步中的环境变量, 主要是CPOLAR_AUTH_TOKEN, 需要到cpolar中注册个免费账号, 才能获取到token

cpolar官网地址

# 构建镜像并启动容器
docker-compose up -d

使用ssh远程连接下, 试试效果

# vim ~/.ssh/config
Host cpolar.internet.company
  HostName xxx.tcp.cpolar.top
  User root
  Port 11111
  IdentityFile ~/.ssh/id_ed25519

# 上传公钥, 开启免密登录, 这一步也是顺便检查了是否能够正常通过内网穿透ssh到容器中
ssh-copy-id cpolar.internet.company -i ~/.ssh/id_ed25519
# 然后, 通过ssh免密登录
ssh cpolar.internet.company

到这就已经基本完成了在任何地方都能联通ssh了, 接下来的就是简化配置, 以及高级应用了

上传镜像到阿里云, 简化启动容器的配置

# 登录
docker login --username=xxx@qq.com registry.cn-hangzhou.aliyuncs.com
## 标记本地镜像并指向目标仓库（ip:port/image_name:tag，该格式为标记版本号）
docker tag cpolar-ssh registry.cn-hangzhou.aliyuncs.com/xxx/cpolar-ssh:latest
## 推送镜像到仓库
docker push registry.cn-hangzhou.aliyuncs.com/xxx/cpolar-ssh:latest

简化后的docker-compose配置

简化后, 就只需要docker-compose配置即可, 当然, 如果没有将cpolar配置整合到Dockerfile中的情况下, 还是需要挂载配置的

services:
  cpolar-ssh:
    image: registry.cn-hangzhou.aliyuncs.com/xxx/cpolar-ssh:latest
    environment:
      - TZ="Asia/Shanghai"
      - CPOLAR_AUTH_TOKEN=${CPOLAR_AUTH_TOKEN}
      - CPOLAR_CONTANER_SSH_NAME=contaner_ssh_1
    restart: unless-stopped
    privileged: true

配合sshuttle工具使用, 方便访问网页

这里, 我们借助sshuttle工具, 通过ssh将流量代理转发到容器中, 实现想访问局域网一样访问容器那边的对应内网上的网页

sshuttle的github地址

# 安装(macos)
brew install sshuttle
# 代理流量
sshuttle --sudoers-user fa --dns --method auto --auto-hosts --auto-nets -D -r cpolar.internet.company 10.0.10.0/24

最后的话

到这就基本完成了我们最初的目标了, 能够正常像在一个局域网中一样, 访问网页以及连接数据库等了

最后说下现有方案还存在的一些问题
- 密码连接相对没那么安全
- 使用到了systemd工具, 也就是docker-compose中必须使用privileged: true, 容器权限太高了
- 用的第三方的服务器(cpolar)做中转, 流量要经过别人的服务器
下期目标
- ssh改为使用密钥方式登录, 禁用密码登录
- 容器服务管理工具不使用systemd, 而是改为更轻量的多服务管理工具tini
  - 这样docker容器也不在需要配置privileged: true了
- 内网穿透改为开源的frp, 当然, 这里就需要自己有一台公网的服务器去部署服务端了
相关链接
- 这篇文章对应的博客文档
- 对应的GitHub仓库, 可以在这里找到相关的全部配置代码

想不到这么快就到说再见的时候了, 稍稍的期待一下吧, 下期再见👋

arthas查看sql

Thu, 05 Sep 2024 00:00:00 GMT

参考文章

watch java.sql.Connection prepareStatement '{params,throwExp}'    -x 3
watch java.sql.Statement executeQuery '{params,throwExp}'    -x 3

watch org.apache.ibatis.mapping.BoundSql getSql '{params,returnObj,throwExp}'    -x 3

temp

watch java.sql.Statement executeQuery '{params,returnObj,throwExp}'  -n 5  -x 3
watch java.sql.Statement executeQuery '{params,returnObj,throwExp}'  -x 3
watch java.sql.Statement executeQuery '{params,returnObj,throwExp}'  -x 2

# 过滤某个表的sql
watch java.sql.Statement executeQuery '{params,returnObj,throwExp}'  -x 2 | grep -C 5 "com_commodity_shop"

# 看到的是jpa的非本地sql
watch javax.persistence.EntityManager createQuery '{params,returnObj,throwExp}'  -n 5  -x 3

一键更换Linux优质的软件源和docker源

Tue, 27 Aug 2024 00:00:00 GMT

参考文章

镜像地址

# 是用root命令执行
# 软件源一键更换
bash <(curl -sSL https://linuxmirrors.cn/main.sh)
# Docker 一键安装
bash <(curl -sSL https://linuxmirrors.cn/docker.sh)

docker镜像源

Thu, 25 Jul 2024 00:00:00 GMT

参考文章

# Docker 官方中国区
# https://registry.docker-cn.com
# 网易
# http://hub-mirror.c.163.com
# ustc
# https://docker.mirrors.ustc.edu.cn

# 测试镜像源
docker run --rm hello-world --registry-mirror=https://registry.docker-cn.com
docker run --rm hello-world --registry-mirror=http://hub-mirror.c.163.com
docker run --rm hello-world --registry-mirror=https://docker.mirrors.ustc.edu.cn

docker run --rm node:14.21.1-slim --registry-mirror=https://registry.docker-cn.com
docker run --rm node:14.21.1-slim --registry-mirror=http://hub-mirror.c.163.com
docker run --rm node:14.21.1-slim --registry-mirror=https://docker.mirrors.ustc.edu.cn

最新可用的docker镜像源
- docker.fxxk.dedyn.io
  - 顺便研究下Cloudflare Workers的工作原理, 感觉挺有用的
  - 相关博客
- 自己部署的docker镜像源
  - docker镜像源

java.lang.OutOfMemoryError : unable to create new native Thread

Wed, 05 Jun 2024 00:00:00 GMT

# 使用此命令查看正在运行的线程数
ps -elfT | wc -l
ps -elfT | grep appName|wc -l
# 要获取进程正在运行的线程数（可以使用 top 或 ps aux 获取进程 pid）：
ps -p <PROCESS_PID> -lfT | wc -l
# 查找哪些进程正在创建线程
ps huH
# 用户可以拥有的线程数量是有限制的。可以通过“最大用户进程数”行进行检查
ulimit -a
# /proc/sys/kernel/threads-max 文件提供系统范围内的线程数限制。 root 用户可以更改该值
# 要更改限制（在本例中为 4096 个线程）：
ulimit -u 4096
# 使用 jps 列出所有 java 进程（只需在 shell 中执行 jps ）并使用每个 Ghost 进程的 kill -9 pid bash 命令分别杀死它们时，它就解决了。
jps

postgresql表死锁问题的排查方式_PostgreSQL_脚本之家

Wed, 05 Jun 2024 00:00:00 GMT

Excerpt

这篇文章主要介绍了postgresql表死锁问题的排查方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

1.查询激活的执行中的sql,查看有哪些更新update的sql。

select * from pg_stat_activity where state = ‘active’;

2. 查询表中存在的锁

select a.locktype, a.database, a.pid, a.mode, a.relation, b.relname from pg_locks a join pg_class b on a.relation = b.oid where lower(b.relname) = ‘h5_game’;

3. 杀掉死锁进程

select pg_terminate_backend(pid) from pg_stat_activity where state = ‘active’ and pid != pg_backend_pid() —and pid = 14172 and pid in (select a.pid from pg_locks a join pg_class b on a.relation = b.oid where lower(b.relname) = ‘news_content’)

锁模式

/* NoLock is not a lock mode, but a flag value meaning “don’t get a lock” */ #define NoLock 0

#define AccessShareLock 1 /* SELECT / #define RowShareLock 2 / SELECT FOR UPDATE/FOR SHARE / #define RowExclusiveLock 3 / INSERT, UPDATE, DELETE / #define ShareUpdateExclusiveLock 4 / VACUUM (non-FULL),ANALYZE, CREATE * INDEX CONCURRENTLY / #define ShareLock 5 / CREATE INDEX (WITHOUT CONCURRENTLY) / #define ShareRowExclusiveLock 6 / like EXCLUSIVE MODE, but allows ROW * SHARE / #define ExclusiveLock 7 / blocks ROW SHARE/SELECT…FOR * UPDATE / #define AccessExclusiveLock 8 / ALTER TABLE, DROP TABLE, VACUUM * FULL, and unqualified LOCK TABLE */

补充：Postgresql死锁的处理

背景：

对表进行所有操作都卡住，原因可能是更新表时导致这个表死锁了，开始进行排查

解决一：查询pg_stat_activity有没有记录

pg版本10.2

select pid,query,* from pg_stat_activity where datname=‘死锁的数据库’ and wait_event_type = ‘Lock’; select pg_cancel_backend(‘死锁那条数据的pid值’);##只能杀死select 语句, 对其他语句不生效 pg_terminate_backend(‘死锁那条数据的pid值’);#select,drop等各种操作

执行后发现select和delete表时正常执行，但truncate和drop表时会一直运行，也不报错。

“drop table” 和 “truncate table” 需要申请排它锁”ACCESS EXCLUSIVE”，执行这个命令卡住时，说明此时这张表上还有操作正在进行，比如查询等，

那么只有等待这个查询操作完成，“drop table” 或”truncate table”或者增加字段的SQL才能获取这张表上的 “ACCESS EXCLUSIVE”锁，操作才能进行下去。

解决二：查询pg_locks是否有这个对象的锁

select oid,relname from pg_class where relname=‘table name’; select locktype,pid,relation,mode,granted,* from pg_locks where relation= ‘上面查询出来的oid’; select pg_terminate_backend(‘进程ID’);

问题解决！！！

坑：一开始不知道pg_cancel_backend(‘死锁那条数据的pid值’);##只能杀死select 语句, 对其他语句不生效，杀了进程查询发现还存在，反复杀反复存在，换了pg_terminate_backend(‘进程ID’)问题就解决了。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。如有错误或未考虑完全的地方，望不吝赐教。

原文链接：https://blog.csdn.net/fsstyle/article/details/87917720

ssh

Sun, 21 Jan 2024 00:00:00 GMT

SSH 隧道简明教程
- 动态转发
  - 请求地址为192.168.1.100:3000，则通过 SSH 转发的请求地址也是192.168.1.100:3000。
  - ssh -N -D localhost:2000 root@192.168.10.85
  - 我们只需要在本地配置上 socks 代理，localhost:2000 即可把所有请求通过 ssh 2000 端口转发到 192.168.10.85 这台机器上去了。
- 本地转发
  - 我们需要在 ServerA 上执行以下命令开启 ssh 隧道：
  - ssh -N -L 8888:192.168.10.134:8888 root@192.168.10.85
  - 执行后 serverA 上已经开始监听 8888 端口了，默认是在本地回环地址上，需要其他机器访问的话可以指定 ip 或者增加 -g 参数开启网关模式。
socks5 代理
参考文章
参考文章1
参考文章2
- 可以使用一个叫做Sockscap的软件，把应用扔进去就能以代理的方式上网了。（部分需要调用多个进程的应用可能不行）
- 如果你想把socks代理转换成http代理，可以用privoxy这个东东。

~/.ssh/config

# 上传密钥~/.ssh/id_ed25519_iu
chmod 400 ~/.ssh/id_ed25519_iu

Host mac.intranet.company
  HostName 10.0.1.251
  User iuin
  IdentityFile ~/.ssh/id_ed25519_iu
  # PasswordAuthentication 123456

# ssh mac.intranet.company 看是否联通

ssh动态代理

# 登录服务器10.0.1.233
# 后台启动ssh动态转发
ssh -o GatewayPorts=yes -D 2000 mac.intranet.company -NTfCg

# 在本机中配置socks代理, 网络流量则会通过ssh转发到服务器上, 然后在访问互联网
# 配置地址: 10.0.1.233:2000

# PS: 可以配合clash一起使用, 实现通过ssh让中间机器去连接指定或多个VPN, 本机不连多余的VPN(其实是不想下载一堆的VPN相关软件), 只用clash就能透传流量过去
port: 7890
socks-port: 7891
allow-lan: false
mode: Rule
log-level: info
external-controller: 127.0.0.1:9090
proxies:
  - name: iuin_bpDev_mac
    type: socks5
    server: 10.0.1.233
    port: 2000
proxy-groups:
  - name: ssh_g
    type: select
    proxies:
      - iuin_bpDev_mac
rules:
 # 乐橘nacos所在服务器
 - IP-CIDR,10.0.10.180/32,ssh_g
 - DOMAIN-SUFFIX,yelomall.cn,ssh_g

docker-compose服务间依赖通过自定义健康检查实现顺序启动

Sat, 18 Nov 2023 00:00:00 GMT

Docker Compose中的condition: service_healthy配置是用来判断依赖的服务是否健康的。当一个服务依赖于另一个服务时，可以使用depends_on和condition: service_healthy来确保依赖的服务已经健康启动。

下面是关于如何判断服务是否健康的一些相关内容：

健康检查命令：在Dockerfile或docker container run命令中，可以使用HEALTHCHECK来定义容器的健康检查命令[1]。健康检查命令可以是任何能够返回0或非0退出代码的命令，例如使用curl命令检查服务是否可访问。
健康检查参数：健康检查命令可以使用一些参数来配置检查的间隔、超时和重试次数等。常用的健康检查参数包括：
- --interval：指定检查的间隔时间，默认为30秒。
- --timeout：指定每次检查的超时时间，默认为30秒。
- --retries：指定连续失败的次数后将服务标记为不健康，默认为3次。
- --start-period：指定容器启动后等待健康检查开始的时间，默认为0秒。
condition: service_healthy配置：在Docker Compose中，可以使用condition: service_healthy来指定依赖的服务是否健康。当依赖的服务的健康状态为健康时，才会启动当前的服务。这样可以确保依赖的服务已经成功启动并且可用。

下面是一个示例的docker-compose.yml文件，演示了如何使用健康检查和condition: service_healthy来判断服务是否健康并依次启动：

version: "3.8"

services:
  flask:
    build:
      context: ./flask
      dockerfile: Dockerfile
    image: flask-demo:latest
    environment:
      - REDIS_HOST=redis-server
      - REDIS_PASS=${REDIS_PASSWORD}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5000"]
      interval: 30s
      timeout: 3s
      retries: 3
      start_period: 40s
    depends_on:
      redis-server:
        condition: service_healthy
    networks:
      - backend
      - frontend

  redis-server:
    image: redis

在上述示例中，flask服务依赖于redis-server服务。flask服务的健康检查命令是使用curl命令检查http://localhost:5000是否可访问。只有当redis-server服务的健康状态为健康时，flask服务才会启动。

Learn more:

参考内容

nocodb部署yml

Doc Record | Blog

Mihomo SSH Config Alias Support

🔗 项目信息

📖 需求背景

✨ 功能特性

1. 完整 SSH Config 支持

2. 智能用户切换 (sudo -u)

3. 零配置密钥

🚀 使用方式

参数说明

配置示例

场景 1：基础跳板机 (ProxyJump)

场景 2：Cloudflare Access (ProxyCommand)

🛠 原理简述

SSH 远程端口转发配置指南：使用 socat 实现灵活的端口映射

目录

概述

配置详解

配置项解析

1. 基本连接配置

2. 端口转发配置

3. 自动启动 socat

4. 其他配置项

工作原理

使用方法

基本使用

后台运行

故障排除

常见问题及解决方案

1. 端口占用错误

2. 无法获得交互式 shell

3. socat 在 SSH 断开后仍然运行

最佳实践

1. 使用不常用端口

2. 添加端口占用检查

3. 使用 autossh 保持连接

4. 日志记录

高级配置

1. 多端口转发

2. 条件执行

3. 使用环境变量

总结

Welcome

(frps selfhost版)有没想过起个容器就能打通整个内网呢? 使用容器打通受限网络: frp+ssh组合镜像以及clash(mihomo)实现打通网络

前言

前提

编写docker-compose.yml(服务端)

编写docker-compose.yml(客户端)

第四步: 启动docker-compose, 测试容器以及上传进行

配合clash(mihomo)工具使用, 方便访问网页

k8s中使用, 打通命名空间中的网络

最后的话

(frps selfhost版)有没想过起个容器就能打通整个内网呢? 使用容器打通受限网络: frp+ssh组合镜像以及clash(mihomo)实现打通网络(full)

前言

前提

第一步: 编写Dockerfile, 用于制作镜像

第二步: 编写docker-compose.yml, 方便构建和运行容器

第三步: 需要一台有公网IP的云服务器(2c2g1m就差不多了, 我的镜像是Debian)

第四步: 启动docker-compose, 测试容器以及上传进行

上传镜像到阿里云, 简化启动容器的配置

简化后的docker-compose配置

配合clash(mihomo)工具使用, 方便访问网页

k8s中使用, 打通命名空间中的网络

最后的话

(frps selfhost版)有没想过起个容器就能打通整个内网呢? 使用容器打通受限网络: frp+ssh组合镜像以及sshuttle打通网络

前言

前提

第一步: 编写Dockerfile, 用于制作镜像

第二步: 编写docker-compose.yml, 方便构建和运行容器

第三步: 需要一台有公网IP的云服务器(2c2g1m就差不多了, 我的镜像是Debian)

第四步: 启动docker-compose, 测试容器以及上传进行

上传镜像到阿里云, 简化启动容器的配置

简化后的docker-compose配置

配合sshuttle工具使用, 方便访问网页

k8s中使用, 打通命名空间中的网络

最后的话

(免费版)有没想过起个容器就能打通整个内网呢? 使用容器打通受限网络: cpolar+ssh组合镜像以及sshuttle打通网络

前言

前提

第一步: 编写Dockerfile, 用于制作镜像

2. 智能用户切换 (`sudo -u`)