Vivek Shukla - Rust

How I Use Cargo Workspace to structure my Rust projects

2025-09-03T00:00:00+00:00

I’ve learn to use Cargo Workspace from Olivia’s post in bluesky</a>, which you should checkout. This article is a way of self-documenting since I’ve come back to it more often. </blockquote>
🔗</a>What is a Cargo Workspace</h2>
A cargo workspace is collection of one or more library or binary crates. Cargo workspace let’s you break your rust project into multiple different crates (or packages), which may aid you in better project structure and management.
🔗</a>Why use Cargo Workspace</h2>

Your rust project has grown big and is hard to manage</li>
Multiple people work on a project, so breaking your project into multiple crates can help with better ownership and less conflict among developers</li>
You want to reduce your project’s compile time</li> </ul>

Read this (external link): Cutting Down Rust Compile Times From 30 to 2 Minutes With One Thousand Crates</a> </blockquote>
🔗</a>Creating a Workspace</h2>
Create a new workspace directory
mkdir runner cd runner</code></pre> Now create Cargo.toml</code> with following content
[workspace] resolver = "3"</code></pre> Here we are using resolver</code> version 3, which is the latest version and comes in Rust 2024 edition (Rust 1.84+). Resolver tells cargo how to resolve the dependencies.
🔗</a>Create a binary crate</h3> We are going to use cargo new</code> command to create a binary crate. When no argument is passed, cargo new command will create binary crate by default, you can use --lib</code> as argument to create library crate or --bin</code> to explicit that you want binary crate. cargo new run</code></pre> Now your workspace will look like this: . ├── Cargo.toml └── run ├── Cargo.toml └── src └── main.rs</code></pre> If you look at your workspace’s Cargo.toml</code> you will notice that cargo has already added the newly added crate run</code> against the members</code> key. [workspace] resolver = "3" members = ["run"]</code></pre>🔗</a>Adding lib crates</h3> Let’s add two lib crates cargo new participant --lib cargo new track --lib</code></pre> Updated structure: . ├── Cargo.lock ├── Cargo.toml ├── participant │ ├── Cargo.toml │ └── src │ └── lib.rs ├── run │ ├── Cargo.toml │ └── src │ └── main.rs └── track ├── Cargo.toml └── src └── lib.rs</code></pre>🔗</a>Adding dependencies</h3> If you try to simply add a dependency like this cargo add uuid --features v4</code></pre> ‼️ it will fail and you will see this error error: `cargo add` could not determine which package to modify. Use the `--package` option to specify a package. available packages: participant, run, track</code></pre> Since inside our Cargo workspace we have 3 packages, therefore cargo is unable to determine to which package dependency belongs to. ✅ We can solve this by using --package</code> arg. cargo add uuid --features v4 --package participant</code></pre>🔗</a>Dependency Resolution</h3> Since in cargo workspace we can have multiple crates, which means we have to add dependency to each crate separately and in that sometimes there may be a version mismatch. Like with uuid</code> in participant</code> crate, it is using version 1.18.1</code> and now you if you try to add uuid</code> of different version in run</code> crate, for example if we want to stick to only 1.17</code> version of the uuid</code> crate: cargo add uuid@=1.17 --features v4 --package run</code></pre> But wait, we got error error: failed to select a version for `uuid`. ... required by package `run v0.1.0 (/home/vivek/Documents/code/hands-on/runner/run)` versions that meet the requirements `=1.17` are: 1.17.0 all possible versions conflict with previously selected packages. previously selected package `uuid v1.18.1` ... which satisfies dependency `uuid = "^1.18.1"` of package `participant v0.1.0 (/home/vivek/Documents/code/hands-on/runner/participant)` failed to select a version for `uuid` which could resolve this conflict</code></pre> It’s because a Cargo workspace can only have one Cargo.lock</code> file, which is shared between all the members of the workspace, so it can only have one version of the dependency across the workspace. So instead of pinning to =1.17</code> version of uuid, we had used just 1.17</code>, cargo would have choosen uuid@1.18.1</code> since that was already being used by participant</code> crate. In order to resolve the dependency across workspace, cargo will try to find the most suitable version of a crate, mostly by downgrading to the appropriate version. </blockquote> 🔗</a>Better way to declare dependency</h3> It’s very normal to have common dependencies across crates, that is why Cargo Workspace let us declare dependencies in workspace’s Cargo.toml</code> and then you can re-use the same dependency inside of your crate. # Cargo.toml [workspace.dependencies] uuid = { version = "=1.17", features = ["v4"] }</code></pre> And then in your crates you can use the dependency with: # participant/Cargo.toml [dependencies] uuid = { workspace = true } # run/Cargo.toml [dependencies] uuid = { workspace = true }</code></pre>🔗</a>Importing members as dependencies</h3> A common way to import a crate (or package) inside another crate is like this: # run/Cargo.toml [dependencies] participant = { path = "../participant" } track = { path = "../track" } # track/Cargo.toml [dependencies] participant = { path = "../participant" }</code></pre> But now if you had to do this for each of the crate in your project and sometime there can be a lot of crates. Also the path is relative to the current Cargo.toml file, so if you dare re-structure your workspace, it can backfire and you will have another mess to deal with. However we can use the same way of delcaring the dependency in the workspace’s Cargo.toml</code> and then just use it inside the members by telling cargo to use workspace’s dependency. # Cargo.toml [workspace] resolver = "3" members = ["participant", "run", "track"] [workspace.dependencies] participant = { path = "participant" } track = { path = "track" } # run/Cargo.toml [dependencies] participant = { workspace = true } track = { workspace = true } # track/Cargo.toml [dependencies] participant = { workspace = true }</code></pre>🔗</a>Multiple Binaries</h3> When you have multiple binaries in your workspace, cargo run</code> won’t work since it doesn’t know which binary crate to run. So instead explicitly pass the crate name: cargo run --package my_bin_crate</code></pre>🔗</a>Cheat sheet</h2> Create workspace: # Cargo.toml [workspace] resolver = "3"</code></pre> Adding bin and lib to workspace: # creates binary crate cargo new my_bin # crates lib crate cargo new my_lib --lib</code></pre> Importing dependencies: # Add dependencies in workspace's Cargo.toml [workspace.dependencies] uuid = { version = "=1.17", features = ["v4"] } # import in members like this: my_lib/Cargo.toml [dependencies] uuid = { workspace = true }</code></pre> Import members like this: # Cargo.toml [workspace] resolver = "3" members = ["my_bin", "my_lib"] [workspace.dependencies] my_lib = { path = "my_lib" } # my_bin/Cargo.toml [dependencies] my_lib = { workspace = true }</code></pre> Other commands: # run if multiple binaries exist cargo run --package my_bin # build specific binary cargo build --package my_bin # build all cargo build --all # test all cargo test --all</code></pre>



How I use Postgres DB as Key Value Store in Rust with SQLx
2025-09-02T00:00:00+00:00
For my smaller application (or personal) or when I’m starting out a new app, I would like to keep the dependencies of my program to minimum. Since I’m going to need a DB anyway, so instead of using Redis and adding one more component to my tech stack, I would like to use Postgres</a> as my key value store.</p>
Prematurely thinking about scaling your system when you don’t even know if it would be successful enough to actually need all those bells and whistle is sure way to extend the deadline and procrastinate.</p>
🔗</a>Overview</h2>
We are going to create a trait</code> called PgStore</code>, which will implement all the functions to set, get, pop and delete the value.</p>
Then you can implement this trait for your own types. Your types must derive serde’s Serialize</code> and Deserialize</code> for this to work.</p>
🔗</a>Dependencies</h2>
You need the following dependencies in your Cargo.toml</code></p>
chrono</span> =</span> { version</span> =</span> "0.4"</span>,</span> features</span> =</span> [</span>"serde"</span>] }</span></span>
serde</span> =</span> { version</span> =</span> "1.0"</span>,</span> features</span> =</span> [</span>"derive"</span>] }</span></span>
serde_json</span> =</span> { version</span> =</span> "1.0"</span> }</span></span>
sqlx</span> =</span> { version</span> =</span> "0.8"</span>,</span> features</span> =</span> [</span></span>
    "runtime-tokio"</span>,</span></span>
    "tls-rustls-ring-native-roots"</span>,</span></span>
    "migrate"</span>,</span></span>
    "postgres"</span>,</span></span>
    "macros"</span>,</span></span>
    "chrono"</span>,</span></span>
] }</span></span></code></pre>🔗</a>Creating static PgPool connection</h2>
I don’t like to pass around DB connection across functions or threads or tasks. Instead I like to use tokio’s OnceCell</code> which is a thread safe Cell which can be written to only once, it’s thread safe which means we can use async code in it.</p>
use</span> sqlx</span>::</span>PgPool</span>;</span></span>
use</span> tokio</span>::</span>sync</span>::</span>OnceCell</span>;</span></span>
</span>
static</span> PG_POOL</span>:</span> OnceCell</span><</span>PgPool</span>></span> =</span> OnceCell</span>::</span>const_new</span>();</span></span>
</span>
pub async fn</span> pg_pool</span>()</span> -> &</span>'</span>static PgPool</span> {</span></span>
    PG_POOL</span></span>
        .</span>get_or_init</span>(</span>async</span> ||</span> {</span></span>
            PgPool</span>::</span>connect</span>(</span>std</span>::</span>env</span>(</span>"DATABASE_URL"</span>)</span>.</span>expect</span>(</span>"DATABASE_URL is not set"</span>))</span></span>
                .</span>await</span></span>
                .</span>expect</span>(</span>"❌ PgPool connection failed"</span>)</span></span>
        })</span></span>
        .</span>await</span></span>
}</span></span></code></pre>
Now we can just use pg_pool().await</code> to fetch the db pool connection wherever we need.</p>
🔗</a>DB Migration</h2>
We are creating a new table kv_store</code> in our Postgres DB. If you notice we are using UNLOGGED</code> keyword to create the table, this tells postgres to not write WAL (write-ahead log) for kv_store</code> table, which improves the performance at the expanse of data durability.</p>
CREATE</span> UNLOGGED </span>TABLE</span> "kv_store"</span> (</span></span>
    "key"</span> VARCHAR</span>(</span>2048</span>)</span> PRIMARY KEY</span>,</span></span>
    "value"</span> TEXT NOT NULL</span>,</span></span>
    "expires"</span> TIMESTAMPTZ NOT NULL</span></span>
);</span></span></code></pre>🔗</a>PgStore Trait</h2>
We are creating PgStore</code> trait which will have methods to store, retrieve and delete the value in the kv_store</code> table.</p>
use</span> chrono</span>::</span>{</span>DateTime</span>,</span> Utc</span>};</span></span>
use</span> serde</span>::</span>Serialize</span>;</span></span>
use</span> serde</span>::</span>de</span>::</span>DeserializeOwned</span>;</span></span>
use</span> std</span>::</span>time</span>::</span>Duration</span>;</span></span>
</span>
#[allow(async_fn_in_trait)]</span></span>
pub trait</span> PgStore</span>:</span> Serialize</span> +</span> DeserializeOwned</span> {</span></span>
    const</span> EXPIRE_IN</span>:</span> usize</span>;</span> // seconds</span></span>
</span>
    fn</span> key_format</span>(key</span>:</span> String</span>)</span> -></span> String</span>;</span></span>
</span>
    fn</span> get_expire_time</span>()</span> -></span> DateTime</span><</span>Utc</span>> {</span></span>
        Utc</span>::</span>now</span>()</span> +</span> Duration</span>::</span>from_secs</span>(</span>Self</span>::</span>EXPIRE_IN</span> as</span> u64</span>)</span></span>
    }</span></span>
</span>
    async fn</span> set_ex</span>(</span>&</span>self</span>, key</span>:</span> String</span>)</span> -></span> Result</span><(),</span> String</span>> {</span></span>
        let</span> value</span> =</span></span>
            serde_json</span>::</span>to_string</span>(</span>&</span>self</span>)</span>.</span>map_err</span>(</span>|</span>_</span>|</span> "Failed to serialize value."</span>.</span>to_string</span>())</span>?</span>;</span></span>
</span>
        sqlx</span>::</span>query!</span>(</span></span>
            r#"INSERT INTO kv_store ("key", "value", expires) VALUES ($1, $2, $3)</span></span>
            ON CONFLICT ("key") DO UPDATE SET "value" = $2, expires = $3"#</span>,</span></span>
            Self</span>::</span>key_format</span>(key),</span></span>
            value,</span></span>
            Self</span>::</span>get_expire_time</span>(),</span></span>
        )</span></span>
        .</span>execute</span>(</span>db</span>::</span>pg_pool</span>()</span>.</span>await</span>)</span></span>
        .</span>await</span></span>
        .</span>map_err</span>(</span>|</span>_</span>|</span> "Failed to set value in kv_store"</span>.</span>to_string</span>())</span>?</span>;</span></span>
</span>
        Ok</span>(())</span></span>
    }</span></span>
</span>
    // it will just fetch the value if it exists</span></span>
    async fn</span> get</span>(key</span>:</span> String</span>)</span> -></span> Result</span><</span>Self</span>,</span> String</span>> {</span></span>
        let</span> record</span> =</span> sqlx</span>::</span>query!</span>(</span></span>
            r#"SELECT "value" FROM kv_store WHERE "key" = $1"#</span>,</span></span>
            Self</span>::</span>key_format</span>(key)</span></span>
        )</span></span>
        .</span>fetch_one</span>(</span>db</span>::</span>pg_pool</span>()</span>.</span>await</span>)</span></span>
        .</span>await</span></span>
        .</span>map_err</span>(</span>|</span>_</span>|</span> "Failed to get value from kv_store"</span>.</span>to_string</span>())</span>?</span>;</span></span>
</span>
        serde_json</span>::</span>from_str</span>(</span>&</span>record</span>.</span>value)</span>.</span>map_err</span>(</span>|</span>_</span>|</span> "Failed to deserialize value"</span>.</span>to_string</span>())</span></span>
    }</span></span>
</span>
    // this will fetch the value while extending the expire time</span></span>
    async fn</span> get_ex</span>(key</span>:</span> String</span>)</span> -></span> Result</span><</span>Self</span>,</span> String</span>> {</span></span>
        let</span> record</span> =</span> sqlx</span>::</span>query!</span>(</span></span>
            r#"UPDATE kv_store SET expires=$2 WHERE "key"=$1 RETURNING "value""#</span>,</span></span>
            Self</span>::</span>key_format</span>(key),</span></span>
            Self</span>::</span>get_expire_time</span>(),</span></span>
        )</span></span>
        .</span>fetch_one</span>(</span>db</span>::</span>pg_pool</span>()</span>.</span>await</span>)</span></span>
        .</span>await</span></span>
        .</span>map_err</span>(</span>|</span>_</span>|</span> "Failed to get value from kv_store"</span>.</span>to_string</span>())</span>?</span>;</span></span>
</span>
        serde_json</span>::</span>from_str</span>(</span>&</span>record</span>.</span>value)</span>.</span>map_err</span>(</span>|</span>_</span>|</span> "Failed to deserialize value"</span>.</span>to_string</span>())</span></span>
    }</span></span>
</span>
    // it will fetch the value while deleting the key</span></span>
    async fn</span> get_del</span>(key</span>:</span> String</span>)</span> -></span> Result</span><</span>Self</span>,</span> String</span>> {</span></span>
        let</span> record</span> =</span> sqlx</span>::</span>query!</span>(</span></span>
            r#"DELETE FROM kv_store WHERE key=$1 RETURNING "value""#</span>,</span></span>
            Self</span>::</span>key_format</span>(key)</span></span>
        )</span></span>
        .</span>fetch_one</span>(</span>db</span>::</span>pg_pool</span>()</span>.</span>await</span>)</span></span>
        .</span>await</span></span>
        .</span>map_err</span>(</span>|</span>_</span>|</span> "Failed to get value from kv_store"</span>.</span>to_string</span>())</span>?</span>;</span></span>
</span>
        serde_json</span>::</span>from_str</span>(</span>&</span>record</span>.</span>value)</span>.</span>map_err</span>(</span>|</span>_</span>|</span> "Failed to deserialize value"</span>.</span>to_string</span>())</span></span>
    }</span></span>
</span>
    async fn</span> del</span>(key</span>:</span> String</span>)</span> -></span> Result</span><(),</span> String</span>> {</span></span>
        sqlx</span>::</span>query!</span>(</span></span>
            r#"DELETE FROM kv_store WHERE key=$1"#</span>,</span></span>
            Self</span>::</span>key_format</span>(key)</span></span>
        )</span></span>
        .</span>execute</span>(</span>db</span>::</span>pg_pool</span>()</span>.</span>await</span>)</span></span>
        .</span>await</span></span>
        .</span>map_err</span>(</span>|</span>_</span>|</span> "Failed to delete value"</span>.</span>to_string</span>())</span>?</span>;</span></span>
</span>
        Ok</span>(())</span></span>
    }</span></span>
}</span></span></code></pre>
By defining our trait like PgStore: Serialize + DeserializeOwned</code>, we are telling that whichever type is going to implement PgStore</code> trait it must also have Serialize</code> and DeserializeOwned</code> implemented.</p>
Following are the brief explaination of PgStore</code>’s attributes:</p>
EXPIRE_IN:</strong> This will be used to set the to be expired in seconds. It must be implemented by the Type you are using it for.</p>
key_format:</strong> This function needs to be implemented. It will be used as a way to generate key.</p>
set_ex:</strong> This method will store the type against the passed key in DB, overwriting value if it already exists.</p>
get:</strong> It will fetch the value for a given key, error will be returned if it does not exist.</p>
get_ex:</strong> Fetches the value while resetting the expire time.</p>
get_del:</strong> Fetch the value while deleting the key. It’s more like pop.</p>
del:</strong> Just deletes the value. Doesn’t return error even if key doesn’t exist.</p>
🔗</a>Cleaning up expired keys</h2>
Then we have a helper function pgstore_cleanup</code> which will cleanup expired keys every 60 seconds. You must spawn to run this function in the background for all the time your program is running.</p>
pub async fn</span> pgstore_cleanup</span>() {</span></span>
    loop</span> {</span></span>
        // tracing::info!("🟡 PgStore cleanup is running...");</span></span>
        sqlx</span>::</span>query!</span>(</span>r#"DELETE FROM kv_store WHERE expires < NOW()"#</span>)</span></span>
            .</span>execute</span>(</span>db</span>::</span>pg_pool</span>()</span>.</span>await</span>)</span></span>
            .</span>await</span></span>
            .</span>ok</span>();</span></span>
        tokio</span>::</span>time</span>::</span>sleep</span>(</span>Duration</span>::</span>from_secs</span>(</span>60</span>))</span>.</span>await</span>;</span></span>
    }</span></span>
}</span></span></code></pre>🔗</a>Usage</h2>
#[derive(serde</span>::</span>Serialize</span>, serde</span>::</span>Deserialize</span>)]</span></span>
pub struct</span> Game</span> {</span></span>
    pub</span> id</span>:</span> usize</span>,</span></span>
    pub</span> name</span>:</span> String</span>,</span></span>
    pub</span> genre</span>:</span> String</span>,</span></span>
}</span></span>
</span>
impl</span> PgStore</span> for</span> Game</span> {</span></span>
    const</span> EXPIRE_IN</span>:</span> usize</span> =</span> 3600</span>;</span></span>
</span>
    fn</span> key_format</span>(key</span>:</span> String</span>)</span> -></span> String</span> {</span></span>
        format!</span>(</span>"game-{}"</span>, key)</span></span>
    }</span></span>
}</span></span>
</span>
#[tokio</span>::</span>main]</span></span>
async fn</span> main</span>() {</span></span>
    // make sure to run this to delete expired keys regularly</span></span>
    tokio</span>::</span>spawn</span>(</span>pgstore_cleanup</span>());</span></span>
</span>
    let</span> game</span> =</span> Game</span> {</span></span>
        id</span>:</span> 1</span>,</span></span>
        name</span>:</span> "Skyrim"</span>.</span>to_string</span>(),</span></span>
        genre</span>:</span> "rpg"</span>.</span>to_string</span>(),</span></span>
    };</span></span>
</span>
    // storing value in kv_store</span></span>
    // it will be store with key: "game-1"</span></span>
    let</span> _</span> =</span> game</span>.</span>set_ex</span>(game</span>.</span>id</span>.</span>to_string</span>())</span>.</span>await</span>;</span></span>
</span>
    // fetching value</span></span>
    if let</span> Ok</span>(v)</span> =</span> Game</span>::</span>get</span>(</span>1</span>.</span>to_string</span>())</span>.</span>await</span> {</span></span>
        println!</span>(</span>"fetched game with name: {}"</span>, v</span>.</span>name);</span></span>
    }</span></span>
</span>
    // deleting key</span></span>
    let</span> _</span> =</span> Game</span>::</span>del</span>(</span>1</span>.</span>to_string</span>())</span>.</span>await</span>;</span></span>
}</span></span></code></pre>
Similarly you can do this with your own types, as long as they derive serde’s Serialize and Deserialize.</p>


Minify HTML in Axum Middleware
2025-09-01T00:00:00+00:00
Minifying HTML is one of the simplest way to save bandwidth and decrease the time in transit. We can easily lower page size by 30-50% by minifying HTML.</p>
We will be using minify-html</a> crate for this. With the use of Axum middleware, minification will be applied to all the eligible routes.</p>
Using axum middleware for HTML minification is template agnostic which means it will work with any template engine such as Askama, Tera, Maud, etc., as long as response type is HTML, it should work fine.</p>
Cargo.toml</strong></p>
Add minify-html</code> to your Cargo.toml.</p>
...</span></span>
minify</span>-</span>html</span> =</span> "0.16.4"</span></span>
...</span></span></code></pre>🔗</a>Basic Usage of minify-html</h2>
minify-html provides minify</code> function which accepts array of bytes and reference to configuration struct which tells it how to minify.</p>
let</span> cfg</span> =</span> minify_html</span>::</span>Cfg</span> {</span></span>
        keep_closing_tags</span>:</span> true</span>,</span></span>
        keep_html_and_head_opening_tags</span>:</span> true</span>,</span></span>
        keep_comments</span>:</span> false</span>,</span></span>
        minify_doctype</span>:</span> false</span>,</span></span>
        minify_css</span>:</span> true</span>,</span></span>
        minify_js</span>:</span> true</span>,</span></span>
        ..</span>Default</span>::</span>default</span>()</span></span>
    };</span></span>
</span>
let mut</span> code</span>: &</span>[</span>u8</span>]</span> =</span> b"<p>  Hello, world!  </p>"</span>;</span></span>
let</span> minified</span> =</span> minify_html</span>::</span>minify</span>(</span>&</span>code,</span> &</span>cfg);</span></span>
assert_eq!</span>(minified,</span> b"<p>Hello, world!</p>"</span>.</span>to_vec</span>());</span></span></code></pre>🔗</a>Creating Axum Middleware</h2>
We are using Axum’s axum::middleware::map_response</code> middleware to modify the response on the fly by passing an async function.</p>
Steps to be performed by middleware:</strong></p>

Only move forward if the Content-Type</code> header of the reponse is text/html</code></li>
Use into_parts</code> method of response to consume the response body give out parts (headers, status code, etc.) and body (actual html content)</li>
Using to_bytes</code> function we collect and convert axum::body::Body</code> type into Bytes</code></li>
Then using minify_html::minify</code> function we minify the html</li>
Finally build the new response using Response::from_parts</code> with the parts that we extracted earlier and new body (minified html)</li>
</ol>
use</span> std</span>::</span>sync</span>::</span>LazyLock</span>;</span></span>
use</span> axum</span>::</span>{</span></span>
    body</span>::</span>{</span>Body</span>, to_bytes},</span></span>
    http</span>::</span>header,</span></span>
    response</span>::</span>Response</span>,</span></span>
};</span></span>
</span>
static</span> MINIFY_CFG</span>:</span> LazyLock</span><minify_html</span>::</span>Cfg</span>></span> =</span> LazyLock</span>::</span>new</span>(</span>||</span> minify_html</span>::</span>Cfg</span> {</span></span>
    keep_closing_tags</span>:</span> true</span>,</span></span>
    keep_html_and_head_opening_tags</span>:</span> true</span>,</span></span>
    minify_doctype</span>:</span> false</span>,</span></span>
    minify_css</span>:</span> true</span>,</span></span>
    minify_js</span>:</span> true</span>,</span></span>
    ..</span>Default</span>::</span>default</span>()</span></span>
});</span></span>
</span>
pub async fn</span> minify_html_response</span>(response</span>:</span> Response</span><</span>Body</span>>)</span> -></span> Response</span><</span>Body</span>> {</span></span>
    let</span> content_type</span> =</span> response</span></span>
        .</span>headers</span>()</span></span>
        .</span>get</span>(</span>header</span>::</span>CONTENT_TYPE</span>)</span></span>
        .</span>map</span>(</span>|</span>h</span>|</span> h</span>.</span>to_str</span>()</span>.</span>unwrap_or_default</span>())</span></span>
        .</span>unwrap_or_default</span>();</span></span>
</span>
    if</span> content_type</span>.</span>contains</span>(</span>"text/html"</span>) {</span></span>
        let</span> (parts, body)</span> =</span> response</span>.</span>into_parts</span>();</span></span>
        let</span> bytes</span> =</span> to_bytes</span>(body,</span> usize</span>::</span>MAX</span>)</span>.</span>await</span>.</span>unwrap_or_default</span>();</span></span>
        let</span> minified</span> =</span> minify_html</span>::</span>minify</span>(</span>&</span>bytes,</span> &</span>MINIFY_CFG</span>);</span></span>
        let</span> new_response</span> =</span> Response</span>::</span>from_parts</span>(parts,</span> Body</span>::</span>from</span>(minified));</span></span>
        return</span> new_response;</span></span>
    }</span></span>
</span>
    response</span></span>
}</span></span></code></pre>
Note: We are using LazyLock</code> to initialize minify_html::Cfg</code> only once, since we are going to need the reference to it for each minify call.</p>
Plugging into the Router:</strong></p>
let</span> router</span> =</span> axum</span>::</span>Router</span>::</span>new</span>()</span></span>
    .</span>route</span>(</span>"/"</span>,</span> get</span>(index_page))</span></span>
    .</span>layer</span>(</span>axum</span>::</span>middleware</span>::</span>map_response</span>(minify_html_response));</span></span></code></pre>🔗</a>Benchmark</h2>
I’ve done very basic benchmarking on this</p>
Overhead:</strong> The overhead of extracting response body and minifying adds around 600</code> to 800</code> µs.</p>
Size Reduction:</strong> This will be varied for everyone and depends on the content they serve. However, I’ve consistently seen at least 30% reduction in HTML document size.</p>


Ed25519 Key Pair Generation in Rust
2025-06-20T00:00:00+00:00
🔗</a>Cargo.toml</h2>
[</span>dependencies</span>]</span></span>
ssh-key</span> =</span> { version</span> =</span> "0.6"</span>,</span> features</span> =</span> [</span>"ed25519"</span>,</span> "rsa"</span>] }</span></span></code></pre>🔗</a>main.rs</h2>
use</span> ssh_key</span>::</span>{</span>LineEnding</span>,</span> PrivateKey</span>,</span> rand_core</span>::</span>OsRng</span>};</span></span>
use</span> std</span>::</span>fs;</span></span>
use</span> std</span>::</span>path</span>::</span>PathBuf</span>;</span></span>
use</span> std</span>::</span>time</span>::</span>Instant</span>;</span></span>
</span>
fn</span> generate_ed25519_key_pair</span>(</span></span>
    path_prefix</span>: &</span>str</span>,</span></span>
    comment</span>: &</span>str</span>,</span></span>
)</span> -></span> Result</span><(),</span> Box</span><</span>dyn</span> std</span>::</span>error</span>::</span>Error</span>>> {</span></span>
    let</span> timer</span> =</span> Instant</span>::</span>now</span>();</span></span>
    let mut</span> private_key</span> =</span> PrivateKey</span>::</span>random</span>(</span>&</span>mut</span> OsRng</span>,</span> ssh_key</span>::</span>Algorithm</span>::</span>Ed25519</span>)</span>?</span>;</span></span>
    private_key</span>.</span>set_comment</span>(comment);</span></span>
</span>
    let</span> private_key_bytes</span> =</span> private_key</span>.</span>to_openssh</span>(</span>LineEnding</span>::</span>LF</span>)</span>?</span>;</span></span>
    let</span> public_key_bytes</span> =</span> private_key</span>.</span>public_key</span>()</span>.</span>to_openssh</span>()</span>?</span>;</span></span>
</span>
    let</span> private_path</span> =</span> PathBuf</span>::</span>from</span>(</span>format!</span>(</span>"{}_ed25519"</span>, path_prefix));</span></span>
    let</span> public_path</span> =</span> PathBuf</span>::</span>from</span>(</span>format!</span>(</span>"{}_ed25519.pub"</span>, path_prefix));</span></span>
    fs</span>::</span>write</span>(</span>&</span>private_path, private_key_bytes)</span>?</span>;</span></span>
    fs</span>::</span>write</span>(</span>&</span>public_path, public_key_bytes)</span>?</span>;</span></span>
</span>
    println!</span>(</span>"Generated Ed25519 key pair:"</span>);</span></span>
    println!</span>(</span>"Private key: {}"</span>, private_path</span>.</span>display</span>());</span></span>
    println!</span>(</span>"Public key: {}"</span>, public_path</span>.</span>display</span>());</span></span>
    println!</span>(</span>"Time Elapsed: {}ms"</span>, timer</span>.</span>elapsed</span>()</span>.</span>as_millis</span>());</span></span>
</span>
    Ok</span>(())</span></span>
}</span></span>
</span>
fn</span> main</span>() {</span></span>
    match</span> generate_ed25519_key_pair</span>(</span>"id"</span>,</span> "example@localhost"</span>) {</span></span>
        Ok</span>(_)</span> =></span> println!</span>(</span>"Successfully generated Ed25519 key pair without passphrase."</span>),</span></span>
        Err</span>(e)</span> =></span> eprintln!</span>(</span>"Error generating Ed25519 key pair: {}"</span>, e),</span></span>
    }</span></span>
}</span></span></code></pre>


Rust Release Build & Publish
2025-06-15T00:00:00+00:00
docker</span> run</span> --rm -it</span> ubuntu /bin/bash</span></span></code></pre># Environment Variables</span></span>
# | Key                   | Purpose                                                          |</span></span>
# | --------------------- | ---------------------------------------------------------------- |</span></span>
# | DEPLOY_KEY            | Private SSH key (public key must be added in Github)                                                  |</span></span>
# | REPO_URL              | Github repository url (ssh)                                      |</span></span>
# | BINARY_NAME           | Binary name in Cargo.toml                                        |</span></span>
# | RCLONE_CONFIG_CONTENT | Contents of the Rclone config. Name must be "remote_destination" |</span></span>
# | RCLONE_COPY_PATH      | Path of the bucket where you want to copy the file               |</span></span>
</span>
# Rclone Config Example</span></span>
# ```</span></span>
# [remote_destination]</span></span>
# type = s3</span></span>
# provider = Other</span></span>
# access_key_id =</span></span>
# secret_access_key =</span></span>
# endpoint =</span></span>
# acl = public-read</span></span>
# ```</span></span>
</span>
export</span> DEBIAN_FRONTEND</span>=</span>noninteractive</span></span>
</span>
apt</span> update</span></span>
</span>
apt</span> install</span> -y</span> build-essential libssl-dev pkg-config curl git openssh-client unzip</span></span>
</span>
curl</span> --proto</span> '=https'</span> --tlsv1.2 -sSf</span> https://sh.rustup.rs</span> |</span> sh</span> -s -- -y</span></span>
.</span> "</span>$HOME</span>/.cargo/env"</span></span>
</span>
curl</span> https://rclone.org/install.sh</span> |</span> bash</span></span>
</span>
export</span> RCLONE_CONFIG</span>=</span>"/rclone.conf"</span></span>
</span>
echo</span> "</span>$RCLONE_CONFIG_CONTENT</span>"</span> ></span> $RCLONE_CONFIG</span></span>
</span>
mkdir</span> -p</span> /root/.ssh</span></span>
</span>
echo</span> "</span>$DEPLOY_KEY</span>"</span> ></span> /root/.ssh/deploy_key</span></span>
</span>
chmod</span> 600</span> /root/.ssh/deploy_key</span></span>
</span>
ssh-keyscan</span> github.com</span> >></span> /root/.ssh/known_hosts</span></span>
</span>
chmod</span> 600</span> /root/.ssh/known_hosts</span></span>
</span>
mkdir</span> -p</span> /app</span></span>
</span>
GIT_SSH_COMMAND</span>=</span>"ssh -i /root/.ssh/deploy_key"</span> git</span> clone</span> $REPO_URL</span> /app</span></span>
</span>
cd</span> /app</span></span>
</span>
FULL_NAME</span>=</span>$BINARY_NAME</span>-</span>$(</span>uname</span> -s</span> |</span> tr</span> '[:upper:]' '[:lower:]'</span>)</span>-</span>$(</span>uname</span> -m</span> |</span> sed</span> -e</span> 's/x86_64/amd64/'</span> -e</span> 's/armv6l/arm/'</span> -e</span> 's/armv7l/arm/'</span> -e</span> 's/aarch64/arm64/'</span>)</span></span>
</span>
cargo</span> build</span> --release</span> &&</span> \</span></span>
    cp</span> target/release/</span>$BINARY_NAME $FULL_NAME</span></span>
</span>
rclone</span> copy "</span>$FULL_NAME</span>" remote_destination:"</span>$RCLONE_COPY_PATH</span>"</span></span></code></pre>


Using SQLite Database in Rust with Sqlx
2025-04-13T00:00:00+00:00
SQLite is self-contained, file based relational database. If you have a simple use case and want to avoid complex databases then SQLite is one of the best choice.</p>
We will use sqlx</code> crate</a> to interact with SQLite database.</p>
Why Sqlx?</p>

Async support</li>
Supports migrations</li>
Compile time type safety</li>
Supports SQLite, Postgres and MySQL</li>
</ul>
🔗</a>Setup</h2>
cargo</span> init sqlite-demo</span></span></code></pre>🔗</a>Cargo.toml</h3>
Add the following dependencies to your Cargo.toml</code> file. We are using tokio runtime</a> and sqlite features of sqlx</code>.</p>
[</span>package</span>]</span></span>
name</span> =</span> "sqlite-demo"</span></span>
version</span> =</span> "0.1.0"</span></span>
edition</span> =</span> "2024"</span></span>
</span>
[</span>dependencies</span>]</span></span>
sqlx</span> =</span> { version</span> =</span> "0.8"</span>,</span> features</span> =</span> [</span></span>
    "runtime-tokio"</span>,</span></span>
    "sqlite"</span>,</span></span>
    "migrate"</span>,</span></span>
] }</span></span>
tokio</span> =</span> { version</span> =</span> "1.44.2"</span>,</span> features</span> =</span> [</span>"full"</span>] }</span></span></code></pre>🔗</a>Connect to SQLite Database</h2>
Here we are using SqliteConnectOptions</code> to connect to SQLite database. We are also creating the database file if it doesn’t exist. We are using SqliteJournalMode::Delete</code> to delete the journal file after commit so that we will only have one file in the database directory.</p>
Since we want file based database, we are using sqlite://main.db</code> as connection string. For memory based database, we can use sqlite::memory:</code> as connection string.</p>
use</span> sqlx</span>::</span>{</span>ConnectOptions</span>,</span> Connection</span>,</span> sqlite</span>::</span>SqliteConnectOptions</span>};</span></span>
use</span> std</span>::</span>str</span>::</span>FromStr</span>;</span></span>
</span>
#[tokio</span>::</span>main]</span></span>
async fn</span> main</span>() {</span></span>
    let mut</span> conn</span> =</span> SqliteConnectOptions</span>::</span>from_str</span>(</span>"sqlite://main.db"</span>)</span></span>
        .</span>unwrap</span>()</span></span>
        .</span>create_if_missing</span>(</span>true</span>)</span></span>
        .</span>journal_mode</span>(</span>sqlx</span>::</span>sqlite</span>::</span>SqliteJournalMode</span>::</span>Delete</span>)</span></span>
        .</span>connect</span>()</span></span>
        .</span>await</span></span>
        .</span>expect</span>(</span>"Failed to connect to database"</span>);</span></span>
</span>
    // Create the users table if it doesn't exist</span></span>
    sqlx</span>::</span>query</span>(</span></span>
        "CREATE TABLE IF NOT EXISTS users (</span></span>
            id INTEGER PRIMARY KEY AUTOINCREMENT,</span></span>
            name TEXT NOT NULL,</span></span>
            age INTEGER</span></span>
        )"</span>,</span></span>
    )</span></span>
    .</span>execute</span>(</span>&</span>mut</span> conn)</span></span>
    .</span>await</span></span>
    .</span>unwrap</span>();</span></span>
</span>
    let</span> _</span> =</span> conn</span>.</span>close</span>()</span>.</span>await</span>;</span></span>
}</span></span></code></pre>🔗</a>Creating Connection Pool</h2>
We will use SqlitePoolOptions</code></a> to create a connection pool.</p>
We will create a helper function db_conn</code> to create a connection pool. This function will return a connection pool that can be used to interact with the database.</p>
use</span> sqlx</span>::</span>{</span></span>
    Pool</span>,</span> Sqlite</span>,</span></span>
    sqlite</span>::</span>{</span>SqliteConnectOptions</span>,</span> SqlitePoolOptions</span>},</span></span>
};</span></span>
use</span> std</span>::</span>{</span>str</span>::</span>FromStr</span>,</span> time</span>::</span>Duration</span>};</span></span>
</span>
#[tokio</span>::</span>main]</span></span>
async fn</span> main</span>() {</span></span>
    let</span> conn</span> =</span> db_conn</span>()</span>.</span>await</span>;</span></span>
</span>
    // Create the users table if it doesn't exist</span></span>
    sqlx</span>::</span>query</span>(</span></span>
        "CREATE TABLE IF NOT EXISTS users (</span></span>
            id INTEGER PRIMARY KEY AUTOINCREMENT,</span></span>
            name TEXT NOT NULL,</span></span>
            age INTEGER</span></span>
        )"</span>,</span></span>
    )</span></span>
    .</span>execute</span>(</span>&</span>conn)</span></span>
    .</span>await</span></span>
    .</span>unwrap</span>();</span></span>
</span>
    let</span> _</span> =</span> conn</span>.</span>close</span>()</span>.</span>await</span>;</span></span>
}</span></span>
</span>
async fn</span> db_conn</span>()</span> -></span> Pool</span><</span>Sqlite</span>> {</span></span>
    let</span> db_url</span> =</span> "sqlite://main.db"</span>;</span></span>
</span>
    SqlitePoolOptions</span>::</span>new</span>()</span></span>
        .</span>max_connections</span>(</span>20</span>)</span></span>
        .</span>idle_timeout</span>(</span>Duration</span>::</span>from_secs</span>(</span>60</span>))</span></span>
        .</span>acquire_timeout</span>(</span>Duration</span>::</span>from_secs</span>(</span>5</span>))</span></span>
        .</span>connect_with</span>(</span></span>
            SqliteConnectOptions</span>::</span>from_str</span>(db_url)</span></span>
                .</span>unwrap</span>()</span></span>
                .</span>create_if_missing</span>(</span>true</span>)</span></span>
                .</span>journal_mode</span>(</span>sqlx</span>::</span>sqlite</span>::</span>SqliteJournalMode</span>::</span>Delete</span>),</span></span>
        )</span></span>
        .</span>await</span></span>
        .</span>unwrap</span>()</span></span>
}</span></span></code></pre>🔗</a>Using OnceCell to create a connection pool</h2>
We can use OnceCell</code></a> to create a connection pool. This will ensure that the connection pool is created only once and can be shared across multiple threads. So that we won’t to pass connection pool to every function, we can just use this helper function to get the connection pool and it will re-use the same one.</p>
use</span> sqlx</span>::</span>{</span></span>
    Pool</span>,</span> Sqlite</span>,</span></span>
    sqlite</span>::</span>{</span>SqliteConnectOptions</span>,</span> SqlitePoolOptions</span>},</span></span>
};</span></span>
use</span> std</span>::</span>{</span>str</span>::</span>FromStr</span>,</span> time</span>::</span>Duration</span>};</span></span>
use</span> tokio</span>::</span>sync</span>::</span>OnceCell</span>;</span></span>
</span>
static</span> DB_CONN</span>:</span> OnceCell</span><</span>Pool</span><</span>Sqlite</span>>></span> =</span> OnceCell</span>::</span>const_new</span>();</span></span>
</span>
async fn</span> db_conn</span>()</span> -></span> Pool</span><</span>Sqlite</span>> {</span></span>
    let</span> db_url</span> =</span> "sqlite://main.db"</span>;</span></span>
</span>
    DB_CONN</span></span>
        .</span>get_or_init</span>(</span>||</span> async</span> {</span></span>
            SqlitePoolOptions</span>::</span>new</span>()</span></span>
                .</span>max_connections</span>(</span>20</span>)</span></span>
                .</span>idle_timeout</span>(</span>Duration</span>::</span>from_secs</span>(</span>60</span>))</span></span>
                .</span>acquire_timeout</span>(</span>Duration</span>::</span>from_secs</span>(</span>5</span>))</span></span>
                .</span>connect_with</span>(</span></span>
                    SqliteConnectOptions</span>::</span>from_str</span>(db_url)</span></span>
                        .</span>unwrap</span>()</span></span>
                        .</span>create_if_missing</span>(</span>true</span>)</span></span>
                        .</span>journal_mode</span>(</span>sqlx</span>::</span>sqlite</span>::</span>SqliteJournalMode</span>::</span>Delete</span>),</span></span>
                )</span></span>
                .</span>await</span></span>
                .</span>unwrap</span>()</span></span>
        })</span></span>
        .</span>await</span></span>
        .</span>clone</span>()</span></span>
}</span></span></code></pre>🔗</a>Handling Database Migrations</h2>
We will use sqlx-cli</code></a> to handle migrations.</p>
cargo</span> install sqlx-cli</span></span></code></pre>
Create migration file for users table.</p>
sqlx</span> migrate add users</span></span></code></pre>
This will create a migration file in migrations</code> directory with empty migration file for users table. Add the following content to the newly created migration file.</p>
-- Add migration script here</span></span>
CREATE TABLE</span> IF</span> NOT EXISTS</span> users (</span></span>
    id </span>INTEGER PRIMARY KEY</span> AUTOINCREMENT,</span></span>
    name TEXT NOT NULL</span>,</span></span>
    age </span>INTEGER</span></span>
);</span></span></code></pre>
Embed the migration file in the executable.</p>
use</span> sqlx</span>::</span>{</span></span>
    Pool</span>,</span> Sqlite</span>,</span></span>
    sqlite</span>::</span>{</span>SqliteConnectOptions</span>,</span> SqlitePoolOptions</span>},</span></span>
};</span></span>
use</span> std</span>::</span>{</span>str</span>::</span>FromStr</span>,</span> time</span>::</span>Duration</span>};</span></span>
use</span> tokio</span>::</span>sync</span>::</span>OnceCell</span>;</span></span>
</span>
#[tokio</span>::</span>main]</span></span>
async fn</span> main</span>() {</span></span>
    // this will make sure migrations are added to the executable</span></span>
    sqlx</span>::</span>migrate!</span>()</span></span>
        .</span>run</span>(</span>&</span>db_conn</span>()</span>.</span>await</span>)</span></span>
        .</span>await</span></span>
        .</span>expect</span>(</span>"Migrations went wrong :("</span>);</span></span>
}</span></span>
</span>
static</span> DB_CONN</span>:</span> OnceCell</span><</span>Pool</span><</span>Sqlite</span>>></span> =</span> OnceCell</span>::</span>const_new</span>();</span></span>
</span>
async fn</span> db_conn</span>()</span> -></span> Pool</span><</span>Sqlite</span>> {</span></span>
    let</span> db_url</span> =</span> "sqlite://main.db"</span>;</span></span>
</span>
    DB_CONN</span></span>
        .</span>get_or_init</span>(</span>||</span> async</span> {</span></span>
            SqlitePoolOptions</span>::</span>new</span>()</span></span>
                .</span>max_connections</span>(</span>20</span>)</span></span>
                .</span>idle_timeout</span>(</span>Duration</span>::</span>from_secs</span>(</span>60</span>))</span></span>
                .</span>acquire_timeout</span>(</span>Duration</span>::</span>from_secs</span>(</span>5</span>))</span></span>
                .</span>connect_with</span>(</span></span>
                    SqliteConnectOptions</span>::</span>from_str</span>(db_url)</span></span>
                        .</span>unwrap</span>()</span></span>
                        .</span>create_if_missing</span>(</span>true</span>)</span></span>
                        .</span>journal_mode</span>(</span>sqlx</span>::</span>sqlite</span>::</span>SqliteJournalMode</span>::</span>Delete</span>),</span></span>
                )</span></span>
                .</span>await</span></span>
                .</span>unwrap</span>()</span></span>
        })</span></span>
        .</span>await</span></span>
        .</span>clone</span>()</span></span>
}</span></span></code></pre>🔗</a>Full Code with Example Queries</h2>
main.rs</strong></p>
use</span> sqlx</span>::</span>{</span></span>
    Pool</span>,</span> Row</span>,</span> Sqlite</span>,</span></span>
    prelude</span>::</span>FromRow</span>,</span></span>
    sqlite</span>::</span>{</span>SqliteConnectOptions</span>,</span> SqlitePoolOptions</span>},</span></span>
};</span></span>
use</span> std</span>::</span>{</span>str</span>::</span>FromStr</span>,</span> time</span>::</span>Duration</span>};</span></span>
use</span> tokio</span>::</span>sync</span>::</span>OnceCell</span>;</span></span>
</span>
#[tokio</span>::</span>main]</span></span>
async fn</span> main</span>() {</span></span>
    sqlx</span>::</span>migrate!</span>()</span></span>
        .</span>run</span>(</span>&</span>db_conn</span>()</span>.</span>await</span>)</span></span>
        .</span>await</span></span>
        .</span>expect</span>(</span>"❌ Migrations went wrong :("</span>);</span></span>
</span>
    sqlx</span>::</span>query</span>(</span>"INSERT INTO users (name, age) VALUES (?, ?)"</span>)</span> // Use ? for placeholders</span></span>
        .</span>bind</span>(</span>"Alice"</span>)</span></span>
        .</span>bind</span>(</span>30</span>)</span></span>
        .</span>execute</span>(</span>&</span>db_conn</span>()</span>.</span>await</span>)</span></span>
        .</span>await</span></span>
        .</span>unwrap</span>();</span></span>
</span>
    let</span> query</span> =</span> sqlx</span>::</span>query</span>(</span>"SELECT count(*) AS count FROM users"</span>)</span></span>
        .</span>fetch_one</span>(</span>&</span>db_conn</span>()</span>.</span>await</span>)</span></span>
        .</span>await</span></span>
        .</span>unwrap</span>();</span></span>
</span>
    println!</span>(</span>"Count: {:?}"</span>, query</span>.</span>get</span>::</span><</span>i64</span>,</span> &</span>str</span>>(</span>"count"</span>));</span></span>
</span>
    let</span> users</span> =</span> sqlx</span>::</span>query_as</span>::</span><_,</span> User</span>>(</span>"SELECT id, name, age FROM users"</span>)</span></span>
        .</span>fetch_all</span>(</span>&</span>db_conn</span>()</span>.</span>await</span>)</span></span>
        .</span>await</span></span>
        .</span>unwrap</span>();</span></span>
</span>
    for</span> user</span> in</span> users {</span></span>
        println!</span>(</span>"Found user: {:?}"</span>, user);</span></span>
    }</span></span>
}</span></span>
</span>
static</span> DB_CONN</span>:</span> OnceCell</span><</span>Pool</span><</span>Sqlite</span>>></span> =</span> OnceCell</span>::</span>const_new</span>();</span></span>
</span>
async fn</span> db_conn</span>()</span> -></span> Pool</span><</span>Sqlite</span>> {</span></span>
    let</span> db_url</span> =</span> "sqlite://main.db"</span>;</span></span>
</span>
    DB_CONN</span></span>
        .</span>get_or_init</span>(</span>||</span> async</span> {</span></span>
            SqlitePoolOptions</span>::</span>new</span>()</span></span>
                .</span>max_connections</span>(</span>20</span>)</span></span>
                .</span>idle_timeout</span>(</span>Duration</span>::</span>from_secs</span>(</span>60</span>))</span></span>
                .</span>acquire_timeout</span>(</span>Duration</span>::</span>from_secs</span>(</span>5</span>))</span></span>
                .</span>connect_with</span>(</span></span>
                    SqliteConnectOptions</span>::</span>from_str</span>(db_url)</span></span>
                        .</span>unwrap</span>()</span></span>
                        .</span>create_if_missing</span>(</span>true</span>)</span></span>
                        .</span>journal_mode</span>(</span>sqlx</span>::</span>sqlite</span>::</span>SqliteJournalMode</span>::</span>Delete</span>),</span></span>
                )</span></span>
                .</span>await</span></span>
                .</span>unwrap</span>()</span></span>
        })</span></span>
        .</span>await</span></span>
        .</span>clone</span>()</span></span>
}</span></span>
</span>
#[derive(</span>Debug</span>,</span> FromRow</span>)]</span></span>
struct</span> User</span> {</span></span>
    id</span>:</span> i64</span>,</span></span>
    name</span>:</span> String</span>,</span></span>
    age</span>:</span> Option</span><</span>i32</span>>,</span></span>
}</span></span></code></pre>


Delete All Rust Target Dirs
2025-03-18T00:00:00+00:00
#!/bin/bash</span></span>
</span>
# Function to delete the 'target' directory recursively</span></span>
delete_target</span>() {</span></span>
    local</span> dir</span>=</span>"</span>$1</span>"</span></span>
</span>
    # Loop through all items in the current directory</span></span>
    for</span> item</span> in</span> "</span>$dir</span>"/*</span>;</span> do</span></span>
        if</span> [[</span> -d</span> "</span>$item</span>"</span> ]]</span>;</span> then</span></span>
            # If the item is a directory, check if it's named 'target'</span></span>
            if</span> [[ $(</span>basename</span> "</span>$item</span>"</span>)</span> ==</span> "target"</span> ]]</span>;</span> then</span></span>
                echo</span> "Deleting directory: </span>$item</span>"</span></span>
                rm</span> -rf</span> "</span>$item</span>"</span></span>
            else</span></span>
                # If not 'target', recurse into this directory</span></span>
                delete_target</span> "</span>$item</span>"</span></span>
            fi</span></span>
        fi</span></span>
    done</span></span>
}</span></span>
</span>
# Start the recursive deletion from the current directory</span></span>
delete_target</span> "."</span></span>
</span>
# Check if the current directory itself is named 'target'</span></span>
if</span> [[ $(</span>basename</span> "</span>$PWD</span>"</span>)</span> ==</span> "target"</span> ]]</span>;</span> then</span></span>
    echo</span> "The current directory is named 'target'. It cannot be deleted from within itself."</span></span>
    echo</span> "Please run this script from outside the 'target' directory if you wish to delete it."</span></span>
fi</span></span></code></pre>


AES Encryption in Rust
2024-03-22T00:00:00+00:00
What we will cover</strong></p>

Brief explanation of AES encryption</li>
AES-256 encryption and decryption</li>
Full Rust code for AES-256 encryption</li>
</ul>
🔗</a>Introduction</h2>
AES stands for Advanced Encryption Standard. It is a type of Symmetric key encryption algorithm, which means the same key is used for encryption and decryption.</p>
In this tutorial we will use aes-gcm</a> crate from Rust Crypto</a>.</p>
There are 3 type of AES encryption: AES-128, AES-192 and AES-256, which represents encryption Key</em> of length 128 bit (16 byte), 192 bit (24 byte) and 256 bit (32 byte) respectively.</p>
Both are pretty secure and hard to crack but for obvious reasons AES-256 is the most secure one.</p>
AES encryption requires key and nonce (for gcm variant) to encrypt/decrypt the data.</p>
🔗</a>Key</h2>
Key means encryption key, which is used to encrypt and decrypt the data. Length of the key matters, AES-128 requires key of 16 byte and AES-256 requires key of 32 byte.</p>
For the simplicity from now on we will focus on AES-256, but the core concept is similar even for AES-128.</p>
Key is byte array of length 32, where each element is of 1 byte. We can either generate the key using aes-gcm crate itself or we can use our own key. It’s prefferable to use our own key, so let’s see it in action:</p>
Create new crypto</em> project and add aes-gcm crate.</p>
cargo</span> new crypto</span></span>
cargo</span> add aes-gcm</span></span></code></pre>
main.rs</em></p>
use</span> aes_gcm</span>::</span>{</span></span>
    aead</span>::</span>{</span>Aead</span>,</span> AeadCore</span>,</span> KeyInit</span>,</span> OsRng</span>},</span></span>
    Aes256Gcm</span>,</span> Key</span>,</span> Nonce</span></span>
};</span></span>
</span>
fn</span> main</span>() {</span></span>
    let</span> key_str</span> =</span> "thiskeystrmustbe32charlongtowork"</span>;</span></span>
    let</span> key</span> =</span> Key</span>::</span><</span>Aes256Gcm</span>></span>::</span>from_slice</span>(key_str</span>.</span>as_bytes</span>());</span></span>
}</span></span></code></pre>
It’s important that the string/str used for key must be 32 char long, since AES-256 requires key length of 32 byte.</p>
Note: If you want to use key string of any length (less or more than 32), you can use Key Derivation Function to generate secure 32 byte long key. Argon2, PBKDF2 are some of the fitting choices for this.</p>
🔗</a>Nonce</h2>
Nonce means “number used only once”. It is an array of random numbers (type: u8) that is unique to each operation. For AES encryption the required size of Nonce is 12 byte.</p>
For each encryption operation the same key can be used but the Nonce must be unique</u>, so we generate Nonce each time we encrypt data.</p>
Since nonce is required to decrypt the data, it is stored along with the encrypted data itself.</p>
let</span> nonce</span> =</span> Aes256Gcm</span>::</span>generate_nonce</span>(</span>&</span>mut</span> OsRng</span>);</span></span></code></pre>🔗</a>Encryption</h2>
We will create encrypt</code> function which will take key_str and plaintext string. This will make our code more readable and easy to use.</p>
use</span> aes_gcm</span>::</span>{</span></span>
    aead</span>::</span>{</span>Aead</span>,</span> AeadCore</span>,</span> KeyInit</span>,</span> OsRng</span>},</span></span>
    Aes256Gcm</span>,</span> Key</span>,</span> Nonce</span></span>
};</span></span>
</span>
fn</span> main</span>() {</span></span>
    let</span> plaintext</span> =</span> "vivekshuk.la"</span>.</span>to_string</span>();</span></span>
</span>
    let</span> key_str</span> =</span> "thiskeystrmustbe32charlongtowork"</span>.</span>to_string</span>();</span></span>
</span>
    let</span> encrypted_data</span> =</span> encrypt</span>(key_str, plaintext);</span></span>
}</span></span>
</span>
fn</span> encrypt</span>(key_str</span>:</span> String</span>, plaintext</span>:</span> String</span>)</span> -></span> Vec</span><</span>u8</span>> {</span></span>
    let</span> key</span> =</span> Key</span>::</span><</span>Aes256Gcm</span>></span>::</span>from_slice</span>(key_str</span>.</span>as_bytes</span>());</span></span>
    let</span> nonce</span> =</span> Aes256Gcm</span>::</span>generate_nonce</span>(</span>&</span>mut</span> OsRng</span>);</span></span>
</span>
    let</span> cipher</span> =</span> Aes256Gcm</span>::</span>new</span>(key);</span></span>
</span>
    let</span> ciphered_data</span> =</span> cipher</span>.</span>encrypt</span>(</span>&</span>nonce, plaintext</span>.</span>as_bytes</span>())</span></span>
        .</span>expect</span>(</span>"failed to encrypt"</span>);</span></span>
</span>
    // combining nonce and encrypted data together</span></span>
    // for storage purpose</span></span>
    let mut</span> encrypted_data</span>:</span> Vec</span><</span>u8</span>></span> =</span> nonce</span>.</span>to_vec</span>();</span></span>
    encrypted_data</span>.</span>extend_from_slice</span>(</span>&</span>ciphered_data);</span></span>
</span>
    encrypted_data</span></span>
}</span></span></code></pre>
Here we are:</p>

creating instance of Aes256Gcm</code> with our encryption key, which will be used for encryption.</li>
we need to convert our plaintext from string to byte array for the encrypt</code> method.</li>
combine nonce and ciphered_data together</li>
</ul>
🔗</a>Decryption</h2>
Here first we will separate out nonce and ciphered data by splitting encrypted data vector at 12th position (because we used nonce of length 12).</p>
Then we create Nonce instance from our nonce array that we got.</p>
After decrypting we will get byte array which we can pass to String::from_utf8</code> function to create our original string value back.</p>
fn</span> decrypt</span>(key_str</span>:</span> String</span>, encrypted_data</span>:</span> Vec</span><</span>u8</span>>)</span> -></span> String</span> {</span></span>
    let</span> key</span> =</span> Key</span>::</span><</span>Aes256Gcm</span>></span>::</span>from_slice</span>(key_str</span>.</span>as_bytes</span>());</span></span>
</span>
    let</span> (nonce_arr, ciphered_data)</span> =</span> encrypted_data</span>.</span>split_at</span>(</span>12</span>);</span></span>
    let</span> nonce</span> =</span> Nonce</span>::</span>from_slice</span>(nonce_arr);</span></span>
</span>
    let</span> cipher</span> =</span> Aes256Gcm</span>::</span>new</span>(key);</span></span>
</span>
    let</span> plaintext</span> =</span> cipher</span>.</span>decrypt</span>(nonce, ciphered_data)</span></span>
        .</span>expect</span>(</span>"failed to decrypt data"</span>);</span></span>
</span>
    String</span>::</span>from_utf8</span>(plaintext)</span></span>
        .</span>expect</span>(</span>"failed to convert vector of bytes to string"</span>)</span></span>
}</span></span></code></pre>🔗</a>Storage</h2>
There is one issue you might encounter that the encrypt function will give out Vector of numbers (u8), which is not easy to store. Of course you might convert it to string by joining them with comma but it’s not good solution.</p>
To solve this we can convert our vector of numbers to hex string, this will make storage and operation much easier for us.</p>
Let’s install hex</code> crate for this.</p>
cargo</span> add hex</span></span></code></pre>
hex</code> crate provides encode</code> (vec to string) and decode</code> (string to vec) function for easy conversion.</p>
let</span> encoded_string</span> =</span> hex</span>::</span>encode</span>(encrypted_data);</span></span>
</span>
let</span> decoded_vec</span> =</span> hex</span>::</span>decode</span>(encoded_string)</span></span>
    .</span>expect</span>(</span>"failed to decode hex string into vec"</span>);</span></span></code></pre>🔗</a>Full Code</h2>
In this final version we have made few changes to incorporate hex</code> conversion within the encrypt</code> and decrypt</code> function itself.</p>
use</span> aes_gcm</span>::</span>{</span></span>
    aead</span>::</span>{</span>Aead</span>,</span> AeadCore</span>,</span> KeyInit</span>,</span> OsRng</span>},</span></span>
    Aes256Gcm</span>,</span> Key</span>,</span> Nonce</span></span>
};</span></span>
</span>
fn</span> main</span>() {</span></span>
    let</span> plaintext</span> =</span> "vivekshuk.la"</span>.</span>to_string</span>();</span></span>
</span>
    let</span> key_str</span> =</span> "thiskeystrmustbe32charlongtowork"</span>.</span>to_string</span>();</span></span>
</span>
    let</span> encrypted_data</span> =</span> encrypt</span>(key_str</span>.</span>clone</span>(), plaintext);</span></span>
</span>
    println!</span>(</span>"encrypted_data: {:?}"</span>, encrypted_data</span>.</span>clone</span>());</span></span>
</span>
    let</span> original</span> =</span> decrypt</span>(key_str, encrypted_data);</span></span>
</span>
    println!</span>(</span>"original: {:?}"</span>, original);</span></span>
}</span></span>
</span>
fn</span> encrypt</span>(key_str</span>:</span> String</span>, plaintext</span>:</span> String</span>)</span> -></span> String</span> {</span></span>
    let</span> key</span> =</span> Key</span>::</span><</span>Aes256Gcm</span>></span>::</span>from_slice</span>(key_str</span>.</span>as_bytes</span>());</span></span>
    let</span> nonce</span> =</span> Aes256Gcm</span>::</span>generate_nonce</span>(</span>&</span>mut</span> OsRng</span>);</span></span>
</span>
    let</span> cipher</span> =</span> Aes256Gcm</span>::</span>new</span>(key);</span></span>
</span>
    let</span> ciphered_data</span> =</span> cipher</span>.</span>encrypt</span>(</span>&</span>nonce, plaintext</span>.</span>as_bytes</span>())</span></span>
        .</span>expect</span>(</span>"failed to encrypt"</span>);</span></span>
</span>
    // combining nonce and encrypted data together</span></span>
    // for storage purpose</span></span>
    let mut</span> encrypted_data</span>:</span> Vec</span><</span>u8</span>></span> =</span> nonce</span>.</span>to_vec</span>();</span></span>
    encrypted_data</span>.</span>extend_from_slice</span>(</span>&</span>ciphered_data);</span></span>
</span>
    hex</span>::</span>encode</span>(encrypted_data)</span></span>
}</span></span>
</span>
fn</span> decrypt</span>(key_str</span>:</span> String</span>, encrypted_data</span>:</span> String</span>)</span> -></span> String</span> {</span></span>
    let</span> encrypted_data</span> =</span> hex</span>::</span>decode</span>(encrypted_data)</span></span>
        .</span>expect</span>(</span>"failed to decode hex string into vec"</span>);</span></span>
</span>
    let</span> key</span> =</span> Key</span>::</span><</span>Aes256Gcm</span>></span>::</span>from_slice</span>(key_str</span>.</span>as_bytes</span>());</span></span>
</span>
    let</span> (nonce_arr, ciphered_data)</span> =</span> encrypted_data</span>.</span>split_at</span>(</span>12</span>);</span></span>
    let</span> nonce</span> =</span> Nonce</span>::</span>from_slice</span>(nonce_arr);</span></span>
</span>
    let</span> cipher</span> =</span> Aes256Gcm</span>::</span>new</span>(key);</span></span>
</span>
    let</span> plaintext</span> =</span> cipher</span>.</span>decrypt</span>(nonce, ciphered_data)</span></span>
        .</span>expect</span>(</span>"failed to decrypt data"</span>);</span></span>
</span>
    String</span>::</span>from_utf8</span>(plaintext)</span></span>
        .</span>expect</span>(</span>"failed to convert vector of bytes to string"</span>)</span></span>
}</span></span></code></pre>

Vivek Shukla - Rust

How I Use Cargo Workspace to structure my Rust projects

🔗</a>Why use Cargo Workspace</h2> Your rust project has grown big and is hard to manage</li> Multiple people work on a project, so breaking your project into multiple crates can help with better ownership and less conflict among developers</li>

How I use Postgres DB as Key Value Store in Rust with SQLx

Minify HTML in Axum Middleware

Ed25519 Key Pair Generation in Rust

Rust Release Build & Publish

Using SQLite Database in Rust with Sqlx

Delete All Rust Target Dirs

AES Encryption in Rust