This log is empowered by Docusaurus.

1. 概述

2. 配置详解

3. 工作原理

4. 使用方法

5. 故障排除

6. 最佳实践

7. 高级配置

概述​

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

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

配置详解​

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

Host fa.remote.intranet.company

  HostName 10.0.16.146

  User root

  IdentityFile \~/.ssh/id\_ed25519\_iu

  RemoteForward 9094 127.0.0.1:9093

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

  ForwardAgent yes

  RequestTTY yes

配置项解析​

1. 基本连接配置​

Host fa.remote.intranet.company

  HostName 10.0.16.146

  User root

  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

工作原理​

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

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

• 使用指定的密钥文件进行身份验证

• 在远程服务器上建立 9094 端口的转发

• 执行 RemoteCommand 中指定的命令

1. socat 启动：RemoteCommand 会：

• 设置退出陷阱

• 启动 socat 监听 9093 端口

• 启动交互式 bash shell

1. 端口转发流程：

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

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

• trap 机制会捕获 EXIT 信号

• 终止 socat 进程

• SSH 连接关闭

• 所有转发端口释放

使用方法​

基本使用​

1. 编辑 SSH 配置文件

nano \~/.ssh/config

添加上述配置内容。

1. 建立连接

ssh fa.remote.intranet.company

1. 验证配置

在远程服务器上执行：

ss -tunlp | grep 9093

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

ss -tunlp | grep 9094

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

1. 测试端口转发

从另一台机器测试：

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\\""

  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 是一种强大的网络工具，能够实现灵活的端口映射和连接管理。通过本文档介绍的配置方法，您可以：

1. 建立可靠的远程端口转发

2. 确保 socat 进程在 SSH 连接断开时自动终止

3. 获得完整的交互式 shell 体验

4. 避免常见的端口冲突和资源泄漏问题

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

更新时间：2025 年 12 月 6 日

版本：1.0

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

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

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 

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

镜像地址

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

title: docker镜像源 date: 2024-05-22 slug: docker-mirror-source​

docker镜像源

参考文章

# 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镜像源

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

1. 健康检查命令：在Dockerfile或docker container run命令中，可以使用HEALTHCHECK来定义容器的健康检查命令[1]。健康检查命令可以是任何能够返回0或非0退出代码的命令，例如使用curl命令检查服务是否可访问。

2. 健康检查参数：健康检查命令可以使用一些参数来配置检查的间隔、超时和重试次数等。常用的健康检查参数包括：

   • --interval：指定检查的间隔时间，默认为30秒。
   • --timeout：指定每次检查的超时时间，默认为30秒。
   • --retries：指定连续失败的次数后将服务标记为不健康，默认为3次。
   • --start-period：指定容器启动后等待健康检查开始的时间，默认为0秒。

3. 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:

1. 【Docker系列】Docker Compose 服务依赖和健康检查_docker-compose healthcheck-CSDN博客
2. [docker]-docker-compose通过healthcheck判断容器状态并依次启动_docker-compose healthcheck-CSDN博客
3. Docker compose 服务依赖关系及健康检查 - 掘金

参考内容​

• nocodb部署yml

# Upload Key ~/.ssh/id_ed25519_iu
chmod 400 ~/.ssh/id_ed25519_iu

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

# ssh mac.intranet.company see whether or not to be set up

• 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
 

• Fork Repository: https://github.com/iuin8/mihomo
• Branch: (Make sure to see branches that contain the ssh-config-alias function, e.g. ssh_system_v1.19.17)
• Core file: adapter/outbound/ssh.go, adapter/outbound/ssh_system.go

📖 Needs background​

In a complex network environment, users often maintain a full set of SSH profiles (~/.ssh/config).These configurations may contain：

1. ProxyJump (dashboard)：requires one or more skippers to access the target inner web server.
2. ProxyCommand：uses third-party authentication tools (e.g. Cloudflare Access, AWS SSM).
3. IdentityFile：uses different key files for different hosts.
4. Host alias：uses short aliases instead of long IP or domain names.

The original Mihomo SSH adapter uses the Go language native SSH library and cannot use these system level configurations directly, resulting in the user having to manually convert complex springboard logic to the Dialer Proxy chain. The configuration is onerous and does not support some advanced instructions (such as the special ProxyCommand).

Target：allows Mihomo to "loan" system SSH client directly, simply fill in a host alias (e.g. my-server), the remaining authentication, skip to system SSH handling.

✨ Features​

Full SSH Config support​

Build tunnels by calling the system ssh command, Mihomo can support all instructions： that support SSH clients

• ✅ ProxyJump / JumpHost
• ✅ ProxyCommand (support cloudfled, nc etc.)
• ✅ IdentityFile, User, Port and so on
• ✅ advanced configuration logic like Match, Include

2. Smart user switching (sudo -u)​

Mihomo usually runs with root permissions (for TUN mode and so on) while the user's SSH configuration is located in the regular user directory.This feature implements：

• Automatically detect or specify actual users.
• Use sudo -u <user> -i to switch identity to perform SSH.
• **-i parameters** ensure that the complete login environment of the user (PATH), ensures that the cloudflared` command can be found.

Zero configuration key​

There is no need to fill the private key content in the Mihomo configuration file. It will automatically read ~/.ssh/id_rsa or the IdentityFile specified in the configuration.

🚀 Usage method​

Parameter Description​

Configuration Example​

Scene 1：Base Jump (ProxyJump)​

SSH Config (~/.ssh/config):

Host base
  HostName 1.2.3.4
  User admin

Post internal-db
  HostName 10.0.5
  User root
  ProxyJump base # automatic bastion jump forward

Mihomo Configuration:

proxies:
  - name: "Internal-DB-SSH"
    type: ssh
    server: "internal-db" # Direct Alias
    port: 22 # Internal SSH port
    use-ssh-config-alias: true
    ssh-user: "your-username" #

Scene 2：Cloudflare Access (ProxyCommand)​

*SSH Config:

Host my-cf-server
  HostName ssh.example.com
  User root
  # Requires cloudfled command in PATH
  ProxyCommand cloudflowed access ssh --hostname %h

Mihomo Configuration:

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

🛠️ Summary of rationale​

Mihomo will perform a command similar to： at the bottom after receiving a connection request

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

This command creates a TCP tunnel for standard input/output to a target SSH port.Mihomo then handshake his own SSH protocol on this tunnel, and set up proxy connections.

使用容器打通受限网络: 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也行 - 当然起个虚拟机去安转也行

第一步: 编写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博客文档地址

使用容器打通受限网络: 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博客文档地址

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

前言​

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

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

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

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

前提​

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

第一步: 编写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远程连接下, 试试效果

# 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仓库, 可以在这里找到相关的全部配置代码

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

Use Container for Restricted Networks: cpolar+ssh Portfolios and sshuttle to enable all inner network services (including k8s) in any environment (webpages and terminal access)

Preface​

There is always a need for access to other company intranets during the development process, usually through vpn from other companies, or jumpserver connections.

A few pain points are usually encountered at this time: - want to access the container services in k8s, k8s internal domain cannot use - to install many bad vpn software, vpn may be different from one company to another, some vpn may even be like rogue software, there are various restrictions - some companies do not offer vpn or jumpserverer, can only go on site - problems with which the network is not interoperable with the company network (some services in which the company wishes to visit home, or some of the company's services at home, etc.)

However, what are the benefits of being connected to the network? - Your own local computer does not need to accommodate too many vpn software for - every inner server that can be touched, becomes a tool for you when and where you can access or act as a springboard - the inner web to open the page, - Web system app can open - Nacos with browser on server - Intranet access - Database is connected via idea or DBeaver.

This means that you have access to the network and ssh access where ssh can arrive, you can pull your own local computer into the same network for interoperability

Prerequisite​

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

Step 1: Writing Dockerfile, used to make image​

I'll find a Linux system, or your own computer (troubleshoots, possible mirrors, need to specify a platform, etc.). Here I choose to use the x86 architectural centos system, and then find a suitable directory such as: /container/cpolar-ssh

• Create a Dockerfile file

# 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"]

Step 2: Write docker-compose.yml, easy to build and run containers​

vim docker-compose.yml

services:
  cpolar-ssh:
    build:
      context:
      dockerfile: Dockerfile
    environment:
      - TZ="Asia/Shanghai"
      - CPOLAR_AUTH_TOKEN=xx
      - CPOLAR_CONTANER_SSH_NAME=coner_ssh_1
    restore: unless-stopped
    primited: true 
    volumes:
      - cpolar.yml:/usr/local/etc/cpolar/cpolar.yml

• Write a cpolar profile to mount
  • This can also be considered to write to Dockerfile, update the variable by way of the environment variable
  • More tunnels need to be configured, then mount them out, thus simplifying the base process

vim cpolar.yml

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

Step 3: Start docker-compose, test container, and upload​

Adjust the environment variable in the last step, mainly CPOLAR_AUTH_TOKEN, needs to register a free account in the polar to get token.

• cpolar官网地址

# Build mirrors and start container
docker-compose up -d

• Try the effect using the ssh remote connection

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

# Upload public key, enable decrypted login by passing through the Intranet to check if you can normally pass through the container to
ssh-copy-id cpolar.internet.company -i ~/.ssh/id_ed25519
# and then log in
ssh cpolar.internet.company

This is almost complete anywhere to connect, followed by simplified configuration, and advanced applications

Upload a mirror to Aliyun to simplify the configuration of the launch container​

# Login to
docker logo --username=xxx@qq.com registry.cn-hangzhou.aliyuncs.com
## Marks local mirrors and points to target repository (ip:port/image_name:tag, this format is the notation number)
docker tag cpolar-ssh registry.cn-hangzhou.aliyuncs.com/xxx/cpolar-ssh:latest
## Push image to repository
docker push registry.cn-hangzhou.aliyuncs.com/xx/polar-ssh:latest

Simplified docker-compose configuration​

Simplified will only require docker-compose. Of course, if the cpolar configuration is not integrated into Dockerfile, it will still need to mount the configuration

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 

Use with sshuttle tool to facilitate access to web pages​

Here we use the sshuttle tool to forward traffic proxies to containers via ssh, so that we want to access the corresponding web page on the container side of the local area network

• sshuttle的github地址

# Installation (macos)
brew install sshuttle
# proxy traffic
sshuttle --sudoers-user fa --dns --method auto-hosts --auto-not-D -r cpolar.internet.company 10.0.0/24

Last applicable​

By this time we have largely completed our initial objectives, have the same access as in a local area network, access pages and connect to databases, etc.

• Finally, there are still some problems with existing programmes

  • Password connection is relatively less secure
  • privileged: true is used in the systemd tool, i.e. `docker-compose', the container is too high
  • The third party server (cpolar) is used to transit traffic through another person's server

• Next objective

  • ssh login using key mode and disable password login
  • Container Service Management tool does not use systemd, but instead has a lighter multiservice management tool tini.
    • This docker container is not required to configure privileged: true.
  • The Intranet penetrates into an open source frp, of course, it needs to have its own public server to deploy the server

• Related links

  • 这篇文章对应的博客文档
  • 对应的GitHub仓库, all relevant config codes can be found here

I think it is time to say a little bit about it, see it next time: waving_hand: