{/* Trang này được tạo tự động từ SKILL.md của kỹ năng bởi website/scripts/generate-skill-docs.py. Chỉnh sửa nguồn SKILL.md, không phải trang này. */}

Đường hầm Pinggy

Không cài đặt đường hầm localhost qua SSH qua Pinggy.

Siêu dữ liệu kỹ năng

Nguồn	Tùy chọn — cài đặt với
`Hermes skills install official/devops/pinggy-tunnel
`
Đường dẫn

optional-skills/devops/pinggy-tunnel ` | | Phiên bản |

0.1.0 ` | | Tác giả | Teknium (teknium1), Đặc vụ Hermes | | Giấy phép | MIT | | Nền tảng | Linux, macOS, Windows | | Thẻ |

Pinggy

, `Tunnel

, `Networking

, `SSH

, `Webhook

, Localhost | | Kỹ năng liên quan |

cloudflared-quick-tunnel

, XPROTECTX23XPROTECTX |

Tham khảo: đầy đủ SKILL.md

thông tin

Sau đây là định nghĩa kỹ năng đầy đủ mà Hermes tải khi kỹ năng này được kích hoạt. Đây là những gì tác nhân coi là hướng dẫn khi kỹ năng được kích hoạt.

Kỹ năng đường hầm Pinggy

Đưa dịch vụ cục bộ (máy chủ dev, bộ thu webhook, điểm cuối MCP, bản demo) lên Internet công cộng bằng cách sử dụng đường hầm đảo ngược Pinggy SSH. Không cần cài đặt daemon — máy khách SSH gốc của người dùng kết nối với a.pinggy.io:443 và Pinggy trao lại URL HTTP/HTTPS công khai.

Cấp miễn phí: đường hầm 60 phút, tên miền phụ ngẫu nhiên, không cần đăng ký. Cấp chuyên nghiệp ($3/tháng) là lựa chọn tham gia bằng mã thông báo.

Khi nào nên sử dụng

• Người dùng yêu cầu "hiển thị nội dung này cục bộ", "chia sẻ máy chủ nhà phát triển của tôi", "đặt URL này ở chế độ công khai", "cổng đường hầm N", "lấy URL công khai cho webhook"
• Cần nhận được lệnh gọi lại webhook trong khi thực hiện tác vụ cục bộ (Stripe, GitHub, Discord, AgentMail)
• Chia sẻ bản demo HTTP một lần (máy chủ MCP, điểm cuối OLlama/vLLM, bảng điều khiển) với một bên từ xa
• Máy chủ có SSH nhưng không có tệp nhị phân cloudflared / ngrok và việc cài đặt một tệp nhị phân sẽ là quá mức cần thiết

Nếu máy chủ đã định cấu hình `cloudflared

, hãy ưu tiên kỹ năng `cloudflared-quick-tunnel

• Đường hầm nhanh Cloudflare không hết hạn sau 60 phút.

Điều kiện tiên quyết

SSH trên ĐƯỜNG ( `SSH -V

). Mặc định trên Linux, macOS và Windows 10+. Không có cài đặt khác.

• Dịch vụ cục bộ lắng nghe trên 127.0.0.1:<port trước khi đường hầm bắt đầu. Pinggy sẽ trả về các URL nhưng chúng sẽ có giá trị 502 cho đến khi nguồn gốc địa phương hết.

Tùy chọn:

PINGGY_TOKEN env var cho các tính năng Pro trả phí (tên miền phụ liên tục, tên miền tùy chỉnh, nhiều đường hầm, không giới hạn 60 phút). Cấp miễn phí không cần thông tin xác thực.

Tham khảo nhanh

# Plain HTTP/HTTPS tunnel for port 8000 (free tier)
SSH -p 443 -o StrictHostKeyChecking=no -o ServerAliveInterval=30 \
    -R0:localhost:8000 free@a.pinggy.io

# TCP tunnel (databases, raw SSH, etc.)
SSH -p 443 -o StrictHostKeyChecking=no -R0:localhost:5432 tcp@a.pinggy.io

# TLS tunnel (Pinggy can't decrypt — bring your own certs at origin)
SSH -p 443 -o StrictHostKeyChecking=no -R0:localhost:443 TLS@a.pinggy.io

# Basic auth gate (b:user:pass)
SSH -p 443 -o StrictHostKeyChecking=no -R0:localhost:8000 \
    "b:admin:secret+free@a.pinggy.io"

# Bearer token gate (k:token)
SSH -p 443 -o StrictHostKeyChecking=no -R0:localhost:8000 \
    "k:mysecrettoken+free@a.pinggy.io"

# IP whitelist (w:CIDR)
SSH -p 443 -o StrictHostKeyChecking=no -R0:localhost:8000 \
    "w:203.0.113.0/24+free@a.pinggy.io"

# Enable CORS + force HTTPS redirect
SSH -p 443 -o StrictHostKeyChecking=no -R0:localhost:8000 \
    "co+x:https+free@a.pinggy.io"

# Pro tier (persistent URL, no 60-min cap)
SSH -p 443 -o StrictHostKeyChecking=no -R0:localhost:8000 "$PINGGY_TOKEN+a.pinggy.io"

`

## Quy trình - Bắt đầu một đường hầm và lấy URL

Mô hình NÊN sử dụng công cụ 
`terminal

. Đường hầm phải tồn tại trong suốt thời gian chia sẻ, vì vậy hãy chạy nó dưới dạng quy trình nền và phân tích cú pháp URL công khai từ thiết bị xuất chuẩn.

### 1. Xác nhận nguồn gốc địa phương là lên

``` bash
curl -sI http://127.0.0.1:8000/ | head -1

# expect HTTP/1.x 200 (or any non-connection-refused response)

`
``Nếu chưa có gì lắng nghe, hãy khởi động nó trước (ví dụ: 
`Python3 -m http.server 8000 --bind 127.0.0.1

). Pinggy sẽ vui vẻ trả lại một URL không trỏ đến đâu - người dùng sẽ thấy 502 cho đến khi xuất hiện nguồn gốc.

### 2. Khởi chạy đường hầm dưới dạng tiến trình nền

Sử dụng 
`terminal(background=True)
` và ghi kết quả đầu ra vào tệp nhật ký (Pinggy in các URL trên thiết bị xuất chuẩn, sau đó giữ kết nối mở):

``` bash
LOG=/tmp/pinggy-8000.log
nohup SSH -p 443 \

    -o StrictHostKeyChecking=no \
    -o UserKnownHostsFile=/dev/null \
    -o ServerAliveInterval=30 \
    -o ServerAliveCountMax=3 \
    -R0:localhost:8000 free@a.pinggy.io \
    > "$LOG" 2>&1 &
echo $! > /tmp/pinggy-8000.pid

`
```StrictHostKeyChecking=no

 + 
`UserKnownHostsFile=/dev/null
` bỏ qua lời nhắc khóa máy chủ chạy lần đầu. 
`ServerAliveInterval=30
` giữ cho phiên SSH không bị phá hủy bởi NAT nhàn rỗi.

### 3. Phân tích URL ra khỏi nhật ký

``` bash
sleep 4
grep -oE 'https://[a-z0-9-]+\.[a-z]+\.pinggy\.link' /tmp/pinggy-8000.log | head -1

`
``Sản lượng dự kiến ​​có dạng:

`
You are not authenticated.
Your tunnel will expire in 60 minutes.
http://yqycl-98-162-69-48.a.free.pinggy.link
https://yqycl-98-162-69-48.a.free.pinggy.link

`
``Trao URL 
`https://...pinggy.link
` cho người dùng.

### 4. Xác minh

`bash
curl -sI https://<the-url>/ | head -3

# expect 200/302/whatever the local origin actually returns

`
``Nếu bạn nhận được 
`502 Bad Gateway

, phiên SSH đã hoạt động nhưng nguồn gốc cục bộ không lắng nghe — trước tiên hãy sửa bước 1.

### 5. Xé nhỏ

``` bash
kill "$(cat /tmp/pinggy-8000.pid)"

# or, if the pid file got lost:
pkill -f 'SSH -p 443 .* free@a\.pinggy\.io'

`
``Nếu bạn có session_id từ 
`terminal(background=True)

, hãy ưu tiên 
`process(action='kill', session_id=...)

.

## Kiểm soát truy cập thông qua từ khóa tên người dùng

Pinggy xếp các cờ kiểm soát vào tên người dùng SSH được phân tách bằng 

+

. Luôn trích dẫn toàn bộ đối số 
`user@host
` khi nó chứa 

+

:

| Từ khóa | Hiệu ứng |
|----------|--------|
| 
`b:user:pass
` | Cổng xác thực HTTP cơ bản |
| 
`k:token
` | Cổng tiêu đề mã thông báo mang (
`Authorization: Bearer <token>

) |
| 
`w:CIDR
` | Danh sách trắng IP (IP đơn hoặc CIDR, có thể lặp lại) |
| 
`co
` | Thêm 
`Access-Control-Allow-Origin: *
` (CORS) |
| 
`x:https
` | Buộc HTTPS — tự động chuyển hướng HTTP sang HTTPS |
| 
`a:Name:Value
` | Thêm tiêu đề yêu cầu |
| 
`u:Name:Value
` | Tiêu đề yêu cầu cập nhật |
| 
`r:Name
` | Xóa tiêu đề yêu cầu |
| 
`qr
` | In mã QR của URL ra thiết bị xuất chuẩn (tiện dụng cho việc chia sẻ trên thiết bị di động) |Kết hợp tự do: 

"b:admin:secret+co+x:https+free@a.pinggy.io"

.

## Trình gỡ lỗi web (tùy chọn)

Pinggy có thể phản chiếu lưu lượng truy cập vào 
`localhost:4300
` để kiểm tra. Thêm chuyển tiếp cục bộ vào lệnh SSH:

``` bash
SSH -p 443 -L4300:localhost:4300 -R0:localhost:8000 free@a.pinggy.io

`
``Sau đó mở 
`http://localhost:4300
` trong trình duyệt để xem các cặp yêu cầu/phản hồi trực tiếp.

## cạm bẫy
- **Giới hạn 60 phút ở cấp miễn phí.** Phiên SSH kết thúc sau 60 phút; URL đã chết. Để chia sẻ lâu hơn, hãy sử dụng 
`PINGGY_TOKEN
` (Pro) hoặc tự động khởi động lại bằng vòng lặp shell (lưu ý rằng URL thay đổi mỗi lần khởi động lại đối với cấp miễn phí).

- **URL cấp miễn phí là ngẫu nhiên và thay đổi khi khởi động lại.** Không đánh dấu trang, không dán vào tệp cấu hình. Phân tích lại từ nhật ký mỗi lần.
- **Các đường hầm miễn phí đồng thời được giới hạn ở một đường hầm cho mỗi IP nguồn.** Việc bắt đầu đường hầm thứ hai từ cùng một máy thường sẽ giết chết đường hầm đầu tiên. Cấp chuyên nghiệp nâng cao điều này.
- **

+
` trong tên người dùng phải được trích dẫn.** Bare 
`SSH ... b:admin:secret+free@a.pinggy.io
` hoạt động trong bash nhưng bị hỏng trong các lớp vỏ xử lý 

+
` một cách đặc biệt hoặc khi được lắp ráp theo chương trình. Luôn gói trong dấu ngoặc kép.
- **Không tạo đường hầm cho bất kỳ nội dung nhạy cảm nào nếu không có cờ kiểm soát truy cập.** Bất kỳ ai có URL đều có thể truy cập đường hầm HTTP đơn giản. Sử dụng 
`b:

, 
`k:
` hoặc 
`w:
` cho các dịch vụ phi công cộng.
- **
`process(action='log')
` có thể thiếu đầu ra biểu ngữ SSH.** Pinggy in các URL và sau đó phiên SSH sẽ tương tác. Luôn chuyển hướng đến tệp nhật ký và 
`grep
` tệp trực tiếp - cùng mẫu với 
`cloudflared-quick-tunnel

.
- **Lời nhắc về khóa máy chủ trong lần chạy đầu tiên.** Cấu hình OpenSSH mặc định yêu cầu người dùng chấp nhận khóa máy chủ của Pinggy. Luôn vượt qua 

-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null
` cho các lần chạy không có người giám sát.
- **Các đường hầm TCP và TLS trả về cặp 

<subdomain>.a.pinggy.online:<port>

, không phải URL https.** Phân tích cú pháp bằng một biểu thức chính quy khác (
`tcp://
` và một cổng). Đừng cho rằng mọi đường hầm Pinggy đều là HTTP.
- **Chế độ chuyên nghiệp yêu cầu mã thông báo làm tên người dùng, không phải cờ.** Sử dụng 

"$PINGGY_TOKEN+a.pinggy.io"
` (không có 
`free@

). Với mã thông báo, bạn cũng có thể thêm 

:persistent
` để có tên miền phụ ổn định - xem 
`pinggy.io/docs/

.

## Công thức nấu ăn

Các mẫu tổng hợp kết hợp nguồn gốc địa phương với đường hầm Pinggy. Mỗi công thức đều khép kín - bắt đầu nguồn gốc, bắt đầu đường hầm, phân tích URL, giao lại cho người dùng.

### Công thức 1 — Nhận lệnh gọi lại webhook

Sử dụng tùy chọn này khi một dịch vụ bên ngoài (Stripe, GitHub, Discord, AgentMail, v.v.) cần POST tới một URL có thể truy cập công khai trong một tác vụ cục bộ.

``` bash

# 1. Tiny capturing server: every request gets appended to /tmp/webhook-hits.log
cat >/tmp/webhook-server.py <<'PY'
 import http.server, JSON, datetime, pathlib
LOG = pathlib.Path("/tmp/webhook-hits.log")
class H(http.server.BaseHTTPRequestHandler):
    def _capture(self):
        n = int(self.headers.get("content-length") or 0)
        body = self.rfile.read(n).decode("utf-8", "replace") if n else ""
        rec = \{"t": datetime.datetime.utcnow().isoformat(), "path": self.path,
               "method": self.command, "headers": dict(self.headers), "body": body}
        with LOG.open("a") as f: f.write(JSON.dumps(rec) + "\n")
        self.send_response(200); self.send_header("content-type","application/JSON")
        self.end_headers(); self.wfile.write(b'\{"ok":true}\n')
    def do_GET(self): self._capture()
    def do_POST(self): self._capture()
    def log_message(self,*a,**k): pass
http.server.HTTPServer(("127.0.0.1", 18080), H).serve_forever()
PY
nohup Python3 /tmp/webhook-server.py >/tmp/webhook-server.log 2>&1 &
echo $! >/tmp/webhook-server.pid

# 2. Tunnel — bearer-token-gate so randos can't pollute the capture log
nohup SSH -p 443 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
    -o ServerAliveInterval=30 \
    -R0:localhost:18080 "k:$(openSSL rand -hex 12)+free@a.pinggy.io" \
    >/tmp/webhook-pinggy.log 2>&1 &
echo $! >/tmp/webhook-pinggy.pid
sleep 5
URL=$(grep -oE 'https://[a-z0-9-]+\.[a-z]+\.pinggy\.link' /tmp/webhook-pinggy.log | head -1)
echo "Webhook URL: $URL"

# 3. While the agent works, watch hits land
tail -f /tmp/webhook-hits.log

`
``Hãy giao 

$URL
` cho dịch vụ cần gọi cho bạn. Xé nhỏ: 
`kill $(cat /tmp/webhook-server.pid) $(cat /tmp/webhook-pinggy.pid)

.

### Công thức 2 — Hiển thị máy chủ MCP qua HTTP/SSE

Sử dụng khi máy khách MCP từ xa (Claude Desktop trên máy khác, trình soạn thảo của đồng đội, v.v.) cần truy cập máy chủ MCP đang chạy trên hộp cục bộ. Chỉ hoạt động đối với các máy chủ MCP hỗ trợ truyền tải HTTP — máy chủ chế độ stdio không thể tạo đường hầm.

``` bash

# 1. Start the MCP server in HTTP mode (example: a FastMCP server on port 8765)
nohup Python3 my_MCP_server.py --transport http --port 8765 \
    >/tmp/MCP-server.log 2>&1 &
echo $! >/tmp/MCP-server.pid

# 2. Tunnel with a bearer token — MCP traffic should not be open to the internet
TOKEN=$(openSSL rand -hex 16)
nohup SSH -p 443 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
    -o ServerAliveInterval=30 \
    -R0:localhost:8765 "k:$TOKEN+free@a.pinggy.io" \
    >/tmp/MCP-pinggy.log 2>&1 &
echo $! >/tmp/MCP-pinggy.pid
sleep 5
URL=$(grep -oE 'https://[a-z0-9-]+\.[a-z]+\.pinggy\.link' /tmp/MCP-pinggy.log | head -1)
echo "MCP URL: $URL"
echo "Bearer token: $TOKEN"

`
``Máy khách từ xa kết nối với 

$URL
` bằng 
`Authorization: Bearer $TOKEN

. Cấu hình máy khách MCP gốc của Hermes: 

\{"transport": "http", "url": "<URL>", "headers": \{"Authorization": "Bearer <TOKEN>"}}

.

### Công thức 3 — Hiển thị điểm cuối LLM cục bộ (OLlama / vLLM / Llama.cpp)

Chia sẻ mô hình cục bộ với người gọi từ xa (một đại lý khác, điện thoại, đồng đội). OLlama nghe trên 

:11434

, vLLM và Llama.cpp thường trên 

:8000

.

``` bash

# Pre-req: the model server is already running on 127.0.0.1:11434 (OLlama default)
TOKEN=$(openSSL rand -hex 16)
nohup SSH -p 443 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
    -o ServerAliveInterval=30 \
    -R0:localhost:11434 "k:$TOKEN+co+free@a.pinggy.io" \
    >/tmp/LLM-pinggy.log 2>&1 &
echo $! >/tmp/LLM-pinggy.pid
sleep 5
URL=$(grep -oE 'https://[a-z0-9-]+\.[a-z]+\.pinggy\.link' /tmp/LLM-pinggy.log | head -1)
echo "Endpoint: $URL"
echo "Token:    $TOKEN"

# Verify
curl -s "$URL/API/tags" -H "Authorization: Bearer $TOKEN" | head

`
```co
` kích hoạt CORS để người gọi trình duyệt có thể truy cập điểm cuối. Bỏ 
`co
` cho người gọi chỉ phụ trợ. Đối với điểm cuối vLLM/Llama.cpp tương thích với OpenAI, người gọi sử dụng URL cơ sở 

$URL/v1
` với 
`Authorization: Bearer $TOKEN
` — nhưng lưu ý rằng Pinggy sẽ loại bỏ/thay thế không có gì trong nội dung, do đó, máy chủ mô hình sẽ tự nhìn thấy mã thông báo của Pinggy; máy chủ cục bộ phải được cấu hình để bỏ qua xác thực (nó đã có trên 
`127.0.0.1

) và để Pinggy thực hiện việc kiểm soát.

### Công thức 4 — Chia sẻ máy chủ dev bằng mật khẩu một lần

Mẫu "để đồng đội chọc vào ứng dụng đang chạy của tôi" nhanh nhất. Mật khẩu ngẫu nhiên, in một lần, chết khi bạn Ctrl-C.

``` bash
PASS=$(openSSL rand -base64 12 | tr -d '+/=' | head -c 12)
echo "Dev server password: $PASS"
SSH -p 443 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \

    -o ServerAliveInterval=30 \
    -R0:localhost:3000 "b:dev:$PASS+co+x:https+free@a.pinggy.io"
# URL prints to the terminal. Share URL + password. Ctrl-C to tear down.

`
```b:dev:$PASS
` cổng URL bằng xác thực HTTP Basic. 
`x:https
` buộc TLS. 
`co
` bổ sung CORS cho giao diện SPA.

## Xác minh

``` bash

# End-to-end: spin up a trivial origin, tunnel it, hit it, tear down
Python3 -m http.server 18000 --bind 127.0.0.1 >/tmp/origin.log 2>&1 &
ORIGIN_PID=$!

nohup SSH -p 443 \
    -o StrictHostKeyChecking=no \
    -o UserKnownHostsFile=/dev/null \
    -R0:localhost:18000 free@a.pinggy.io >/tmp/pinggy-verify.log 2>&1 &
SSH_PID=$!

sleep 5
URL=$(grep -oE 'https://[a-z0-9-]+\.[a-z]+\.pinggy\.link' /tmp/pinggy-verify.log | head -1)
echo "URL: $URL"
curl -sI "$URL/" | head -1`kill "$SSH_PID" "$ORIGIN_PID"

`
``Dự kiến: URL 
`pinggy.link
` và 
`HTTP/2 200
` trên đầu uốn.