Merge a526fee728 into ec231aade6

docs/Advanced_settings/HIGH_LOAD.en.md

@@ -1,141 +0,0 @@
-# High-Load Configuration & Tuning Guide
-When deploying Telemt under high-traffic load (tens or hundreds of thousands of concurrent connections), the standard OS network stack limits can lead to packet drops, high CPU context switching, and connection failures. This guide covers Linux kernel tuning, hardware configuration, and architecture optimizations required to prepare the server for high-load scenarios.
-
----
-## 1. System Limits & File Descriptors
-Every TCP connection requires a file descriptor. At 100k connections, standard Linux limits (often 1024 or 65535) will be exhausted immediately.
-### System-Wide Limits (`sysctl`)
-Increase the global file descriptor limit in `/etc/sysctl.conf`:
-```ini
-fs.file-max = 2097152
-fs.nr_open = 2097152
-```
-### User-Level Limits (`limits.conf`)
-Edit `/etc/security/limits.conf` to allow the telemt (or proxy) user to allocate them:
-```conf
-* soft nofile 1048576
-* hard nofile 1048576
-root soft nofile 1048576
-root hard nofile 1048576
-```
-### Systemd / Docker Overrides
-If using **Systemd**, add to your `telemt.service`:
-```ini
-[Service]
-LimitNOFILE=1048576
-LimitNPROC=65535
-TasksMax=infinity
-```
-If using **Docker**, configure `ulimits` in `docker-compose.yaml`:
-```yaml
-services:
-  telemt:
-    ulimits:
-      nofile:
-        soft: 1048576
-        hard: 1048576
-```
-
----
-## 2. Kernel Network Stack Tuning (`sysctl`)
-Create a dedicated file `/etc/sysctl.d/99-telemt-highload.conf` and apply it via `sysctl -p /etc/sysctl.d/99-telemt-highload.conf`.
-### 2.1 Connection Queues & SYN Flood Protection
-Increase the size of accept queues to absorb sudden connection spikes (bursts) and mitigate SYN floods:
-```ini
-net.core.somaxconn = 65535
-net.core.netdev_max_backlog = 65535
-net.ipv4.tcp_max_syn_backlog = 65535
-net.ipv4.tcp_syncookies = 1
-```
-### 2.2 Port Exhaustion & TIME-WAIT Sockets
-High churn rates lead to ephemeral port exhaustion. Expand the range and rapidly recycle closed sockets:
-```ini
-net.ipv4.ip_local_port_range = 10000 65535
-net.ipv4.tcp_fin_timeout = 15
-net.ipv4.tcp_tw_reuse = 1
-net.ipv4.tcp_max_tw_buckets = 2000000
-```
-### 2.3 TCP Keepalive (Aggressive Dead Connection Culling)
-By default, Linux keeps silent, dropped connections open for over 2 hours. This consumes memory at scale. Configure the system to detect and drop them in < 5 minutes:
-```ini
-net.ipv4.tcp_keepalive_time = 300
-net.ipv4.tcp_keepalive_intvl = 30
-net.ipv4.tcp_keepalive_probes = 5
-```
-### 2.4 TCP Buffers & Congestion Control
-Optimize memory usage per socket and switch to BBR (Bottleneck Bandwidth and Round-trip propagation time) to improve latency on lossy networks:
-```ini
-# Core buffer sizes
-net.core.rmem_default = 262144
-net.core.wmem_default = 262144
-net.core.rmem_max = 16777216
-net.core.wmem_max = 16777216
-# TCP specific buffers (min, default, max)
-net.ipv4.tcp_rmem = 4096 87380 16777216
-net.ipv4.tcp_wmem = 4096 65536 16777216
-# Enable BBR
-net.core.default_qdisc = fq
-net.ipv4.tcp_congestion_control = bbr
-```
-
----
-## 3. Conntrack (Netfilter) Tuning
-If your server uses `iptables`, `ufw`, or `firewalld`, the Linux kernel tracks every connection state in a table (`nf_conntrack`). When this table fills up, Linux drops new packets.
-Check your current limit and usage:
-```bash
-sysctl net.netfilter.nf_conntrack_max
-sysctl net.netfilter.nf_conntrack_count
-```
-If it gets close to the limit, tune it up, and reduce the time established connections linger in the tracker:
-```ini
-# In /etc/sysctl.d/99-telemt-highload.conf
-net.netfilter.nf_conntrack_max = 2097152
-# Reduce timeout from default 5 days to 1 hour
-net.netfilter.nf_conntrack_tcp_timeout_established = 3600
-net.netfilter.nf_conntrack_tcp_timeout_time_wait = 12
-```
-*Note: Depending on your OS, you may need to run `modprobe nf_conntrack` before setting these parameters.*
-
----
-## 4. Multi-Tier Architecture: HAProxy Setup
-For massive traffic loads, buffering Telemt behind a reverse proxy like HAProxy can help absorb connection spikes and handle basic TCP connections before handing them off.
-### HAProxy High-Load `haproxy.cfg`
-```haproxy
-global
-    # Disable detailed logging under load
-    log stdout format raw local0 err
-    # maxconn 250000
-    
-    # Buffer tuning
-    tune.bufsize 16384
-    tune.maxaccept 64
-defaults
-    log     global
-    mode    tcp
-    option  clitcpka
-    option  srvtcpka
-    timeout connect 5s
-    timeout client  1h
-    timeout server  1h
-    # Quick purge for dead peers
-    timeout client-fin 10s
-    timeout server-fin 10s
-frontend proxy_in
-    bind *:443
-    maxconn 250000
-    option tcp-smart-accept
-    default_backend telemt_backend
-backend telemt_backend
-    option tcp-smart-connect
-    # Send-Proxy-V2 to preserve Client IP for Telemt's internal logic
-    server telemt_core 10.10.10.1:443 maxconn 250000 send-proxy-v2 check inter 5s
-```
-**Important**: Telemt must be configured to process the `PROXY` protocol on port `443` for this chain to work and preserve client IPs.
-
----
-## 5. Diagnostics & Monitoring
-When operating under load, these commands are useful for diagnostics:
-* **Checking dropped connections (Queues full)**: `netstat -s | grep "times the listen queue of a socket overflowed"`
-* **Checking Conntrack drops**: `dmesg | grep conntrack`
-* **Checking File Descriptor usage**: `cat /proc/sys/fs/file-nr`
-* **Real-time connection states**: `ss -s` (Avoid using `netstat` on heavy loads).

docs/Advanced_settings/HIGH_LOAD.ru.md

@@ -1,139 +0,0 @@
-# Руководство по High-Load конфигурации и тюнингу
-При развертывании Telemt под высокой нагрузкой (десятки и сотни тысяч одновременных подключений), стандартные ограничения сетевого стека ОС могут приводить к потерям пакетов, переключениям контекста CPU и отказам в соединениях. В данном руководстве описана настройка ядра Linux, системных лимитов и аппаратной конфигурации для работы в подобных сценариях.
-
----
-## 1. Системные лимиты и файловые дескрипторы
-Каждое TCP-сосоединение требует файлового дескриптора. При 100 тысячах соединений стандартные лимиты Linux (зачастую 1024 или 65535) будут исчерпаны немедленно.
-### Общесистемные лимиты (`sysctl`)
-Увеличьте глобальный лимит файловых дескрипторов в `/etc/sysctl.conf`:
-```ini
-fs.file-max = 2097152
-fs.nr_open = 2097152
-```
-### На уровне пользователя (`limits.conf`)
-Отредактируйте `/etc/security/limits.conf`, чтобы разрешить пользователю (от которого запущен telemt) резервировать дескрипторы:
-```conf
-* soft nofile 1048576
-* hard nofile 1048576
-root soft nofile 1048576
-root hard nofile 1048576
-```
-### Переопределения для Systemd / Docker
-Если используется **Systemd**, добавьте в ваш `telemt.service`:
-```ini
-[Service]
-LimitNOFILE=1048576
-LimitNPROC=65535
-TasksMax=infinity
-```
-Если используется **Docker**, задайте `ulimits` в `docker-compose.yaml`:
-```yaml
-services:
-  telemt:
-    ulimits:
-      nofile:
-        soft: 1048576
-        hard: 1048576
-```
-
----
-## 2. Тонкая настройка сетевого стека ядра (`sysctl`)
-Создайте выделенный файл `/etc/sysctl.d/99-telemt-highload.conf` и примените его через `sysctl -p /etc/sysctl.d/99-telemt-highload.conf`.
-### 2.1 Очереди соединений и защита от SYN-флуда
-Увеличьте размеры очередей, чтобы поглощать внезапные всплески соединений и смягчить атаки типа SYN flood:
-```ini
-net.core.somaxconn = 65535
-net.core.netdev_max_backlog = 65535
-net.ipv4.tcp_max_syn_backlog = 65535
-net.ipv4.tcp_syncookies = 1
-```
-### 2.2 Исчерпание портов и TIME-WAIT сокеты
-Высокая текучесть приводит к нехватке временных (ephemeral) портов. Расширьте диапазон портов и позвольте ядру быстро переиспользовать закрытые сокеты:
-```ini
-net.ipv4.ip_local_port_range = 10000 65535
-net.ipv4.tcp_fin_timeout = 15
-net.ipv4.tcp_tw_reuse = 1
-net.ipv4.tcp_max_tw_buckets = 2000000
-```
-### 2.3 TCP Keepalive (Агрессивная очистка мертвых соединений)
-По умолчанию Linux держит "оборванные" TCP-сессии более 2 часов. Задайте параметры для обнаружения и сброса мертвых соединений за менее чем 5 минут:
-```ini
-net.ipv4.tcp_keepalive_time = 300
-net.ipv4.tcp_keepalive_intvl = 30
-net.ipv4.tcp_keepalive_probes = 5
-```
-### 2.4 Буферы TCP и управление перегрузками (Congestion Control)
-Оптимизируйте использование памяти на сокет и переключитесь на алгоритм BBR (Bottleneck Bandwidth and Round-trip propagation time) для улучшения задержки на плохих сетях:
-```ini
-# Размеры буферов ядра (по умолчанию и макс)
-net.core.rmem_default = 262144
-net.core.wmem_default = 262144
-net.core.rmem_max = 16777216
-net.core.wmem_max = 16777216
-# Специфичные TCP буферы (min, default, max)
-net.ipv4.tcp_rmem = 4096 87380 16777216
-net.ipv4.tcp_wmem = 4096 65536 16777216
-# Включение BBR
-net.core.default_qdisc = fq
-net.ipv4.tcp_congestion_control = bbr
-```
-
----
-## 3. Тюнинг Conntrack (Netfilter)
-Если ваш сервер использует `iptables`, `ufw` или `firewalld`, ядро вынуждено отслеживать каждое соединение в таблице состояний (`nf_conntrack`). Когда эта таблица переполняется, Linux отбрасывает новые пакеты без уведомления приложения.
-Проверьте текущие лимиты и использование:
-```bash
-sysctl net.netfilter.nf_conntrack_max
-sysctl net.netfilter.nf_conntrack_count
-```
-Если вы близки к пределу, увеличьте таблицу и заставьте ядро быстрее удалять установленные соединения. Добавьте в `/etc/sysctl.d/99-telemt-highload.conf`:
-```ini
-net.netfilter.nf_conntrack_max = 2097152
-# Снижаем таймаут с дефолтных 5 дней до 1 часа
-net.netfilter.nf_conntrack_tcp_timeout_established = 3600
-net.netfilter.nf_conntrack_tcp_timeout_time_wait = 12
-```
-*Внимание: в зависимости от ОС, вам может потребоваться выполнить `modprobe nf_conntrack` перед установкой этих параметров.*
-
----
-## 4. Архитектура: Развертывание за HAProxy
-Для максимальных нагрузок выставление Telemt напрямую в интернет менее эффективно, чем использование оптимизированного L4-балансировщика. HAProxy эффективен в поглощении TCP атак, обработке рукопожатий и сглаживании всплесков подключений.
-### Оптимизация `haproxy.cfg` для High-Load
-```haproxy
-global
-    # Отключить детальные логи соединений под нагрузкой
-    log stdout format raw local0 err
-    maxconn 250000
-    # Тюнинг буферов и приема сокетов
-    tune.bufsize 16384
-    tune.maxaccept 64
-defaults
-    log     global
-    mode    tcp
-    option  clitcpka
-    option  srvtcpka
-    timeout connect 5s
-    timeout client  1h
-    timeout server  1h
-    # Быстрая очистка мертвых пиров
-    timeout client-fin 10s
-    timeout server-fin 10s
-frontend proxy_in
-    bind *:443
-    maxconn 250000
-    option tcp-smart-accept
-    default_backend telemt_backend
-backend telemt_backend
-    option tcp-smart-connect
-    # Send-Proxy-V2 обязателен для сохранения IP клиента внутри внутренней логики Telemt
-    server telemt_core 10.10.10.1:443 maxconn 250000 send-proxy-v2 check inter 5s
-```
-**Важно**: Telemt должен быть настроен на обработку протокола `PROXY` на порту `443`, чтобы получать оригинальные IP-адреса клиентов.
-
----
-## 5. Диагностика
-Команды для выявления узких мест:
-* **Проверка дропов TCP (переполнение очередей)**: `netstat -s | grep "times the listen queue of a socket overflowed"`
-* **Контроль отбрасывания пакетов Conntrack**: `dmesg | grep conntrack`
-* **Проверка использования файловых дескрипторов**: `cat /proc/sys/fs/file-nr`
-* **Отображение состояния сокетов**: `ss -s` (Избегайте использования `netstat` под высокой нагрузкой).

docs/Setup_examples/XRAY_DOUBLE_HOP.en.md

@@ -2,16 +2,16 @@
 
 ## Concept
 - **Server A** (_e.g., RU_):\
-  Entry point, accepts Telegram proxy user traffic via **Xray** (port `443\tcp`)\
-  and sends it through the tunnel to Server **B**.\
-  Public port for Telegram clients — `443\tcp`
+  Entry point, accepts Telegram proxy user traffic via **HAProxy** (port `443\tcp`)\
+  and sends it through the local **Xray** client (port `10443\tcp`) to Server **B**.\
+  Public port for HAProxy clients — `443\tcp`
 - **Server B** (_e.g., NL_):\
   Exit point, runs the **Xray server** (to terminate the tunnel entry point) and **telemt**.\
   The server must have unrestricted access to Telegram Data Centers.\
   Public port for VLESS/REALITY (incoming) — `443\tcp`\
   Internal telemt port (where decrypted Xray traffic ends up) — `8443\tcp`
 
-The tunnel works over the `VLESS-XTLS-Reality` (or `VLESS/xhttp/reality`) protocol. The original client IP address is preserved thanks to the PROXYv2 protocol, which Xray on Server A dynamically injects via a local loopback before wrapping the traffic into Reality, transparently delivering the real IPs to telemt on Server B.
+The tunnel works over the `VLESS-XTLS-Reality` (or `VLESS/xhttp/reality`) protocol. The original client IP address is preserved thanks to the PROXYv2 protocol, which HAProxy prepends before passing to Xray, and which transparently reaches telemt.
 
 ---
 
@@ -40,11 +40,6 @@ xray x25519
 openssl rand -hex 16
 # Save the output (e.g.: 0123456789abcdef0123456789abcdef) — this is <SHORT_ID>
 ```
-4. **Random Path (for xhttp):**
-```bash
-openssl rand -hex 8
-# Save the output (e.g., abc123def456) to replace <YOUR_RANDOM_PATH> in configs
-```
 
 ---
 
@@ -66,7 +61,6 @@ File content:
   },
   "inbounds": [
     {
-      "tag": "vless-in",
       "port": 443,
       "protocol": "vless",
       "settings": {
@@ -78,7 +72,7 @@ File content:
         "decryption": "none"
       },
       "streamSettings": {
-        "network": "xhttp",
+        "network": "tcp",
         "security": "reality",
         "realitySettings": {
           "dest": "yahoo.com:443",
@@ -89,32 +83,31 @@ File content:
           "shortIds": [
             "<SHORT_ID>"
           ]
-        },
-        "xhttpSettings": {
-          "path": "/<YOUR_RANDOM_PATH>",
-          "mode": "auto"
         }
+      },
+      "sockopt": {
+        "tcpFastOpen": true,
+        "tcpNoDelay": true,
+        "tcpKeepAliveIdle": 60,
+        "tcpKeepAliveInterval": 15
       }
     }
   ],
   "outbounds": [
     {
-      "tag": "tunnel-to-telemt",
       "protocol": "freedom",
+      "tag": "direct",
       "settings": {
         "destination": "127.0.0.1:8443"
       }
     }
   ],
   "routing": {
-    "domainStrategy": "AsIs",
     "rules": [
       {
         "type": "field",
-        "inboundTag": [
-          "vless-in"
-        ],
-        "outboundTag": "tunnel-to-telemt"
+        "inboundTag": ["all-in"],
+        "outboundTag": "direct"
       }
     ]
   }
@@ -136,7 +129,7 @@ sudo systemctl enable xray
 ### Configuration for Server A (_RU_):
 
 Similarly, edit `/usr/local/etc/xray/config.json`.
-Here Xray acts as the public entry point: it listens on `443\tcp`, uses a local loopback (via internal port `10444`) to prepend the `PROXYv2` header, and encapsulates the payload via Reality to Server B, instructing Server B to deliver it to its *local* `127.0.0.1:8443` port (where telemt will listen).
+Here Xray acts as a local client: it listens on `10443\tcp` (for traffic from HAProxy), encapsulates it via Reality to Server B, and instructs Server B to deliver it to its *local* `127.0.0.1:8443` port (where telemt will listen).
 
 ```bash
 nano /usr/local/etc/xray/config.json
@@ -151,19 +144,7 @@ File content:
   },
   "inbounds": [
     {
-      "tag": "public-in",
-      "port": 443,
-      "listen": "0.0.0.0",
-      "protocol": "dokodemo-door",
-      "settings": {
-        "address": "127.0.0.1",
-        "port": 10444,
-        "network": "tcp"
-      }
-    },
-    {
-      "tag": "tunnel-in",
-      "port": 10444,
+      "port": 10443,
       "listen": "127.0.0.1",
       "protocol": "dokodemo-door",
       "settings": {
@@ -175,14 +156,6 @@ File content:
   ],
   "outbounds": [
     {
-      "tag": "local-injector",
-      "protocol": "freedom",
-      "settings": {
-        "proxyProtocol": 2
-      }
-    },
-    {
-      "tag": "vless-out",
       "protocol": "vless",
       "settings": {
         "vnext": [
@@ -199,45 +172,34 @@ File content:
         ]
       },
       "streamSettings": {
-        "network": "xhttp",
+        "network": "tcp",
         "security": "reality",
         "realitySettings": {
           "serverName": "yahoo.com",
           "publicKey": "<SERVER_B_PUBLIC_KEY>",
           "shortId": "<SHORT_ID>",
-          "spiderX": "/",
+          "spiderX": "",
           "fingerprint": "chrome"
         },
-        "xhttpSettings": {
-          "path": "/<YOUR_RANDOM_PATH>"
+        "sockopt": {
+          "tcpFastOpen": true,
+          "tcpNoDelay": true,
+          "tcpKeepAliveIdle": 60,
+          "tcpKeepAliveInterval": 15
         }
+      },
+      "mux": {
+        "enabled": true,
+        "concurrency": 256,
+        "xudpConcurrency": 16,
+        "xudpProxyUDP443": "reject"
       }
     }
-  ],
-  "routing": {
-    "domainStrategy": "AsIs",
-    "rules": [
-      {
-        "type": "field",
-        "inboundTag": ["public-in"],
-        "outboundTag": "local-injector"
-      },
-      {
-        "type": "field",
-        "inboundTag": ["tunnel-in"],
-        "outboundTag": "vless-out"
-      }
-    ]
-  }
+  ]
 }
 ```
 *Replace `<PUBLIC_IP_SERVER_B>` with the public IP address of Server B.*
 
-Open the firewall port for clients (if enabled):
-```bash
-sudo ufw allow 443/tcp
-```
-
 Restart and setup Xray to run at boot:
 ```bash
 sudo systemctl restart xray
@@ -246,7 +208,81 @@ sudo systemctl enable xray
 
 ---
 
-## Step 2. Install telemt on Server B (_EU_)
+## Step 2. Setup HAProxy on Server A (_RU_)
+
+HAProxy will run on the public port `443` of Server A, receive incoming connections from Telegram users, attach a `PROXYv2` header (to forward the true user IP) and send the stream to the local Xray client.
+Docker installation is like the [AmneziaWG instructions](./VPS_DOUBLE_HOP.en.md).
+
+> [!WARNING]
+> If you don't run as `root` or have issues with binding to port `443` (`cannot bind socket`), allow unprivileged usage:
+> ```bash
+> echo "net.ipv4.ip_unprivileged_port_start = 0" | sudo tee -a /etc/sysctl.conf && sudo sysctl -p
+> ```
+
+#### Create HAProxy Directory:
+```bash
+mkdir -p /opt/docker-compose/haproxy && cd $_
+```
+
+#### Create `docker-compose.yaml`
+```yaml
+services:
+  haproxy:
+    image: haproxy:latest
+    container_name: haproxy
+    restart: unless-stopped
+    # user: "root"
+    network_mode: "host"
+    volumes:
+      - ./haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "1m"
+        max-file: "1"
+```
+
+#### Create HAProxy Config `haproxy.cfg`
+```haproxy
+global
+    log stdout format raw local0
+    maxconn 10000
+
+defaults
+    log     global
+    mode    tcp
+    option  tcplog
+    option  clitcpka
+    option  srvtcpka
+    timeout connect 5s
+    timeout client  2h
+    timeout server  2h
+    timeout check   5s
+
+frontend tcp_in_443
+    bind *:443
+    maxconn 8000
+    option tcp-smart-accept
+    default_backend telemt_nodes
+
+backend telemt_nodes
+    option tcp-smart-connect
+    server telemt_core 127.0.0.1:10443 check inter 5s rise 2 fall 3 maxconn 250000 send-proxy-v2
+
+```
+>[!WARNING]
+>**The configuration file must end with an empty newline, otherwise HAProxy fails to start!**
+
+#### Start the HAProxy Container
+Allow port `443\tcp` in your firewall and launch Docker compose:
+```bash
+sudo ufw allow 443/tcp
+docker compose up -d
+```
+
+---
+
+## Step 3. Install telemt on Server B (_EU_)
 
 telemt installation is heavily covered in the [Quick Start Guide](../QUICK_START_GUIDE.en.md).
 By contrast to standard setups, telemt must listen strictly _locally_ (since Xray occupies the public `443` interface) and must expect `PROXYv2` packets.
@@ -266,7 +302,7 @@ public_port = 443
 ```
 
 - Address `127.0.0.1` and `port = 8443` instructs the core proxy router to process connections unpacked locally via Xray-server.
-- `proxy_protocol = true` commands telemt to parse the injected PROXY header (from Server A's Xray local loopback) and log genuine end-user IPs.
+- `proxy_protocol = true` commands telemt to parse the injected PROXY header (from Server A's HAProxy) and log genuine end-user IPs.
 - Under `public_host`, place Server A's public IP address or FQDN to ensure working links are generated for Telegram users.
 
 Restart `telemt`. Your server is now robust against DPI scanners, passing traffic optimally.

docs/Setup_examples/XRAY_DOUBLE_HOP.ru.md

@@ -2,16 +2,16 @@
 
 ## Концепция
 - **Сервер A** (_РФ_):\
-  Точка входа, принимает трафик пользователей Telegram-прокси напрямую через **Xray** (порт `443\tcp`)\
-  и отправляет его в туннель на Сервер **B**.\
-  Порт для клиентов Telegram — `443\tcp`
+  Точка входа, принимает трафик пользователей Telegram-прокси через **HAProxy** (порт `443\tcp`)\
+  и отправляет его через локальный клиент **Xray** (порт `10443\tcp`) на Сервер **B**.\
+  Порт для клиентов HAProxy — `443\tcp`
 - **Сервер B** (_условно Нидерланды_):\
   Точка выхода, на нем работает **Xray-сервер** (принимает подключения точки входа) и **telemt**.\
   На сервере должен быть неограниченный доступ до серверов Telegram.\
   Порт для VLESS/REALITY (вход) — `443\tcp`\
   Внутренний порт telemt (куда пробрасывается трафик) — `8443\tcp`
 
-Туннель работает по протоколу VLESS-XTLS-Reality (или VLESS/xhttp/reality). Оригинальный IP-адрес клиента сохраняется благодаря протоколу PROXYv2, который Xray на Сервере А добавляет через локальный loopback перед упаковкой в туннель, благодаря чему прозрачно доходит до telemt.
+Туннель работает по протоколу VLESS-XTLS-Reality (или VLESS/xhttp/reality). Оригинальный IP-адрес клиента сохраняется благодаря протоколу PROXYv2, который HAProxy добавляет перед отправкой в Xray, и который прозрачно доходит до telemt.
 
 ---
 
@@ -40,11 +40,6 @@ xray x25519
 openssl rand -hex 16
 # Сохраните вывод (например: 0123456789abcdef0123456789abcdef) — это <SHORT_ID>
 ```
-4. **Random Path (путь для xhttp):**
-```bash
-openssl rand -hex 8
-# Сохраните вывод (например, abc123def456), чтобы заменить <YOUR_RANDOM_PATH> в конфигах
-```
 
 ---
 
@@ -66,7 +61,6 @@ nano /usr/local/etc/xray/config.json
   },
   "inbounds": [
     {
-      "tag": "vless-in",
       "port": 443,
       "protocol": "vless",
       "settings": {
@@ -78,7 +72,7 @@ nano /usr/local/etc/xray/config.json
         "decryption": "none"
       },
       "streamSettings": {
-        "network": "xhttp",
+        "network": "tcp",
         "security": "reality",
         "realitySettings": {
           "dest": "yahoo.com:443",
@@ -89,32 +83,31 @@ nano /usr/local/etc/xray/config.json
           "shortIds": [
             "<SHORT_ID>"
           ]
-        },
-        "xhttpSettings": {
-          "path": "/<YOUR_RANDOM_PATH>",
-          "mode": "auto"
         }
+      },
+      "sockopt": {
+        "tcpFastOpen": true,
+        "tcpNoDelay": true,
+        "tcpKeepAliveIdle": 60,
+        "tcpKeepAliveInterval": 15
       }
     }
   ],
   "outbounds": [
     {
-      "tag": "tunnel-to-telemt",
       "protocol": "freedom",
+      "tag": "direct",
       "settings": {
         "destination": "127.0.0.1:8443"
       }
     }
   ],
   "routing": {
-    "domainStrategy": "AsIs",
     "rules": [
       {
         "type": "field",
-        "inboundTag": [
-          "vless-in"
-        ],
-        "outboundTag": "tunnel-to-telemt"
+        "inboundTag": ["all-in"],
+        "outboundTag": "direct"
       }
     ]
   }
@@ -136,7 +129,7 @@ sudo systemctl enable xray
 ### Конфигурация Сервера A (_РФ_):
 
 Аналогично, редактируем `/usr/local/etc/xray/config.json`.
-Здесь Xray выступает публичной точкой: он принимает трафик на внешний порт `443\tcp`, пропускает через локальный loopback (порт `10444`) для добавления PROXYv2-заголовка, и упаковывает в Reality до Сервера B, прося тот доставить данные на *свой локальный* порт `127.0.0.1:8443` (именно там будет слушать telemt).
+Здесь Xray выступает клиентом: он локально принимает трафик на порту `10443\tcp` (от HAProxy) и упаковывает его в Reality до Сервера B, прося тот доставить данные на *свой локальный* порт `127.0.0.1:8443` (именно там будет слушать telemt).
 
 ```bash
 nano /usr/local/etc/xray/config.json
@@ -151,19 +144,7 @@ nano /usr/local/etc/xray/config.json
   },
   "inbounds": [
     {
-      "tag": "public-in",
-      "port": 443,
-      "listen": "0.0.0.0",
-      "protocol": "dokodemo-door",
-      "settings": {
-        "address": "127.0.0.1",
-        "port": 10444,
-        "network": "tcp"
-      }
-    },
-    {
-      "tag": "tunnel-in",
-      "port": 10444,
+      "port": 10443,
       "listen": "127.0.0.1",
       "protocol": "dokodemo-door",
       "settings": {
@@ -175,14 +156,6 @@ nano /usr/local/etc/xray/config.json
   ],
   "outbounds": [
     {
-      "tag": "local-injector",
-      "protocol": "freedom",
-      "settings": {
-        "proxyProtocol": 2
-      }
-    },
-    {
-      "tag": "vless-out",
       "protocol": "vless",
       "settings": {
         "vnext": [
@@ -199,45 +172,34 @@ nano /usr/local/etc/xray/config.json
         ]
       },
       "streamSettings": {
-        "network": "xhttp",
+        "network": "tcp",
         "security": "reality",
         "realitySettings": {
           "serverName": "yahoo.com",
           "publicKey": "<SERVER_B_PUBLIC_KEY>",
           "shortId": "<SHORT_ID>",
-          "spiderX": "/",
+          "spiderX": "",
           "fingerprint": "chrome"
         },
-        "xhttpSettings": {
-          "path": "/<YOUR_RANDOM_PATH>"
+        "sockopt": {
+          "tcpFastOpen": true,
+          "tcpNoDelay": true,
+          "tcpKeepAliveIdle": 60,
+          "tcpKeepAliveInterval": 15
         }
+      },
+      "mux": {
+        "enabled": true,
+        "concurrency": 256,
+        "xudpConcurrency": 16,
+        "xudpProxyUDP443": "reject"
       }
     }
-  ],
-  "routing": {
-    "domainStrategy": "AsIs",
-    "rules": [
-      {
-        "type": "field",
-        "inboundTag": ["public-in"],
-        "outboundTag": "local-injector"
-      },
-      {
-        "type": "field",
-        "inboundTag": ["tunnel-in"],
-        "outboundTag": "vless-out"
-      }
-    ]
-  }
+  ]
 }
 ```
 *Замените `<PUBLIC_IP_SERVER_B>` на внешний IP-адрес Сервера B.*
 
-Открываем порт на фаерволе для клиентов:
-```bash
-sudo ufw allow 443/tcp
-```
-
 Перезапускаем Xray:
 ```bash
 sudo systemctl restart xray
@@ -246,7 +208,80 @@ sudo systemctl enable xray
 
 ---
 
-## Шаг 2. Установка и настройка telemt на Сервере B (_Нидерланды_)
+## Шаг 2. Настройка HAProxy на Сервере A (_РФ_)
+
+HAProxy будет висеть на публичном порту `443` Сервера A, принимать подключения от Telegram-клиентов, добавлять заголовок `PROXYv2` (чтобы пробросить реальный IP пользователя) и отправлять в локальный клиент Xray.
+Установка Docker аналогична [инструкции AmneziaWG варианта](./VPS_DOUBLE_HOP.ru.md).
+
+> [!WARNING]
+> Если запускаете не под `root` или возникают проблемы с правами на `443` порт:
+> ```bash
+> echo "net.ipv4.ip_unprivileged_port_start = 0" | sudo tee -a /etc/sysctl.conf && sudo sysctl -p
+> ```
+
+#### Создаем папку для HAProxy:
+```bash
+mkdir -p /opt/docker-compose/haproxy && cd $_
+```
+
+#### Создаем файл `docker-compose.yaml`
+```yaml
+services:
+  haproxy:
+    image: haproxy:latest
+    container_name: haproxy
+    restart: unless-stopped
+    # user: "root"
+    network_mode: "host"
+    volumes:
+      - ./haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "1m"
+        max-file: "1"
+```
+
+#### Создаем файл конфигурации `haproxy.cfg`
+```haproxy
+global
+    log stdout format raw local0
+    maxconn 10000
+
+defaults
+    log     global
+    mode    tcp
+    option  tcplog
+    option  clitcpka
+    option  srvtcpka
+    timeout connect 5s
+    timeout client  2h
+    timeout server  2h
+    timeout check   5s
+
+frontend tcp_in_443
+    bind *:443
+    maxconn 8000
+    option tcp-smart-accept
+    default_backend telemt_nodes
+
+backend telemt_nodes
+    option tcp-smart-connect
+    server telemt_core 127.0.0.1:10443 check inter 5s rise 2 fall 3 maxconn 250000 send-proxy-v2
+
+```
+>[!WARNING]
+>**Файл должен заканчиваться пустой строкой, иначе HAProxy не запустится!**
+
+#### Разрешаем порт `443\tcp` в фаерволе и запускаем контейнер
+```bash
+sudo ufw allow 443/tcp
+docker compose up -d
+```
+
+---
+
+## Шаг 3. Установка и настройка telemt на Сервере B (_Нидерланды_)
 
 Установка telemt описана [в основной инструкции](../QUICK_START_GUIDE.ru.md).
 Отличие в том, что telemt должен слушать *внутренний* порт (так как 443 занят Xray-сервером), а также ожидать `PROXY` протокол из Xray туннеля.
@@ -265,7 +300,7 @@ public_port = 443
 ```
 
 - `port = 8443` и `listen_addr_ipv4 = "127.0.0.1"` означают, что telemt принимает подключения только изнутри (приходящие от локального Xray-процесса).
-- `proxy_protocol = true` заставляет telemt парсить PROXYv2-заголовок (который добавил Xray на Сервере A через loopback), восстанавливая IP-адрес конечного пользователя (РФ).
+- `proxy_protocol = true` заставляет telemt парсить PROXYv2-заголовок (который добавил HAProxy на Сервере A и протащил Xray), восстанавливая IP-адрес конечного пользователя (РФ).
 - В `public_host` укажите публичный IP-адрес или домен Сервера A, чтобы ссылки на подключение генерировались корректно.
 
 Перезапустите `telemt`, и клиенты смогут подключаться по выданным ссылкам.