이미지 로딩 중...
AI Generated
2025. 11. 13. · 5 Views
Rust 입문 가이드 1 Rust 설치와 개발 환경 구축하기
Rust 프로그래밍을 시작하는 첫 번째 단계로, Rust 설치부터 개발 환경 구축까지 초보자도 쉽게 따라할 수 있도록 안내합니다. rustup을 통한 설치 방법과 VSCode 설정, 첫 프로젝트 생성까지 다룹니다.
목차
- Rustup 도구체인 매니저 설치 - Rust 개발의 시작점
- Cargo 패키지 매니저 소개 - Rust의 강력한 동반자
- VSCode와 rust-analyzer 설정 - 최고의 개발 경험
- Hello World 프로젝트 생성 - 첫 Rust 프로그램
- Cargo.toml 파일 이해하기 - 프로젝트의 설계도
- rustc 컴파일러 기초 - 코드를 실행 파일로
- 표준 라이브러리 문서 활용 - 내장 도구 탐색
- 크로스 플랫폼 타겟 추가 - 다양한 환경 지원
1. Rustup 도구체인 매니저 설치 - Rust 개발의 시작점
시작하며
여러분이 새로운 프로그래밍 언어를 배우려고 할 때, 가장 먼저 막히는 부분이 무엇인가요? 바로 설치와 환경 설정입니다.
"어떤 버전을 설치해야 하지?", "이 도구는 왜 필요한 거지?", "설정을 잘못해서 나중에 문제가 생기면 어떡하지?" 같은 고민들이 시작도 전에 의욕을 꺾어버립니다. Rust는 이런 문제를 매우 영리하게 해결했습니다.
바로 rustup이라는 공식 도구체인 매니저를 제공하는 것이죠. 이 도구 하나만 설치하면 Rust 컴파일러, 패키지 관리자, 표준 라이브러리, 심지어 여러 버전 관리까지 모두 자동으로 처리됩니다.
이 강력한 도구를 통해 여러분은 복잡한 설정 과정 없이 단 몇 분 만에 Rust 개발을 시작할 수 있습니다. 마치 npm이나 pip처럼 간단하지만, 훨씬 더 강력한 기능을 제공합니다.
개요
간단히 말해서, rustup은 Rust 프로그래밍 환경을 관리하는 공식 도구체인 매니저입니다. 다른 언어를 배울 때를 떠올려보세요.
Python은 버전 관리 때문에 pyenv를 추가로 설치하고, Node.js는 nvm을 따로 설정해야 했죠. 하지만 Rust는 처음부터 이런 고민을 해결하기 위해 rustup을 공식 도구로 제공합니다.
이는 Rust 커뮤니티가 개발자 경험(Developer Experience)을 얼마나 중요하게 생각하는지 보여주는 좋은 예입니다. 기존에는 언어마다 컴파일러, 패키지 관리자, 버전 관리자를 각각 설치하고 설정해야 했다면, 이제는 rustup 하나로 모든 것을 통합 관리할 수 있습니다.
rustup의 핵심 특징은 세 가지입니다. 첫째, 여러 Rust 버전을 동시에 관리할 수 있습니다.
둘째, stable, beta, nightly 채널을 쉽게 전환할 수 있습니다. 셋째, 크로스 컴파일을 위한 타겟 플랫폼을 간단히 추가할 수 있습니다.
이러한 특징들은 실무에서 여러 프로젝트를 동시에 진행하거나, 다양한 플랫폼을 지원해야 할 때 빛을 발합니다.
코드 예제
# Linux/macOS에서 rustup 설치
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# Windows에서는 rustup-init.exe를 다운로드하여 실행
# https://rustup.rs 에서 다운로드
# 설치 후 버전 확인
rustc --version
# rustup 자체 업데이트
rustup self update
# Rust 컴파일러 업데이트
rustup update
설명
이것이 하는 일: rustup은 Rust 개발에 필요한 모든 도구를 설치하고 관리하는 통합 관리자입니다. 마치 앱스토어처럼 필요한 컴포넌트를 자동으로 다운로드하고 설치하며, 업데이트도 간단하게 처리합니다.
첫 번째로, curl 명령어를 통해 rustup 설치 스크립트를 다운로드하고 실행합니다. 이 스크립트는 여러분의 운영체제를 자동으로 감지하고, 적합한 바이너리를 다운로드합니다.
--proto와 --tlsv1.2 옵션은 보안을 강화하여 안전한 HTTPS 연결만 허용합니다. 이렇게 하는 이유는 악의적인 코드가 주입되는 것을 방지하기 위함입니다.
그 다음으로, 설치가 완료되면 rustc 명령어로 컴파일러가 제대로 설치되었는지 확인합니다. 이 명령어는 현재 설치된 Rust 컴파일러의 버전을 출력합니다.
만약 버전 정보가 정상적으로 표시된다면, 설치가 성공적으로 완료된 것입니다. 내부적으로 rustup은 환경변수(PATH)를 자동으로 설정하여, 어느 디렉토리에서든 Rust 명령어를 사용할 수 있게 합니다.
마지막으로, rustup update 명령어를 실행하면 최신 버전의 Rust로 업데이트됩니다. 이 과정은 매우 안전합니다.
rustup은 기존 버전을 백업하고, 문제가 생기면 이전 버전으로 롤백할 수 있는 메커니즘을 갖추고 있습니다. 여러분이 이 설치 과정을 완료하면, Rust 컴파일러(rustc), 패키지 관리자(cargo), 표준 라이브러리, 그리고 공식 문서(rust-docs)가 모두 자동으로 설치됩니다.
특히 cargo는 프로젝트 생성, 의존성 관리, 빌드, 테스트를 모두 처리하는 강력한 도구로, Rust 개발의 핵심입니다.
실전 팁
💡 설치 중 "Proceed with installation" 메시지가 나오면 1을 입력하여 기본 설정으로 진행하세요. 기본 설정이 대부분의 경우에 최적입니다.
💡 설치 후 터미널을 재시작해야 PATH 환경변수가 적용됩니다. 만약 rustc 명령어가 인식되지 않는다면, 터미널을 닫고 다시 열어보세요.
💡 회사 방화벽 뒤에서 설치가 실패한다면, 프록시 설정이 필요할 수 있습니다. HTTPS_PROXY 환경변수를 설정하거나, IT 부서에 문의하세요.
💡 rustup을 정기적으로 업데이트하세요. 매 6주마다 새로운 Rust 버전이 릴리즈되며, 버그 수정과 새로운 기능이 추가됩니다.
💡 개인 프로젝트에는 stable 버전을, 최신 기능을 실험하고 싶다면 nightly 버전을 사용하세요. rustup default nightly로 채널을 전환할 수 있습니다.
2. Cargo 패키지 매니저 소개 - Rust의 강력한 동반자
시작하며
프로젝트를 시작할 때마다 폴더 구조를 어떻게 만들지, 빌드 스크립트를 어떻게 작성할지 고민해본 적 있나요? C나 C++을 다뤄본 분들은 Makefile이나 CMake의 복잡함에 지친 경험이 있을 겁니다.
Rust는 이런 번거로움을 cargo라는 통합 빌드 시스템과 패키지 매니저로 해결했습니다. cargo는 단순히 패키지를 관리하는 것을 넘어, 프로젝트 생성부터 빌드, 테스트, 문서화, 배포까지 모든 개발 워크플로우를 자동화합니다.
이 강력한 도구를 통해 여러분은 복잡한 빌드 설정 없이, 코드 작성에만 집중할 수 있습니다. npm, pip, maven의 장점들을 모두 흡수하고 더 발전시킨 도구라고 할 수 있습니다.
개요
간단히 말해서, cargo는 Rust의 공식 빌드 시스템이자 패키지 매니저로, 프로젝트의 전체 생명주기를 관리합니다. 왜 cargo가 필요한지 실무 관점에서 설명하자면, 현대적인 소프트웨어 개발은 수많은 외부 라이브러리(의존성)에 의존합니다.
이런 의존성을 수동으로 관리하는 것은 거의 불가능합니다. cargo는 Cargo.toml 파일 하나로 모든 의존성을 선언하고, 자동으로 다운로드하고 버전을 관리합니다.
예를 들어, 웹 서버를 만들 때 HTTP 라이브러리가 필요하다면, cargo add tokio 한 줄로 추가할 수 있습니다. 기존에는 라이브러리를 수동으로 다운로드하고, 컴파일 경로를 설정하고, 링커 옵션을 지정해야 했다면, 이제는 cargo가 모든 것을 자동으로 처리합니다.
cargo의 핵심 특징을 살펴보면, 첫째, 프로젝트 템플릿을 자동 생성합니다. 둘째, 의존성 해결과 버전 관리를 자동화합니다.
셋째, 증분 컴파일로 빌드 시간을 최소화합니다. 넷째, 테스트와 벤치마크를 통합 지원합니다.
이러한 특징들이 중요한 이유는, 개발자가 반복적인 작업에 시간을 낭비하지 않고 본질적인 문제 해결에 집중할 수 있게 해주기 때문입니다.
코드 예제
# 새 프로젝트 생성 (바이너리 애플리케이션)
cargo new my_project
# 새 라이브러리 프로젝트 생성
cargo new my_library --lib
# 프로젝트 빌드 (디버그 모드)
cargo build
# 프로젝트 빌드 및 실행
cargo run
# 릴리즈 모드로 최적화 빌드
cargo build --release
# 테스트 실행
cargo test
# 의존성 추가
cargo add serde
설명
이것이 하는 일: cargo는 Rust 프로젝트의 모든 개발 작업을 하나의 일관된 인터페이스로 제공하는 통합 도구입니다. 여러분이 실행하는 각 cargo 명령어는 내부적으로 복잡한 작업들을 자동으로 수행합니다.
첫 번째로, cargo new 명령어는 표준화된 프로젝트 구조를 생성합니다. src/ 디렉토리에 main.rs 또는 lib.rs 파일을 만들고, Cargo.toml 설정 파일을 생성하며, git 저장소까지 자동으로 초기화합니다.
이렇게 하는 이유는 모든 Rust 프로젝트가 동일한 구조를 따르도록 하여, 다른 개발자가 프로젝트를 쉽게 이해할 수 있게 하기 위함입니다. 실제로 GitHub의 Rust 프로젝트들을 보면 거의 모두 이 구조를 따르고 있습니다.
그 다음으로, cargo build가 실행되면 Cargo.toml에 명시된 의존성을 분석하고, 필요한 라이브러리를 crates.io(Rust의 공식 패키지 저장소)에서 다운로드합니다. 그런 다음 의존성 그래프를 구성하고, 올바른 순서로 컴파일을 진행합니다.
내부에서는 rustc 컴파일러를 호출하지만, 개발자는 이런 복잡한 과정을 신경 쓸 필요가 없습니다. 빌드 결과물은 target/debug/ 디렉토리에 저장됩니다.
세 번째 단계로, cargo run은 빌드와 실행을 한 번에 처리합니다. 코드가 변경되었다면 자동으로 재컴파일하고, 변경되지 않았다면 캐시된 바이너리를 실행합니다.
이런 스마트한 증분 컴파일 덕분에 개발 속도가 크게 향상됩니다. 마지막으로, cargo build --release는 최적화 옵션을 활성화하여 프로덕션용 바이너리를 생성합니다.
일반 빌드보다 시간은 더 걸리지만, 실행 속도는 훨씬 빠릅니다. 여러분이 cargo를 사용하면 복잡한 빌드 시스템을 직접 구성할 필요 없이, 즉시 생산적인 개발을 시작할 수 있습니다.
특히 팀 프로젝트에서 모든 팀원이 동일한 빌드 환경을 가질 수 있다는 점은 엄청난 이점입니다. "내 컴퓨터에서는 되는데"라는 말이 사라집니다.
실전 팁
💡 cargo check 명령어를 자주 사용하세요. 실제 바이너리를 생성하지 않고 컴파일 에러만 확인하므로, cargo build보다 훨씬 빠릅니다.
💡 cargo.toml의 [dependencies] 섹션에 직접 패키지를 추가할 수도 있지만, cargo add를 사용하면 최신 버전을 자동으로 찾아줍니다.
💡 cargo fmt로 코드 포맷팅을, cargo clippy로 코드 품질 검사를 할 수 있습니다. 이 도구들은 rustup component add로 설치할 수 있습니다.
💡 CI/CD 파이프라인에서는 cargo build --release를 사용하고, 로컬 개발에서는 일반 cargo build를 사용하세요. 릴리즈 빌드는 최적화로 인해 시간이 오래 걸립니다.
💡 target/ 디렉토리는 .gitignore에 추가하세요. 빌드 결과물은 용량이 크고, 다른 사람의 환경에서 재생성될 수 있기 때문입니다.
3. VSCode와 rust-analyzer 설정 - 최고의 개발 경험
시작하며
여러분이 새로운 언어를 배울 때 가장 답답한 순간이 언제인가요? 바로 코드를 작성하는데 자동완성도 안 되고, 에러가 어디서 발생했는지도 모르고, 함수 정의를 찾으려면 문서를 일일이 검색해야 할 때입니다.
Rust는 이런 문제를 rust-analyzer라는 강력한 LSP(Language Server Protocol) 구현으로 해결했습니다. 이 도구는 VSCode와 결합하여 마치 IDE 수준의 지능적인 코드 편집 경험을 제공합니다.
타입 추론, 실시간 에러 검사, 스마트한 자동완성이 모두 가능합니다. 이 환경을 구축하면 여러분은 Rust의 복잡한 타입 시스템도 훨씬 쉽게 다룰 수 있습니다.
컴파일러가 친절하게 가이드해주고, 편집기가 실시간으로 피드백을 주는 환경에서 학습 곡선이 크게 완화됩니다.
개요
간단히 말해서, rust-analyzer는 Rust 코드를 이해하고 분석하여 편집기에 지능적인 기능을 제공하는 언어 서버입니다. 왜 rust-analyzer가 필요한지 설명하자면, Rust는 강력한 타입 시스템과 소유권 개념 때문에 처음 배우기가 까다로운 언어입니다.
하지만 좋은 도구의 도움을 받으면 훨씬 쉬워집니다. rust-analyzer는 여러분이 코드를 작성하는 순간순간 타입 정보를 보여주고, 잠재적인 에러를 미리 경고하며, 정확한 자동완성을 제공합니다.
예를 들어, 복잡한 제네릭 타입을 다룰 때 마우스를 올리면 추론된 타입을 바로 볼 수 있습니다. 기존에는 컴파일을 해봐야 에러를 알 수 있었고, 함수 시그니처를 확인하려면 문서를 찾아야 했다면, 이제는 편집기에서 실시간으로 모든 정보를 얻을 수 있습니다.
rust-analyzer의 핵심 특징은 다음과 같습니다. 첫째, 증분 분석으로 대규모 프로젝트에서도 빠르게 동작합니다.
둘째, 매크로 확장 결과를 보여줘서 복잡한 매크로도 이해할 수 있습니다. 셋째, 코드 리팩토링 기능이 내장되어 있어 변수명 변경, 함수 추출 등이 안전하게 가능합니다.
이러한 특징들은 실무에서 대규모 코드베이스를 다룰 때 생산성을 극대화해줍니다.
코드 예제
// VSCode에서 rust-analyzer 설치 후 사용 예시
// 1. 타입 추론 - 마우스를 올리면 타입이 표시됨
let numbers = vec![1, 2, 3, 4, 5]; // Vec<i32>로 추론됨
// 2. 자동완성 - . 을 입력하면 사용 가능한 메서드가 나타남
numbers.iter().map(|x| x * 2).collect(); // iter, map, collect 자동완성
// 3. 에러 검사 - 실시간으로 에러가 빨간 밑줄로 표시됨
let result = numbers[10]; // 인덱스 범위 경고
// 4. 정의로 이동 - F12 또는 Cmd/Ctrl + 클릭
// Vec 타입 정의로 바로 이동 가능
// 5. 코드 액션 - 전구 아이콘으로 자동 수정 제안
let unused_variable = 42; // 사용하지 않는 변수 경고 및 수정 제안
설명
이것이 하는 일: rust-analyzer는 백그라운드에서 지속적으로 코드를 분석하고, LSP를 통해 편집기와 통신하여 다양한 지능적 기능을 제공합니다. 첫 번째로, VSCode 확장 마켓플레이스에서 "rust-analyzer"를 검색하여 설치하면, 자동으로 언어 서버 바이너리가 다운로드됩니다.
이 바이너리는 별도의 프로세스로 실행되며, 여러분의 코드를 지속적으로 분석합니다. 왜 이렇게 하는지 궁금하시죠?
LSP는 언어와 편집기를 분리하는 표준 프로토콜입니다. 덕분에 rust-analyzer는 VSCode뿐만 아니라 Vim, Emacs, IntelliJ 등 다양한 편집기에서 동일하게 작동합니다.
그 다음으로, 코드를 작성하면 rust-analyzer가 실시간으로 타입을 추론합니다. 예를 들어 let numbers = vec![1, 2, 3]이라고 작성하면, 내부적으로 rustc의 타입 체커를 활용하여 Vec<i32> 타입임을 파악합니다.
이 정보를 편집기에 전달하면, 마우스를 올렸을 때 타입이 표시됩니다. 복잡한 제네릭 타입이나 트레이트 바운드도 모두 정확하게 추론됩니다.
세 번째 단계로, 자동완성이 동작할 때 rust-analyzer는 현재 스코프에서 사용 가능한 모든 아이템(함수, 변수, 메서드)을 찾습니다. 단순히 이름만 나열하는 것이 아니라, 타입 정보를 고려하여 적합한 것만 제안합니다.
예를 들어 numbers.라고 입력하면 Vec<i32>에 정의된 메서드만 나타납니다. 마지막으로, 에러 검사는 파일을 저장할 때마다(또는 설정에 따라 실시간으로) 수행됩니다.
rust-analyzer는 cargo check를 백그라운드에서 실행하고, 컴파일러의 진단 메시지를 파싱하여 편집기에 표시합니다. 이 과정은 매우 빠르게 진행되어 사용자는 거의 지연을 느끼지 못합니다.
여러분이 이 환경을 사용하면 Rust의 가파른 학습 곡선이 크게 완화됩니다. 컴파일러가 거부하는 코드를 작성하기 전에 미리 알 수 있고, 복잡한 타입도 시각적으로 이해할 수 있으며, 리팩토링도 안전하게 수행할 수 있습니다.
실무에서는 이런 도구 없이 Rust를 개발하는 것은 상상하기 어렵습니다.
실전 팁
💡 VSCode 설정에서 "rust-analyzer.checkOnSave.command"를 "clippy"로 변경하면, 더 엄격한 코드 품질 검사를 받을 수 있습니다.
💡 Cmd/Ctrl + . 단축키로 코드 액션 메뉴를 열면, 자동 수정이나 리팩토링 옵션을 바로 볼 수 있습니다. 놓치기 쉬운 전구 아이콘을 찾지 않아도 됩니다.
💡 큰 프로젝트에서 rust-analyzer가 느리다면, Cargo.toml에서 사용하지 않는 의존성을 제거하세요. 분석 시간은 의존성 크기에 비례합니다.
💡 매크로를 작성할 때는 "Rust Analyzer: Expand macro recursively" 명령을 사용하여 확장 결과를 확인하세요. 매크로 디버깅에 필수적입니다.
💡 팀원들과 동일한 rust-analyzer 설정을 공유하려면, .vscode/settings.json 파일을 git에 커밋하세요. 일관된 개발 경험을 보장할 수 있습니다.
4. Hello World 프로젝트 생성 - 첫 Rust 프로그램
시작하며
여러분은 새로운 언어를 배울 때 "Hello, World!"를 출력하는 순간을 기억하시나요? 그 간단한 프로그램이 돌아갈 때의 설렘과 성취감 말이죠.
하지만 환경 설정이 잘못되어서 첫 프로그램조차 실행하지 못한 경험도 있을 겁니다. Rust에서는 cargo 덕분에 이런 걱정이 없습니다.
단 두 개의 명령어로 완전히 작동하는 프로젝트를 생성하고 실행할 수 있습니다. 복잡한 빌드 설정도, 이상한 에러 메시지도 없이 말이죠.
지금부터 여러분의 첫 Rust 프로그램을 만들어보겠습니다. 이 과정을 통해 Rust 프로젝트의 기본 구조와 cargo의 작동 방식을 자연스럽게 이해하게 될 것입니다.
개요
간단히 말해서, cargo new 명령어는 표준화된 Rust 프로젝트를 자동으로 생성하고, cargo run으로 즉시 실행할 수 있습니다. 왜 이 과정이 중요한지 설명하자면, 프로젝트 구조가 표준화되어 있으면 협업이 훨씬 쉬워집니다.
Rust 커뮤니티의 모든 프로젝트가 동일한 구조를 따르기 때문에, 다른 사람의 코드를 볼 때도 어디에 뭐가 있는지 바로 알 수 있습니다. 또한 CI/CD 파이프라인을 구축할 때도 일관된 명령어(cargo build, cargo test)만 사용하면 되므로 자동화가 간단합니다.
기존에는 프로젝트를 시작할 때마다 디렉토리를 만들고, 빌드 파일을 작성하고, 의존성 관리 시스템을 설정해야 했다면, 이제는 cargo가 모든 것을 자동으로 처리합니다. cargo new의 핵심 특징은 세 가지입니다.
첫째, 올바른 디렉토리 구조를 자동 생성합니다. 둘째, git 저장소를 초기화하고 .gitignore를 추가합니다.
셋째, 실행 가능한 템플릿 코드를 제공합니다. 이러한 특징들이 중요한 이유는, 프로젝트 초기 설정에 시간을 낭비하지 않고 바로 코드 작성을 시작할 수 있기 때문입니다.
코드 예제
# 새 프로젝트 생성
cargo new hello_rust
cd hello_rust
# 생성된 main.rs 내용 (src/main.rs)
fn main() {
println!("Hello, world!");
}
# 프로젝트 실행
cargo run
# 출력:
# Compiling hello_rust v0.1.0 (/path/to/hello_rust)
# Finished dev [unoptimized + debuginfo] target(s) in 0.50s
# Running `target/debug/hello_rust`
# Hello, world!
설명
이것이 하는 일: cargo new는 완전한 Rust 프로젝트 구조를 생성하고, main 함수가 포함된 실행 가능한 코드를 자동으로 작성합니다. 첫 번째로, cargo new hello_rust를 실행하면 현재 디렉토리에 hello_rust 폴더가 생성됩니다.
이 폴더 안에는 src/ 디렉토리, Cargo.toml 파일, .git/ 디렉토리, .gitignore 파일이 자동으로 만들어집니다. 왜 이런 구조일까요?
src/ 디렉토리는 모든 소스 코드가 들어가는 표준 위치입니다. Cargo.toml은 프로젝트 메타데이터와 의존성을 선언하는 설정 파일입니다.
TOML은 간결하고 읽기 쉬운 설정 파일 형식으로, JSON이나 YAML보다 사람이 편집하기 좋습니다. 그 다음으로, src/main.rs 파일이 자동으로 생성되며 기본 코드가 작성됩니다.
fn main()은 Rust 프로그램의 진입점(entry point)입니다. 모든 실행 가능한 Rust 프로그램은 main 함수에서 시작합니다.
println!은 매크로로, 느낌표(!)가 붙어 있는 것이 특징입니다. 일반 함수가 아닌 매크로인 이유는 가변 인자를 받고, 컴파일 타임에 포맷 문자열을 검증하기 위함입니다.
이는 런타임 에러를 방지하는 Rust의 철학을 보여줍니다. 세 번째 단계로, cargo run을 실행하면 여러 작업이 순차적으로 진행됩니다.
먼저 cargo는 코드가 변경되었는지 확인합니다. 변경되었다면 cargo build를 자동으로 실행하여 컴파일합니다.
컴파일 결과는 target/debug/ 디렉토리에 실행 파일로 저장됩니다. 마지막으로 생성된 바이너리를 자동으로 실행합니다.
이 모든 과정이 하나의 명령어로 처리됩니다. 마지막으로, 출력 메시지를 살펴보면 "Compiling hello_rust v0.1.0"은 컴파일 단계를, "Finished dev [unoptimized + debuginfo]"는 디버그 모드로 빌드되었음을, "Running target/debug/hello_rust"는 실행 단계를 나타냅니다.
여러분이 이 과정을 완료하면, Rust의 기본 워크플로우를 이해하게 됩니다. 코드 작성 → cargo run → 결과 확인이라는 간단한 사이클을 반복하면서 자연스럽게 Rust 문법을 익힐 수 있습니다.
이 구조는 개인 프로젝트든 회사 프로젝트든 동일하게 적용됩니다.
실전 팁
💡 프로젝트 이름은 소문자와 언더스코어만 사용하세요. Rust 컨벤션은 snake_case를 따릅니다. 하이픈은 cargo가 자동으로 언더스코어로 변환합니다.
💡 cargo run --release를 사용하면 최적화된 빌드로 실행됩니다. 성능 테스트를 할 때는 반드시 릴리즈 모드를 사용하세요. 디버그 모드는 10배 이상 느릴 수 있습니다.
💡 main.rs를 수정한 후 파일을 저장하고 cargo run을 실행하면, 자동으로 재컴파일됩니다. 별도의 clean 명령어가 필요 없습니다.
💡 println! 대신 dbg! 매크로를 사용하면 변수 이름과 값을 함께 출력할 수 있어 디버깅에 유용합니다. 예: dbg!(numbers);
💡 cargo new --vcs none을 사용하면 git 초기화를 건너뛸 수 있습니다. 이미 git 저장소 안에서 작업할 때 유용합니다.
5. Cargo.toml 파일 이해하기 - 프로젝트의 설계도
시작하며
여러분이 npm의 package.json이나 Python의 requirements.txt를 사용해본 적 있나요? 이런 파일들이 없다면 프로젝트의 의존성을 어떻게 관리할까요?
팀원마다 다른 버전의 라이브러리를 사용하면서 "내 컴퓨터에서는 되는데요"라는 말이 오가는 악몽을 겪게 됩니다. Rust의 Cargo.toml은 이런 문제를 해결하는 프로젝트의 핵심 설정 파일입니다.
프로젝트 메타데이터, 의존성, 빌드 설정을 모두 여기서 관리합니다. TOML 형식은 읽기 쉽고 작성하기 편해서, JSON보다 덜 번거롭고 YAML보다 명확합니다.
이 파일을 제대로 이해하면 복잡한 의존성도 쉽게 관리할 수 있고, 프로젝트 설정을 자유자재로 조정할 수 있습니다. 실무에서 가장 자주 다루게 될 파일 중 하나입니다.
개요
간단히 말해서, Cargo.toml은 Rust 프로젝트의 모든 메타데이터와 설정을 담고 있는 선언적 설정 파일입니다. 왜 이 파일이 필요한지 설명하자면, 현대적인 소프트웨어는 수많은 외부 라이브러리를 조합하여 만들어집니다.
이런 의존성을 명시적으로 선언하지 않으면 재현 가능한(reproducible) 빌드가 불가능합니다. Cargo.toml은 정확히 어떤 패키지의 어떤 버전을 사용하는지 명시합니다.
예를 들어, 웹 프레임워크인 actix-web을 사용한다면, [dependencies] 섹션에 actix-web = "4.0"이라고 작성하면 됩니다. 기존에는 의존성을 설치 스크립트로 관리하거나, 문서에 "이 라이브러리를 설치하세요"라고 적어두었다면, 이제는 Cargo.toml 하나로 모든 것이 자동화됩니다.
Cargo.toml의 핵심 구성 요소는 다음과 같습니다. 첫째, [package] 섹션은 프로젝트 이름, 버전, 에디션을 정의합니다.
둘째, [dependencies] 섹션은 런타임 의존성을 나열합니다. 셋째, [dev-dependencies]는 테스트와 개발에만 필요한 의존성을 분리합니다.
넷째, [profile] 섹션은 빌드 최적화 수준을 조정합니다. 이러한 구조가 중요한 이유는, 프로젝트의 전체 구성을 한눈에 파악할 수 있고, 팀원 간 설정을 공유하기 쉽기 때문입니다.
코드 예제
[package]
name = "hello_rust"
version = "0.1.0"
edition = "2021" # Rust 에디션, 2021이 최신
[dependencies]
serde = "1.0" # JSON 직렬화 라이브러리
tokio = { version = "1.28", features = ["full"] } # 비동기 런타임
[dev-dependencies]
criterion = "0.5" # 벤치마크 도구
[profile.release]
opt-level = 3 # 최대 최적화
lto = true # Link Time Optimization 활성화
설명
이것이 하는 일: Cargo.toml은 cargo가 프로젝트를 빌드하고 관리하는 데 필요한 모든 정보를 제공하는 선언적 설정 파일입니다. 첫 번째로, [package] 섹션은 프로젝트의 기본 정보를 정의합니다.
name은 패키지 이름으로, crates.io에 배포할 때 고유해야 합니다. version은 Semantic Versioning(SemVer)을 따르며, MAJOR.MINOR.PATCH 형식입니다.
edition은 Rust 언어의 에디션을 지정합니다. 왜 에디션이 필요할까요?
Rust는 하위 호환성을 깨뜨리지 않으면서 언어를 발전시키기 위해 에디션 시스템을 사용합니다. 2018 에디션에서는 async/await가 도입되었고, 2021 에디션에서는 더 나은 클로저 캡처 규칙이 추가되었습니다.
그 다음으로, [dependencies] 섹션에서 의존성을 선언하면 cargo가 자동으로 crates.io에서 다운로드합니다. 버전 지정 방식은 유연합니다.
serde = "1.0"은 실제로는 "^1.0"을 의미하며, 1.0 이상 2.0 미만의 최신 버전을 사용합니다. 이는 SemVer의 호환성 약속에 기반합니다.
메이저 버전이 같으면 API가 호환된다는 가정입니다. 만약 정확한 버전이 필요하다면 serde = "=1.0.130"처럼 작성할 수 있습니다.
세 번째 단계로, features 필드는 조건부 컴파일을 가능하게 합니다. tokio = { version = "1.28", features = ["full"] }은 tokio의 모든 기능을 활성화합니다.
라이브러리들은 기본적으로 필수 기능만 포함하고, 선택적 기능은 feature flag로 제공합니다. 이렇게 하는 이유는 컴파일 시간을 단축하고 바이너리 크기를 줄이기 위함입니다.
마지막으로, [profile.release] 섹션은 릴리즈 빌드의 최적화 수준을 조정합니다. opt-level = 3은 최대 최적화를 의미하며, 컴파일 시간은 길어지지만 실행 속도는 최고가 됩니다.
lto = true는 링크 타임 최적화를 활성화하여, 크레이트 경계를 넘어선 최적화를 수행합니다. 이는 바이너리 크기를 줄이고 성능을 향상시킵니다.
여러분이 Cargo.toml을 잘 활용하면 프로젝트 설정을 체계적으로 관리할 수 있습니다. 새 팀원이 합류해도 cargo build만 실행하면 모든 의존성이 자동으로 설치되고, 빌드가 성공합니다.
이는 온보딩 시간을 크게 단축시키고, "환경 설정 문제"로 인한 시간 낭비를 없애줍니다.
실전 팁
💡 의존성 버전을 업데이트하려면 cargo update를 실행하세요. 이는 Cargo.lock 파일을 갱신하여 호환되는 범위 내에서 최신 버전을 사용합니다.
💡 cargo add 명령어를 사용하면 Cargo.toml을 직접 편집하지 않고도 의존성을 추가할 수 있습니다. 최신 버전을 자동으로 찾아줍니다.
💡 [dependencies]와 [dev-dependencies]를 구분하세요. 테스트 도구나 벤치마크 도구는 dev-dependencies에 넣어야 최종 바이너리 크기가 작아집니다.
💡 cargo tree 명령어로 의존성 그래프를 시각화할 수 있습니다. 어떤 패키지가 어떤 패키지를 의존하는지 파악할 때 유용합니다.
💡 작업공간(workspace)이 필요하면 [workspace] 섹션을 추가하세요. 여러 크레이트를 하나의 저장소에서 관리할 수 있습니다.
6. rustc 컴파일러 기초 - 코드를 실행 파일로
시작하며
여러분이 Python이나 JavaScript 같은 인터프리터 언어를 사용해봤다면, 코드를 작성하면 바로 실행되는 것이 당연하게 느껴질 겁니다. 하지만 Rust는 컴파일 언어입니다.
코드를 실행하기 전에 기계어로 변환하는 과정이 필요합니다. 이 컴파일 과정이 귀찮게 느껴질 수 있지만, 실제로는 엄청난 이점을 제공합니다.
타입 에러, 메모리 안전성 문제, 동시성 버그를 런타임이 아닌 컴파일 타임에 잡아냅니다. "실행은 되는데 나중에 터지는" 상황을 원천적으로 방지하는 것이죠.
rustc는 Rust의 공식 컴파일러로, LLVM을 백엔드로 사용하여 최적화된 기계어를 생성합니다. cargo가 내부적으로 rustc를 호출하지만, rustc를 직접 이해하면 컴파일 과정을 더 깊이 이해할 수 있습니다.
개요
간단히 말해서, rustc는 Rust 소스 코드를 분석하고 검증하여 실행 가능한 바이너리로 변환하는 컴파일러입니다. 왜 컴파일러를 이해해야 하는지 설명하자면, 컴파일러는 단순히 코드를 번역하는 것이 아니라 코드의 정확성을 검증하는 역할도 합니다.
Rust 컴파일러는 특히 엄격하기로 유명한데, 이는 런타임 에러를 최소화하기 위함입니다. 예를 들어, 메모리 안전성 문제(use-after-free, 이중 해제 등)를 컴파일 타임에 잡아냅니다.
이는 C/C++에서 흔히 발생하는 보안 취약점을 원천 차단합니다. 기존에는 C/C++처럼 런타임에 segmentation fault가 발생하거나, Java처럼 가비지 컬렉터의 오버헤드를 감수해야 했다면, Rust는 컴파일 타임 검증으로 양쪽의 장점을 모두 취합니다.
rustc의 핵심 특징은 다음과 같습니다. 첫째, 소유권 시스템을 통해 메모리 안전성을 보장합니다.
둘째, 제로 코스트 추상화를 제공하여 고수준 코드도 최적화됩니다. 셋째, 친절한 에러 메시지로 문제 해결을 돕습니다.
이러한 특징들이 중요한 이유는, 프로그래머가 안전하고 빠른 코드를 작성할 수 있게 해주기 때문입니다.
코드 예제
// hello.rs 파일 생성
fn main() {
println!("Hello from rustc!");
}
// rustc로 직접 컴파일
// $ rustc hello.rs
// 생성된 실행 파일 확인
// $ ls -lh hello
// -rwxr-xr-x 1 user group 4.2M Jan 1 12:00 hello
// 실행
// $ ./hello
// Hello from rustc!
// 최적화 옵션으로 컴파일
// $ rustc -C opt-level=3 hello.rs
설명
이것이 하는 일: rustc는 Rust 소스 코드를 읽어서 파싱하고, 타입 검사를 수행하고, 소유권 규칙을 검증한 후, LLVM IR로 변환하여 최종적으로 네이티브 기계어를 생성합니다. 첫 번째로, rustc hello.rs를 실행하면 컴파일러가 소스 코드를 읽습니다.
파싱 단계에서 문법적 오류를 찾고, AST(Abstract Syntax Tree)를 구성합니다. 왜 AST가 필요할까요?
코드를 구조화된 형태로 표현해야 이후 분석 단계에서 처리하기 쉽기 때문입니다. 만약 문법 에러가 있다면 이 단계에서 즉시 발견됩니다.
그 다음으로, 타입 체커가 동작하여 모든 변수와 함수의 타입을 추론하고 검증합니다. Rust는 강타입 언어이므로 타입이 맞지 않으면 컴파일이 실패합니다.
예를 들어 let x: i32 = "hello";는 타입 불일치로 거부됩니다. 이 과정에서 제네릭 타입도 구체화(monomorphization)됩니다.
Vec<i32>와 Vec<String>은 각각 별도의 기계어로 컴파일되어, 런타임 오버헤드 없이 타입 안전성을 보장합니다. 세 번째 단계로, 보로우 체커(borrow checker)가 소유권 규칙을 검증합니다.
이는 Rust의 가장 독특한 특징입니다. 각 값이 정확히 하나의 소유자를 가지는지, 참조가 유효한 범위를 벗어나지 않는지, 가변 참조와 불변 참조가 동시에 존재하지 않는지를 확인합니다.
이 검증 덕분에 데이터 경쟁(data race)이나 use-after-free 같은 메모리 버그가 컴파일 타임에 제거됩니다. 마지막으로, 모든 검증을 통과하면 LLVM 백엔드로 전달되어 최적화가 수행됩니다.
LLVM은 인라이닝, 루프 최적화, 벡터화 등 다양한 최적화 기법을 적용합니다. -C opt-level=3 옵션은 최대 최적화를 지시합니다.
최종적으로 생성된 바이너리는 운영체제에서 직접 실행 가능한 네이티브 코드입니다. 여러분이 rustc의 동작을 이해하면 컴파일 에러 메시지를 더 잘 해석할 수 있습니다.
"cannot borrow as mutable" 같은 메시지가 나오면, 이는 보로우 체커가 소유권 규칙 위반을 발견했다는 의미입니다. 실무에서는 cargo가 rustc를 래핑하지만, 내부 동작을 아는 것은 디버깅에 큰 도움이 됩니다.
실전 팁
💡 실무에서는 rustc를 직접 사용하지 않고 cargo를 사용하세요. cargo는 의존성 관리, 증분 컴파일, 병렬 빌드 등 많은 기능을 추가로 제공합니다.
💡 컴파일 에러 메시지에 표시되는 에러 코드(예: E0382)를 rustc --explain E0382로 조회하면 상세한 설명을 볼 수 있습니다.
💡 rustc --version --verbose를 실행하면 LLVM 버전, 호스트 트리플 등 상세 정보를 볼 수 있습니다. 크로스 컴파일 문제를 디버깅할 때 유용합니다.
💡 rustc --emit=llvm-ir hello.rs를 사용하면 LLVM IR 코드를 볼 수 있습니다. 최적화가 어떻게 적용되는지 학습할 때 도움이 됩니다.
💡 빠른 컴파일을 위해 개발 중에는 opt-level=0을 사용하고, 배포 전에만 opt-level=3로 빌드하세요. 개발 속도와 실행 속도의 균형이 중요합니다.
7. 표준 라이브러리 문서 활용 - 내장 도구 탐색
시작하며
여러분이 새로운 라이브러리를 배울 때 가장 답답한 순간이 언제인가요? "이 함수가 정확히 뭘 하는 거지?", "어떤 메서드를 사용해야 하지?", "예제 코드는 어디 있지?" 같은 질문에 대한 답을 찾지 못할 때입니다.
Rust는 이 문제를 매우 우아하게 해결했습니다. 모든 라이브러리가 표준화된 문서를 제공하며, cargo doc 명령어로 로컬에서 문서를 생성하고 브라우저에서 바로 볼 수 있습니다.
문서에는 상세한 설명, 예제 코드, 심지어 검색 기능까지 포함되어 있습니다. 특히 Rust의 표준 라이브러리(std) 문서는 품질이 매우 높기로 유명합니다.
각 타입과 함수에 대한 설명이 자세하고, 실용적인 예제가 풍부하며, 관련된 항목으로 쉽게 이동할 수 있습니다. 이 문서를 활용하는 법을 익히면 학습 속도가 비약적으로 향상됩니다.
개요
간단히 말해서, Rust의 표준 라이브러리 문서는 모든 내장 타입과 함수에 대한 완벽한 레퍼런스이며, cargo doc으로 로컬에서 쉽게 접근할 수 있습니다. 왜 문서가 이렇게 중요한지 설명하자면, 프로그래밍은 결국 다양한 API를 조합하는 작업입니다.
API의 동작을 정확히 이해하지 못하면 버그가 발생합니다. Rust는 문서를 코드와 함께 관리하는 문화를 가지고 있어, 문서가 항상 최신 상태로 유지됩니다.
예를 들어, Vec<T> 타입의 push 메서드가 궁금하다면, 문서에서 시간 복잡도, 메모리 할당 동작, 예제 코드를 모두 확인할 수 있습니다. 기존에는 외부 블로그나 Stack Overflow에서 단편적인 정보를 찾아야 했다면, 이제는 공식 문서만으로 충분합니다.
Rust 문서의 핵심 특징은 다음과 같습니다. 첫째, 모든 공개 API가 문서화되어 있습니다.
둘째, 예제 코드가 자동으로 테스트되어 정확성이 보장됩니다. 셋째, 타입 시그니처와 트레이트 구현 목록이 명확히 표시됩니다.
넷째, 검색 기능이 강력하여 원하는 기능을 빠르게 찾을 수 있습니다. 이러한 특징들은 자가 학습과 문제 해결을 크게 도와줍니다.
코드 예제
// 표준 라이브러리 문서를 로컬에서 열기
// $ rustup doc
// 현재 프로젝트의 문서 생성 및 열기
// $ cargo doc --open
// 의존성 문서도 함께 생성
// $ cargo doc --no-deps --open
// 코드에서 문서 주석 작성 (문서에 포함됨)
/// 두 수를 더하는 함수
///
/// # Examples
///
/// ```
/// let result = add(2, 3);
/// assert_eq!(result, 5);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
a + b
}
설명
이것이 하는 일: Rust의 문서 시스템은 코드의 특수 주석(///)을 파싱하여 HTML 문서를 자동 생성하고, 예제 코드를 테스트하여 정확성을 보장합니다. 첫 번째로, rustup doc 명령어를 실행하면 기본 브라우저에서 Rust 표준 라이브러리 문서가 열립니다.
이 문서는 rustup 설치 시 함께 다운로드되어 로컬에 저장됩니다. 왜 로컬 문서가 중요할까요?
인터넷 연결 없이도 학습할 수 있고, 로딩 속도가 빠르며, 버전이 여러분이 설치한 Rust와 정확히 일치하기 때문입니다. 문서 페이지에서는 좌측 사이드바로 모듈을 탐색하고, 상단 검색창으로 원하는 타입이나 함수를 빠르게 찾을 수 있습니다.
그 다음으로, cargo doc --open을 실행하면 현재 프로젝트와 모든 의존성의 문서가 생성됩니다. 내부적으로 cargo는 각 크레이트의 소스 코드를 분석하고, rustdoc 도구를 호출하여 HTML을 생성합니다.
--open 플래그는 생성 후 자동으로 브라우저를 엽니다. 이렇게 생성된 문서는 target/doc/ 디렉토리에 저장됩니다.
의존성이 많은 프로젝트에서는 이 과정이 시간이 걸릴 수 있으므로, --no-deps 옵션으로 현재 크레이트만 문서화할 수 있습니다. 세 번째 단계로, 코드에 /// 주석으로 문서를 작성하면 이것이 공식 문서의 일부가 됩니다.
마크다운 문법을 사용할 수 있어 서식을 자유롭게 지정할 수 있습니다. # Examples 섹션에 작성한 코드 블록은 cargo test를 실행할 때 실제로 컴파일되고 테스트됩니다.
이는 문서가 낡아서 실제 코드와 맞지 않는 상황을 방지합니다. 문서의 예제 코드가 틀렸다면 테스트가 실패하므로, 항상 정확성이 보장됩니다.
마지막으로, 생성된 문서에는 각 함수의 시그니처, 파라미터 설명, 반환값, 구현된 트레이트 목록이 모두 포함됩니다. 예를 들어 Vec 문서를 보면, push, pop, len 등 수십 개의 메서드가 카테고리별로 정리되어 있고, 각 메서드의 시간 복잡도와 예제를 확인할 수 있습니다.
여러분이 이 문서 시스템을 활용하면 학습이 훨씬 효율적이 됩니다. 새로운 크레이트를 사용할 때 docs.rs에서 문서를 확인하는 습관을 들이세요.
코드만 보는 것보다 훨씬 빠르게 사용법을 파악할 수 있습니다. 실무에서도 자신이 작성한 public API에는 반드시 문서 주석을 추가하여, 팀원들이 쉽게 이해하고 사용할 수 있도록 하세요.
실전 팁
💡 std::vec::Vec처럼 전체 경로를 알고 있다면, 브라우저 주소창에 직접 입력하여 빠르게 이동할 수 있습니다. docs.rs/std에서도 동일한 문서를 볼 수 있습니다.
💡 문서 검색 시 단축키 S를 누르면 검색창에 포커스됩니다. 타입, 함수, 트레이트 이름을 입력하여 즉시 찾을 수 있습니다.
💡 코드 작성 중 VSCode에서 Cmd/Ctrl + 호버하면 인라인으로 문서를 볼 수 있습니다. 별도로 브라우저를 열 필요가 없습니다.
💡 /// # Panics, /// # Errors, /// # Safety 같은 표준 섹션을 사용하여 함수의 특수한 동작을 명확히 문서화하세요.
💡 cargo doc --document-private-items을 사용하면 private 함수와 모듈도 문서화됩니다. 대규모 프로젝트에서 내부 구조를 파악할 때 유용합니다.
8. 크로스 플랫폼 타겟 추가 - 다양한 환경 지원
시작하며
여러분이 만든 프로그램을 다른 운영체제에서도 실행하고 싶었던 적 있나요? 보통 이를 위해서는 각 플랫폼에서 별도로 컴파일하거나, 가상 머신을 사용해야 합니다.
특히 Windows, Linux, macOS를 모두 지원하려면 세 가지 환경을 각각 준비해야 하죠. Rust는 크로스 컴파일을 매우 쉽게 만들었습니다.
rustup을 통해 타겟 플랫폼을 추가하면, 한 시스템에서 여러 플랫폼용 바이너리를 생성할 수 있습니다. 예를 들어 macOS에서 Linux용 실행 파일을 빌드하거나, Windows에서 ARM 아키텍처용 바이너리를 만들 수 있습니다.
이 기능은 CI/CD 파이프라인을 구축할 때 특히 유용합니다. 한 번의 빌드로 모든 플랫폼용 바이너리를 생성하여 배포할 수 있기 때문입니다.
개요
간단히 말해서, rustup target add 명령어로 다른 플랫폼용 컴파일 도구체인을 추가하면, 크로스 컴파일을 통해 다양한 환경용 바이너리를 생성할 수 있습니다. 왜 크로스 컴파일이 필요한지 설명하자면, 현대 소프트웨어는 다양한 환경에서 실행되어야 합니다.
웹 서버는 Linux에서, 데스크톱 앱은 Windows와 macOS에서, IoT 장치는 ARM에서 동작합니다. 각 환경마다 별도의 빌드 시스템을 유지하는 것은 비효율적입니다.
Rust의 크로스 컴파일은 이 문제를 해결합니다. 예를 들어, macOS에서 개발하면서 Linux 서버용 바이너리를 빌드할 수 있습니다.
기존에는 도커 컨테이너나 가상 머신을 사용해야 했다면, 이제는 rustup 명령어 하나로 해결됩니다. 크로스 컴파일의 핵심 특징은 다음과 같습니다.
첫째, 타겟 트리플(target triple) 시스템으로 플랫폼을 명확히 지정합니다. 둘째, 표준 라이브러리가 타겟별로 미리 컴파일되어 제공됩니다.
셋째, cargo가 올바른 링커를 자동으로 선택합니다. 이러한 특징들은 복잡한 빌드 환경을 단순화하고, 멀티 플랫폼 지원을 현실적으로 만듭니다.
코드 예제
# 사용 가능한 타겟 목록 확인
rustup target list
# Linux용 타겟 추가 (x86_64)
rustup target add x86_64-unknown-linux-gnu
# Windows용 타겟 추가
rustup target add x86_64-pc-windows-gnu
# ARM 아키텍처용 타겟 추가 (Raspberry Pi 등)
rustup target add armv7-unknown-linux-gnueabihf
# 특정 타겟으로 빌드
cargo build --target x86_64-unknown-linux-gnu
# 릴리즈 모드로 크로스 컴파일
cargo build --release --target x86_64-pc-windows-gnu
설명
이것이 하는 일: rustup은 지정된 타겟 플랫폼에 필요한 표준 라이브러리와 컴파일 도구를 다운로드하고, cargo는 이를 사용하여 다른 플랫폼용 바이너리를 생성합니다. 첫 번째로, rustup target list를 실행하면 지원되는 모든 타겟 트리플 목록이 표시됩니다.
타겟 트리플은 아키텍처-벤더-운영체제 형식으로 구성됩니다. 예를 들어 x86_64-unknown-linux-gnu는 "64비트 x86 아키텍처, 벤더 무관, GNU 도구체인을 사용하는 Linux"를 의미합니다.
왜 이렇게 세밀하게 구분할까요? 동일한 운영체제라도 ABI(Application Binary Interface)나 링커가 다를 수 있기 때문입니다.
예를 들어 musl과 gnu는 둘 다 Linux지만 C 표준 라이브러리가 다릅니다. 그 다음으로, rustup target add를 실행하면 해당 타겟용 표준 라이브러리(libstd)가 다운로드됩니다.
이 라이브러리는 미리 컴파일된 형태(.rlib 파일)로 제공됩니다. 내부적으로 rustup은 공식 서버에서 타겟별 아티팩트를 받아와 로컬 캐시에 저장합니다.
이렇게 하는 이유는 표준 라이브러리를 직접 컴파일하면 시간이 오래 걸리기 때문입니다. 미리 빌드된 버전을 사용하면 몇 초 만에 타겟 추가가 완료됩니다.
세 번째 단계로, cargo build --target을 실행하면 지정된 타겟에 맞게 컴파일이 진행됩니다. cargo는 자동으로 올바른 링커를 찾으려 하지만, 일부 타겟에서는 크로스 컴파일 도구체인을 별도로 설치해야 할 수 있습니다.
예를 들어 Linux에서 Windows용으로 빌드하려면 mingw-w64 같은 크로스 컴파일러가 필요합니다. 빌드 결과는 target/<타겟-트리플>/debug/ 또는 release/ 디렉토리에 저장됩니다.
마지막으로, 생성된 바이너리는 타겟 플랫폼에서 직접 실행할 수 있습니다. 단, 동적 링킹된 라이브러리가 있다면 타겟 시스템에도 해당 라이브러리가 설치되어 있어야 합니다.
완전히 독립적인 바이너리를 만들려면 정적 링킹(static linking)을 사용할 수 있습니다. 여러분이 크로스 컴파일을 활용하면 배포 프로세스가 크게 간소화됩니다.
GitHub Actions 같은 CI 환경에서 한 번의 워크플로우로 Windows, Linux, macOS용 바이너리를 모두 생성할 수 있습니다. 사용자는 자신의 플랫폼에 맞는 바이너리를 다운로드하여 바로 실행할 수 있습니다.
이는 오픈소스 프로젝트나 상용 소프트웨어 배포에 매우 유용합니다.
실전 팁
💡 musl 타겟(x86_64-unknown-linux-musl)을 사용하면 완전히 정적으로 링크된 Linux 바이너리를 만들 수 있어, 어떤 Linux 배포판에서도 동작합니다.
💡 크로스 컴파일 시 링커 에러가 발생한다면, .cargo/config.toml 파일에서 링커를 명시적으로 지정하세요. [target.x86_64-pc-windows-gnu] linker = "x86_64-w64-mingw32-gcc" 형식으로 작성합니다.
💡 cargo-cross 도구를 사용하면 도커 컨테이너를 활용하여 더 복잡한 크로스 컴파일을 쉽게 할 수 있습니다. cargo install cross로 설치 가능합니다.
💡 WebAssembly 타겟(wasm32-unknown-unknown)을 추가하면 Rust 코드를 웹 브라우저에서 실행할 수 있습니다. 프론트엔드 개발에 활용 가능합니다.
💡 CI/CD에서 릴리즈 빌드를 할 때는 strip 명령어로 디버그 심볼을 제거하여 바이너리 크기를 줄이세요. 수 MB를 절약할 수 있습니다.