我在 Rust + Actix-web 中有 hello world web 项目。我有几个问题。首先是代码的每次更改都会导致重新编译整个项目，包括下载和编译每个 crate。我想像在正常开发中一样工作 - 这意味着缓存编译的 crate 并且只重新编译我的代码库。第二个问题是它没有公开我的应用程序。无法通过网络浏览器访问
Dockerfile：
FROM rust
WORKDIR /var/www/app
COPY . .
EXPOSE 8080
RUN cargo run
docker-compose.yml：
version: "3"
services:
app:
container_name: hello-world
build: .
ports:
- '8080:8080'
volumes:
- .:/var/www/app
- registry:/root/.cargo/registry
volumes:
registry:
driver: local
main.rs：
extern crate actix_web;
use actix_web::{web, App, HttpServer, Responder};
fn index() -> impl Responder {
"Hello world"
}
fn main() -> std::io::Result<()> {
HttpServer::new(|| App::new().service(web::resource("/").to(index)))
.bind("0.0.0.0:8080")?
.run()
}
Cargo.toml：
[package]
name = "hello-world"
version = "0.1.0"
authors = []
edition = "2018"
[dependencies]
actix-web = "1.0"
似乎您并不孤单，通过 docker 构建过程来缓存 rust 依赖项。这是一篇很棒的文章，可以帮助您： https://blog.mgattozzi.dev/caching-rust-docker-builds/
它的要点是你首先需要一个 dummy.rs 和你的 Cargo.toml，然后构建它来缓存依赖项，然后稍后复制你的应用程序源代码，以免每次构建时使缓存失效。
Dockerfile
FROM rust
WORKDIR /var/www/app
COPY dummy.rs .
COPY Cargo.toml .
RUN sed -i 's#src/main.rs#dummy.rs#' Cargo.toml
RUN cargo build --release
RUN sed -i 's#dummy.rs#src/main.rs#' Cargo.toml
COPY . .
RUN cargo build --release
CMD ["target/release/app"]
CMD 应用程序名称"app"基于您在 Cargo.toml 中为二进制文件指定的内容。
dummy.rs
fn main() {}
Cargo.toml
[package]
name = "app"
version = "0.1.0"
authors = ["..."]
[[bin]]
name = "app"
path = "src/main.rs"
[dependencies]
actix-web = "1.0.0"
src/main.rs
extern crate actix_web;
use actix_web::{web, App, HttpServer, Responder};
fn index() -> impl Responder {
"Hello world"
}
fn main() -> std::io::Result<()> {
HttpServer::new(|| App::new().service(web::resource("/").to(index)))
.bind("0.0.0.0:8080")?
.run()
}
使用(仍处于实验阶段的)Docker Buildkit，您终于可以在docker build步骤中正确缓存构建文件夹：
Dockerfile：
# syntax=docker/dockerfile:experimental
from rust
ENV HOME=/home/root
WORKDIR $HOME/app
[...]
RUN --mount=type=cache,target=/usr/local/cargo/registry
--mount=type=cache,target=/home/root/app/target
cargo build --release
然后运行：
DOCKER_BUILDKIT=1 docker build . --progress=plain
后续的 docker 构建将重用缓存中的 cargo 和目标文件夹，从而大大加快您的构建速度。
要清除 docker 缓存挂载，请执行以下操作：docker builder prune --filter type=exec.cachemount
如果您没有看到正确的缓存：如果您没有看到正确的缓存，请确保在 docker 映像中确认您的货物/注册表和目标文件夹的位置。
最小工作示例：https://github.com/benmarten/sccache-docker-test/tree/no-sccache
您可以使用cargo-chef通过多阶段构建来利用 Docker 层缓存。
FROM rust as planner
WORKDIR app
# We only pay the installation cost once,
# it will be cached from the second build onwards
RUN cargo install cargo-chef
COPY . .
RUN cargo chef prepare --recipe-path recipe.json
FROM rust as cacher
WORKDIR app
RUN cargo install cargo-chef
COPY --from=planner /app/recipe.json recipe.json
RUN cargo chef cook --release --recipe-path recipe.json
FROM rust as builder
WORKDIR app
COPY . .
# Copy over the cached dependencies
COPY --from=cacher /app/target target
RUN cargo build --release --bin app
FROM rust as runtime
WORKDIR app
COPY --from=builder /app/target/release/app /usr/local/bin
ENTRYPOINT ["./usr/local/bin/app"]
它不需要 Buildkit，适用于简单的项目和工作区。 您可以在发布公告中找到更多详细信息。
而 electronix384128 答案非常好。我想通过使用 git 为任何依赖项所需的.cargo/git添加缓存并添加多阶段 docker 示例来扩展它。
使用 rust-musl-builder 和 Docker Buildkit 功能，这在 Docker Desktop 2.4 中是默认的。在其他版本上，您可能仍需要通过以下方式启用它：DOCKER_BUILDKIT=1 docker build .
rusl-musl-builder的工作目录是/home/rust/src
尝试在--mount上设置 uid/gid，但由于目标中的权限问题而无法编译 rust。
# syntax=docker/dockerfile:1.2
FROM ekidd/rust-musl-builder:stable AS builder
COPY . .
RUN --mount=type=cache,target=/home/rust/.cargo/git
--mount=type=cache,target=/home/rust/.cargo/registry
--mount=type=cache,sharing=private,target=/home/rust/src/target
sudo chown -R rust: target /home/rust/.cargo &&
cargo build --release &&
# Copy executable out of the cache so it is available in the final image.
cp target/x86_64-unknown-linux-musl/release/my-executable ./my-executable
FROM alpine
COPY --from=builder /home/rust/src/my-executable .
USER 1000
CMD ["./my-executable"]
根据@ckaserer的回答，可以在构建应用之前RUN echo "fn main() {}" > ./src/main.rs构建依赖项。
首先只复制您的Cargo.toml和Cargo.lock文件，然后构建虚拟 main.rs 文件：
FROM rust as rust-builder
WORKDIR /usr/src/app
# Copy Cargo files
COPY ./Cargo.toml .
COPY ./Cargo.lock .
# Create fake main.rs file in src and build
RUN mkdir ./src && echo 'fn main() { println!("Dummy!"); }' > ./src/main.rs
RUN cargo build --release
然后你可以复制你的真实src目录并再次运行build：
# Copy source files over
RUN rm -rf ./src
COPY ./src ./src
# The last modified attribute of main.rs needs to be updated manually,
# otherwise cargo won't rebuild it.
RUN touch -a -m ./src/main.rs
RUN cargo build --release
然后我们可以将我们的文件复制到 debain 的苗条版本。 这是完整的 docker 文件：
FROM rust as rust-builder
WORKDIR /usr/src/app
COPY ./Cargo.toml .
COPY ./Cargo.lock .
RUN mkdir ./src && echo 'fn main() { println!("Dummy!"); }' > ./src/main.rs
RUN cargo build --release
RUN rm -rf ./src
COPY ./src ./src
RUN touch -a -m ./src/main.rs
RUN cargo build --release
FROM debian:buster-slim
COPY --from=rust-builder /usr/src/app/target/release/app /usr/local/bin/
WORKDIR /usr/local/bin
CMD ["app"]
这是对@ckaserer回答的改进，结合了评论和一些个人经历。 它不需要在存储库中创建虚拟文件，也不需要在生成时编辑 Cargo.toml 文件。
RUN echo 'fn main() { panic!("Dummy Image Called!")}' > ./src/main.rs
COPY ["Cargo.toml", "Cargo.lock", "./"]
RUN cargo build --release
COPY src src
#need to break the cargo cache
RUN touch ./src/main.rs
RUN cargo build --release
我认为问题是您的volumes定义没有进行绑定挂载。我相信您当前的配置是将HOST ./registry/复制到DOCKER /root/.cargo/registry/中，写入DOCKER /root/.cargo/registry/，并在容器关闭时丢弃内容。
相反，您需要在卷上指定bind类型：
version: "3"
services:
app:
container_name: hello-world
build: .
environment:
- CARGO_HOME=/var/www/
ports:
- '8080:8080'
volumes:
- .:/var/www/app
- type: bind
source: ./registry
target: /root/.cargo/registry
但是，请记住，还会创建一个/root/.cargo/.package-cache文件，但不会保留在此处。相反，您可以将source更改为./.cargo，并将目标更改为/root/.cargo。
对于我自己的(主要是 cli)rust 项目，我喜欢使用我为cargo编写的直接替换，我已经确认在构建之间缓存包，从而大大减少了构建时间。这可以复制到/usr/local/bin以供全局使用，也可以在单个项目中作为./cargo build运行。但请记住，此特定脚本假定应用位于容器内的/usr/src/app，因此可能需要进行调整以供使用。
这就是我所做的，它与构建脚本兼容。这是一个多阶段生成，因此它会产生一个小映像，但在第一个映像中缓存生成的依赖项。
FROM rust:1.43 AS builder
RUN apt-get update
RUN cd /tmp && USER=root cargo new --bin <projectname>
WORKDIR /tmp/<projectname>
# cache rust dependencies in docker layer
COPY Cargo.toml Cargo.lock ./
RUN touch build.rs && echo "fn main() {println!("cargo:rerun-if-changed=\"/tmp/<projectname>/build.rs\"");}" >> build.rs
RUN cargo build --release
# build the real stuff and disable cache via the ADD
ADD "https://www.random.org/cgi-bin/randbyte?nbytes=10&format=h" skipcache
COPY ./build.rs ./build.rs
# force the build.rs script to run by modifying it
RUN echo " " >> build.rs
COPY ./src ./src
RUN cargo build --release
FROM rust:1.43
WORKDIR /bin
COPY --from=builder /tmp/<projectname>/target/release/server /bin/<project binary>
RUN chmod +x ./<project binary>
CMD ./<project binary>
我遇到了与您完全相同的问题，并尝试了多种方法通过缓存依赖项来缩短构建时间。
1. @ckaserer的答案
它完成了工作，并且通过易于理解的解释来解释它为什么有效，这是一个很好的解决方案。 但是，这归结为首选项，但是如果您不以这种方式缓存依赖项，则可以遵循#2。
2. 使用cargo-chef
创建者本人@LukeMathWalker经历了使用cargo-chef所需的步骤，但这里有一个来自 github 页面的*略微调整的示例。
Dockerfile
FROM lukemathwalker/cargo-chef:latest-rust-1.60.0 AS chef
WORKDIR /app
FROM chef as planner
COPY . .
RUN cargo chef prepare --recipe-path recipe.json
FROM chef as builder
COPY --from=planner /app/recipe.json recipe.json
# Build the dependencies (and add to docker's caching layer)
# This caches the dependency files similar to how @ckaserer's solution
# does, but is handled solely through the `cargo-chef` library.
RUN cargo chef cook --release --recipe-path recipe.json
# Build the application
COPY . .
RUN cargo build --release --bin emailer
FROM debian:buster-slim AS runtime
WORKDIR /app
COPY --from=builder /app/target/release/<Name of Rust Application> /usr/local/bin
ENTRYPOINT ["/usr/local/bin/<Name of Rust Application>"]
您应该注意到上述更改的构建时间显着减少！
旁注，据我所知，这篇博客文章虽然不是关于 dockerized 构建的，但包含有关在本地机器上更快地编译 rust 应用程序的最佳信息。您可能会发现它很有帮助，因此如果您有兴趣，我建议您查看一下。
我意识到这个答案有点晚了，但是我相信我找到了一个略有不同的解决方案(尽管基本思想相同)，但它将在单个 Docker 层中创建构建依赖项，这意味着它们将被缓存 - 您可以简单地从下面复制RUN命令层：
...
COPY Cargo.toml /app/
RUN mkdir src &&
echo 'fn main() {nprintln!("Hello, world!");n}' > src/main.rs &&
cargo build &&
cargo clean --package $(awk '/name/ {gsub(/"/,""); print $3}' Cargo.toml | sed ':a;N;$!ba;s/n//g' | tr -d 'r') &&
rm -rf src
COPY src /app/src
...
首先复制Cargo.toml文件及其依赖项，然后在下面插入RUN层，然后复制实际代码。
这首先运行一个虚拟应用程序(直接从cargo init复制)，并且此包的名称与您的项目相同，然后它仅在该包上运行cargo clean，这意味着如果您添加代码并再次运行构建，则所有依赖项都已缓存，它只是重新构建您的代码。通过将整个事情组合在一个层中，如果管道进一步发生变化，它将节省时间。