使用 Async Rust 構建簡單的 P2P 節點

P2P 簡介

P2P：peer-to-peer
P2P 是一種網路技術，可以在不同的計算機之間共享各種計算資源，如 CPU、網路帶寬和存盤，
P2P 是當今用戶在線共享檔案（如音樂、影像和其他數字媒體）的一種非常常用的方法，
- Bittorrent 和 Gnutella 是流行的檔案共享 p2p 應用程式的例子，以及位元幣和以太坊等區塊鏈網路，
- 它們不依賴中央服務器或中介來連接多個客戶端，
- 最重要的是，它們利用用戶的計算機作為客戶端和服務器，從而將計算從中央服務器上卸載下來，
傳統的分布式系統使用 Client-Server 范式來部署
P2P 是另一種分布式系統
- 在 P2P 中，一組節點（或對等點，Peer）彼此直接互動以共同提供公共服務，而無需中央協調器或管理員
- P2P 系統中的每個節點（或 Peer）都可以充當客戶端（從其他節點請求資訊）和服務器（存盤/檢索資料并回應客戶端請求執行必要的計算），
- P2P 網路中的所有節點不必完全相同，一個關鍵特征將 Client-Server 網路與 P2P 網路區分開來：缺乏具有唯一權限的專用服務器，在開放、無許可的 P2P 網路中，任何節點都可以決定提供與 P2P 節點相關的全部或部分服務集，

P2P 的特點

與 Client-Server 網路相比，P2P 網路能夠在其上構建不同類別的應用程式，這些應用程式是無許可、容錯和抗審查的，
- 無許可：因為資料和狀態是跨多個節點復制的，所以沒有服務器可以切斷客戶機對資訊的訪問，
- 容錯性：因為沒有單點故障，例如中央服務器，
- 抗審查：如區塊鏈等網路，
- P2P 計算還可以更好地利用資源，

P2P 的復雜性

構建 P2P 系統要比傳統 Client-Server 的系統復雜
- 傳輸：P2P 網路中的每個 Peer 都可以使用不同的協議，例如HTTP(s)、TCP、UDP等，
- 身份：每個 Peer 都需要知道其想要連接并發送訊息的 Peer 的身份，
- 安全性：每個 Peer 都應該能夠以安全的方式與其他 Peer 通信，而不存在第三方攔截或修改訊息的風險等，
- 路由：每個 Peer 可以通過各種路由（例如資料包在 IP 協議中的分布方式）從其他 Peer 接收訊息，這意味著如果訊息不是針對自身的，則每個 Peer 都應該能夠將訊息路由到其他 Peer，
- 訊息傳遞：P2P 網路應該能夠發送點對點訊息或組訊息（以發布/訂閱模式），

P2P 的要求 - 傳輸

TCP/IP 和 UDP 協議無處不在，在撰寫網路應用程式時非常流行，但還有其他更高級別的協議，如 HTTP（TCP上分層）和 QUIC（UDP上分層），
P2P 網路中的每個 Peer 都應該能夠啟動到另一個節點的連接，并且由于網路中 peer 的多樣性，能夠通過多個協議監聽傳入的連接，

P2P 的要求 - Peer 身份

與 web 開發領域不同，在 web 開發領域中，服務器由唯一的域名標識（例如 www.rust-lang.org，然后使用域名服務將其決議為服務器的IP地址）
P2P 網路中的節點需要唯一身份，以便其他節點可以訪問它們，
P2P 網路中的節點使用公鑰和私鑰對（非對稱公鑰加密）與其他節點建立通信，
- P2P 網路中的節點的身份稱為 PeerId，是節點公鑰的加密散列，

P2P 的要求 - 安全

加密密鑰對和 PeerId 使節點能夠與它的 peers 建立安全、經過身份驗證的通信通道，但這只是安全的一個方面，
節點還需要實作授權框架，該框架為哪個節點可以執行何種操作建立規則，
還有需要解決的網路級安全威脅，如 sybil 攻擊（其中一個節點運營商利用不同身份啟動大量節點，以獲得網路中的優勢地位）或 eclipse 攻擊（其中一組惡意節點共謀以特定節點為目標，使后者無法到達任何合法節點），

P2P 的要求 - Peer 路由

P2P 網路中的節點首先需要找到其他 peer 才能進行通信，這是通過維護 peer 路由表來實作的，該表包含對網路中其他 peer 的參考，
但是，在具有數千個或更多動態變化的節點（即節點加入和離開網路）的 P2P 網路中，任何單個節點都難以為網路中的所有節點維護完整而準確的路由表，Peer 路由使節點能夠將不是給自己準備的訊息路由到目標節點，

P2P 的要求 - 訊息

P2P 網路中的節點可以向特定節點發送訊息，但也可以參與廣播訊息協議，
- 例如，發布/訂閱，其中節點注冊對特定主題的興趣（訂閱），發送該主題訊息的任何節點（發布）都由訂閱該主題的所有節點接收，這種技術通常用于將訊息的內容傳輸到整個網路，

P2P 的要求 - 流多路復用

流多路復用（Stream multiplexing）是通過公共通信鏈路發送多個資訊流的一種方法，
在 P2P 的情況下，它允許多個獨立的“邏輯”流共享一個公共 P2P 傳輸層，
- 當考慮到一個節點與不同 peers 具有多個通信流的可能性，或者兩個遠程節點之間也可能存在多個并發連接的可能性時，這一點變得很重要，
- 流多路復用有助于優化 peer 之間建立連接的開銷，

注意：多路復用在后端服務開發中很常見，其中客戶端可以與服務器建立底層網路連接，然后通過底層網路連接多路復用不同的流（每個流具有唯一的埠號），

Libp2p

libp2p 是一個由協議、規范和庫組成的模塊化系統，它支持 P2P 應用程式的開發，
它目前支持三種語言：JS、Go、Rust
- 未來將支持 Haskell、Java、Python等
它被許多流行的專案使用，例如：IPFS、Filecoin 和 Polkadot 等，

Libp2p 的主要模塊

傳輸（Transport）：負責從一個 peer 到另一個 peer 的資料的實際傳輸和接收
身份（Identity）：libp2p 使用公鑰密鑰（PKI）作為 peer 節點身份的基礎，使用加密演算法為每個節點生成唯一的 peer id，
安全（Security）：節點使用其私鑰對訊息進行簽名，節點之間的傳輸連接可以升級為安全的加密通道，以便遠程 peer 可以相互信任，并且沒有第三方可以攔截它們之間的通信，
Peer 發現（Peer Discovery）：允許 peer 在 libp2p 網路中查找并相互通信，
Peer 路由（Peer Routing）：使用其他 peer 的知識資訊來實作與 peer 節點的通信，
內容發現（Content Discovery）：在不知道哪個 peer 節點擁有該內容的情況下，允許 peer 節點從其他 peer 節點獲取部分內容，
訊息（Messaging）：其中發布/訂閱：允許向對某個主題感興趣的一組 peer 發送訊息，

P2P 節點的身份

P2P Node

PeerId: 12d3k.....

~/rust via ?? base
? cargo new p2p
     Created binary (application) `p2p` package

~/rust via ?? base
? cd p2p

p2p on  master [?] via ?? 1.67.1 via ?? base
? c  # code .

p2p on  master [?] via ?? 1.67.1 via ?? base
?

公鑰和私鑰

加密身份使用公鑰基礎設施（PKI），廣泛用于為用戶、設備和應用程式提供唯一身份，并保護端到端通信的安全，
它的作業原理是創建兩個不同的加密密鑰，也稱為由私鑰和公鑰組成的密鑰對，它們之間具有數學關系，
密鑰對有著廣泛的應用，但在 P2P 網路中
- 節點使用密鑰對彼此進行身份識別和身份驗證，
- 公鑰可以在網路中與其他人共享，但決不能泄漏節點的私鑰，

公鑰和私鑰的例子 - 訪問傳統的服務器

如果您想連接到資料中心的遠程服務器（使用SSH），用戶可以生成密鑰對并在遠程服務器上配置公鑰，從而授予用戶訪問權限，
但遠程服務器如何知道哪個用戶是該公鑰的所有者？
- 為了實作這一點，當連接（通過SSH）到遠程服務器時，用戶必須指定私鑰（與存盤在服務器上的公鑰關聯的），
- 私鑰從不發送到遠程服務器，但SSH客戶端（在本地服務器上運行）使用用戶的私鑰向遠程SSH服務器進行身份驗證，

Cmake

把 cmake 的路徑添加到 PATH

~ via ?? base
? cmake
Usage

  cmake [options] <path-to-source>
  cmake [options] <path-to-existing-build>
  cmake [options] -S <path-to-source> -B <path-to-build>

Specify a source directory to (re-)generate a build system for it in the
current working directory.  Specify an existing build directory to
re-generate its build system.

Run 'cmake --help' for more information.


~ via ?? base
?

use libp2p::{identity, PeerId};

#[tokio::main]
async fn main() {
    let new_key = identity::Keypair::generate_ed25519();
    let new_peer_id = PeerId::from(new_key.public());

    println!("New Peer ID is: {:?}", new_peer_id);
    // New Peer ID is: PeerId("12D3KooWF9nTF7cBU63Ac6ZEnvgzisRqjLwkc8BdM56Axxxxxxxx")
}

多地址（Multiaddresses）

在 libp2p 中，peer 的身份在其整個生命周期內都是穩定且可驗證的，
但 libp2p 區分了 peer 的身份和位置，
- peer 的身份是 peer id，
peer 的位置是可以到達對方的網路地址，
- 例如，可以通過 TCP、websockets、QUIC 或任何其他協議訪問 peer，
- libp2p 將這些網路地址編碼成一個自描述格式，它叫做 multiaddress（multiaddr），
- 因此，在 libp2p中，multiaddress 表示 peer 的位置，

多地址

當 p2p 網路上的節點共享其聯系資訊時，它們會發送一個保護網路地址和 peer id 的多地址（multiaddress），
節點多地址的 peer id 表示如下：
- /p2p/12D3KooWBu3fmjZgSmLkQ2p...
多地址的網路地址表示如下：
- /ip4/192.158.1.23/tcp/1234
節點的完整地址就是 peer id 和網路地址的組合：
- /ip4/192.158.1.23/tcp/1234/p2p/12D3KooWBu3fmjZgSmLkQ2p...

Swarm 和網路行為

Swarm 是 libp2p 中給定 P2P 節點內的網路管理器模塊，
它維護從給定節點到遠程節點的所有活動和掛起連接，并管理已打開的所有子流的狀態，

Swarm 的結構和背景關系環境

Swarm 代表了一個低級介面，并提供了對 libp2p 網路的細粒度控制，Swarm 是使用傳輸、網路行為和節點 peer id 的組合構建的，
傳輸（Transport）會指明如何在網路上發送位元組，而網路行為會指明發送什么位元組，發送給誰，
- 多個網路行為可以與單個運行節點相關聯，
需要注意的是，同一套代碼在 libp2p 網路的所有節點上運行，這與客戶端和服務器具有不同代碼庫的 Client-Server 模型不同，

問題解決：

https://stackoverflow.com/questions/52225498/strange-error-cannot-use-the-operator-in-a-function-that-returns

代碼

use libp2p::futures::StreamExt; // 異步流有關
use libp2p::swarm::{DummyBehaviour, Swarm, SwarmEvent};
use libp2p::{identity, PeerId};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let new_key = identity::Keypair::generate_ed25519();
    let new_peer_id = PeerId::from(new_key.public());
    println!("New Peer ID is: {:?}", new_peer_id);
    let behaviour = DummyBehaviour::default(); // 創建 網路行為
    let transport = libp2p::development_transport(new_key).await?; // 使用密鑰對創建傳輸
    let mut swarm = Swarm::new(transport, behaviour, new_peer_id); // 創建Swarm
    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;

    loop {
        match swarm.select_next_some().await {
            SwarmEvent::NewListenAddr { address, .. } => {
                println!("Listening on local Address {:?}", address)
            }
            _ => {}
        }
    }
}

Cargo.toml

[package]
name = "p2p"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
libp2p = "0.46.1"
tokio ={ version = "1.19.2", features = ["full"]}

運行

p2p on  master [?] is ?? 0.1.0 via ?? 1.67.1 via ?? base 
? cargo run
   Compiling p2p v0.1.0 (/Users/qiaopengjun/rust/p2p)
    Finished dev [unoptimized + debuginfo] target(s) in 3.17s
     Running `target/debug/p2p`
New Peer ID is: PeerId("12D3KooWEzm5roUNjRgY2NfvFQBRhfYjRLsBQaDnDHdTBArhG3Qz")
Listening on local Address "/ip4/127.0.0.1/tcp/51422"
Listening on local Address "/ip4/192.168.0.100/tcp/51422"


p2p on  master [?] is ?? 0.1.0 via ?? 1.67.1 via ?? base 
? cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/p2p`
New Peer ID is: PeerId("12D3KooWEqEEHHZYTv3QeEMjGdyy5HrW2u43oPGDyfj118QRGDcA")
Listening on local Address "/ip4/127.0.0.1/tcp/51426"
Listening on local Address "/ip4/192.168.0.100/tcp/51426"

在 peer 節點之間交換 ping 命令

use libp2p::futures::StreamExt; // 異步流有關
use libp2p::ping::{Ping, PingConfig};
use libp2p::swarm::{Swarm, SwarmEvent};
use libp2p::{identity, Multiaddr, PeerId};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let new_key = identity::Keypair::generate_ed25519();
    let new_peer_id = PeerId::from(new_key.public());
    println!("New Peer ID is: {:?}", new_peer_id);

    let transport = libp2p::development_transport(new_key).await?; // 使用密鑰對創建傳輸
    let behaviour = Ping::new(PingConfig::new().with_keep_alive(true)); // 創建 網路行為
    let mut swarm = Swarm::new(transport, behaviour, new_peer_id); // 創建Swarm
    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;

    // 本地節點向遠程節點發出連接  從命令列輸入的引數取出
    if let Some(remote_peer) = std::env::args().nth(1) {
        let remote_peer_multiaddr: Multiaddr = remote_peer.parse()?;
        swarm.dial(remote_peer_multiaddr)?;
        println!("Dialed remote peer: {:?}", remote_peer); // 列印遠程地址
    }

    loop {
        match swarm.select_next_some().await {
            SwarmEvent::NewListenAddr { address, .. } => {
                println!("Listening on local Address {:?}", address)
            }
            SwarmEvent::Behaviour(event) => println!("Event received from peer is {:?}", event),
            _ => {}
        }
    }
}

運行

p2p on  master [?] is ?? 0.1.0 via ?? 1.67.1 via ?? base took 17m 31.5s 
? cargo run
   Compiling p2p v0.1.0 (/Users/qiaopengjun/rust/p2p)
    Finished dev [unoptimized + debuginfo] target(s) in 2.35s
     Running `target/debug/p2p`
New Peer ID is: PeerId("12D3KooWEnxeFEWM3fvcNw8HV1tWojkmTaNVhrQfhPgL2REnngBS")
Listening on local Address "/ip4/127.0.0.1/tcp/51574"
Listening on local Address "/ip4/192.168.0.100/tcp/51574"
Event received from peer is Event { peer: PeerId("12D3KooWCEnQmgt6o5q9no2EfbpCU1xtyRFgRHjWJTiFdC3PTjB8"), result: Ok(Pong) }
Event received from peer is Event { peer: PeerId("12D3KooWCEnQmgt6o5q9no2EfbpCU1xtyRFgRHjWJTiFdC3PTjB8"), result: Ok(Ping { rtt: 193.542μs }) }


p2p on  master [?] is ?? 0.1.0 via ?? 1.67.1 via ?? base took 17m 3.0s 
? cargo run /ip4/127.0.0.1/tcp/51574               
    Finished dev [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/p2p /ip4/127.0.0.1/tcp/51574`
New Peer ID is: PeerId("12D3KooWCEnQmgt6o5q9no2EfbpCU1xtyRFgRHjWJTiFdC3PTjB8")
Dialed remote peer: "/ip4/127.0.0.1/tcp/51574"
Listening on local Address "/ip4/127.0.0.1/tcp/51582"
Listening on local Address "/ip4/192.168.0.100/tcp/51582"
Event received from peer is Event { peer: PeerId("12D3KooWEnxeFEWM3fvcNw8HV1tWojkmTaNVhrQfhPgL2REnngBS"), result: Ok(Pong) }
Event received from peer is Event { peer: PeerId("12D3KooWEnxeFEWM3fvcNw8HV1tWojkmTaNVhrQfhPgL2REnngBS"), result: Ok(Ping { rtt: 192.584μs }) }
Event received from peer is Event { peer: PeerId("12D3KooWEnxeFEWM3fvcNw8HV1tWojkmTaNVhrQfhPgL2REnngBS"), result: Ok(Ping { rtt: 448.375μs }) }

發現 peer

mDNS 是由 RFC 6762（datatracker.ietf.org/doc/html/rfc6762）定義的協議，它將主機名決議為 IP 地址，
- 在 libp2p 中，它用于發現網路上的其他節點，
在 libp2p 中實作的網路行為 mDNS 將自動發現本地網路上的其他 libp2p 節點，

use libp2p::{
    futures::StreamExt, // 異步流有關
    identity,
    mdns::{Mdns, MdnsConfig, MdnsEvent},
    swarm::{Swarm, SwarmEvent},
    PeerId,
};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let new_key = identity::Keypair::generate_ed25519();
    let new_peer_id = PeerId::from(new_key.public());
    println!("New Peer ID is: {:?}", new_peer_id);

    let transport = libp2p::development_transport(new_key).await?; // 使用密鑰對創建傳輸

    let behaviour = Mdns::new(MdnsConfig::default()).await?; // 創建網路行為

    let mut swarm = Swarm::new(transport, behaviour, new_peer_id); // 創建Swarm
    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;

    loop {
        match swarm.select_next_some().await {
            SwarmEvent::NewListenAddr { address, .. } => {
                println!("Listening on local Address {:?}", address)
            }
            SwarmEvent::Behaviour(MdnsEvent::Discovered(peers)) => {
                for (peer, addr) in peers {
                    println!("discovered {} {}", peer, addr);
                }
            }
            SwarmEvent::Behaviour(MdnsEvent::Expired(expired)) => {
                for (peer, addr) in expired {
                    println!("expired {} {}", peer, addr);
                }
            }

            _ => {}
        }
    }
}

運行

p2p on  master [?] is ?? 0.1.0 via ?? 1.67.1 via ?? base took 7m 50.0s 
? cargo run
   Compiling p2p v0.1.0 (/Users/qiaopengjun/rust/p2p)
    Finished dev [unoptimized + debuginfo] target(s) in 2.46s
     Running `target/debug/p2p`
New Peer ID is: PeerId("12D3KooWNn7jV9VWPf4nH1MtABEjoTL1hp61C5m1SXA91nWyKtfv")
Listening on local Address "/ip4/127.0.0.1/tcp/51717"
Listening on local Address "/ip4/192.168.0.100/tcp/51717"
discovered 12D3KooWNkA9WyKhPBhJ8CNN9P11qgE9r4ZP1VbMyxM3DvUXkRxd /ip4/192.168.0.100/tcp/51718
discovered 12D3KooWNkA9WyKhPBhJ8CNN9P11qgE9r4ZP1VbMyxM3DvUXkRxd /ip4/127.0.0.1/tcp/51718
discovered 12D3KooWG9pdAXdJXQKF3KAMLfJVCbXcoxWzkQWFym3sCynUxsrF /ip4/192.168.0.100/tcp/51721
discovered 12D3KooWG9pdAXdJXQKF3KAMLfJVCbXcoxWzkQWFym3sCynUxsrF /ip4/127.0.0.1/tcp/51721

p2p on  master [?] is ?? 0.1.0 via ?? 1.67.1 via ?? base took 7m 10.2s 
? cargo run                         
    Finished dev [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/p2p`
New Peer ID is: PeerId("12D3KooWNkA9WyKhPBhJ8CNN9P11qgE9r4ZP1VbMyxM3DvUXkRxd")
Listening on local Address "/ip4/127.0.0.1/tcp/51718"
Listening on local Address "/ip4/192.168.0.100/tcp/51718"
discovered 12D3KooWNn7jV9VWPf4nH1MtABEjoTL1hp61C5m1SXA91nWyKtfv /ip4/192.168.0.100/tcp/51717
discovered 12D3KooWNn7jV9VWPf4nH1MtABEjoTL1hp61C5m1SXA91nWyKtfv /ip4/127.0.0.1/tcp/51717
discovered 12D3KooWG9pdAXdJXQKF3KAMLfJVCbXcoxWzkQWFym3sCynUxsrF /ip4/192.168.0.100/tcp/51721
discovered 12D3KooWG9pdAXdJXQKF3KAMLfJVCbXcoxWzkQWFym3sCynUxsrF /ip4/127.0.0.1/tcp/51721

p2p on  master [?] is ?? 0.1.0 via ?? 1.67.1 via ?? base 
? cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.16s
     Running `target/debug/p2p`
New Peer ID is: PeerId("12D3KooWG9pdAXdJXQKF3KAMLfJVCbXcoxWzkQWFym3sCynUxsrF")
Listening on local Address "/ip4/127.0.0.1/tcp/51721"
Listening on local Address "/ip4/192.168.0.100/tcp/51721"
discovered 12D3KooWNkA9WyKhPBhJ8CNN9P11qgE9r4ZP1VbMyxM3DvUXkRxd /ip4/192.168.0.100/tcp/51718
discovered 12D3KooWNkA9WyKhPBhJ8CNN9P11qgE9r4ZP1VbMyxM3DvUXkRxd /ip4/127.0.0.1/tcp/51718
discovered 12D3KooWNn7jV9VWPf4nH1MtABEjoTL1hp61C5m1SXA91nWyKtfv /ip4/192.168.0.100/tcp/51717
discovered 12D3KooWNn7jV9VWPf4nH1MtABEjoTL1hp61C5m1SXA91nWyKtfv /ip4/127.0.0.1/tcp/51717

本文來自博客園，作者：QIAOPENGJUN，轉載請注明原文鏈接：https://www.cnblogs.com/QiaoPengjun/p/17418735.html

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/553009.html

標籤：其他

上一篇：用go設計開發一個自己的輕量級登錄庫/框架吧(拓展篇)

下一篇：返回列表