[フレーム]
Docs Pricing
Login Book a meeting Try Redis

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:

mod landing_tests{useredis::Commands;fn run(){letmutr=matchredis::Client::open("redis://127.0.0.1"){Ok(client)=>{matchclient.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;}};ifletOk(res)=r.set("foo","bar"){letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting foo");}matchr.get("foo"){Ok(res)=>{letres: String =res;println!("{res}");// >>> bar
},Err(e)=>{println!("Error getting foo: {e}");return;}};lethash_fields=[("model","Deimos"),("brand","Ergonom"),("type","Enduro bikes"),("price","4972"),];ifletOk(res)=r.hset_multiple("bike:1",&hash_fields){letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting bike:1");}matchr.hget("bike:1","model"){Ok(res)=>{letres: String =res;println!("{res}");// >>> Deimos
},Err(e)=>{println!("Error getting bike:1 model: {e}");return;}}matchr.hget("bike:1","price"){Ok(res)=>{letres: String =res;println!("{res}");// >>> 4972
},Err(e)=>{println!("Error getting bike:1 price: {e}");return;}}matchr.hgetall("bike:1"){Ok(res)=>{letres: Vec<(String,String)>=res;for(key,value)inres{println!("{key}: {value}");}// >>> model: Deimos
// >>> brand: Ergonom
// >>> type: Enduro bikes
// >>> price: 4972
},Err(e)=>{println!("Error getting bike:1: {e}");return;}}}}
Rust-Sync Quick-Start 
mod tests{useredis::AsyncCommands;asyncfn run(){letmutr=matchredis::Client::open("redis://127.0.0.1"){Ok(client)=>{matchclient.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;}};ifletOk(res)=r.set("foo","bar").await{letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting foo");}matchr.get("foo").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> bar
},Err(e)=>{println!("Error getting foo: {e}");return;}};lethash_fields=[("model","Deimos"),("brand","Ergonom"),("type","Enduro bikes"),("price","4972"),];ifletOk(res)=r.hset_multiple("bike:1",&hash_fields).await{letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting bike:1");}matchr.hget("bike:1","model").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> Deimos
},Err(e)=>{println!("Error getting bike:1 model: {e}");return;}}matchr.hget("bike:1","price").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> 4972
},Err(e)=>{println!("Error getting bike:1 price: {e}");return;}}matchr.hgetall("bike:1").await{Ok(res)=>{letres: Vec<(String,String)>=res;for(key,value)inres{println!("{key}: {value}");}// >>> model: Deimos
// >>> brand: Ergonom
// >>> type: Enduro bikes
// >>> price: 4972
},Err(e)=>{println!("Error getting bike:1: {e}");return;}}}}
Rust-Async Quick-Start

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

mod landing_tests{useredis::Commands;fn run(){letmutr=matchredis::Client::open("redis://127.0.0.1"){Ok(client)=>{matchclient.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;}};ifletOk(res)=r.set("foo","bar"){letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting foo");}matchr.get("foo"){Ok(res)=>{letres: String =res;println!("{res}");// >>> bar
},Err(e)=>{println!("Error getting foo: {e}");return;}};lethash_fields=[("model","Deimos"),("brand","Ergonom"),("type","Enduro bikes"),("price","4972"),];ifletOk(res)=r.hset_multiple("bike:1",&hash_fields){letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting bike:1");}matchr.hget("bike:1","model"){Ok(res)=>{letres: String =res;println!("{res}");// >>> Deimos
},Err(e)=>{println!("Error getting bike:1 model: {e}");return;}}matchr.hget("bike:1","price"){Ok(res)=>{letres: String =res;println!("{res}");// >>> 4972
},Err(e)=>{println!("Error getting bike:1 price: {e}");return;}}matchr.hgetall("bike:1"){Ok(res)=>{letres: Vec<(String,String)>=res;for(key,value)inres{println!("{key}: {value}");}// >>> model: Deimos
// >>> brand: Ergonom
// >>> type: Enduro bikes
// >>> price: 4972
},Err(e)=>{println!("Error getting bike:1: {e}");return;}}}}
Rust-Sync Quick-Start 
mod tests{useredis::AsyncCommands;asyncfn run(){letmutr=matchredis::Client::open("redis://127.0.0.1"){Ok(client)=>{matchclient.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;}};ifletOk(res)=r.set("foo","bar").await{letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting foo");}matchr.get("foo").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> bar
},Err(e)=>{println!("Error getting foo: {e}");return;}};lethash_fields=[("model","Deimos"),("brand","Ergonom"),("type","Enduro bikes"),("price","4972"),];ifletOk(res)=r.hset_multiple("bike:1",&hash_fields).await{letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting bike:1");}matchr.hget("bike:1","model").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> Deimos
},Err(e)=>{println!("Error getting bike:1 model: {e}");return;}}matchr.hget("bike:1","price").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> 4972
},Err(e)=>{println!("Error getting bike:1 price: {e}");return;}}matchr.hgetall("bike:1").await{Ok(res)=>{letres: Vec<(String,String)>=res;for(key,value)inres{println!("{key}: {value}");}// >>> model: Deimos
// >>> brand: Ergonom
// >>> type: Enduro bikes
// >>> price: 4972
},Err(e)=>{println!("Error getting bike:1: {e}");return;}}}}
Rust-Async Quick-Start

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

mod landing_tests{useredis::Commands;fn run(){letmutr=matchredis::Client::open("redis://127.0.0.1"){Ok(client)=>{matchclient.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;}};ifletOk(res)=r.set("foo","bar"){letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting foo");}matchr.get("foo"){Ok(res)=>{letres: String =res;println!("{res}");// >>> bar
},Err(e)=>{println!("Error getting foo: {e}");return;}};lethash_fields=[("model","Deimos"),("brand","Ergonom"),("type","Enduro bikes"),("price","4972"),];ifletOk(res)=r.hset_multiple("bike:1",&hash_fields){letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting bike:1");}matchr.hget("bike:1","model"){Ok(res)=>{letres: String =res;println!("{res}");// >>> Deimos
},Err(e)=>{println!("Error getting bike:1 model: {e}");return;}}matchr.hget("bike:1","price"){Ok(res)=>{letres: String =res;println!("{res}");// >>> 4972
},Err(e)=>{println!("Error getting bike:1 price: {e}");return;}}matchr.hgetall("bike:1"){Ok(res)=>{letres: Vec<(String,String)>=res;for(key,value)inres{println!("{key}: {value}");}// >>> model: Deimos
// >>> brand: Ergonom
// >>> type: Enduro bikes
// >>> price: 4972
},Err(e)=>{println!("Error getting bike:1: {e}");return;}}}}
Rust-Sync Quick-Start 
mod tests{useredis::AsyncCommands;asyncfn run(){letmutr=matchredis::Client::open("redis://127.0.0.1"){Ok(client)=>{matchclient.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;}};ifletOk(res)=r.set("foo","bar").await{letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting foo");}matchr.get("foo").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> bar
},Err(e)=>{println!("Error getting foo: {e}");return;}};lethash_fields=[("model","Deimos"),("brand","Ergonom"),("type","Enduro bikes"),("price","4972"),];ifletOk(res)=r.hset_multiple("bike:1",&hash_fields).await{letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting bike:1");}matchr.hget("bike:1","model").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> Deimos
},Err(e)=>{println!("Error getting bike:1 model: {e}");return;}}matchr.hget("bike:1","price").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> 4972
},Err(e)=>{println!("Error getting bike:1 price: {e}");return;}}matchr.hgetall("bike:1").await{Ok(res)=>{letres: Vec<(String,String)>=res;for(key,value)inres{println!("{key}: {value}");}// >>> model: Deimos
// >>> brand: Ergonom
// >>> type: Enduro bikes
// >>> price: 4972
},Err(e)=>{println!("Error getting bike:1: {e}");return;}}}}
Rust-Async Quick-Start

You can also easily store and retrieve a hash:

mod landing_tests{useredis::Commands;fn run(){letmutr=matchredis::Client::open("redis://127.0.0.1"){Ok(client)=>{matchclient.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;}};ifletOk(res)=r.set("foo","bar"){letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting foo");}matchr.get("foo"){Ok(res)=>{letres: String =res;println!("{res}");// >>> bar
},Err(e)=>{println!("Error getting foo: {e}");return;}};lethash_fields=[("model","Deimos"),("brand","Ergonom"),("type","Enduro bikes"),("price","4972"),];ifletOk(res)=r.hset_multiple("bike:1",&hash_fields){letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting bike:1");}matchr.hget("bike:1","model"){Ok(res)=>{letres: String =res;println!("{res}");// >>> Deimos
},Err(e)=>{println!("Error getting bike:1 model: {e}");return;}}matchr.hget("bike:1","price"){Ok(res)=>{letres: String =res;println!("{res}");// >>> 4972
},Err(e)=>{println!("Error getting bike:1 price: {e}");return;}}matchr.hgetall("bike:1"){Ok(res)=>{letres: Vec<(String,String)>=res;for(key,value)inres{println!("{key}: {value}");}// >>> model: Deimos
// >>> brand: Ergonom
// >>> type: Enduro bikes
// >>> price: 4972
},Err(e)=>{println!("Error getting bike:1: {e}");return;}}}}
Rust-Sync Quick-Start 
mod tests{useredis::AsyncCommands;asyncfn run(){letmutr=matchredis::Client::open("redis://127.0.0.1"){Ok(client)=>{matchclient.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;}};ifletOk(res)=r.set("foo","bar").await{letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting foo");}matchr.get("foo").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> bar
},Err(e)=>{println!("Error getting foo: {e}");return;}};lethash_fields=[("model","Deimos"),("brand","Ergonom"),("type","Enduro bikes"),("price","4972"),];ifletOk(res)=r.hset_multiple("bike:1",&hash_fields).await{letres: String =res;println!("{res}");// >>> OK
}else{println!("Error setting bike:1");}matchr.hget("bike:1","model").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> Deimos
},Err(e)=>{println!("Error getting bike:1 model: {e}");return;}}matchr.hget("bike:1","price").await{Ok(res)=>{letres: String =res;println!("{res}");// >>> 4972
},Err(e)=>{println!("Error getting bike:1 price: {e}");return;}}matchr.hgetall("bike:1").await{Ok(res)=>{letres: Vec<(String,String)>=res;for(key,value)inres{println!("{key}: {value}");}// >>> model: Deimos
// >>> brand: Ergonom
// >>> type: Enduro bikes
// >>> price: 4972
},Err(e)=>{println!("Error getting bike:1: {e}");return;}}}}
Rust-Async Quick-Start

More information

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

RATE THIS PAGE
Back to top ↑

On this page

AltStyle によって変換されたページ (->オリジナル) /