Here's a simple example of a reverse proxy in Rust:

use hyper::{Body, Request, Response, Server};
use hyper::service::{make_service_fn, service_fn};
use hyper::client::HttpConnector;
use hyper_tls::HttpsConnector;
use futures::future::{ok, Future};
use std::env;

fn main() {
    let target = env::var("TARGET").unwrap_or_else(|_| "http://localhost:8000".to_string());
    let addr = env::var("ADDR").unwrap_or_else(|_| "127.0.0.1:8080".to_string());

    let make_svc = make_service_fn(move |_conn| {
        let target = target.clone();
        service_fn(move |req: Request<Body>| {
            let uri = req.uri().clone();
            let https = HttpsConnector::new();
            let client = hyper::Client::builder().build::<_, Body>(https);
            client
                .request(req)
                .map(move |res| {
                    let mut new_res = res;
                    new_res.headers_mut().remove("content-length");
                    new_res
                })
                .map_err(|e| {
                    eprintln!("error: {}", e);
                    e
                })
                .and_then(|res| {
                    ok(Response::builder()
                        .status(res.status())
                        .headers(res.headers().clone())
                        .body(res.into_body())
                        .unwrap())
                })
        })
    });

    let server = Server::bind(&addr)
        .serve(make_svc)
        .map_err(|e| eprintln!("server error: {}", e));

    hyper::rt::run(server);
}

Explanation:

    The main function starts by reading the target URL and the address for the reverse proxy from environment variables. If the variables are not set, it defaults to "http://localhost:8000" for the target and "127.0.0.1:8080" for the address.

    The make_service_fn creates a service function that will handle incoming requests. The service function takes a Request object, clones its URI, and sends a request to the target URL using the hyper library.

    The response from the target is then returned as a new response with the content-length header removed.

    Finally, the reverse proxy is started using the Server::bind and serve methods, which bind the reverse proxy to the specified address and start serving incoming requests.

This example shows how to implement a simple reverse proxy in Rust using the hyper library. The reverse proxy takes incoming requests, forwards them to the target URL, and returns the response from the target.
นี่คือตัวอย่างง่ายๆ ของพร็อกซีย้อนกลับใน Rust: ใช้ไฮเปอร์::{Body, Request, Response, Server}; ใช้ไฮเปอร์ :: บริการ :: {make_service_fn, service_fn}; ใช้ไฮเปอร์::ไคลเอนต์::HttpConnector; ใช้hyper_tls::HttpsConnector; ใช้ฟิวเจอร์ส :: อนาคต :: {ตกลงอนาคต}; ใช้มาตรฐาน::env; fn main() { ให้ target = env::var("TARGET").unwrap_or_else(|_| "http://localhost:8000".to_string()); ให้ addr = env::var("ADDR").unwrap_or_else(|_| "127.0.0.1:8080".to_string()); ให้ make_svc = make_service_fn(move |_conn| { la target = target.clone(); service_fn(move |req: Request<Body>| { la uri = req.uri().clone(); ให้ https = HttpsConnector:: ใหม่ (); ให้ไคลเอนต์ = ไฮเปอร์::ไคลเอนต์::ผู้สร้าง().build::<_, Body>(https); ลูกค้า .request(req) .map(ย้าย |res| { ให้ mut new_res = res; new_res .headers_mut().remove("content-length"); new_res }) .map_err(|e| { eprintln!("error: {}", e); e }) .and_then(|res| { ok(การตอบกลับ ::builder() .status(res.status()) .headers(res.headers().clone()) .body(res.into_body()) .unwrap()) }) }) }); ให้เซิร์ฟเวอร์ = Server::bind(&addr) .serve(make_svc) .map_err(|e| eprintln!("ข้อผิดพลาดของเซิร์ฟเวอร์: {}", e)); ไฮเปอร์::rt::run(เซิร์ฟเวอร์); } คำอธิบาย: ฟังก์ชันหลักเริ่มต้นด้วยการอ่าน URL เป้าหมายและที่อยู่สำหรับพร็อกซีย้อนกลับจากตัวแปรสภาพแวดล้อม หากไม่ได้ตั้งค่าตัวแปร จะมีค่าเริ่มต้นเป็น "http://localhost:8000" สำหรับเป้าหมายและ "127.0.0.1:8080" สำหรับที่อยู่ make_service_fn สร้างฟังก์ชันบริการที่จะจัดการกับคำขอที่เข้ามา ฟังก์ชั่นบริการรับวัตถุคำขอ โคลน URI และส่งคำขอไปยัง URL เป้าหมายโดยใช้ไฮเปอร์ไลบรารี จากนั้นการตอบสนองจากเป้าหมายจะถูกส่งกลับเป็นการตอบกลับใหม่โดยลบส่วนหัวที่มีความยาวเนื้อหาออก สุดท้าย Reverse Proxy จะเริ่มทำงานโดยใช้เมธอด Server::bind and service ซึ่งจะผูก Reverse Proxy กับที่อยู่ที่ระบุและเริ่มให้บริการคำขอที่เข้ามา ตัวอย่างนี้แสดงวิธีการใช้พร็อกซีย้อนกลับอย่างง่ายใน Rust โดยใช้ไฮเปอร์ไลบรารี Reverse Proxy รับคำขอที่เข้ามา ส่งต่อไปยัง URL เป้าหมาย และส่งคืนการตอบกลับจากเป้าหมาย
spam fails_task lang_mismatch pii not_appropriate hate_speech sexual_content quality toxicity humor helpfulness creativity violence