第一步：把脚本保存到本地

cat > ~/run_panda_pick_place.sh <<'BASH'
#!/usr/bin/env bash
set -euo pipefail

echo "=== Panda MoveIt 抓取演示：一键运行脚本 ==="

# 0) 基础环境
if [ -f /opt/ros/noetic/setup.bash ]; then
  source /opt/ros/noetic/setup.bash
else
  echo "未发现 /opt/ros/noetic，需先安装 ROS Noetic。"; exit 1
fi

ROS_DISTRO_CUR=$(rosversion -d 2>/dev/null || echo "unknown")
echo "当前 ROS 发行版: ${ROS_DISTRO_CUR}"
if [ "${ROS_DISTRO_CUR}" != "noetic" ]; then
  echo "警告：脚本按 Noetic 准备，当前为 ${ROS_DISTRO_CUR}，继续尝试运行…"
fi

# 1) 准备工作空间与依赖
WS=~/ws_arm
PKG=class_demo
mkdir -p "$WS/src"

# 确保必须的包存在（若缺失，尝试安装）
need_pkg() { rospack find "$1" >/dev/null 2>&1 || return 0; return 1; }
if ! rospack find panda_moveit_config >/dev/null 2>&1; then
  echo "未找到 panda_moveit_config，准备安装依赖（需要 sudo 密码）…"
  sudo apt update
  sudo apt install -y ros-noetic-moveit ros-noetic-moveit-resources-panda-moveit-config python3-catkin-tools
fi

# 2) 创建/更新演示包与脚本
if ! rospack find ${PKG} >/dev/null 2>&1; then
  pushd "$WS/src" >/dev/null
  if ! command -v catkin >/dev/null 2>&1; then
    echo "安装 catkin 工具（需要 sudo）…"
    sudo apt update && sudo apt install -y python3-catkin-tools
  fi
  if [ ! -f "$WS/.catkin_tools/profiles/default/config.yaml" ]; then
    catkin init
  fi
  if [ ! -d "${PKG}" ]; then
    catkin_create_pkg ${PKG} rospy geometry_msgs
    mkdir -p ${PKG}/scripts
  fi
  popd >/dev/null
fi

# 写入演示脚本（已修正：组名、cartesian path 参数、无 f-string）
cat > "${WS}/src/${PKG}/scripts/pick_place_demo.py" <<'PY'
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys, time, rospy
import moveit_commander, geometry_msgs.msg

def wait_for_state_update(scene, name, box_is_known=False, box_is_attached=False, timeout=4.0):
    start = time.time()
    while (time.time() - start) < timeout and not rospy.is_shutdown():
        attached = len(scene.get_attached_objects([name])) > 0
        known = name in scene.get_known_object_names()
        if attached == box_is_attached and (known == box_is_known or box_is_attached):
            return True
        rospy.sleep(0.1)
    return False

def open_gripper(hand):
    try:
        hand.set_named_target("open")
        hand.go(wait=True); return
    except Exception:
        pass
    joints = hand.get_active_joints()
    targets = {j: 0.04 for j in joints}
    hand.set_joint_value_target(targets); hand.go(wait=True)

def close_gripper(hand):
    try:
        hand.set_named_target("close")
        hand.go(wait=True); return
    except Exception:
        pass
    joints = hand.get_active_joints()
    targets = {j: 0.005 for j in joints}
    hand.set_joint_value_target(targets); hand.go(wait=True)

def main():
    rospy.init_node("class_pick_place")
    moveit_commander.roscpp_initialize(sys.argv)

    rospy.loginfo("初始化 MoveIt 接口…")
    robot = moveit_commander.RobotCommander()
    scene = moveit_commander.PlanningSceneInterface(synchronous=True)
    arm = moveit_commander.MoveGroupCommander("panda_arm")
    hand = moveit_commander.MoveGroupCommander("panda_hand")
    eef_link = arm.get_end_effector_link()

    arm.set_planner_id("RRTConnectkConfigDefault")
    arm.set_planning_time(5.0)
    arm.set_num_planning_attempts(10)
    arm.set_max_acceleration_scaling_factor(0.5)
    arm.set_max_velocity_scaling_factor(0.5)
    rospy.sleep(1.0)

    # 1) 添加方块
    rospy.loginfo("添加方块到场景…")
    box_name = "demo_box"
    box_pose = geometry_msgs.msg.PoseStamped()
    box_pose.header.frame_id = robot.get_planning_frame()
    box_pose.pose.position.x, box_pose.pose.position.y, box_pose.pose.position.z = 0.40, 0.00, 0.02
    box_pose.pose.orientation.w = 1.0
    scene.add_box(box_name, box_pose, size=(0.04, 0.04, 0.04))
    wait_for_state_update(scene, box_name, box_is_known=True)

    # 2) 张开夹爪
    rospy.loginfo("张开夹爪…")
    open_gripper(hand)

    # 3) 移动到方块上方
    rospy.loginfo("移动到方块上方（预抓取位）…")
    pre = geometry_msgs.msg.Pose()
    pre.position.x, pre.position.y, pre.position.z = 0.40, 0.00, 0.25
    pre.orientation.x, pre.orientation.y, pre.orientation.z, pre.orientation.w = 0.0, 1.0, 0.0, 0.0
    arm.set_pose_target(pre)
    arm.go(wait=True); arm.stop(); arm.clear_pose_targets()

    # 4) 直线下探到抓取高度
    rospy.loginfo("直线下探…")
    grasp = geometry_msgs.msg.Pose()
    grasp.position.x, grasp.position.y, grasp.position.z = 0.40, 0.00, 0.12
    grasp.orientation = pre.orientation
    start_pose = arm.get_current_pose().pose
    plan, fraction = arm.compute_cartesian_path([start_pose, grasp], 0.01, True)
    rospy.loginfo("下探轨迹覆盖率: {:.2f}".format(fraction))
    arm.execute(plan, wait=True)

    # 5) 闭合夹爪并附着方块
    rospy.loginfo("闭合夹爪并附着方块…")
    close_gripper(hand)
    touch_links = robot.get_link_names(group="panda_hand")
    scene.attach_box(eef_link, box_name, touch_links=touch_links)
    wait_for_state_update(scene, box_name, box_is_attached=True)

    # 6) 直线抬起
    rospy.loginfo("直线抬起…")
    start_pose = arm.get_current_pose().pose
    up_pose = geometry_msgs.msg.Pose()
    up_pose.position.x = start_pose.position.x
    up_pose.position.y = start_pose.position.y
    up_pose.position.z = start_pose.position.z + 0.12
    up_pose.orientation = start_pose.orientation
    plan, fraction = arm.compute_cartesian_path([start_pose, up_pose], 0.01, True)
    rospy.loginfo("抬起轨迹覆盖率: {:.2f}".format(fraction))
    arm.execute(plan, wait=True)

    # 7) 移动到放置位置上方
    rospy.loginfo("移动到放置位置上方…")
    place_top = geometry_msgs.msg.Pose()
    place_top.position.x, place_top.position.y, place_top.position.z = 0.30, -0.20, 0.25
    place_top.orientation = pre.orientation
    arm.set_pose_target(place_top)
    arm.go(wait=True); arm.stop(); arm.clear_pose_targets()

    # 8) 下放
    rospy.loginfo("下放…")
    place = geometry_msgs.msg.Pose()
    place.position.x, place.position.y, place.position.z = 0.30, -0.20, 0.12
    place.orientation = place_top.orientation
    start_pose = arm.get_current_pose().pose
    plan, fraction = arm.compute_cartesian_path([start_pose, place], 0.01, True)
    rospy.loginfo("下放轨迹覆盖率: {:.2f}".format(fraction))
    arm.execute(plan, wait=True)

    # 9) 张开夹爪，释放方块
    rospy.loginfo("张开夹爪，释放方块…")
    open_gripper(hand)
    scene.remove_attached_object(eef_link, name=box_name)
    wait_for_state_update(scene, box_name, box_is_known=True, box_is_attached=False)

    # 10) 移除世界中的方块（可选）
    rospy.loginfo("从场景移除方块（可选）…")
    scene.remove_world_object(box_name)

    # 11) 回到安全位
    rospy.loginfo("回到安全位…")
    safe = geometry_msgs.msg.Pose()
    safe.position.x, safe.position.y, safe.position.z = 0.35, 0.0, 0.35
    safe.orientation = pre.orientation
    arm.set_pose_target(safe)
    arm.go(wait=True); arm.stop(); arm.clear_pose_targets()

    rospy.loginfo("演示完成 ✅")

if __name__ == "__main__":
    try:
        main()
    finally:
        try:
            moveit_commander.roscpp_shutdown()
        except Exception:
            pass
PY

chmod +x "${WS}/src/${PKG}/scripts/pick_place_demo.py"

# 3) 构建（保证可被 rospack/rosrun 找到）
pushd "$WS" >/dev/null
if ! command -v catkin >/dev/null 2>&1; then
  echo "安装 catkin 工具（需要 sudo）…"
  sudo apt update && sudo apt install -y python3-catkin-tools
fi
catkin build
popd >/dev/null

# 4) 启动 MoveIt + RViz（若未运行）
source "${WS}/devel/setup.bash"

if ! rosnode list 2>/dev/null | grep -q "^/move_group$"; then
  echo "启动 MoveIt demo（后台运行，日志在 ~/.ros/panda_demo.launch.log）…"
  roslaunch panda_moveit_config demo.launch > ~/.ros/panda_demo.launch.log 2>&1 &
  echo -n "等待 move_group 就绪"
  for i in $(seq 1 60); do
    if rosnode list 2>/dev/null | grep -q "^/move_group$"; then echo " …OK"; break; fi
    echo -n "."; sleep 1
    if [ "$i" -eq 60 ]; then echo " 超时未就绪，请查看 ~/.ros/panda_demo.launch.log"; exit 1; fi
  done
else
  echo "检测到 move_group 已在运行，跳过启动。"
fi

# 5) 运行抓取演示
echo "执行抓取脚本…"
rosrun ${PKG} pick_place_demo.py || { echo "脚本运行失败，查看 ~/.ros/log/latest/ 下日志"; exit 1; }

echo
echo "演示已完成。"
echo "若想让 RViz 画面更干净："
echo "  - MotionPlanning → Trajectory：取消勾选 Show Trail、Loop Animation；"
echo "  - MotionPlanning → Planning Request：取消勾选 Query Start/Goal State；"
echo "  - 如仍有重复机器人，可关闭单独的 RobotModel 显示项。"
echo "你也可以手动 File → Save Config As… 保存一个清爽配置以便下次直接使用。"
BASH

第二步：给脚本执行权限

chmod +x ~/run_panda_pick_place.sh

第三步：运行脚本

bash ~/run_panda_pick_place.sh

📘 说明与可选项

脚本会自动完成以下操作：

• ✅ 检查并安装必要依赖（panda_moveit_config、catkin 工具等）
• ✅ 创建或更新 ~/ws_arm/class_demo 包，并写入修好的 pick_place_demo.py
• ✅ 自动构建并启动 MoveIt + RViz
• ✅ 等待系统就绪后执行完整的抓取流程： 打开 → 下探 → 闭合 → 抬起 → 移动 → 放置 → 打开

🧩 RViz 视图优化

脚本末尾已提示如何在 RViz 左侧 Displays 面板中清理画面：

• 取消勾选：

  • MotionPlanning → Trajectory → Show Trail
  • MotionPlanning → Trajectory → Loop Animation
  • MotionPlanning → Planning Request → Query Start/Goal State

• 如仍有重复机器人，可关闭单独的 RobotModel 显示项。

💡 可选：

source ~/ws_arm/devel/setup.bash rosrun class_demo pick_place_demo.py

🚀 1. NVM（Node.js 版本管理器）一键安装与使用

🧩 安装（任选其一）

# 使用 curl
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

# 或使用 wget
wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

⚙️ 激活环境

重新打开终端，或执行以下命令（根据你的 Shell 类型选择）：

# Bash 用户
source ~/.bashrc

# Zsh 用户
source ~/.zshrc

💡 核心命令

# 验证安装
nvm --version

# 安装最新 LTS 版本
nvm install --lts

# 安装指定版本
nvm install 18.17.0

# 查看所有已安装版本
nvm ls

# 切换版本
nvm use 18.17.0

🔐 2. SSH 免密登录（配置公钥）

关键文件：服务器上的 ~/.ssh/authorized_keys

✅ 方法一：一键配置（推荐）

在本地电脑上执行，自动完成配置：

ssh-copy-id [用户名]@[服务器IP]

🛠 方法二：手动配置

1. 在本地电脑上 查看公钥：

   cat ~/.ssh/id_rsa.pub

2. 在服务器上 创建目录并写入公钥：

   # 确保目录存在
   mkdir -p ~/.ssh
   
   # 将复制的公钥追加进去
   echo "在此处粘贴你的公钥内容" >> ~/.ssh/authorized_keys
   
   # 设置权限（必须执行）
   chmod 700 ~/.ssh
   chmod 600 ~/.ssh/authorized_keys

获取本地ip

curl ipinfo.io/ip

#curl不可用

wget -qO- ifconfig.me

还原docker命令

docker inspect my_container | jq -r '
  .[0] as $c |
  "docker run -d " +
  ([$c.HostConfig.PortBindings | to_entries[] | "--publish \(.key | split("/")[0]):\(.value[0].HostPort)"] | join(" ")) + " " +
  ([$c.Mounts[] | "--volume \(.Source):\(.Destination)"] | join(" ")) + " " +
  "--name " + $c.Name[1:] + " " +
  $c.Config.Image + " " +
  ($c.Config.Cmd | join(" "))
'

docker启动ipv6

编辑/etc/docker/daemon.json文件，写入下面的内容：

{
  "ipv6": true,
  "fixed-cidr-v6": "fc00:0000:0000:1::/64",
  "experimental": true,
  "ip6tables": true
}

重启docker

systemctl restart docker

vps加速

wget -O tcpx.sh "https://github.com/ylx2016/Linux-NetSpeed/raw/master/tcpx.sh" && chmod +x tcpx.sh && ./tcpx.sh
bash <(curl -fsSL https://tcp.hy2.sh/)

很多时候，给容器设置 HTTP_PROXY/ALL_PROXY 并不可靠：有的程序不读环境变量，有的仅支持 HTTP 代理不支持 SOCKS5，还有的会把一部分流量绕过代理。更稳的做法是系统级透明代理——把容器里的所有 TCP 流量统一“劫持”并转发到指定的 SOCKS5，由此实现一个容器一个出口 IP。

思路与架构

我们做一个单独的“网关容器”，在这个容器里运行：

• redsocks：把透明转发的 TCP 连接封装成 SOCKS5 请求；
• iptables (NAT/OUTPUT)：在该网络命名空间内重定向所有 TCP 出站流量到 redsocks 监听口。

随后，让业务容器通过 --network container:<网关容器名> 复用网关容器的网络栈。这样业务容器无感知地全量走代理。

业务容器 → (共享网络栈) → iptables(OUTPUT) → redsocks:12345 → SOCKS5 → 目标网站

优点：

• 应用容器无需更改镜像或配置；
• 真正“全局”代理（TCP 层），不依赖应用是否支持代理环境变量；
• 多个网关容器 = 多个出口 IP；业务容器按需绑定对应网关。

环境准备

• 宿主机：Debian/Ubuntu（其他 Linux 发行版亦可）
• 已安装 Docker，能拉取镜像、启动容器
• 具备一个或多个可用 SOCKS5 代理（可匿名或带用户名/密码）

实操步骤（逐步 + 每步目的）

以网关容器名 proxy1、示例 SOCKS5 60.188.121.252:20002 为例。

1. 创建“网关容器”

docker run -d --name proxy1 --cap-add=NET_ADMIN --restart unless-stopped debian:bookworm-slim sleep infinity

目的：

• --cap-add=NET_ADMIN 让容器内能设置 iptables；
• 独立网络命名空间，用作“透明代理网关”；
• sleep infinity 占位常驻；重启策略保证容器随宿主开机恢复。

2. 安装工具（redsocks / iptables / curl 等）

docker exec -it proxy1 bash -lc 'apt update && apt install -y redsocks iptables curl procps net-tools ca-certificates'

目的：

• redsocks 做透明转发至 SOCKS5；
• iptables 写 NAT/OUTPUT 规则；
• curl 用于探测代理可用与验证出口 IP；
• procps/net-tools 用于排错（ps/netstat）；
• ca-certificates 避免 HTTPS 验证问题。

3. 先直接用 curl 测 SOCKS5 是否可用（绕过 redsocks）

docker exec -it proxy1 bash -lc 'curl -v --socks5 60.188.121.252:20002 https://ipinfo.io/ip'

目的：

• 在启用透明代理前，确认 SOCKS5 本身能正常出外网；
• 如果这里就超时/失败，后续即使配置再完美也没用。

4. 写入 redsocks.conf

docker exec -i proxy1 bash <<'EOF'
cat > /etc/redsocks.conf <<'EOC'
base {
  log_debug = off;
  log_info  = on;
  log       = "stderr";
  daemon    = on;
  redirector = iptables;
}
redsocks {
  local_ip   = 127.0.0.1;
  local_port = 12345;
  ip   = 60.188.121.252;   # SOCKS5 服务器 IP
  port = 20002;            # SOCKS5 端口
  type = socks5;
  # 若需认证，取消注释：
  # login = "username";
  # password = "password";
}
EOC
EOF

目的与要点：

• 配置 redsocks 监听 127.0.0.1:12345；
• 指向你的 SOCKS5；
• 配置文件必须是纯 ASCII，避免中文/奇怪字符导致解析失败。

5. 启动 redsocks

docker exec -d proxy1 bash -lc 'redsocks -c /etc/redsocks.conf'

目的：

• 让 redsocks 常驻监听；如需诊断可用 -t 前台模式查看日志。

6. 下发 iptables 规则（透明转发）

docker exec -it proxy1 bash -lc '
iptables -t nat -F
iptables -t nat -A OUTPUT -p tcp -d 127.0.0.1 -j RETURN
iptables -t nat -A OUTPUT -p tcp -d 60.188.121.252 -j RETURN
iptables -t nat -A OUTPUT -p tcp -j REDIRECT --to-ports 12345
'

目的与要点：

• 清空旧规则，避免重复叠加；
• 放行本机回环与代理服务器本身（否则会套娃死循环）；
• 其余 TCP 全部重定向到 12345 → 由 redsocks 送往 SOCKS5。

说明：这是在 proxy1 的网络命名空间 内生效，不影响宿主机和其他容器。

7. 验证出口 IP（确认透明代理生效）

docker exec -it proxy1 bash -lc 'curl -s https://ipinfo.io/ip'

期望：输出为 SOCKS5 的公网 IP（例如 114.86.2.30）。 意义：证明透明代理链路 容器 → iptables → redsocks → SOCKS5 正常。

8. 让业务容器复用网关网络（“一容器一出口 IP”）

docker run -d \
  --restart unless-stopped \
  --network container:proxy1 \
  packetshare/packetshare \
  -accept-tos \
  -email=<你的邮箱> \
  -password=<你的密码>

目的：

• 业务容器与 proxy1 共用网络栈，因此自动走上一步配置好的透明代理；
• 适用于任何镜像，不需要在应用层配置代理变量。

切换/替换 SOCKS5 的正确姿势

当旧代理失效，需要切换新代理时：

# 1) 恢复直连（避免“断网时无法 apt/curl”）
docker exec -it proxy1 bash -lc 'iptables -t nat -F'

# 2) 重启或重启 redsocks（如需）
docker restart proxy1   # 简洁做法，顺带清理僵尸进程

# 3) 先直接用 curl 测新 SOCKS5 是否通
docker exec -it proxy1 bash -lc 'curl -v --socks5 <NEW_IP:PORT> https://ipinfo.io/ip'

# 4) 改 /etc/redsocks.conf，启动 redsocks
# 5) 重新下发三条 iptables 规则（放行 127.0.0.1 / 新代理 IP / 其余全转发）

常见问题 & 排错建议

• redsocks 报“unexpected char / unclosed section” → 配置文件含中文或 ${VAR} 这类 shell 变量占位符（redsocks 不会展开），改为硬编码纯 ASCII。

• curl -s https://ipinfo.io/ip 无输出 → 常见于 SOCKS5 仅“能连上端口”但不能完整转发 HTTPS（公开代理很多这种）。先用 curl -v --socks5 <IP:PORT> https://ipinfo.io/ip 直连测试；查代理质量。

• [redsocks] <defunct> 僵尸进程 → 代理或配置异常导致短启即死，重启容器最干净：docker restart proxy1。 重新按「先清规则 → 测代理 → 写配置 → 启动 → 下规则」顺序来。

• DNS/UDP 泄漏 → 透明代理本方案主要拦截 TCP。对 DNS 建议：应用侧启用 DoH/DoT 或使用 redudp/dns2socks 进一步处理。 （如果你的业务全是 HTTPS/TLS，通常已足够。）

• IPv6 → 如需代理 IPv6，另配一组 ip6tables -t nat ... 规则（思路同 IPv4）。

一键脚本（先测 SOCKS5，再自动建“网关容器”）

把下面内容保存为 create_proxy_container.sh，赋予执行权限 chmod +x create_proxy_container.sh。 用法：./create_proxy_container.sh <容器名> <SOCKS_IP> <SOCKS_PORT>

#!/bin/bash
# ===============================
# 一键创建 SOCKS5 透明代理“网关容器”
# 用法示例：
#   ./create_proxy_container.sh proxy1 60.188.121.252 20002
# ===============================

set -e

NAME=$1
SOCKS_IP=$2
SOCKS_PORT=$3
TARGET_URL="https://ipinfo.io/ip"

if [[ -z "$NAME" || -z "$SOCKS_IP" || -z "$SOCKS_PORT" ]]; then
  echo "用法: $0 <容器名> <SOCKS_IP> <SOCKS_PORT>"
  exit 1
fi

# 1) 准备容器
if docker ps -a --format '{{.Names}}' | grep -q "^${NAME}$"; then
  echo "容器 ${NAME} 已存在，直接使用。"
else
  echo "创建容器 ${NAME}..."
  docker run -d --name "$NAME" --cap-add=NET_ADMIN --restart unless-stopped debian:bookworm-slim sleep infinity
fi

# 2) 安装依赖
echo "安装 redsocks 和依赖..."
docker exec "$NAME" bash -lc 'apt update -qq && apt install -y -qq redsocks iptables curl procps net-tools ca-certificates >/dev/null'

# 3) 预检 SOCKS5 可用性（绕过透明代理）
echo "测试 SOCKS5 代理是否可用 (${SOCKS_IP}:${SOCKS_PORT}) ..."
if docker exec "$NAME" bash -lc "curl -s --max-time 6 --socks5 ${SOCKS_IP}:${SOCKS_PORT} ${TARGET_URL}" >/dev/null 2>&1; then
  echo "✅ SOCKS5 测试通过"
else
  echo "❌ SOCKS5 无法连接或超时，请检查地址/端口/可用性"
  exit 1
fi

# 4) 写入 redsocks 配置
echo "写入 /etc/redsocks.conf..."
docker exec -i "$NAME" bash <<EOF
cat > /etc/redsocks.conf <<EOC
base {
  log_debug = off;
  log_info  = on;
  log       = "stderr";
  daemon    = on;
  redirector = iptables;
}
redsocks {
  local_ip   = 127.0.0.1;
  local_port = 12345;
  ip   = ${SOCKS_IP};
  port = ${SOCKS_PORT};
  type = socks5;
}
EOC
EOF

# 5) 启动 redsocks
echo "启动 redsocks..."
docker exec -d "$NAME" bash -lc 'redsocks -c /etc/redsocks.conf'

# 6) 配置 iptables（先清空再下发）
echo "配置 iptables 规则..."
docker exec "$NAME" bash -lc "
iptables -t nat -F
iptables -t nat -A OUTPUT -p tcp -d 127.0.0.1 -j RETURN
iptables -t nat -A OUTPUT -p tcp -d ${SOCKS_IP} -j RETURN
iptables -t nat -A OUTPUT -p tcp -j REDIRECT --to-ports 12345
"

# 7) 验证出口 IP（透明代理是否生效）
echo "验证透明代理出口 IP..."
IP_OUT=$(docker exec "$NAME" bash -lc "curl -s --max-time 8 ${TARGET_URL}" || true)
if [[ -n "$IP_OUT" ]]; then
  echo "✅ 代理工作正常，出口 IP: $IP_OUT"
  echo "👉 可通过 '--network container:${NAME}' 让其他容器共用此代理。"
  exit 0
else
  echo "⚠️ 未能获取出口 IP，请手动检查 redsocks/iptables/代理可用性。"
  exit 2
fi

使用例子：

./create_proxy_container.sh proxy1 60.188.121.252 20002

# 让业务容器共享代理网络
docker run -d --network container:proxy1 packetshare/packetshare \
  -accept-tos -email=<你的邮箱> -password=<你的密码>

一、前置检查

1. 确认 IPv6 连通性（宿主机）

ip -6 addr show
ping -6 -c 3 google.com

2. 安装 Docker（若未安装）

curl -fsSL https://get.docker.com | sh

全局启动ipv6 编辑 /etc/docker/daemon.json ，加上以下内容。（如果没有这个文件直接创建。）

{
  "ipv6": true,
  "fixed-cidr-v6": "fd00::/80",
  "experimental": true,
  "ip6tables": true
}

重启docker engine

sudo systemctl restart docker

测试

sudo docker run --rm -it busybox ping -6 -c4 ipv6-test.com

3. 安装并启用 nftables

apt-get update && apt-get install -y nftables || yum install -y nftables
systemctl enable --now nftables
nft --version

4. （建议）开启 IPv6 转发

便于容器经宿主机转发出网（NAT66）。

sysctl -w net.ipv6.conf.all.forwarding=1
echo 'net.ipv6.conf.all.forwarding=1' > /etc/sysctl.d/99-ipv6-forward.conf
sysctl --system

二、准备一个不冲突的 Docker IPv6 网络

你之前的 docker0 里有 fd00:dead:beef::/48，所以新网络不要使用该段下的前缀，以免报 “Pool overlaps”。

1. 选择一个 ULA 子网（示例用 fd00:1:1:1::/64）

docker network create \
  --ipv6 \
  --subnet fd00:1:1:1::/64 \
  psnet

• 成功后可查看：

docker network inspect psnet | grep -A3 IPv6

如果报 overlaps，就换个段，比如：fd00:2:2:2::/64、fd10:abcd:1:1::/64 等，总之与现有网络不重叠即可。

三、为容器分配内部 IPv6（落在上面的子网）

在用户自定义网络里才可以用 --ip6 指定静态 IPv6。 下面示例给容器分配 fd00:1:1:1::101（在 fd00:1:1:1::/64 内）。

docker run -d \
  --restart unless-stopped \
  --network psnet \
  --ip6 fd00:1:1:1::101 \
  --name pxxxxe \
  pxxxe/pxxxe \

检查分配结果：

docker inspect -f '{{.NetworkSettings.Networks.psnet.GlobalIPv6Address}}' packetshare

应显示：fd00:1:1:1::101

四、把容器的内部 IPv6 映射到指定公网 IPv6（NAT66）

你的宿主机上有多个公网 IPv6（例如 2a0e:97c0:3f0:1::1d63），我们要让这个容器的出口永远使用它。 使用 nftables NAT（IPv6） 在 postrouting 做 SNAT。

1. 创建表与链（首次）

nft add table ip6 docker_snat
nft add chain ip6 docker_snat postrouting '{ type nat hook postrouting priority srcnat; }'

2. 添加 SNAT 规则 将容器内部 IPv6 fd00:1:1:1::101 映射为公网 2a0e:97c0:3f0:1::1d63：

nft add rule ip6 docker_snat postrouting ip6 saddr fd00:1:1:1::101 snat to 2a0e:97c0:3f0:1::1d63

3. 查看当前规则

nft list table ip6 docker_snat
# 或带 handle 编号：
nft -a list table ip6 docker_snat

五、验证

1. 容器内测试出网地址

docker exec -it packetshare curl -6 ifconfig.co
# 也可：docker exec -it packetshare curl -6 ip.sb

返回应为：2a0e:97c0:3f0:1::1d63（你在 SNAT 指定的那个）。

2. 连通性测试

docker exec -it packetshare ping -6 -c 3 google.com

六、多个容器、多公网地址

• 再起一个容器（内部 IPv6 换一个）：

docker run -d \
  --restart unless-stopped \
  --network psnet \
  --ip6 fd00:1:1:1::102 \
  --name packetshare2 \
  packetshare/packetshare \
    -accept-tos \
    -email=aabbccddwo@outlook.com \
    -password=Abcdefg6

• 给它 SNAT 到另一个公网 IPv6（如 2a0e:97c0:3f0:1::1d62）：

nft add rule ip6 docker_snat postrouting ip6 saddr fd00:1:1:1::102 snat to 2a0e:97c0:3f0:1::1d62

• 验证：

docker exec -it packetshare2 curl -6 ifconfig.co

应看到 2a0e:97c0:3f0:1::1d62。

七、常用维护操作

1) 查看/删除 SNAT 规则

• 查看含 handle 编号：

nft -a list table ip6 docker_snat

• 按 handle 删除：

nft delete rule ip6 docker_snat postrouting handle <编号>

• 清空整链（谨慎）：

nft flush chain ip6 docker_snat postrouting

• 删整张表（谨慎）：

nft delete table ip6 docker_snat

2) 持久化 nft 规则（防重启丢失）

• 保存当前规则：

nft list ruleset > /etc/nftables.conf

• 确保开机加载：

systemctl enable --now nftables

若你的发行版使用 nftables-persistent，也可以：

apt-get install -y nftables-persistent
netfilter-persistent save

3) 容器与网络排查

• 查看网络详情：

docker network inspect psnet

• 查看容器 IPv6：

docker inspect -f '{{.NetworkSettings.Networks.psnet.GlobalIPv6Address}}' <容器名>

八、常见报错与快速修复

• invalid pool request: Pool overlaps... 说明你新建的子网与现有 Docker 网络（比如 docker0）重叠。换一个 ULA 前缀，如 fd00:1:1:1::/64、fd10:abcd:1:1::/64。

• user specified IP address is supported on user defined networks only 你在默认 bridge 网络里指定了 --ip6。请先用 docker network create 创建自定义网络，再在该网络里指定 --ip6。

• invalid subinterface vlan name eth0, example formatting is eth0.10（macvlan/ipvlan） 说明云环境不允许直接用二层（或需要显式子接口），多数 VPS 建议放弃 macvlan/ipvlan，改用本指南的 NAT66 方案。

• 容器能解析但出不了网 先检查宿主 ping -6 是否通，再确认：

1. sysctl net.ipv6.conf.all.forwarding=1
2. nft 的 SNAT 规则是否匹配了容器 ip6 saddr
3. 云厂商安全组/防火墙是否放行所需端口/协议（ICMPv6、TCP/UDP）

九、（可选）一体化管理脚本

下面的脚本提供：add / del / list

• add <name> <public_ipv6> <email> <password>：创建网络（如无）→ 启容器 → 添加 SNAT
• del <name>：删除容器 + 清理对应 SNAT
• list：查看容器与 SNAT

保存为 ps_manager.sh：

#!/bin/bash
set -e

NETNAME="psnet"
SUBNET="fd00:1:1:1::/64"    # 如与现有冲突可改
TABLE="docker_snat"
CHAIN="postrouting"

init_env() {
  if ! docker network inspect $NETNAME >/dev/null 2>&1; then
    echo "[+] 创建 Docker 网络 $NETNAME ($SUBNET)"
    docker network create --ipv6 --subnet $SUBNET $NETNAME
  fi
  if ! nft list table ip6 $TABLE >/dev/null 2>&1; then
    echo "[+] 创建 nftables 表 $TABLE"
    nft add table ip6 $TABLE
    nft add chain ip6 $TABLE $CHAIN '{ type nat hook postrouting priority srcnat; }'
  fi
}

gen_internal_ip() { # 根据容器名生成稳定的末尾
  local NAME=$1
  local SUFFIX=$(echo -n $NAME | md5sum | cut -c1-4)
  echo "fd00:1:1:1::${SUFFIX}"
}

add_container() {
  local NAME=$1 PUBIP=$2 EMAIL=$3 PASSWORD=$4
  if [ -z "$NAME" ] || [ -z "$PUBIP" ] || [ -z "$EMAIL" ] || [ -z "$PASSWORD" ]; then
    echo "用法: $0 add <name> <public_ipv6> <email> <password>"; exit 1
  fi
  init_env
  local INIP=$(gen_internal_ip "$NAME")
  echo "[+] 启动容器 $NAME (内部=$INIP, 公网=$PUBIP)"
  docker rm -f "$NAME" >/dev/null 2>&1 || true
  docker run -d --restart unless-stopped --network "$NETNAME" --ip6 "$INIP" --name "$NAME" \
    packetshare/packetshare -accept-tos -email="$EMAIL" -password="$PASSWORD"
  echo "[+] 添加 SNAT: $INIP -> $PUBIP"
  nft add rule ip6 $TABLE $CHAIN ip6 saddr $INIP snat to $PUBIP
  sleep 2
  docker exec -it "$NAME" curl -6 ifconfig.co || true
}

del_container() {
  local NAME=$1
  if [ -z "$NAME" ]; then echo "用法: $0 del <name>"; exit 1; fi
  local INIP=$(gen_internal_ip "$NAME")
  echo "[+] 删除容器 $NAME"
  docker rm -f "$NAME" >/dev/null 2>&1 || true
  echo "[+] 清理 SNAT（匹配 $INIP）"
  local HANDLES=$(nft -a list table ip6 $TABLE 2>/dev/null | awk "/$INIP/ {print \$NF}")
  for h in $HANDLES; do
    nft delete rule ip6 $TABLE $CHAIN handle $h && echo "  删除规则 handle $h"
  done
}

list_all() {
  echo "=== 容器 ==="
  docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Networks}}"
  echo; echo "=== SNAT 规则 ==="
  nft list table ip6 $TABLE || echo "暂无 SNAT 规则"
}

case "$1" in
  add) shift; add_container "$@";;
  del) shift; del_container "$@";;
  list) list_all;;
  *) echo "用法: $0 {add|del|list}"; exit 1;;
esac

使用：

chmod +x ps_manager.sh
./ps_manager.sh add ps1 2a0e:97c0:3f0:1::1d63 aabbccddwo@outlook.com Abcdefg6
./ps_manager.sh list
./ps_manager.sh del ps1

完成！ 照这份指南操作，你就能让每个容器用固定的内部 IPv6并映射到指定的公网 IPv6对外通信。

引言

今天是我深入 LangChain 生态系统的一天。虽然感觉学习过程中遇到了不少挑战和错误，但回过头来整理，发现收获远比想象的多。从基础的提示词重写到复杂的 Agent 构建，每一个概念都在为构建更智能的 AI 应用打下基础。

今天的主要学习内容

1. 深入理解 MessagesPlaceholder 的工作机制

学习重点：MessagesPlaceholder 不是普通的字符串占位符，而是专门用于在聊天提示模板中插入消息对象列表的特殊组件。

核心发现：

• 它保持了对话历史的结构完整性，让 LLM 能够理解真正的对话轮次
• 与普通的 {chat_history} 相比，它不会将消息列表转换为混乱的字符串
• 在多轮对话和 RAG 应用中至关重要

# 关键代码示例
rewrite_prompt = ChatPromptTemplate.from_messages([
    ("system", "根据对话历史改写用户问题..."),
    MessagesPlaceholder(variable_name="chat_history"), 
    ("human", "{question}")
])

2. 掌握 RunnablePassthrough.assign 的数据流增强技术

学习重点：这是 LCEL 中的高级组件，用于在数据流中添加新信息而不丢失原有数据。

实际应用场景：

• 在 RAG 中同时保留用户问题和检索到的上下文
• 避免数据在链式传递中的丢失问题
• 实现数据流的优雅扩充

# 实践案例
rag_chain = RunnablePassthrough.assign(
    context=(lambda x: x['question']) | retriever | format_docs
) | rag_prompt | model | StrOutputParser()

3. 完成 RAG 提示词重写功能的实现

项目成果：成功构建了一个能够根据对话历史重写用户问题的 RAG 系统，提高了检索的准确性和对话的连贯性。

技术亮点：

• 使用对话历史优化检索查询
• 实现了多轮对话的上下文理解
• 提升了 RAG 系统的用户体验

4. 深入理解 LangChain Agent 的核心概念

重要认知转变：Agent 与 Chain 的根本区别在于决策的动态性：

• Chain：预定义的固定执行路径（像菜谱）
• Agent：基于 LLM 推理的动态决策系统（像有思考能力的大厨）

Agent 的三大核心组件：

1. Tools：Agent 可使用的能力集合
2. LLM：作为推理引擎的大脑
3. Agent Executor：驱动 ReAct 循环的执行器

5. 探索多种搜索工具集成方案

实践经验：

• 发现了 DuckDuckGo 搜索的局限性
• 学习了 Tavily 搜索的优势："We will be using Tavily (a search engine) as a tool"
• 成功实现了 Wikipedia 专用搜索 Agent
• 体验了不同工具在实际应用中的表现差异

6. 理解 LangChain Hub 的价值和作用

重要发现：LangChain Hub 是一个"提示词模板仓库"，让开发者可以：

• 使用经过验证的高质量 Prompt 模板
• 避免从零开始设计复杂的 Agent Prompt
• 利用社区的集体智慧和最佳实践

# 使用 Hub 中的经典 ReAct 模板
prompt = hub.pull("hwchase17/react")

7. 学会处理 LangChain 版本变更和 API 迁移

实战经验：

• 遇到了 ImportError 和 LangChainDeprecationWarning 等版本兼容问题
• 学会了如何阅读错误信息和迁移指南
• 理解了 LangChain v0.2 的模块化架构变化
• 掌握了从旧版本 API 迁移到新版本的方法

今天遇到的挑战与解决方案

挑战 1：工具导入路径变更

问题：from langchain.agents import load_tools 已被弃用 解决：迁移到 from langchain_community.agent_toolkits import load_tools

挑战 2：Tavily 集成问题

问题：TavilySearchResults 的导入和使用方式发生变化 解决：使用传统但稳定的 Wikipedia 搜索工具作为替代方案

挑战 3：版本兼容性

问题：不同版本间的 API 差异 解决：学会查阅最新文档，使用稳定的替代方案

核心技术收获

1. ReAct 框架的深度理解

掌握了 ReAct（Reasoning and Acting）的核心思想："The agent is using a reasoning engine to determine which actions to take to get a result"

ReAct 循环：

• Thought（思考）：LLM 分析问题并规划下一步
• Action（行动）：决定调用哪个工具
• Action Input（行动输入）：确定工具的参数
• Observation（观察）：接收工具执行结果
• 循环直至得到最终答案

2. 工具集成的最佳实践

学会了如何：

• 选择合适的搜索工具（Wikipedia vs Tavily vs DuckDuckGo）
• 自定义工具的创建和集成
• 处理工具调用中的错误和异常

3. 项目结构和错误处理

• 实现了健壮的错误处理机制
• 学会了使用 verbose=True 调试 Agent 思考过程
• 掌握了模块化的代码组织方式

实际应用价值

今天的学习不仅仅是理论知识，更是实践技能的积累：

1. RAG 系统优化：通过提示词重写提升了检索质量
2. 智能对话能力：实现了具备工具调用能力的对话系统
3. 知识检索增强：构建了专门的 Wikipedia 知识助手
4. 错误处理经验：在解决版本兼容问题中积累了宝贵经验

未来学习方向

基于今天的学习基础，接下来的重点将是：

1. LangGraph 深入学习：官方推荐："For more information on Agents, please check out the LangGraph documentation"
2. 多 Agent 系统构建：探索 "multi-agent workflows" 的应用场景
3. 生产环境部署：学习 Agent 的性能优化和监控
4. 自定义工具开发：为特定业务场景开发专用工具

总结与反思

虽然今天的学习过程中遇到了不少技术问题，但这些"坑"反而让我对 LangChain 的理解更加深入。"理论只能带你走这么远。你可以整天阅读文档，但真正的魔法——以及真正的头疼——在你真正构建一个时才会出现"

每一个错误都是学习的机会，每一次调试都是对框架更深层理解的积累。从提示词重写到 Agent 构建，从工具集成到版本迁移，这一天的学习为我在 AI 应用开发道路上奠定了坚实的基础。

最重要的收获：不是完美地运行了某段代码，而是培养了面对技术挑战时的解决能力，以及对 LangChain 生态系统的整体把握。这种能力，比任何单一的技术点都更加宝贵。

学习永无止境，每一天的积累都在为更大的突破做准备。今天的"挫折"，都是明天成功的垫脚石。

前言

我最近正在学习 LangChain，这是一个强大的大型语言模型（LLM）应用开发框架。为了检验自己的学习水平并明确下一步的方向，我与 AI 进行了一次深入的问答式学习。这篇笔记记录了从评估我的初始认知，到深入理解核心组件，再到解决具体疑惑的全过程。希望我的学习路径和思考，也能为同样走在这条路上的你提供一些参考。

第一站：知识水平评估——我最初的理解

在开始时，我对 LangChain 的理解停留在比较宏观的层面：

• 核心价值：我认为 LangChain 的价值在于为 LLM 赋能，拓展其能力边界，解决大模型应用开发缓慢的问题。
• 基础组件：
  • Models: 对接 OpenAI 等大模型 API。
  • Prompts: 提示词模板。
  • Output Parsers: 用于结构化输出。
• RAG 流程：我对检索增强生成（RAG）的流程非常熟悉，即 加载 -> 分割 -> 向量化 -> 存储 -> 检索。
• Chains vs. Agents：我能区分 Chains（确定性流程）和 Agents（动态决策）的区别。

AI 指出了我的知识盲区：Memory（记忆）、LCEL（LangChain 表达式语言）以及 Debugging（调试）。这便是我此行学习的重点。

第二站：核心组件深潜——那些我新学到的关键概念

这是本次学习的核心，我重点掌握了以下几个以前模糊不清或完全不知道的概念。

1. LCEL (LangChain Expression Language) - 现代化的构建方式

这是我此行最大的收获之一。LCEL 是 LangChain 官方推荐的、用于组合组件的声明式方法。

• 核心语法：使用管道符 | 将组件像流水线一样连接起来。
• 代码示例：一个简单的“提示+模型+解析器”链。

    from langchain_openai import ChatOpenAI
    from langchain_core.prompts import ChatPromptTemplate
    from langchain_core.output_parsers import StrOutputParser
  
    prompt = ChatPromptTemplate.from_template("请告诉我关于 {topic} 的一个笑话。")
    model = ChatOpenAI()
    output_parser = StrOutputParser()
  
    # 这就是 LCEL 的魔力！
    chain = prompt | model | output_parser
  
    chain.invoke({"topic": "程序员"})

• 优势：相比旧版的 Chain 类，LCEL 更简洁、透明，并且原生支持流式（streaming）、并行（parallelism）和异步（async）调用，是现代 LangChain 开发的基石。

2. 调试 LCEL 链 - set_debug(True)

学会了如何构建，下一步就是如何调试。对于 LCEL，verbose=True 的旧方法不再适用。取而代之的是一个强大的全局函数：

• 启用方法：

    from langchain.globals import set_debug
  
    set_debug(True)

• 日志解读：开启后，控制台会打印出非常详细的、带颜色的日志。通过 > 符号可以清晰地看到链的嵌套结构，[llm/start]、[parser/end] 等标签则标明了每个组件的类型、输入、输出和耗时。这对于理解复杂链条的数据流向至关重要。

3. RunnableSequence vs. RunnableParallel - 链的两种基本形态

在解读日志时，我遇到了这两个概念，它们的区别是理解 LCEL 工作流的关键。

• RunnableSequence (顺序执行)：就是由 | 创建的流水线。上一步的输出是下一步的输入，按顺序执行。
• RunnableParallel (并行执行)：通常表现为一个字典。它会将同一个输入分发给字典中的多个处理分支，各分支独立运行，最后将结果汇总成一个字典。它常用于为下一步的 Prompt 准备多个不同的输入变量（如 context 和 question）。

4. RunnableLambda - 流水线上的“DIY”工具

当标准组件不满足需求时，RunnableLambda 就派上了用场。

• 作用：它可以将任何一个 Python 函数包装成一个可以在 LCEL 链中使用的组件。
• 应用场景：执行自定义的数据转换、调用外部 API、筛选数据，或者仅仅是在链中某个位置打印中间数据进行调试。在我们的对话式 RAG 示例中，它被用来从 Memory 对象中提取历史聊天记录。

5. Retriever (检索器) - 知识库的“图书管理员”

我之前只知道从向量数据库检索，但对 Retriever 的角色有些模糊。

• 核心职责：一个专门负责根据查询，从数据源中检索出最相关信息的接口。
• 与 Vector Store 的区别：
  • Vector Store (向量数据库) 是存储和搜索的底层工具，是被动的数据库。
  • Retriever (检索器) 是封装了检索逻辑的上层应用接口。它知道“如何去取信息”。

• 代码示例：

  # 从一个向量数据库创建一个检索器
  retriever = vectorstore.as_retriever()

  这个 retriever 对象现在就是一个可以被放入 LCEL 链中的组件了。

第三站：旅途终点与新起点

通过这次深入的探讨学习，我不仅补齐了知识短板，更重要的是建立了一套完整的 LangChain 知识体系。

我的核心收获：

1. 现代化开发范式：我已完全理解 LCEL，并能用它来构建和调试链。这是从“能用”到“会用”的关键一步。
2. 构建对话应用的核心：掌握了 Memory 组件，我终于可以构建能联系上下文的聊天机器人了。
3. 洞察内部机制：通过学习解读 debug 日志，我对数据如何在链条中流动有了直观的认识，这让我有能力解决更复杂的问题。

接下来，我将基于今天的学习，继续我的 LangChain 探索之旅：

• 动手实践：构建一个更复杂的、带有查询重写功能的对话式 RAG Agent。
• 探索高级功能：研究 LangServe 以便将我的应用部署为 API。