Déchaîner le proxy Svr par Golang

Uchain est un serveur proxy léger et facile à utiliser conçu pour contourner efficacement les restrictions réseau, la censure et la surveillance.

Principales fonctionnalités

• Prise en charge du protocole : gère de manière transparente les paquets TCP et UDP (VLESS) sur WebSocket avec la prise en charge de TLS/Cloudflare.
• Créez votre propre entreprise VPN : fournit une plate-forme robuste pour démarrer vos propres services VPN.
• Compatibilité : Entièrement compatible avec les clients proxy populaires comme v2rayN ou toute application prenant en charge le protocole VLESS WebSocket.

Comment ça marche

Unchain fonctionne comme un serveur proxy/VPN, compatible avec les clients proxy populaires tels que v2rayN ou toute application prenant en charge le protocole VLESS WebSocket. Il accepte le trafic de diverses applications clientes, notamment :

• v2rayN
• v2rayA
• Choc
• v2rayNG
• Application iOS Shadowrocket

Déchaînez les processus du trafic entrant et transférez-le en toute sécurité vers le serveur de destination, garantissant à la fois la sécurité et l'efficacité de la communication.

Déchaîner l'architecture

Unchain est un simple VLESS sur un serveur proxy Websocket.
La logique commerciale de base ne comporte que 200 lignes de code. app_ws_vless.go.

Le serveur Unchain utilise une architecture simple qui est VLESS sur WebSocket (WS) TLS.

             V2rayN,V2rayA,Clash or ShadowRocket                          
                 +------------------+
                 |   VLESS Client   |
                 |   +-----------+  |
                 |   | TLS Layer  | |
                 |   +-----------+  |
                 |   | WebSocket  | |
                 |   +-----------+  |
                 +--------|---------+
                          |
                          | Encrypted VLESS Traffic (wss://)
                          |
           +--------------------------------------+
           |         Internet (TLS Secured)       |
           +--------------------------------------+
                          |
                          |
        +-----------------------------------+
        |        Reverse Proxy Server       |
        | (e.g., Nginx or Cloudflare)       |
        |                                   |
        |   +---------------------------+   |
        |   | HTTPS/TLS Termination     |   |
        |   +---------------------------+   |
        |   | WebSocket Proxy (wss://)  |   |
        |   +---------------------------+   |
        |     Forward to VLESS Server       |
        +------------------|----------------+
                           |
           +--------------------------------+
           |     Unchain       Server       |
           |                                |
           |   +------------------------+   |
           |   | WebSocket Handler      |   |
           |   +------------------------+   |
           |   | VLESS Core Processing  |   |
           |   +------------------------+   |
           |                                |
           |   Forward Traffic to Target    |
           +------------------|-------------+
                              |
                     +-----------------+
                     | Target Server   |
                     | or Destination  |
                     +-----------------+

Usage

1. Construire à partir de la source

Pour créer à partir des sources, suivez ces étapes :

1. Clonez le référentiel et accédez au répertoire cmd/node :

   cd cmd/node

1. Copiez l'exemple de fichier de configuration et personnalisez-le :

   cp config.example.standalone.toml config.toml

1. Exécutez l'application :

   go run main.go

2. Déploiement sur votre propre serveur Ubuntu à l'aide des actions GitHub

Vous pouvez déployer l'application sur un serveur Ubuntu à l'aide de GitHub Actions. Voici comment :

1. Forkez le référentiel sur votre compte GitHub.
2. Créez un environnement nommé production dans les paramètres de votre référentiel.

3. Ajoutez les détails de connexion SSH suivants aux secrets d'environnement :

   • EC2_HOST : l'hôte SSH avec le port (par exemple, 1.1.1.1:20).
   • EC2_USER : l'utilisateur SSH (par exemple, Ubuntu).
   • EC2_KEY : Votre clé privée SSH.

4. Ajoutez le contenu de votre fichier de configuration TOML aux variables d'environnement :

   • CONFIG_TOML : copiez le contenu de votre fichier config.toml, remplacez tout " par " et collez-le ici.

en savoir plus dans .github/workflows/deploy.sh

3. Exécution de l'application

Une fois l'application exécutée, vous verrez une URL de schéma de connexion VLESS dans la sortie standard. Copiez et collez cette URL dans votre client V2rayN.

Félicitations ! Votre serveur proxy auto-hébergé est maintenant opérationnel.

4. (Facultatif) créez votre propre application d'administration pour l'authentification et le trafic de données

créer une API RESTful pour le push du serveur proxy en chaîne :
Enregistrez un exemple de code API

Créez votre propre entreprise VPN

En utilisant la page cloudflare, UnchainAdmin, démarrez votre propre entreprise VPN.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!