Speeding up Rust SDK execution

[sondrelg]

Hi!

Thanks, first of all, to the creators of dagger. Really cool project 👏

Background

I have a short list of operations I would like my CI run to perform, for my Rust monorepo:

cargo clippy -p {{ function-name }} -- --deny warnings
cargo test -p {{ function-name }}
cargo deny --manifest-path "./functions/{{ function-name }}/Cargo.toml" check
cargo +nightly udeps -p {{ function-name }}
cargo audit

To try and make this reasonably efficient, I've first defined a Dockerfile, like this:

FROM rust:1.74.1

RUN rustup component add clippy \
    && cargo install cargo-binstall \
    && cargo binstall cargo-udeps --locked --no-confirm \
    && cargo binstall cargo-audit --locked --no-confirm \
    && cargo binstall cargo-lambda --locked --no-confirm \
    && cargo binstall sccache --locked --no-confirm

ENV RUSTC_WRAPPER="/usr/local/cargo/bin/sccache" \
    SCCACHE_DIR="/opt/sccache"

and then I've created the following Rust code:

use color_eyre::eyre;
use dagger_sdk::HostDirectoryOpts;
use std::env;
use std::process::exit;

const PROJECT: &str = "/project";

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let args: Vec<String> = env::args().collect();
    let function_name = args.get(1).expect("Missing function name argument");

    let client = dagger_sdk::connect().await?;
    let root_dir = client.host().directory_opts(
        ".",
        HostDirectoryOpts {
            exclude: Some(vec!["target"]),
            include: None,
        },
    );

    if client
        .container()
        // Build the dockerfile
        .build(client.host().directory("./ci"))
        // Mount project root
        .with_mounted_directory(PROJECT, root_dir)
        // Add caches
        .with_mounted_cache(format!("{PROJECT}/target"), client.cache_volume("target"))
        .with_mounted_cache("/usr/local/cargo/registry", client.cache_volume("cargo-registry"))
        .with_mounted_cache("/usr/local/cargo/git/db", client.cache_volume("cargo-git"))
        .with_mounted_cache("/opt/sccache", client.cache_volume("sccache"))
        // Run commands
        .with_workdir(PROJECT)
        .with_exec(vec!["cargo", "clippy", "-p", function_name, "--", "--deny", "warnings"])
        .with_exec(vec!["cargo", "test", "-p", function_name])
        .with_exec(vec!["cargo", "deny", "--manifest-path", &format!("./functions/{function_name}/Cargo.toml"), "check", ])
        .with_exec(vec!["cargo", "audit"])
        .stdout()
        .await
        .is_err()
    {
        exit(1);
    };
    Ok(())
}

My question

This seems to cache almost all steps on repeat runs, and seems to be fairly efficient. That said, a cached run still takes ~18 seconds to execute, whereas just running the steps outside of dagger takes ~4 seconds.

Are there obvious ways to improve the base runtime of the dagger pipeline, or should I expect some overhead per step, because there's just a lot of work being done on the smart-caching side?

[marcosnils]

That said, a cached run still takes ~18 seconds to execute, whereas just running the steps outside of dagger takes ~4 seconds.

that's quite strange. It definitely shouldn't take that much time. Were you able to spot which operation in your pipeline is the one that takes 18 seconds? I'd assume there's a misconfiguration somewhere that's causing the caching not to be kicking in accordingly.

[kjuulh]

From what I can see. It can be because there is a lot of data to be sent between the different docker contexts.

When you got the 4 sec time, was that just running pure cargo, or was it an image and then the commands?

It may also be because when you load the directory. It by default loads everything. I can see that it is used above, but you should be able to see it in the output how much it is loading it will say something like Transferring context (x Mbs)

[sondrelg]

It was pure cargo, yep 👍 No docker involved at all