1. Riak Generated Key Time Hostname List
2. Riak Generated Key Time Hostname Lookup

At the end of this guide, you should be familiar with:

Aug 03, 2007  Note Before issuing this command, ensure that your router has a host name and IP domain name configured (with the hostname and ip domain-name commands). You will be unable to complete the crypto key generate rsa command without a host name and IP domain name. (This situation is not true when you only generate a named key pair.). The Riak client for Ruby. Contribute to basho/riak-ruby-client development by creating an account on GitHub. Distributed NoSQL database optimized for IoT/Time Series. Fault-tolerant, S3-compatible, distributed storage. Keep up with our Community. Want to keep up to date with the latest news or get involved with our open source community? Learn More This work is licensed under a. I am changing the hostname of the router, which, I am told, will cause me to need to generate a new RSA encryption key on the 2811. I want to confirm whether it is the hostname, the domain name or both that affects the RSA encryption key. Thus, if I change ONLY the hostname will I need to generate a new encryption key.

• Working with buckets and bucket properties
• Listing buckets and keys
• Fetching, storing, and deleting values
• Using value metadata

This and the other guides in this wiki assume you have Riak installedlocally. If you don't have Riak already, please read and followhow to install Riak andthen come back to this guide. If you haven't yet installed the clientlibrary, please do so before starting this guide.

This guide also assumes you know how toconnect the client to Riak. All examples assumea local variable of client which is an instance of Riak::Clientand points at some Riak node you want to work with.

Key-Value

Riak is a near-purekey-value store, whichmeans that you have no tables, collections, or databases. Each keystands on its own, independent of all the others. Keys are namespacedin Buckets, which alsoencapsulate properties which are common among all keys in thenamespace (for example, the replication factor n_val). If youconceived of Riak as a big distributed Hash, it might look likethis:

What's missing from that picture:

• Each pair is given a specific spot within a cluster of Riak nodes,so any node in the cluster can find it without having to ask. Thisis also known as'consistent hashing'.
• There are 3 copies of the pair by default.
• The value has metadata that you can manipulate as well as the rawvalue.
• A key may have multiple values in the case of race-conditions andnetwork errors. (Don't worry about this for now, but do readResolving Conflicts when you're ready.)

Enough with the exposition, let's look at some data!

Buckets

Since our keys are all grouped into buckets, in the Ruby client, weget a Riak::Bucket object before doing any key-value operations.Here's how to get one:

This gives a Riak::Bucket object with the name 'guides' that islinked to the Riak::Client instance.

'But wait', you say, 'doesn't that bucket need to exist in Riakalready? How do we know which bucket to request?' Buckets are virtualnamespaces as we mentioned above; they have no schema, no manifestother than any properties you set on them (see below) and so you don'tneed to explicitly create them. In fact, the above code doesn't eventalk to Riak! Generally, we pick bucket names that have meaning to ourapplication, or are chosen for us automatically by another frameworklike Ripple orRisky.

Listing buckets

If you are just starting out and don't know which buckets have data inthem, you can use the 'list buckets' feature. Note that this willgive you a warning about its usage with a backtrace. You shouldn't runthis operation in your application.

Looks like we don't have any buckets stored. Why? We haven't storedany data yet! Riak gets the list of buckets by examining all the keysfor unique bucket names.

Listing keys

You can also list the keys that are in the bucket to know what'sthere. Again, this is another operation that is for experimentationonly and has horrible performance in production. Don't do it.

You can 'stream' keys through a block (where the block will be passedan Array of keys as the server sends them in chunks), which isslightly more efficient for large key lists, but we'll skip that fornow. Check out theAPI docs for moreinformation.

Bucket properties

Earlier we alluded to bucket properties. If you want to grab theproperties from a bucket, call the props method (which is alsoaliased to properties).

There are a lot of things in this Hash that we don't need to careabout. The most commonly-used properties are detailed on theRiak wiki. Let's set thereplication factor, n_val.

A number of the most common properties are exposed directly on theBucket object like shown above. Note that you can pass an incompleteHash of properties, and only the properties that are part of theHash will be changed.

The other bucket property we might care about is allow_mult, whichallows your application todetect and resolve conflicting writes. It isalso exposed directly:

Fetching and storing values

Now let's fetch a key from our bucket:

Depending on which protocol and backend you chose when connecting,you'll get an exception:

This means that the object does not exist (if you rescue theRiak::FailedRequest exception, its not_found? method will returntrue, tell you that the error represents a missing key). If you wantto avoid the error for a key you're not sure about, you can check forits existence explicitly:

If you don't care whether the key exists yet or not, but want to startworking with the value so you can store it, use get_or_new:

This gives us a new[[Riak::RObject http://rdoc.info/gems/riak-client/Riak/RObject]] towork with, which is a container for the value. In Riak's terminology,the combination of bucket, key, metadata and value is called an'object' -- please do not confuse this with Ruby's concept of anObject. All 'Riak objects' are wrapped by the Riak::RObjectclass. Since this is a new object, the client assumes we want to storeRuby data as JSON in Riak and so sets the content-type for us to'application/json', which we can see in the inspect output. Thedefault value of the object is nil. Let's set the data to somethinguseful:

Now we can persist that object to Riak using the store method.

If we list the keys again, we can see that the key is now part of thebucket (this time we use the bucket accessor on the object insteadof going from the client object):

Now let's fetch our object again:

Assuming we're done with the object, we can delete it:

*Note: Deleting an RObject will freeze the object, makingmodifications to it impossible.

Working with metadata

We mentioned before that every value in Riak also has metadata, andthe Riak::RObject lets you manipulate it. The only one we've reallyseen so far is the content type metadata, so let's examine that moreclosely.

Content type

For the sake of interoperability and ease of working withyour data, Riak requires every value to have a content-type. Let'slook at our previous object's content type:

Riak Generated Key Time Hostname List

Under the covers, the Ruby client will automatically convert that toand from JSON when storing and retrieving the value. If we wanted toserialize our Ruby data as a different type, we can just change thecontent-type:

Now our object will be serialized to YAML. The Ruby clientautomatically supports JSON, YAML, Marshal, and plain-textserialization. (If you want to add your own, check out theSerializers guide.)

Riak Generated Key Time Hostname Lookup

But what if the data we want to store is not a Ruby data type, butsome binary chunk of information that comes from another system. Notto worry, you can bypass serializers altogether using the raw_dataaccessors. Let's say I want to store a PNG image that I have on mydesktop. I could do it like so:

When the client doesn't know how to deserialize the content type, itwill simply display the byte size on inspection. Now here's a funpart: since I just stored an image, I can open it with my browser:

User metadata

You can also specify a bunch of free-form metadata on an RObjectusing the meta accessor, which is simply a Hash. For example, ifwe wanted to credit the PNG image we stored above to a specificperson, we could add that and it would not affect the value of theobject:

Now the next time we fetch the object, we'll get back that metadatatoo:

The values come back as Arrays because HTTP allows multiple valuesper header, and user metadata is sent as HTTP headers.

Vector clock

The Vector clock isRiak's means of internal accounting; that is, tracking differentversions of your data and automatically updating them whereappropriate. You don't usually need to worry about the vector clock,but it is accessible on the RObject as well:

If you use encryption to store data then you generate the IV using CryptGenRandom (or its.net equivalent RandomNumberGenerator.GetBytes) and save it along the document (in clear, no need to protect the IV). You never write down the key, the key is provided by the user. (C#) Generate Encryption Key Discusses symmetric encryption key generation techniques for block encryption algorithms such as AES, Blowfish, and Twofish, or for other algorithms such as ChaCha20. Chilkat.NET Downloads. Generating secure random strong encryption keys PowerShell. The code snippets below can be run from LINQPad or by copying the following code into a new project and referencing System.Security. OpenSSL is well known for its ability to generate certificates but it can also be used to. C# generate random encryption key download.

That vector clock will automatically be threaded through anyoperations you perform directly on the RObject (like store,delete, and reload) so that you don't have to worry about it.

Last-Modified time and ETag

Especially if you're using the HTTP interface, the last_modified andetag are useful. Whenreloading your object,they will be used to prevent full fetches when the object hasn'tchanged in Riak. They can also be used as a form of optimisticconcurrency control (with very weak guarantees, mind you) by settingthe prevent_stale_writes flag:

Riak prevented the stale write by sending a 412 Precondition Failedresponse over HTTP.

Secondary Indexes and Links

You can also access the Secondary Indexes andLinks directly from the RObject, but we won't coverthose here.

What to do next

Congratulations, you finished the 'Key-Value Operations' guide! Afterthis guide, you can go beyond into more advanced querying methods, ortake advantage of extended features of theclient. Secondary Indexes are a very popular feature, and as allgood Rubyists have thorough test suites, the Test Server is alsoa good next step.