redis-rs guide (Rust)

Connect your Rust application to a Redis database

redis-rs is the Rust client for Redis. The sections below explain how to install redis-rs and connect your application to a Redis database.

Note:

Although we provide basic documentation for redis-rs, it is a third-party client library and is not developed or supported directly by Redis.

redis-rs requires a running Redis server. See here for Redis Open Source installation instructions.

Install

To use the synchronous API, add the redis crate as a dependency in your Cargo.toml file:

[dependencies]
redis = "0.32.5"

If you want to use the asynchronous API, you should also enable either tokio or smol as your async platform:

[dependencies]
# if you use tokio
tokio = { version = "1.32.0", features = ["full"] }
redis = { version = "0.32.5", features = ["tokio-comp"] }

# if you use smol
smol = "2.0.2"
redis = { version = "0.32.5", features = ["smol-comp"] }

Connect

Start by importing the Commands or AsyncCommands trait from the redis crate:

Rust-Sync

use redis::Commands;

fn main() {
    let mut r = match redis::Client::open("redis://127.0.0.1") {
        Ok(client) => {
            match client.get_connection() {
                Ok(conn) => conn,
                Err(e) => {
                    println!("Failed to connect to Redis: {e}");
                    return;
                }
            }
        },
        Err(e) => {
            println!("Failed to create Redis client: {e}");
            return;
        }
    };

    if let Ok(res) = r.set("foo", "bar") {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting foo");
    }
    
    match r.get("foo") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> bar
        },
        Err(e) => {
            println!("Error getting foo: {e}");
            return;
        }
    };

    let hash_fields = [
        ("model", "Deimos"),
        ("brand", "Ergonom"),
        ("type", "Enduro bikes"),
        ("price", "4972"),
    ];

    if let Ok(res) = r.hset_multiple("bike:1", &hash_fields) {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting bike:1");
    }

    match r.hget("bike:1", "model") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> Deimos
        },
        Err(e) => {
            println!("Error getting bike:1 model: {e}");
            return;
        }   
    }

    match r.hget("bike:1", "price") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> 4972
        },
        Err(e) => {
            println!("Error getting bike:1 price: {e}");
            return;
        }   
    }

    match r.hgetall("bike:1") {
        Ok(res) => {
            let res: Vec<(String, String)> = res;
            for (key, value) in res {
                println!("{key}: {value}");
            }
            // >>> model: Deimos
            // >>> brand: Ergonom
            // >>> type: Enduro bikes
            // >>> price: 4972
        },
        Err(e) => {
            println!("Error getting bike:1: {e}");
            return;
        }   
    }
}

Rust-Async

use redis::AsyncCommands;

#[tokio::main]
async fn main() {
    let mut r = match redis::Client::open("redis://127.0.0.1") {
        Ok(client) => {
            match client.get_multiplexed_async_connection().await {
                Ok(conn) => conn,
                Err(e) => {
                    println!("Failed to connect to Redis: {e}");
                    return;
                }
            }
        },
        Err(e) => {
            println!("Failed to create Redis client: {e}");
            return;
        }
    };

    if let Ok(res) = r.set("foo", "bar").await {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting foo");
    }

    match r.get("foo").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> bar
        },
        Err(e) => {
            println!("Error getting foo: {e}");
            return;
        }
    };

    let hash_fields = [
        ("model", "Deimos"),
        ("brand", "Ergonom"),
        ("type", "Enduro bikes"),
        ("price", "4972"),
    ];

    if let Ok(res) = r.hset_multiple("bike:1", &hash_fields).await {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting bike:1");
    }

    match r.hget("bike:1", "model").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> Deimos
        },
        Err(e) => {
            println!("Error getting bike:1 model: {e}");
            return;
        }
    }

    match r.hget("bike:1", "price").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> 4972
        },
        Err(e) => {
            println!("Error getting bike:1 price: {e}");
            return;
        }
    }

    match r.hgetall("bike:1").await {
        Ok(res) => {
            let res: Vec<(String, String)> = res;
            for (key, value) in res {
                println!("{key}: {value}");
            }
            // >>> model: Deimos
            // >>> brand: Ergonom
            // >>> type: Enduro bikes
            // >>> price: 4972
        },
        Err(e) => {
            println!("Error getting bike:1: {e}");
            return;
        }
    }
}

The following example shows the simplest way to connect to a Redis server:

Rust-Sync

use redis::Commands;

fn main() {
    let mut r = match redis::Client::open("redis://127.0.0.1") {
        Ok(client) => {
            match client.get_connection() {
                Ok(conn) => conn,
                Err(e) => {
                    println!("Failed to connect to Redis: {e}");
                    return;
                }
            }
        },
        Err(e) => {
            println!("Failed to create Redis client: {e}");
            return;
        }
    };

    if let Ok(res) = r.set("foo", "bar") {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting foo");
    }
    
    match r.get("foo") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> bar
        },
        Err(e) => {
            println!("Error getting foo: {e}");
            return;
        }
    };

    let hash_fields = [
        ("model", "Deimos"),
        ("brand", "Ergonom"),
        ("type", "Enduro bikes"),
        ("price", "4972"),
    ];

    if let Ok(res) = r.hset_multiple("bike:1", &hash_fields) {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting bike:1");
    }

    match r.hget("bike:1", "model") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> Deimos
        },
        Err(e) => {
            println!("Error getting bike:1 model: {e}");
            return;
        }   
    }

    match r.hget("bike:1", "price") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> 4972
        },
        Err(e) => {
            println!("Error getting bike:1 price: {e}");
            return;
        }   
    }

    match r.hgetall("bike:1") {
        Ok(res) => {
            let res: Vec<(String, String)> = res;
            for (key, value) in res {
                println!("{key}: {value}");
            }
            // >>> model: Deimos
            // >>> brand: Ergonom
            // >>> type: Enduro bikes
            // >>> price: 4972
        },
        Err(e) => {
            println!("Error getting bike:1: {e}");
            return;
        }   
    }
}

Rust-Async

use redis::AsyncCommands;

#[tokio::main]
async fn main() {
    let mut r = match redis::Client::open("redis://127.0.0.1") {
        Ok(client) => {
            match client.get_multiplexed_async_connection().await {
                Ok(conn) => conn,
                Err(e) => {
                    println!("Failed to connect to Redis: {e}");
                    return;
                }
            }
        },
        Err(e) => {
            println!("Failed to create Redis client: {e}");
            return;
        }
    };

    if let Ok(res) = r.set("foo", "bar").await {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting foo");
    }

    match r.get("foo").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> bar
        },
        Err(e) => {
            println!("Error getting foo: {e}");
            return;
        }
    };

    let hash_fields = [
        ("model", "Deimos"),
        ("brand", "Ergonom"),
        ("type", "Enduro bikes"),
        ("price", "4972"),
    ];

    if let Ok(res) = r.hset_multiple("bike:1", &hash_fields).await {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting bike:1");
    }

    match r.hget("bike:1", "model").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> Deimos
        },
        Err(e) => {
            println!("Error getting bike:1 model: {e}");
            return;
        }
    }

    match r.hget("bike:1", "price").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> 4972
        },
        Err(e) => {
            println!("Error getting bike:1 price: {e}");
            return;
        }
    }

    match r.hgetall("bike:1").await {
        Ok(res) => {
            let res: Vec<(String, String)> = res;
            for (key, value) in res {
                println!("{key}: {value}");
            }
            // >>> model: Deimos
            // >>> brand: Ergonom
            // >>> type: Enduro bikes
            // >>> price: 4972
        },
        Err(e) => {
            println!("Error getting bike:1: {e}");
            return;
        }
    }
}

After connecting, you can test the connection by storing and retrieving a simple string:

Rust-Sync

use redis::Commands;

fn main() {
    let mut r = match redis::Client::open("redis://127.0.0.1") {
        Ok(client) => {
            match client.get_connection() {
                Ok(conn) => conn,
                Err(e) => {
                    println!("Failed to connect to Redis: {e}");
                    return;
                }
            }
        },
        Err(e) => {
            println!("Failed to create Redis client: {e}");
            return;
        }
    };

    if let Ok(res) = r.set("foo", "bar") {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting foo");
    }
    
    match r.get("foo") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> bar
        },
        Err(e) => {
            println!("Error getting foo: {e}");
            return;
        }
    };

    let hash_fields = [
        ("model", "Deimos"),
        ("brand", "Ergonom"),
        ("type", "Enduro bikes"),
        ("price", "4972"),
    ];

    if let Ok(res) = r.hset_multiple("bike:1", &hash_fields) {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting bike:1");
    }

    match r.hget("bike:1", "model") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> Deimos
        },
        Err(e) => {
            println!("Error getting bike:1 model: {e}");
            return;
        }   
    }

    match r.hget("bike:1", "price") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> 4972
        },
        Err(e) => {
            println!("Error getting bike:1 price: {e}");
            return;
        }   
    }

    match r.hgetall("bike:1") {
        Ok(res) => {
            let res: Vec<(String, String)> = res;
            for (key, value) in res {
                println!("{key}: {value}");
            }
            // >>> model: Deimos
            // >>> brand: Ergonom
            // >>> type: Enduro bikes
            // >>> price: 4972
        },
        Err(e) => {
            println!("Error getting bike:1: {e}");
            return;
        }   
    }
}

Rust-Async

use redis::AsyncCommands;

#[tokio::main]
async fn main() {
    let mut r = match redis::Client::open("redis://127.0.0.1") {
        Ok(client) => {
            match client.get_multiplexed_async_connection().await {
                Ok(conn) => conn,
                Err(e) => {
                    println!("Failed to connect to Redis: {e}");
                    return;
                }
            }
        },
        Err(e) => {
            println!("Failed to create Redis client: {e}");
            return;
        }
    };

    if let Ok(res) = r.set("foo", "bar").await {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting foo");
    }

    match r.get("foo").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> bar
        },
        Err(e) => {
            println!("Error getting foo: {e}");
            return;
        }
    };

    let hash_fields = [
        ("model", "Deimos"),
        ("brand", "Ergonom"),
        ("type", "Enduro bikes"),
        ("price", "4972"),
    ];

    if let Ok(res) = r.hset_multiple("bike:1", &hash_fields).await {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting bike:1");
    }

    match r.hget("bike:1", "model").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> Deimos
        },
        Err(e) => {
            println!("Error getting bike:1 model: {e}");
            return;
        }
    }

    match r.hget("bike:1", "price").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> 4972
        },
        Err(e) => {
            println!("Error getting bike:1 price: {e}");
            return;
        }
    }

    match r.hgetall("bike:1").await {
        Ok(res) => {
            let res: Vec<(String, String)> = res;
            for (key, value) in res {
                println!("{key}: {value}");
            }
            // >>> model: Deimos
            // >>> brand: Ergonom
            // >>> type: Enduro bikes
            // >>> price: 4972
        },
        Err(e) => {
            println!("Error getting bike:1: {e}");
            return;
        }
    }
}

You can also easily store and retrieve a hash:

Rust-Sync

use redis::Commands;

fn main() {
    let mut r = match redis::Client::open("redis://127.0.0.1") {
        Ok(client) => {
            match client.get_connection() {
                Ok(conn) => conn,
                Err(e) => {
                    println!("Failed to connect to Redis: {e}");
                    return;
                }
            }
        },
        Err(e) => {
            println!("Failed to create Redis client: {e}");
            return;
        }
    };

    if let Ok(res) = r.set("foo", "bar") {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting foo");
    }
    
    match r.get("foo") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> bar
        },
        Err(e) => {
            println!("Error getting foo: {e}");
            return;
        }
    };

    let hash_fields = [
        ("model", "Deimos"),
        ("brand", "Ergonom"),
        ("type", "Enduro bikes"),
        ("price", "4972"),
    ];

    if let Ok(res) = r.hset_multiple("bike:1", &hash_fields) {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting bike:1");
    }

    match r.hget("bike:1", "model") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> Deimos
        },
        Err(e) => {
            println!("Error getting bike:1 model: {e}");
            return;
        }   
    }

    match r.hget("bike:1", "price") {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> 4972
        },
        Err(e) => {
            println!("Error getting bike:1 price: {e}");
            return;
        }   
    }

    match r.hgetall("bike:1") {
        Ok(res) => {
            let res: Vec<(String, String)> = res;
            for (key, value) in res {
                println!("{key}: {value}");
            }
            // >>> model: Deimos
            // >>> brand: Ergonom
            // >>> type: Enduro bikes
            // >>> price: 4972
        },
        Err(e) => {
            println!("Error getting bike:1: {e}");
            return;
        }   
    }
}

Rust-Async

use redis::AsyncCommands;

#[tokio::main]
async fn main() {
    let mut r = match redis::Client::open("redis://127.0.0.1") {
        Ok(client) => {
            match client.get_multiplexed_async_connection().await {
                Ok(conn) => conn,
                Err(e) => {
                    println!("Failed to connect to Redis: {e}");
                    return;
                }
            }
        },
        Err(e) => {
            println!("Failed to create Redis client: {e}");
            return;
        }
    };

    if let Ok(res) = r.set("foo", "bar").await {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting foo");
    }

    match r.get("foo").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> bar
        },
        Err(e) => {
            println!("Error getting foo: {e}");
            return;
        }
    };

    let hash_fields = [
        ("model", "Deimos"),
        ("brand", "Ergonom"),
        ("type", "Enduro bikes"),
        ("price", "4972"),
    ];

    if let Ok(res) = r.hset_multiple("bike:1", &hash_fields).await {
        let res: String = res;
        println!("{res}"); // >>> OK
    } else {
        println!("Error setting bike:1");
    }

    match r.hget("bike:1", "model").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> Deimos
        },
        Err(e) => {
            println!("Error getting bike:1 model: {e}");
            return;
        }
    }

    match r.hget("bike:1", "price").await {
        Ok(res) => {
            let res: String = res;
            println!("{res}"); // >>> 4972
        },
        Err(e) => {
            println!("Error getting bike:1 price: {e}");
            return;
        }
    }

    match r.hgetall("bike:1").await {
        Ok(res) => {
            let res: Vec<(String, String)> = res;
            for (key, value) in res {
                println!("{key}: {value}");
            }
            // >>> model: Deimos
            // >>> brand: Ergonom
            // >>> type: Enduro bikes
            // >>> price: 4972
        },
        Err(e) => {
            println!("Error getting bike:1: {e}");
            return;
        }
    }
}

More information

See the redis-rs documentation and the GitHub repository for more information and examples.

Products

Tools

Get Redis

Connect

Learn

Latest

See how it works

redis-rs guide (Rust)

Install

Connect

More information

On this page