HTTP 톺아보기 with Rust

#네트워크/웹

HTTP는 TCP 프로토콜 위에 작성된 텍스트 기반의 프로토콜이다.

소위 "웹"이라고 하는 것들은 전부 HTTP로 작성된 서버를 말한다.
그래서 모든 웹사이트는 HTTP로 작성된다.

버전 히스토리

HTTP 1.1

1999년에 처음 나왔다.
진정한 HTTP의 역사는 1.1부터 시작한다고 보면 된다.
대부분의 웹 환경은 다 HTTP 1.1을 지원하고, 사용하는데다, 대부분의 라이브러리나 프레임워크에서도 이게 기본값이다.

그냥 브라우저 켜서 어디 들어가면 다 HTTP 1.1로 동작한다.

HTTP 2

2015년에 나왔다.
HTTP 1.1은 단순하고 잘 동작했지만 단점이 꽤 많았는데, 성능적인 측면에서 개선을 많이 가한 게 버전 2다.
gRPC 프로토콜이 HTTP 2 위에서 동작한다.

1. Multiplexed Stream

예를 들어, 1.1은 리소스를 차례대로만 로드했기 때문에 한 리소스가 느려지면 다른 리소스들도 가져오지 못하는 비효율적인 동작이 있었는데, HTTP2에서는 동시 획득이 가능한 multiplexed stream 기능이 추가됐다.
위 그림과 같다.

2. 헤더 압축
동일한 Header 전송 반복으로 인한 성능 낭비를 막기 위해 헤더를 압축해서 전송하는 HPACK 기법이 추가됐다.

3. 서버 푸시
HTTP 2는 클라이언트가 서버에게 일방적으로 보내는게 아니라, 서버가 클라이언트에게 보내는 것도 가능하다.
요청할 것이라고 예상되는 정적 리소스 데이터를 요청하기 전에 미리 보내주는 거라서, 캐시의 개념에 가깝다.

HTTP 3 (quic)

2022년에 발표됐다.
대격변이 일어난 버전이다.

여기서는 TCP를 버리고 UDP 소켓을 기반으로 재구현을 했다! TCP에 불필요한 레거시한 구성요소들이 너무 많아서 그걸 덜어내는 것이 주 목적이었다.

아직 에코시스템이 충분히 갖춰져있지는 않다는 것이 큰 단점이다.

전반적으로 성능이 더 빠른데다, HTTP2 대비 패킷 손실에 대한 처리가 더 좋아졌다.

IP 변경
IP가 바뀌어도 연결이 유지되는 기능이 추가됐다.

TLS
TLS(SSL)가 기본으로 들어간다. 게다가 핸드셰이크와 동시에 처리되기 때문에 훨씬 빨라진다.

Zero RTT(Round Trip Time)
HTTP에는 왕복 시간(RTT)이라는 개념이 있었다.
핸드셰이크를 위해서 불필요한 네트워크 지연시간이 많이 발생했었는데, HTTP3에서는 이미 연결된 서버에서는 핸드셰이크를 하지 않는다. 물론 최초 연결시에는 한다.

장단점

요청<->응답의 구조가 명확하게 분리되어있고, 캐시, 인코딩 등 여러가지 필요한 기능들이 전부 다 완비된데다, 텍스트 기반의 프로토콜이라 사용이나 분석이 매우 쉽다는 장점이 있다.
게다가 모든 프로그래밍 언어에서 완벽한 구현체들을 제공하고 있다는 점에서 MSA에서의 RPC에도 가장 강력한 장점을 갖고 있다. 이건 gRPC도 따라오지 못하는 부분이다.

대신 통짜 텍스트로만 데이터를 처리하다보니, 무거운 데이터를 실어나를때는 조금 느릴 수도 있다는 단점이 있다. 그게 걸리면 gRPC를 쓰면 된다.

아주 많은 곳에 사용되고 있고, 앞으로도 더욱 그럴 것이다.

까보기

TCP 소켓을 기반으로 HTTP 1.1를 직접 구현해보면서 그 구조를 이해해보는 시간을 갖도록 하겠다.
사실 골치아프고 복잡한건 이미 TCP 레이어에서 다 처리해주기 때문에, 생각보다 그리 복잡하거나 어려운건 별로 없다.

만약 다음과 같이 API를 호출한다면

다음과 같은 형태로 TCP 데이터를 주고받는다.
아래는 wireshark의 tcp stream으로 조회한 내용이다.

뻘건색이 요청이고, 퍼런색이 응답 데이터다.
그냥 저걸 주고받고 파싱하는 것만 구현해주면 된다..

Server: 요청 받아보기

먼저 서버 껍데기부터 만들어보겠다.
우선 TCP 요청을 받아서, 그 요청에 딸린 패킷 데이터를 한번 까보겠다.

use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("0.0.0.0:8888").await?;

    loop {
        let (mut socket, _) = listener.accept().await?;

        tokio::spawn(async move {
            let mut read_buffer = [0; 1024];

            loop {
                let n = match socket.read(&mut read_buffer).await {
                    // socket closed
                    Ok(n) if n == 0 => return,
                    Ok(n) => n,
                    Err(e) => {
                        eprintln!("failed to read from socket; err = {:?}", e);
                        return;
                    }
                };

                let text = String::from_utf8(Vec::from(read_buffer)).unwrap();

                println!("Client Says: {:?}", text);

                // 대답하기...
                let write_buffer = [0; 1024];

                if let Err(e) = socket.write_all(&write_buffer[0..n]).await {
                    eprintln!("failed to write to socket; err = {:?}", e);
                    return;
                }
            }
        });
    }
}

실행하고

브라우저로 찔러보면

접속은 되지 않더라도, 브라우저에서 쏘아보낸 요청 데이터는 읽어볼 수 있을 것이다.

그럼 대략 이런식으로 데이터가 날라온다.
저기 들어있는게 다 요청 headers들이다.
텍스트 기반이라 알아보기는 참 쉽다.

서버에서는 저걸 그대로 파싱해서 사용하면 되는 것이다.

이런식으로다가

Server: 응답 보내기

이번에는 응답까지 구성해서 브라우저에서도 정상 동작이 되게끔 만들어보겠다.

방법은 그리 어렵지 않다.
응답 텍스트의 포맷은 아래와 같은 형태인데

응답 상태
응답 헤더1
응답 헤더2
...
응답 헤더N

응답 본문

저대로 딱 구성해서 보내주면 된다.

필수 헤더는 Content-Length 정도다.

저래갖고 다시 실행해보면

이제 될 것이다.

전체 코드

use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("0.0.0.0:8888").await?;

    loop {
        let (mut socket, _) = listener.accept().await?;

        tokio::spawn(async move {
            let mut read_buffer = [0; 1024];

            loop {
                let n = match socket.read(&mut read_buffer).await {
                    // socket closed
                    Ok(n) if n == 0 => return,
                    Ok(n) => n,
                    Err(e) => {
                        eprintln!("failed to read from socket; err = {:?}", e);
                        return;
                    }
                };
                println!("read {} bytes", n);

                let text = String::from_utf8(Vec::from(&read_buffer[0..n])).unwrap();

                println!("Client Says: {:?}", text);

                let mut method = "NONE";
                let mut uri = "";
                let mut host = "";
                for line in text.split("\r\n") {
                    match line {
                        line if line.starts_with("GET") => {
                            method = "GET";
                            uri = line.split(" ").nth(1).unwrap();
                        }
                        line if line.starts_with("POST") => {
                            method = "POST";
                            uri = line.split(" ").nth(1).unwrap();
                        }
                        line if line.starts_with("Host") => {
                            host = line.split(" ").nth(1).unwrap();
                        }
                        _ => {}
                    }
                }
                println!("{method} {host}{uri}");

                // 대답하기...
                let response_headers =
                    vec!["HTTP/1.1 200 OK", "Content-Length: 11", "", "Hello World"];
                let response_messages = response_headers.join("\r\n");

                println!("{response_messages}");

                if let Err(e) = socket.write_all(response_messages.as_bytes()).await {
                    eprintln!("failed to write to socket; err = {:?}", e);
                    return;
                }
            }
        });
    }
}

Client 구현해보기

이번에는 client를 직접 구현해서 원래 있던

이 서버에 요청을 날려보겠다.
내가 만든게 아니라 express로 구현된 서버다.

Client도 TCP 위에서 구현하는거라면 쉽다.
아래의 형태로 요청 데이터를 말아서 tcp로 쏘고, 다시 응답을 받아오면 그만이다.

METHOD 경로 HTTP버전
요청 헤더1
요청 헤더2
...
요청 헤더N

요청 바디

이렇게 말이다.

그럼 잘 돌아갈 것이다.

전체 코드

use tokio::{
    io::{AsyncReadExt, AsyncWriteExt},
    net::TcpStream,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = TcpStream::connect("localhost:8110").await.unwrap();

    let messages = vec![
        "GET / HTTP/1.1",
        "Host: localhost:8110",
        "Connection: keep-alive",
        "",
        "",
    ];

    client
        .write_all(messages.join("\r\n").as_bytes())
        .await
        .unwrap();

    let mut buffer = [0; 1024];
    client.read(&mut buffer).await.unwrap();

    println!("{}", String::from_utf8_lossy(&buffer));

    Ok(())
}

참조
https://developer.mozilla.org/ko/docs/Web/HTTP/Messages
https://doc.rust-lang.org/book/ch20-01-single-threaded.html
https://www.cloudflare.com/ko-kr/learning/performance/http2-vs-http1.1/