One place for hosting & domains

      Sets

      How To Configure Keyfile Authentication for MongoDB Replica Sets on Ubuntu 20.04


      Introduction

      MongoDB, also known as Mongo, is an open-source document database used in many modern web applications. It is classified as a NoSQL database because it does not rely on the relational database model. Instead, it uses JSON-like documents with dynamic schemas. This means that, unlike relational databases, MongoDB does not require a predefined schema before you add data to a database.

      When you’re working with multiple distributed MongoDB instances, as in the case of a replica set or a sharded database architecture, it’s important to ensure that the communications between them are secure. One way to do this is through keyfile authentication. This involves creating a special file that essentially functions as a shared password for each member in the cluster.

      This tutorial outlines how to update an existing replica set to use keyfile authentication. The procedure involved in this guide will also ensure that the replica set doesn’t go through any downtime, so the data within the replica set will remain available for any clients or applications that need access to it.

      Prerequisites

      To complete this tutorial, you will need:

      • Three servers, each running Ubuntu 20.04. All three of these servers should have an administrative non-root user and a firewall configured with UFW. To set this up, follow our initial server setup guide for Ubuntu 20.04.
      • MongoDB installed on each of your Ubuntu servers. Follow our tutorial on How To Install MongoDB on Ubuntu 20.04, making sure to complete each step on each of your servers.
      • All three of your MongoDB installations configured as a replica set. Follow this tutorial on How To Configure a MongoDB Replica Set on Ubuntu 20.04 to set this up.
      • SSH keys generated for each server. In addition, you should ensure that each server has the other two servers’ public keys added to its authorized_keys file. This is to ensure that each machine can communicate with one another over SSH, which will make it easier to distribute the keyfile to each of them in Step 2. To set these up, follow our guide on How To Set Up SSH Keys on Ubuntu 20.04.

      Please note that, for clarity, this guide will follow the conventions established in the prerequisite replica set tutorial and refer to the three servers as mongo0, mongo1, and mongo2. It will also assume that you’ve completed Step 1 of that guide and configured each server’s hosts file so that the following hostnames will resolve to given server’s IP address:

      Hostname Resolves to
      mongo0.replset.member mongo0
      mongo1.replset.member mongo1
      mongo2.replset.member mongo2

      There are a few instances in this guide in which you must run a command or update a file on only one of these servers. In such cases, this guide will default to using mongo0 in examples and will signify this by showing commands or file changes in a blue background, like this:

      Any commands that must be run or file changes that must be made on multiple servers will have a standard gray background, like this:

      About Keyfile Authentication

      In MongoDB, keyfile authentication relies on Salted Challenge Response Authentication Mechanism (SCRAM), the database system’s default authentication mechanism. SCRAM involves MongoDB reading and verifying credentials presented by a user against a combination of their username, password, and authentication database, all of which are known by the given MongoDB instance. This is the same mechanism used to authenticate users who supply a password when connecting to the database.

      In keyfile authentication, the keyfile acts as a shared password for each member in the cluster. A keyfile must contain between 6 and 1024 characters. Keyfiles can only contain characters from the base64 set, and note that MongoDB strips whitespace characters when reading keys. Beginning in version 4.2 of Mongo, keyfiles use YAML format, allowing you to share multiple keys in a single keyfile.

      Warning: The Community version of MongoDB comes with two authentication methods that can help keep your database secure, keyfile authentication and x.509 authentication. For production deployments that employ replication, the MongoDB documentation recommends using x.509 authentication, and it describes keyfiles as “bare-minimum forms of security” that are “best suited for testing or development environments.”

      The process of obtaining and configuring x.509 certificates comes with a number of caveats and decisions that must be made on a case-by-case basis, meaning that this procedure is beyond the scope of a DigitalOcean tutorial. If you plan on using a replica set in a production environment, we strongly encourage you to review the official MongoDB documentation on x.509 authentication.

      If you plan on using your replica set for testing or development, you can proceed with following this tutorial to add a layer of security to your cluster.

      Step 1 — Creating a User Administrator

      When you enable authentication in MongoDB, it will also enable role-based access control for the replica set. Per the MongoDB documentation:

      MongoDB uses Role-Based Access Control (RBAC) to govern access to a MongoDB system. A user is granted one or more roles that determine the user’s access to database resources and operations.

      When access control is enabled on a MongoDB instance, it means that you won’t be able to access any of the resources on the system unless you’ve authenticated as a valid MongoDB user. Even then, you must authenticate as a user with the appropriate privileges to access a given resource.

      If you don’t create a user for your MongoDB system before enabling keyfile authentication (and, consequently, access control), you will not be locked out of your replica set. You can create a MongoDB user which you can use to authenticate to the set and, if necessary, create other users through Mongo’s localhost exception. This is a special exception MongoDB makes for configurations that have enabled access control but lack users. This exception only allows you to connect to the database on the localhost and then create a user in the admin database.

      However, relying on the localhost exception to create a MongoDB user after enabling authentication means that your replica set will go through a period of downtime, since the replicas will not be able to authenticate their connection until after you create a user. This step outlines how to create a user before enabling authentication to ensure that your replica set remains available. This user will have permissions to create other users on the database, giving you the freedom to create other users with whatever permissions they need in the future. In MongoDB, a user with such permissions is known as a user administrator.

      To begin, connect to the primary member of your replica set. If you aren’t sure which of your members is the primary, you can run the rs.status() method to identify it.

      Run the following mongo command from the bash prompt of any of the Ubuntu servers hosting a MongoDB instance in your replica set. This command’s --eval option instructs the mongo operation to not open up the shell interface environment that appears when you run mongo by itself and instead run the command or method, wrapped in single quotes, that follows the --eval argument:

      • mongo --eval 'rs.status()'

      rs.status() returns a lot of information, but the relevant portion of the output is the "members" : array. In the context of MongoDB, an array is a collection of documents held between a pair of square brackets ([ and ]).

      In the "members": array you’ll find a number of documents, each of which contains information about one of the members in your replica set. Within each of these member documents, find the "stateStr" field. The member whose "stateStr" value is "PRIMARY" is the primary member of your replica set. The following example shows a situation where mongo0 is the primary:

      Output

      . . . "members" : [ { "_id" : 0, "name" : "mongo0.replset.member:27017", "health" : 1, "state" : 1, "stateStr" : "PRIMARY", . . . }, . . .

      Once you know which of your replica set members is the primary, SSH into the server hosting that instance. For demonstration purposes, this guide will continue to use examples in which mongo0 is the primary:

      • ssh sammy@mongo0_ip_address

      After logging into the server, connect to MongoDB by opening up the mongo shell environment:

      When creating a user in MongoDB, you must create them within a specific database which will be used as their authentication database. The combination of the user’s name and their authentication database serve as a unique identifier for that user.

      Certain administrative actions are only available to users whose authentication database is the admin database — a special privileged database included in every MongoDB installation — including the ability to create new users. Because the goal of this step is to create an user administrator that can create other users in the replica set, connect to the admin database so you can grant this user the appropriate privileges:

      Output

      switched to db admin

      MongoDB comes installed with a number of JavaScript-based shell methods you can use to manage your database. One of these, the db.createUser method, is used to create new users in the database in which the method is run.

      Initiate the db.createUser method:

      Note: Mongo won’t register the db.createUser method as complete until you enter a closing parenthesis. Until you do, the prompt will change from a greater than sign (>) to an ellipsis (...).

      This method requires you to specify a username and password for the user, as well as any roles you want the user to have. Recall that MongoDB stores its data in JSON-like documents; when you create a new user, all you’re doing is creating a document to hold the appropriate user data as individual fields.

      As with objects in JSON, documents in MongoDB begin and end with curly braces ({ and }). Enter an opening curly brace to begin the user document:

      Next, enter a user: field, with your desired username as the value in double quotes followed by a comma. The following example specifies the username UserAdminSammy, but you can enter whatever username you like:

      Next, enter a pwd field with the passwordPrompt() method as its value. When you execute the db.createUser method, the passwordPrompt() method will provide a prompt for you to enter your password. This is more secure than the alternative, which is to type out your password in cleartext as you did for your username.

      Note: The passwordPrompt() method is only compatible with MongoDB versions 4.2 and newer. If you’re using an older version of Mongo, then you will have to write out your password in cleartext, similarly to how you wrote out your username:

      Be sure to follow this field with a comma as well:

      Then enter a roles field followed by an array detailing the roles you want your administrative user to have. In MongoDB, roles define what actions the user can perform on the resources that they have access to. You can define custom roles yourself, but Mongo also comes with a number of built-in roles that grant commonly-needed permissions.

      Because you’re creating a user administrator, at a minimum you should grant them the built-in userAdminAnyDatabase role over the admin database. This will allow the user administrator to create and modify new users and roles. Because the administrative user has this role in the admin database, this will also grant it superuser access to the entire cluster:

      • roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]

      Following that, enter a closing brace to signify the end of the document:

      Then enter a closing parenthesis to close and execute the db.createUser method:

      All together, here’s what your db.createUser method should look like:

      > db.createUser(
      ... {
      ... user: "UserAdminSammy",
      ... pwd: passwordPrompt(),
      ... roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
      ... }
      ... )
      

      If each line’s syntax is correct, the method will execute properly and you’ll be prompted to enter a password:

      Output

      Enter password:

      Enter a strong password of your choosing. Then, you’ll receive a confirmation that the user was added:

      Output

      Successfully added user: { "user" : "UserAdminSammy", "roles" : [ { "role" : "userAdminAnyDatabase", "db" : "admin" }, "readWriteAnyDatabase" ] }

      With that, you’ve added a MongoDB user profile which you can use to manage other users and roles on your system. You can test this out by creating another user, as outlined in the remainder of this step.

      Begin by authenticating as the user administrator you just created:

      • db.auth( "UserAdminSammy", passwordPrompt() )

      db.auth() will return 1 if authentication was successful:

      Output

      1

      Note: In the future, if you want to authenticate as the user administrator when connecting to the cluster, you can do so directly from your server prompt with a command like the following:

      • mongo -u "UserAdminSammy" -p --authenticationDatabase "admin"

      In this command, the -u option tells the shell that the following argument is the username which you want to authenticate as. The -p flag tells it to prompt you to enter a password, and the --authenticationDatabase option precedes the name of the user’s authentication database. If you enter an incorrect password or the username and authentication database do not match, you won’t be able to authenticate and you’ll have to try connecting again.

      Also, be aware that in order for you to create new users in the replica set as the user administrator, you must be connected to the set’s primary member.

      The procedure for adding another user is the same as it was for the user administrator. The following example creates a new user with the clusterAdmin role, which means they will be able to perform a number of operations related to replication and sharding. Within the context of MongoDB, a user with these privileges is known as a cluster administrator.

      Having a dedicated user to perform specific functions like this is a good security practice, as it limits the number of privileged users you have on your system. After you enable keyfile authentication later in this tutorial, any client that wants to perform any of the operations allowed by the clusterAdmin role — such as any of the rs. methods, like rs.status() or rs.conf() — must first authenticate as the cluster administrator.

      That said, you can provide whatever role you’d like to this user, and likewise provide them with a different name and authentication database. However, if you want the new user to function as a cluster administrator, then you must grant them the clusterAdmin role within the admin database.

      In addition to creating a user to serve as the cluster administrator, the following method names the user ClusterAdminSammy and uses the passwordPrompt() method to prompt you to enter a password:

      • db.createUser(
      • {
      • user: "ClusterAdminSammy",
      • pwd: passwordPrompt(),
      • roles: [ { role: "clusterAdmin", db: "admin" } ]
      • }
      • )

      Again, if you’re using a version of MongoDB that precedes version 4.2, then you will have to write out your password in cleartext instead of using the passwordPrompt() method.

      If each line’s syntax is correct, the method will execute properly and you’ll be prompted to enter a password:

      Output

      Enter password:

      Enter a strong password of your choosing. Then, you’ll receive a confirmation that the user was added:

      Output

      Successfully added user: { "user" : "ClusterAdminSammy", "roles" : [ { "role" : "clusterAdmin", "db" : "admin" } ] }

      This output confirms that your user administrator is able to create new users and grant them roles. You can now close the MongoDB shell:

      Alternatively, you can close the shell by pressing CTRL + C.

      At this point, if you have any clients or applications connected to your MongoDB cluster, it would be a good time to create one or more dedicated users with the appropriate roles which they can use to authenticate to the database. Otherwise, read on to learn how to generate a keyfile, distribute it among the members of your replica set, and then configure each one to require the replica set members to authenticate with the keyfile.

      Step 2 — Creating and Distributing an Authentication Keyfile

      Before creating a keyfile, it can be helpful to create a directory on each server where you will store the keyfile in order to keep things organized. Run the following command, which creates a directory named mongo-security in the administrative Ubuntu user’s home directory, on each of your three servers:

      Then generate a keyfile on one of your servers. You can do this on any one of your servers but, for illustration purposes, this guide will generate the keyfile on mongo0.

      Navigate to the mongo-security directory you just created:

      Within that directory, create a keyfile with the following openssl command:

      • openssl rand -base64 768 > keyfile.txt

      Take note of this command’s arguments:

      • rand: instructs OpenSSL to generate pseudo-random bytes of data
      • -base64: specifies that the command should use base64 encoding to represent the pseudo-random data as printable text. This is important because, as mentioned previously, MongoDB keyfiles can only contain characters in the base64 set
      • 768: the number of bytes the command should generate. In base64 encoding, three binary bytes of data are represented as four characters. Because MongoDB keyfiles can have a maximum of 1024 characters, 768 is the maximum number of bytes you can generate for a valid keyfile

      Following this command’s 768 argument is a greater-than sign (>). This redirects the command’s output into a new file named keyfile.txt which will serve as your keyfile. Feel free to name the keyfile something other than keyfile.txt if you’d like, but be sure to change the filename whenever it appears in later commands.

      Next, modify the keyfile’s permissions so that only the owner has read access:

      Following this, distribute the keyfile to the other two servers hosting the MongoDB instances in your replica set. Assuming you followed the prerequisite guide on How To Set Up SSH Keys, you can do so with the scp command:

      • scp keyfile.txt sammy@mongo1.replset.member:/home/sammy/mongo-security
      • scp keyfile.txt sammy@mongo2.replset.member:/home/sammy/mongo-security

      Notice that each of these commands copies the keyfile directly to the ~/mongo-security/ directories you created previously on mongo1 and mongo2. Be sure to change sammy to the name of the administrative Ubuntu user profile you created on each server.

      Next, change the file’s owner to the mongodb user profile. This is a special user that was created when you installed MongoDB, and it’s used to run the mongod service. This user must have access to the keyfile in order for MongoDB to use it for authentication.

      Run the following command on each of your servers to change the keyfile’s owner to the mongodb user account:

      • sudo chown mongodb:mongodb ~/mongo-security/keyfile.txt

      After changing the keyfiles’ owner on each server, you’re ready to reconfigure each of your MongoDB instances to enforce keyfile authentication.

      Step 3 — Enabling Keyfile Authentication

      Now that you’ve generated a keyfile and distributed it to each of the servers in your replica set, you can update the MongoDB configuration file on each server to enforce keyfile authentication.

      In order to avoid any downtime while configuring the members of your replica set to require authentication, this step involves reconfiguring the secondary members of the set first. Then, you’ll direct your primary member to step down and become a secondary member. This will cause the secondary members to hold an election to select a new primary, keeping your cluster available to whatever clients or applications need access to it. You’ll then reconfigure the former primary node to enable authentication.

      On each of your servers hosting a secondary member of your replica set, open up MongoDB’s configuration file with your preferred text editor:

      • sudo nano /etc/mongod.conf

      Within the file, find the security section. It will look like this by default:

      /etc/mongod.conf

      . . .
      #security:
      . . .
      

      Uncomment this line by removing the pound sign (#). Then, on the next line, add a keyFile: directive followed by the full path to the keyfile you created in the previous step:

      /etc/mongod.conf

      . . .
      security:
        keyFile: /home/sammy/mongo-security/keyfile.txt
      . . .
      

      Note that there are two spaces at the beginning of this new line. These are necessary for the configuration file to be read correctly. When you enter this line in your own configuration files, make sure that the path you provide reflects the actual path of the keyfile on each server.

      Below the keyFile directive, add a transitionToAuth directive with a value of true. When set to true, this configuration option allows the MongoDB instance to accept both authenticated and non-authenticated connections. This is useful when reconfiguring a replica set to enforce authentication, as it will ensure that your data remains available as you restart each member of the set:

      /etc/mongod.conf

      . . .
      security:
        keyFile: /home/sammy/mongo-security/keyfile.txt
        transitionToAuth: true
      . . .
      

      Again, make sure that you include two blank spaces before the transitionToAuth directive.

      After making those changes, save and close the file. If you used nano to edit it, you can do so by pressing CTRL + X, Y, and then ENTER.

      Then restart the mongod service on both of the secondary instances’ servers to immediately put these changes into effect:

      • sudo systemctl restart mongod

      With that, you’ve configured keyfile authentication for the secondary members of your replica set. At this point, both authenticated and non-authenticated users can access these members without restriction.

      Next, you’ll repeat this procedure on the primary member. Before doing so, though, you must step down the member so it’s no longer the primary. To do this, open up the MongoDB shell on the server hosting the primary member. For illustration purposes, this guide will again assume this is mongo0:

      From the prompt, run the rs.stepDown() method. This will instruct the primary to become a secondary member, and will cause the current secondary members to hold an election to determine which will serve as the new primary:

      If the method returns "ok" : 1 in the output, it means the primary member successfully stepped down to become a secondary:

      Output

      { "ok" : 1, "$clusterTime" : { "clusterTime" : Timestamp(1614795467, 1), "signature" : { "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="), "keyId" : NumberLong(0) } }, "operationTime" : Timestamp(1614795467, 1) }

      After stepping down the primary, you can close the Mongo shell:

      Next, open up the MongoDB configuration file on this server:

      • sudo nano /etc/mongod.conf

      Find the security section and uncomment the security header by removing the pound sign. Then add the same keyFile and transitionToAuth directives you added to the other MongoDB instances. After making these changes, the security section will look like this:

      /etc/mongod.conf

      . . .
      security:
        keyFile: /home/sammy/mongo-security/keyfile.txt
        transitionToAuth: true
      . . .
      

      Again, make sure that the file path after the keyFile directive reflects the keyfile’s actual location on this server.

      When finished, save and close the file. Then restart the mongod process:

      • sudo systemctl restart mongod

      Following that, all of your MongoDB instances are able to accept both authenticated and non-authenticated connections. In the final step of this guide, you’ll configure your instances to require users to authenticate before performing privileged actions.

      Step 4 — Restarting Each Member Without transitionToAuth to Enforce Authentication

      At this point, each of your MongoDB instances are configured with the transitionToAuth set to true. This means that even though you’ve enabled each server to use the keyfile you created to authenticate connections internally, they’re still able to accept non-authenticated connections.

      To change this and require each member to enforce authentication, reopen the mongod.conf file on each server:

      • sudo nano /etc/mongod.conf

      Find the security section and disable the transitionToAuth directive. You can do this by commenting the line out by prepending it with a pound sign:

      /etc/mongod.conf

      . . .
      security:
        keyFile: /home/sammy/mongo-security/keyfile.txt
        #transitionToAuth: true
      . . .
      

      After disabling the transitionToAuth directive in each instance’s configuration file, save and close each file.

      Then, restart the mongod service on each server:

      • sudo systemctl restart mongod

      Following that, each of the MongoDB instances in your replica set will require you to authenticate to perform privileged actions.

      To test this, try running a MongoDB method that works when invoked by an authenticated user that has the appropriate privileges. Try running the following command from any of your Ubuntu servers’ prompts:

      • mongo --eval 'rs.status()'

      Even though you ran this method successfully in Step 1, the rs.status() method can now only be run by a user that has been granted the clusterAdmin or clusterManager roles since you’ve enabled keyfile authentication. Regardless of whether you run this command on a server hosting the primary member or one of the secondary members, it will not work because you have not authenticated:

      Output

      . . . MongoDB server version: 4.4.4 { "operationTime" : Timestamp(1616184183, 1), "ok" : 0, "errmsg" : "command replSetGetStatus requires authentication", "code" : 13, "codeName" : "Unauthorized", "$clusterTime" : { "clusterTime" : Timestamp(1616184183, 1), "signature" : { "hash" : BinData(0,"huJUmB/lrrxpx9YfnONM4mayJwo="), "keyId" : NumberLong("6941116945081040899") } } }

      Recall that, after enabling access control, all of the cluster administration methods (including rs. methods like rs.status()) will only work when invoked by an authenticated user that has been granted the appropriate cluster management roles. If you’ve created a cluster administrator — as outlined in Step 1 — and authenticate as that user, then this method will work as expected:

      • mongo -u "ClusterAdminSammy" -p --authenticationDatabase "admin" --eval 'rs.status()'

      After entering the user’s password when prompted, you will see the rs.status() method’s output:

      Output

      . . . MongoDB server version: 4.4.4 { "set" : "shard2", "date" : ISODate("2021-03-19T20:21:45.528Z"), "myState" : 2, "term" : NumberLong(4), "syncSourceHost" : "mongo1.replset.member:27017", "syncSourceId" : 2, "heartbeatIntervalMillis" : NumberLong(2000), "majorityVoteCount" : 2, . . .

      This confirms that the replica set is enforcing authentication, and that you’re able to authenticate successfully.

      Conclusion

      By completing this tutorial, you created a keyfile with OpenSSL and then configured a MongoDB replica set to require its members to use it for internal authentication. You also created a user administrator which will allow you to manage users and roles in the future. Throughout all of this, your replica set will not have gone through any downtime and your data will have remained available to your clients and applications.

      If you’d like to learn more about MongoDB, we encourage you to check out our entire library of MongoDB content.



      Source link

      So verwalten Sie sortierte Sets in Redis


      Einführung

      Redis ist ein Open-Source-, In-Memory-Datenspeicher mit Schlüsselwerte-Datenstruktur. Sortierte Sets in Redis sind ein Datentyp, der den Sets ähnelt. Beide sind Gruppen von Zeichenfolgen, die keine Wiederholungen zulassen. Der Unterschied besteht darin, dass in einem sortierten Set jedes Mitglied mit einem Score verknüpft ist, wodurch diese vom kleinsten bis zum größten Score sortiert werden können. So wie bei Sets darf jedes Mitglied eines sortieren Sets in diesem nur einmalig vorkommen, wobei mehrere Mitglieder den gleichen Score haben können.

      Dieses Tutorial erklärt, wie man sortierte Sets erstellt, Ihre Mitglieder abruft und entfernt und wie man neue sortierte Sets aus bestehenden Sets erstellen kann.

      So verwenden Sie diesen Leitfaden

      Dieser Leitfaden ist wie ein Spickzettel mit eigenständigen Beispielen geschrieben. Sie können beliebig zu jedem Abschnitt springen, der zu der Aufgabe passt, die Sie ausführen möchten.

      Die in diesem Leitfaden verwendeten Befehle wurden auf einem Ubuntu 18.04-Server mit der Redis-Version 4.0.9 getestet. Um eine ähnliche Umgebung einzurichten, können Sie Schritt 1 unseres Leitfadens Installieren und Sichern von Redis unter Ubuntu 18.04 folgen. Wir zeigen, wie diese Befehle sich verhalten, wenn sie mit redis-cli, der Befehlszeilenschnittstelle von Redis, angewendet werden. Beachten Sie, dass bei der Anwendung einer anderen Redis-Schnittstelle – z. B. Redli – die genaue Ausgabe bestimmter Befehle abweichen kann.

      Alternativ können Sie ein verwaltetes Exemplar einer Redis-Datenbank bereitstellen, um diese Befehle zu testen. Beachten Sie jedoch, dass abhängig vom Kontrollniveau, das Ihr Datenbankanbieter erlaubt, einige Befehle in diesem Leitfaden nicht wie beschrieben funktionieren könnten. Um eine von DigitalOcean verwaltete Datenbank bereitzustellen, folgen Sie bitte unserer Produktdokumentation über verwaltete Datenbanken. Dann müssen Sie entweder Redli installieren oder einen TLS-Tunnel einrichten, um sich mit der verwalteten Datenbank über TLS zu verbinden.

      Erstellen von sortierten Sets und Hinzufügen von Mitgliedern

      Um ein sortiertes Set zu erstellen, verwenden Sie den Befehl zadd. zadd akzeptiert als Argumente den Namen des Schlüssels, der das sortierte Set speichert, gefolgt vom Score des Mitglieds, das Sie hinzufügen, sowie dem Wert des Mitglieds selbst. Der folgende Befehl erstellt den Schlüssel eines sortierten Sets namens faveGuitarists mit einem Mitglied, "Joe Pass", das einen Score von 1 hat:

      • zadd faveGuitarists 1 "Joe Pass"

      zadd gibt eine ganze Zahl (Integer) aus, die anzeigt, wie viele Mitglieder dem sortierten Set hinzugefügt wurden, wenn es erfolgreich erstellt wurde.

      Output

      (integer) 1

      Mit zadd können Sie einem sortierten Set mehr als ein Mitglied hinzufügen. Beachten Sie, dass deren Scores nicht sequenziell sein müssen. Zwischen den Scores kann es Lücken geben und mehrere Mitglieder aus demselben sortierten Set können den gleichen Score haben:

      • zadd faveGuitarists 4 "Stephen Malkmus" 2 "Rosetta Tharpe" 3 "Bola Sete" 3 "Doug Martsch" 8 "Elizabeth Cotten" 12 "Nancy Wilson" 4 "Memphis Minnie" 12 "Michael Houser"

      Output

      (integer) 8

      zadd kann die folgenden Optionen akzeptieren, die Sie nach dem Schlüsselnamen und vor dem ersten Score eines Mitglieds eingeben müssen:

      • NX oder XX: Diese Optionen haben gegensätzliche Effekte, daher können Sie nur eine davon in eine zadd-Operation einfügen:
        • NX weist zadd an, die bestehenden Mitglieder nicht zu aktualisieren. Mit dieser Option fügt zadd nur neue Elemente hinzu.
        • XX weist zadd an, nur bestehende Elemente zu aktualisieren. Mit dieser Option fügt zadd niemals neue Mitglieder hinzu.
      • CH: Normalerweise gibt zadd nur die Anzahl der neuen Elemente aus, die dem sortierten Set hinzugefügt werden. Doch mit dieser Option gibt zadd die Anzahl der geänderten Elemente aus. Dazu gehören neu hinzugefügte Mitglieder sowie Mitglieder, deren Scores geändert wurden.
      • INCR: Führt dazu, dass der Befehl den Score-Wert des Mitglieds inkrementiert. Wenn das Mitglied noch nicht existiert, fügt der Befehl es mit dem Inkrement als Score in das sortierte Set ein, so als wäre sein ursprünglicher Score 0. Mit INCR gibt zadd bei erfolgreicher Ausführung den neuen Score des Mitglieds aus. Beachten Sie, dass Sie mit dieser Option jeweils nur ein Score/Mitglied-Paar einbeziehen können.

      Statt INCR mit zadd einzugeben, können Sie stattdessen den Befehl zincrby verwenden, der sich genauso verhält. Statt so wie zadd dem Mitglied des sortierten Sets den durch den Score-Wert angezeigten Wert zu geben, inkrementiert er den Score des Mitglieds auf diesen Wert. Beispiel: Der folgende Befehl inkrementiert den Score des Mitglieds "Stephen Malkmus", der ursprünglich 4 war, um 5 auf 9.

      • zincrby faveGuitarists 5 "Stephen Malkmus"

      Output

      "9"

      So wie bei der zadd-Befehlsoption INCR wird zincrby, falls das angegebene Mitglied nicht existiert, es mit dem inkrementellen Wert als seinen Score kreieren.

      Abrufen von Mitgliedern aus sortierten Sets

      Die grundlegendste Möglichkeit, die in einem sortierten Set enthaltenen Mitglieder abzurufen, ist die Verwendung des Befehls zrange. Dieser Befehl akzeptiert als Argumente den Namen des Schlüssels, dessen Mitglieder Sie abrufen möchten und eine Reihe von darin enthaltenen Mitgliedern. Die Reihe ist durch zwei Zahlen definiert, die nullbasierte Indexe repräsentieren. Das bedeutet, dass 0 das erste Mitglied im sortierten Set (oder das Mitglied mit dem niedrigsten Score) repräsentiert, 1 repräsentiert das nächste, und so fort.

      Das folgende Beispiel gibt die ersten vier Mitglieder aus dem im vorherigen Abschnitt erstellten Set faveGuitarists aus:

      • zrange faveGuitarists 0 3

      Output

      1) "Joe Pass" 2) "Rosetta Tharpe" 3) "Bola Sete" 4) "Doug Martsch"

      Beachten Sie: Falls das sortierte Set, das Sie an zrange übergeben, zwei oder mehr Elemente hat, die den gleichen Score teilen, werden diese Elemente in lexikografischer oder alphabetischer Reihenfolge sortiert.

      Die Start- und Stopp-Indizes können auch negative Zahlen sein, wobei -1 das letzte Mitglied repräsentiert, -2 das vorletzte Mitglied, und so fort:

      • zrange faveGuitarists -5 -2

      Output

      1) "Memphis Minnie" 2) "Elizabeth Cotten" 3) "Stephen Malkmus" 4) "Michael Houser"

      zrange akzeptiert zudem das Argument WITHSCORES. Wenn es enthalten ist, gibt es auch die Scores der Mitglieder aus:

      • zrange faveGuitarists 5 6 WITHSCORES

      Output

      1) "Elizabeth Cotten" 2) "8" 3) "Stephen Malkmus" 4) "9"

      zrange kann eine Reihe von Mitgliedern nur in aufsteigender numerischer Reihenfolge ausgeben. Um das umzukehren und eine Reihe in absteigender Reihenfolge auszugeben, müssen Sie den Befehl zrevrange verwenden. Stellen Sie sich diesen Befehl als vorübergehende Umkehrung der Reihenfolge des gegebenen sortierten Sets vor der Ausgabe der Mitglieder vor, die in den angegebenen Bereich fallen. Bei zrevrange repräsentiert 0 das letzte im Schlüssel enthaltene Mitglied, 1 das vorletzte, und so fort:

      • zrevrange faveGuitarists 0 5

      Output

      1) "Nancy Wilson" 2) "Michael Houser" 3) "Stephen Malkmus" 4) "Elizabeth Cotten" 5) "Memphis Minnie" 6) "Doug Martsch"

      zrevrange akzeptiert auch die Option WITHSCORES.

      Mit dem Befehl zrangebyscore können Sie eine Reihe von Mitgliedern auf der Grundlage ihrer Scores ausgeben. Im folgenden Beispiel gibt der Befehl jedes Mitglied, das im Schlüssel faveGuitarists enthalten ist und einen Score von 2, 3 oder 4 hat, aus:

      • zrangebyscore faveGuitarists 2 4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch" 4) "Memphis Minnie"

      In diesem Beispiel ist die Reihe integrativ. Das bedeutet, dass sie Mitglieder mit Scores von 2 oder 4 ausgibt. Sie können jedes Ende der Reihe ausschließen, indem Sie eine offene Klammer davorsetzen ((). Das folgende Beispiel gibt jedes Mitglied mit einem Score, der größer oder gleich 2, jedoch kleiner als 4 ist, aus:

      • zrangebyscore faveGuitarists 2 (4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      So wie bei zrange akzeptiert zrangebyscore das Argument WITHSCORES. Außerdem akzeptiert es die Option LIMIT, die Sie verwenden können, um nur eine Auswahl von Elementen aus der Ausgabe von zrangebyscore abzurufen. Diese Option akzeptiert ein Offset, das das erste Mitglied in der Reihe markiert, die der Befehl zurückgibt, sowie einen Zählstand, der festlegt, wie viele Mitglieder der Befehl insgesamt ausgibt. Der folgende Befehl z. B. konzentriert sich auf die ersten sechs Mitglieder des sortierten Sets faveGuitarists, gibt aber nur 3 dieser Mitglieder aus, beginnend mit dem zweiten Mitglied in der Reihe, repräsentiert durch 1:

      • zrangebyscore faveGuitarists 0 5 LIMIT 1 3

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      Der Befehl zrevrangebyscore gibt eine umgekehrte Reihe von Mitgliedern auf der Grundlage ihrer Scores aus. Der folgende Befehl gibt jedes Mitglied des Sets mit einem Score zwischen 10 und 6 aus:

      • zrevrangebyscore faveGuitarists 10 6

      Output

      1) "Stephen Malkmus" 2) "Elizabeth Cotten"

      So wie bei zrangebyscore kann zrevrangebyscore sowohl die Option WITHSCORES als auch die Option LIMIT akzeptieren. Außerdem können Sie jedes Ende der Reihe ausschließen, indem Sie vor dieses eine offene Klammer setzen.

      Es kann vorkommen, dass alle Mitglieder in einem sortierten Set den gleichen Score haben. In einem solchen Fall können Sie redis zwingen, mit dem Befehl zrangebylex eine Reihe von Elementen, die in lexikografischer oder in alphabetischer Reihenfolge sortiert sind, auszugeben. Um diesen Befehl auszuprobieren, führen Sie den folgenden zadd-Befehl aus, um ein sortiertes Set zu erstellen, in dem jedes Mitglied den gleichen Score hat:

      • zadd SomervilleSquares 0 Davis 0 Inman 0 Union 0 porter 0 magoun 0 ball 0 assembly

      Auf zrangebylex müssen ein Schlüsselname, ein Startintervall und ein Stoppinterval folgen. Die Start- und Stoppintervalle müssen mit einer offenen runden Klammer (() oder einer offenen eckigen Klammer ([) beginnen:

      • zrangebylex SomervilleSquares [a [z

      Output

      1) "assembly" 2) "ball" 3) "magoun" 4) "porter"

      Beachten Sie, dass dieses Beispiel nur vier der acht Mitglieder im Set ausgegeben hat, obwohl der Befehl eine Reihe von a bis z suchte. Das liegt daran, dass Redis-Werte groß-/kleinschreibungsabhängig sind. Daher wurden die Mitglieder, die mit Großbuchstaben beginnen, aus der Ausgabe ausgeschlossen. Um diese auszugeben, können Sie Folgendes ausführen:

      • zrangebylex SomervilleSquares [A [z

      Output

      1) "Davis" 2) "Inman" 3) "Union" 4) "assembly" 5) "ball" 6) "magoun" 7) "porter"

      zrangebylex akzeptiert auch die Sonderzeichen -, das negative Unendlichkeit, und +, das positive Unendlichkeit darstellt. Daher gibt die folgende Befehlssyntax auch jedes Mitglied des sortierten Sets aus:

      • zrangebylex SomervilleSquares - +

      Beachten Sie, dass zrangebylex Mitglieder eines sortierten Sets nicht in umgekehrter lexikografischer (ansteigend alphabetischer) Reihenfolge ausgeben kann. Hierfür verwenden Sie zrevrangebylex:

      • zrevrangebylex SomervilleSquares + -

      Output

      1) "porter" 2) "magoun" 3) "ball" 4) "assembly" 5) "Union" 6) "Inman" 7) "Davis"

      Da es für die Verwendung mit sortierten Sets bestimmt ist, bei denen jedes Mitglied den gleichen Score hat, akzeptiert zrangebylex nicht die Option WITHSCORES. Es akzeptiert jedoch die Option LIMIT.

      Abrufen von Informationen aus sortierten Sets

      Um herauszufinden, wie viele Mitglieder sich in einem gegebenen sortierten Set befinden (oder anders ausgedrückt, um seine Kardinalität zu bestimmen), verwenden Sie den Befehl zcard. Das folgende Beispiel zeigt, wie viele Mitglieder im Schlüssel faveGuitarists aus dem ersten Abschnitt dieses Leitfadens enthalten sind:

      Output

      (integer) 9

      zcount kann Ihnen zeigen, wie viele Elemente in einem gegebenen sortierten Set enthalten sind, die in einen Bereich von Scores fallen. Die erste Zahl, die auf den Schlüssel folgt, ist der Beginn des Bereichs und die zweite das Ende des Bereichs:

      • zcount faveGuitarists 3 8

      Output

      (integer) 4

      zscore gibt den Score eines angegebenen Mitglieds eines sortierten Sets aus:

      • zscore faveGuitarists "Bola Sete"

      Output

      "3"

      Wenn entweder das angegebene Mitglied oder der Schlüssel nicht existieren, gibt zscore als Ausgabe (nil) an.

      zrank ist ähnlich wie zscore, aber anstatt den Score des gegebenen Mitglieds auszugeben, gibt es stattdessen seinen Rang aus. In Redis ist Rang – rank – ein nullbasierter Index der Mitglieder eines sortierten Sets, der nach ihrem Score geordnet wird. Beispielsweise hat "Joe Pass" einen Score von 1, aber weil dies der niedrigste Score aller Mitglieder im Schlüssel ist, hat er den Rang 0:

      • zrank faveGuitarists "Joe Pass"

      Output

      (integer) 0

      Ein weiterer Redis-Befehl namens zrevrank führt die gleiche Funktion wie zrank aus, kehrt aber stattdessen den Rang der Mitglieder im Set um. Im folgenden Beispiel hat das Mitglied "Joe Pass" den niedrigsten Score und daraus folgend den höchsten umgekehrten Rang:

      • zrevrank faveGuitarists "Joe Pass"

      Output

      (integer) 8

      Die einzige Beziehung zwischen dem Score eines Mitglieds und seinem Rang besteht darin, wo sein Score im Verhältnis zu dem der anderen Mitglieder steht. Wenn zwischen zwei aufeinanderfolgenden Mitgliedern eine Lücke beim Score besteht, reflektiert sich diese nicht in ihrem Rang. Beachten Sie: Wenn zwei Mitglieder den gleichen Score haben, nimmt das Mitglied, das alphabetisch zuerst kommt, den unteren Rang ein.

      Wie zscore geben zrank und zrevrank als Ausgabe (nil) an, wenn der Schlüssel oder das Mitglied nicht existiert.

      zlexcount kann Ihnen zeigen, wie viele Mitglieder in einem sortierten Set innerhalb eines lexikografischen Bereichs enthalten sind. Das folgende Beispiel verwendet das sortierte Set SomervilleSquares aus dem vorherigen Abschnitt:

      • zlexcount SomervilleSquares [M [t

      Output

      (integer) 5

      Dieser Befehl folgt derselben Syntax wie der Befehl zrangebylex. Einzelheiten zum Definieren eines Stringbereichs entnehmen Sie dem vorherigen Abschnitt.

      Entfernen von Mitgliedern aus sortierten Sets

      Der Befehl zrem kann ein oder mehrere Mitglieder aus einem sortierten Set entfernen:

      • zrem faveGuitarists "Doug Martsch" "Bola Sete"

      zrem gibt eine ganze Zahl aus, die anzeigt, wie viele Mitglieder aus dem sortierten Set entfernt wurden:

      Output

      (integer) 2

      Es gibt drei Redis-Befehle, die es Ihnen ermöglichen, Mitglieder eines sortierten Sets auf der Grundlage eines Bereichs zu entfernen. Wenn z. B. jedes Mitglied in einem sortierten Set den gleichen Score hat, können Sie Mitglieder auf der Grundlage eines lexikografischen Bereichs mit zremrangebylex entfernen. Dieser Befehl verwendet die gleiche Syntax wie zrangebylex. Das folgende Beispiel entfernt jedes Mitglied, das mit einem Großbuchstaben beginnt, aus dem im vorherigen Abschnitt erstellten Schlüssel SomervilleSquares:

      • zremrangebylex SomervilleSquares [A [Z

      zremrangebylex gibt eine ganze Zahl an, die anzeigt, wie viele Mitglieder entfernt wurden:

      Output

      (integer) 3

      Außerdem können Sie Mitglieder auf der Grundlage eines Score-Bereichs mit dem Befehl zremrangebyscore entfernen, der die gleiche Syntax wie der Befehl zrangebyscore verwendet. Das folgende Beispiel entfernt jedes in faveGuitarists enthaltene Mitglied mit einem Score von 4, 5 oder 6:

      • zremrangebyscore faveGuitarists 4 6

      Output

      (integer) 1

      Sie können Mitglieder aus einem Set auf der Grundlage eines Rangbereichs mit dem Befehl zremrangebyrank entfernen, der die gleiche Syntax wie zrangebyrank verwendet. Der folgende Befehl entfernt die drei Mitglieder des sortierten Sets mit den niedrigsten Rängen, die durch einen Bereich von nullbasierten Indizes definiert sind:

      • zremrangebyrank faveGuitarists 0 2

      Output

      (integer) 3

      Beachten Sie, dass an remrangebyrank übergebene Zahlen auch negativ sein können, wobei -1 den höchsten Rang repräsentiert, -2 den nächsthöheren, und so fort.

      Erstellen von neuen sortierten Sets aus bestehenden Sets

      Redis enthält zwei Befehle, die es Ihnen ermöglichen, Mitglieder mehrerer sortierter Sets zu vergleichen und auf der Grundlage dieser Vergleiche neue Sets zu erstellen: zinterstore und zunionstore. Um diese Befehle auszuprobieren, führen Sie die folgenden zadd-Befehle aus, um einige sortierte Beispielsets zu erstellen.

      • zadd NewKids 1 "Jonathan" 2 "Jordan" 3 "Joey" 4 "Donnie" 5 "Danny"
      • zadd Nsync 1 "Justin" 2 "Chris" 3 "Joey" 4 "Lance" 5 "JC"

      zinterstore findet die Mitglieder, die von zwei oder mehreren sortierten Sets geteilt werden – deren Schnittmenge – und erzeugt ein neues sortiertes Set, das nur diese Mitglieder enthält. Dieser Befehl muss den Namen eines Zielschlüssels, in dem die sich überschneidenden Mitglieder als sortiertes Set gespeichert werden, die Anzahl der an zinterstore übergebenden Schlüssel und die Namen der Schlüssel, die Sie analysieren möchten, in der Reihenfolge enthalten:

      • zinterstore BoyBands 2 NewKids Nsync

      zinterstore gibt dann eine ganze Zahl aus, die die Anzahl der im sortierten Zielset gespeicherten Elemente anzeigt. Da NewKids und Nsync nur ein Mitglied teilen – "Joey"– gibt der Befehl 1 aus:

      Output

      (integer) 1

      Bitte beachten Sie: Falls der Zielschlüssel bereits existiert, überschreibt zinterstore dessen Inhalt.

      zunionstore erstellt ein neues sortiertes Set, das jedes Mitglied der an den Befehl übergebenen Schlüssel enthält. Dieser Befehl verwendet die gleiche Syntax wie zinterstore und erfordert den Namen eines Zielschlüssels, die Anzahl der an den Befehl übergebenen Schlüssel und die Namen der Schlüssel:

      • zunionstore SuperGroup 2 NewKids Nsync

      Wie zinterstore gibt zunionstore eine ganze Zahl aus, die die Anzahl der im Zielschlüssel gespeicherten Elemente anzeigt. Obwohl beide der ursprünglich sortierten Sets fünf Mitglieder enthalten, die sortierten Sets jedoch keine sich wiederholenden Mitglieder enthalten können und jeder Schlüssel ein Mitglied mit dem Namen "Joey" beinhaltet, ist die resultierende ganze Zahl 9:

      Output

      (integer) 9

      Wie zinterstore überschreibt zunionstore den Inhalt des Zielschlüssels, wenn dieser bereits existiert.

      Um Ihnen beim Erstellen von neuen sortierten Sets mit zinterstore und zunionstore mehr Kontrolle über die Scores der Mitglieder zu geben, akzeptieren beide Befehle die Optionen WEIGHTS und AGGREGATE.

      Auf die Option WEIGHTS folgt eine Zahl für jedes im Befehl enthaltene sortierte Set, welche die Scores jedes Mitglieds bewertet oder vervielfacht. Die erste Zahl nach der Option WEIGHTS bewertet die Scores des ersten an den Befehl übergebenen Schlüssels, die zweite Zahl den zweiten Schlüssel, und so fort.

      Das folgende Beispiel erstellt ein neues sortiertes Set, das die überschneidenden Schlüssel aus den sortierten Sets NewKids und Nsync enthält. Es bewertet die Scores im Schlüssel NewKids mit dem Faktor drei und die im Schlüssel Nsync mit dem Faktor sieben:

      • zinterstore BoyBandsWeighted 2 NewKids Nsync WEIGHTS 3 7

      Wenn die Option WEIGHTS nicht enthalten ist, wird die Bewertung standardmäßig auf 1 gesetzt, sowohl für zinterstore als auch für zunionstore.

      AGGREGATE akzeptiert drei Suboptionen. Die erste davon, SUM, implementiert das Standardverhalten von zinterstore und zunionstore, indem sie die Scores von übereinstimmenden Mitgliedern den kombinierten Sets hinzufügt.

      Wenn Sie in zwei sortierten Sets, die ein Mitglied teilen, eine zinterstore– oder zunionstore-Operation ausführen, dieses Mitglied aber in jedem Set einen anderen Score hat, können Sie die Operation mit der Suboption MIN zwingen, den niedrigeren der beiden Punktstände zuzuweisen.

      • zinterstore BoyBandsWeightedMin 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MIN

      Da die beiden sortierten Sets nur ein übereinstimmendes Mitglied mit dem gleichen Score (3) haben, erstellt dieser Befehl ein neues Set mit einem Mitglied, das den niedrigeren der beiden bewerteten Scores hat:

      • zscore BoyBandsWeightedMin "Joey"

      Output

      "9"

      Ebenso kann AGGREGATE zinterstore oder zunionstore zwingen, mit der Option MAX den höheren der beiden Scores zuzuweisen:

      • zinterstore BoyBandsWeightedMax 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MAX

      Dieser Befehl erstellt ein neues Set mit einem Mitglied, "Joey", das den höheren der beiden bewerteten Scores hat:

      • zscore BoyBandsWeightedMax "Joey"

      Output

      "21"

      Es kann hilfreich sein, sich WEIGHTS als eine Möglichkeit vorzustellen, die Scores von Mitgliedern vorübergehend zu manipulieren, bevor sie analysiert werden. Ebenso ist es hilfreich, sich die Option AGGREGATE als Entscheidungsmöglichkeit vorzustellen, wie die Scores der Mitglieder kontrolliert werden können, bevor sie in ihre neuen Sets aufgenommen werden.

      Zusammenfassung

      Dieser Leitfaden erläutert eine Reihe von Befehlen, die zur Erstellung und Verwaltung von sortierten Sets in Redis verwendet werden. Wenn es andere verwandte Befehle, Argumente oder Verfahren gibt, die Sie in diesem Leitfaden erklärt sehen möchten, schreiben Sie bitte eine Frage oder einen Vorschlag in das Kommentarfeld unten.

      Weitere Informationen zu Redis finden Sie in unserer Tutorialserie Verwalten einer Redis-Datenbank.



      Source link

      Comment gérer les sets triés dans Redis


      Introduction

      Redis est un magasin open source de données clé-valeur en mémoire. Dans Redis, les sets triés sont un type de données semblable aux sets, en ce sens qu’ils sont tous deux des groupes de chaînes non répétitifs. La différence est que chaque membre d’un set trié est associé à un score, ce qui permet de les trier du plus petit score au plus grand. Comme pour les sets, chaque membre d’un set trié doit être unique, même si plusieurs membres peuvent partager le même score.

      Ce tutoriel explique comment créer des sets triés, récupérer et supprimer leurs membres, et créer de nouveaux sets triés à partir de ceux qui existent déjà.

      Ce guide est rédigé sous la forme d’une fiche avec des exemples autonomes. Nous vous encourageons à passer directement à la section qui correspond à la tâche que vous essayez d’accomplir.

      Les commandes présentées dans ce guide ont été testées sur un serveur Ubuntu 18.04 exécutant la version 4.0.9 de Redis. Pour mettre en place un environnement similaire, vous pouvez suivre l’étape 1 de notre guide Comment installer et sécuriser Redis sur Ubuntu 18.04. Nous montrerons comment ces commandes se comportent en les exécutant avec redis-cli, l’interface en ligne de commande Redis. Notez que si vous utilisez une autre interface Redis, Redli par exemple, la sortie exacte de certaines commandes peut différer.

      Vous pouvez également provisionner une instance de base de données Redis gérée pour tester ces commandes, mais notez que selon le niveau de contrôle autorisé par votre fournisseur de base de données, certaines commandes de ce guide peuvent ne pas fonctionner comme décrit. Pour provisionner une base de données gérée DigitalOcean, suivez la documentation de notre produit Managed Databases. Ensuite, vous devez soit installer Redli, soit mettre en place un tunnel TLS afin de vous connecter à la base de données gérée via TLS.

      Création de sets triés et ajout de membres

      Pour créer un set trié, utilisez la commande zadd. zadd accepte comme arguments le nom de la clé qui contiendra le set trié, suivi du score du membre que vous ajoutez et de la valeur du membre lui-même. La commande suivante va créer une clé de set trié appelée faveGuitarists avec un membre, "Joe Pass", qui a un score de 1 :

      • zadd faveGuitarists 1 "Joe Pass"

      zadd renverra un entier indiquant combien de membres ont été ajoutés au set trié s’il a été créé avec succès.

      Output

      (integer) 1

      Vous pouvez ajouter plus d’un membre à un set trié avec zadd. Notez que leurs scores n’ont pas besoin d’être séquentiels, il peut y avoir des écarts entre les scores, et plusieurs membres détenus dans un même set trié peuvent partager le même score :

      • zadd faveGuitarists 4 "Stephen Malkmus" 2 "Rosetta Tharpe" 3 "Bola Sete" 3 "Doug Martsch" 8 "Elizabeth Cotten" 12 "Nancy Wilson" 4 "Memphis Minnie" 12 "Michael Houser"

      Output

      (integer) 8

      zadd peut accepter les options suivantes, que vous devez saisir après le nom de la clé et avant le premier score de membre :

      • NX ou XX : ces options ont des effets opposés, de sorte que vous ne pouvez en inclure qu’une seule dans toute opération zadd :
        • NX : dit à zadd de ne pas mettre à jour les membres existants. Avec cette option, zadd ne fera qu’ajouter de nouveaux éléments.
        • XX : dit à zadd de seulement mettre à jour les éléments existants. Avec cette option, zadd n’ajoutera jamais de nouveaux membres.
      • CH : normalement, zadd ne renvoie que le nombre de nouveaux éléments ajoutés au set trié. Cependant, si cette option est incluse, zadd renvoie le nombre d’éléments modifiés. Cela inclut les membres nouvellement ajoutés et les membres dont les scores ont été modifiés.
      • INCR : avec cette option, la commande incrémente la valeur du score du membre. Si le membre n’existe pas encore, la commande l’ajoutera au set trié avec l’incrément comme score, comme si son score initial était de 0. Avec INCR inclus, zadd retournera le nouveau score du membre si la commande est réussie. Notez que vous ne pouvez inclure qu’une seule paire score/membre à la fois lorsque vous utilisez cette option.

      Au lieu de passer l’option INCR à zadd, vous pouvez utiliser la commande zincrby qui se comporte exactement de la même manière. Au lieu de donner au membre du set trié la valeur indiquée par la valeur du score comme zadd, elle incrémente le score de ce membre de cette valeur. Par exemple, la commande suivante augmente de 5 le score du membre "Stephen Malkmus", qui passe alors de 4 à 9.

      • zincrby faveGuitarists 5 "Stephen Malkmus"

      Output

      "9"

      Comme c’est le cas avec l’option INCR de la commande zadd, si le membre spécifié n’existe pas, zincrby le créera avec la valeur d’incrément comme score.

      La façon la plus simple de récupérer les membres détenus dans un set trié est d’utiliser la commande zrange. Cette commande accepte comme arguments le nom de la clé dont vous voulez récupérer les membres et une série de membres détenus en son sein. La plage est définie par deux nombres qui représentent des indices basés sur zéro, ce qui signifie que 0 représente le premier membre du set trié (ou le membre ayant le score le plus bas), 1 représente le suivant, et ainsi de suite.

      L’exemple suivant renvoie les quatre premiers membres du set trié faveGuitarists créé dans la section précédente :

      • zrange faveGuitarists 0 3

      Output

      1) "Joe Pass" 2) "Rosetta Tharpe" 3) "Bola Sete" 4) "Doug Martsch"

      Notez que si le set trié que vous passez à zrange comporte deux éléments ou plus qui partagent le même score, il triera ces éléments dans l’ordre lexicographique, ou alphabétique.

      Les indices de départ et d’arrêt peuvent également être des nombres négatifs, avec -1 représentant le dernier membre, -2 l’avant-dernier, etc. :

      • zrange faveGuitarists -5 -2

      Output

      1) "Memphis Minnie" 2) "Elizabeth Cotten" 3) "Stephen Malkmus" 4) "Michael Houser"

      zrange peut accepter l’argument WITHSCORES qui, une fois inclus, rendra également les scores des membres :

      • zrange faveGuitarists 5 6 WITHSCORES

      Output

      1) "Elizabeth Cotten" 2) "8" 3) "Stephen Malkmus" 4) "9"

      zrange ne peut renvoyer une série de membres que dans l’ordre numérique croissant. Pour inverser cela et renvoyer une plage par ordre décroissant, vous devez utiliser la commande zrevrange. Considérez cette commande comme une inversion temporaire de l’ordre du set trié donné avant de renvoyer les membres qui se trouvent dans la plage spécifiée. Ainsi, avec zrevrange, 0 représentera le dernier membre détenu dans la clé, 1 représentera l’avant-dernier, et ainsi de suite :

      • zrevrange faveGuitarists 0 5

      Output

      1) "Nancy Wilson" 2) "Michael Houser" 3) "Stephen Malkmus" 4) "Elizabeth Cotten" 5) "Memphis Minnie" 6) "Doug Martsch"

      zrevrange peut également accepter l’option WITHSCORES.

      Vous pouvez renvoyer une série de membres en fonction de leurs scores avec la commande zrangebyscore. Dans l’exemple suivant, la commande renverra tout membre détenu dans la clé faveGuitarists avec un score de 2, 3 ou 4 :

      • zrangebyscore faveGuitarists 2 4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch" 4) "Memphis Minnie"

      Dans cet exemple, la fourchette est inclusive, ce qui signifie qu’elle renvoie les membres ayant un score de 2 ou 4. Vous pouvez exclure l’une ou l’autre des extrémités de la plage en la faisant précéder d’une parenthèse ouverte ((). Dans l’exemple suivant, la commande renverra chaque membre dont le score est supérieur ou égal à 2, mais inférieur à 4 :

      • zrangebyscore faveGuitarists 2 (4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      Comme pour zrange, zrangebyscore peut accepter l’argument WITHSCORES. La commande accepte également l’option LIMIT, que vous pouvez utiliser pour ne récupérer qu’une sélection d’éléments de la sortie zrangebyscore. Cette option accepte un décalage, qui marque le premier membre de la plage que la commande retournera, et un comptage, qui définit combien de membres la commande retournera au total. Par exemple, la commande suivante examinera les six premiers membres du set trié faveGuitarists mais n’en renverra que trois, à partir du deuxième membre du set, représenté par 1 :

      • zrangebyscore faveGuitarists 0 5 LIMIT 1 3

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      La commande zrevrangebyscore renvoie une plage inversée de membres en fonction de leurs scores. La commande suivante renvoie chaque membre du set avec un score compris entre 10 et 6 :

      • zrevrangebyscore faveGuitarists 10 6

      Output

      1) "Stephen Malkmus" 2) "Elizabeth Cotten"

      Comme pour zrangebyscore, zrevrangebyscore peut accepter à la fois les options WITHSCORES et LIMIT. De plus, vous pouvez exclure l’une ou l’autre extrémité de la plage en la faisant précéder d’une parenthèse ouverte.

      Il peut arriver que tous les membres d’un set trié aient le même score. Dans ce cas, vous pouvez forcer redis à renvoyer une série d’éléments triés lexicographiquement, ou par ordre alphabétique, avec la commande zrangebylex. Pour essayer cette commande, lancez la commande zadd suivante pour créer un set trié où chaque membre a le même score :

      • zadd SomervilleSquares 0 Davis 0 Inman 0 Union 0 porter 0 magoun 0 ball 0 assembly

      zrangebylex doit être suivi du nom d’une clé, d’un intervalle de démarrage et d’un intervalle d’arrêt. Les intervalles de démarrage et d’arrêt doivent commencer par une parenthèse ouverte (() ou une accolade ouverte ([), comme ceci :

      • zrangebylex SomervilleSquares [a [z

      Output

      1) "assembly" 2) "ball" 3) "magoun" 4) "porter"

      Notez que cet exemple n’a renvoyé que quatre des huit membres du set, même si la commande recherchait une plage de a à z. Cela s’explique par le fait que les valeurs Redis sont sensibles à la casse, de sorte que les membres qui commencent par des lettres majuscules ont été exclus de sa sortie. Pour les restituer, vous pouvez procéder comme suit :

      • zrangebylex SomervilleSquares [A [z

      Output

      1) "Davis" 2) "Inman" 3) "Union" 4) "assembly" 5) "ball" 6) "magoun" 7) "porter"

      zrangebylex accepte également les caractères spéciaux -, qui représente l’infini négatif, et +, qui représente l’infini positif. Ainsi, la syntaxe de commande suivante renverra également chaque membre du set trié :

      • zrangebylex SomervilleSquares - +

      Notez que zrangebylex ne peut pas renvoyer les membres d’un set trié dans l’ordre lexicographique inverse (ordre alphabétique croissant). Pour ce faire, utilisez zrevrangebylex :

      • zrevrangebylex SomervilleSquares + -

      Output

      1) "porter" 2) "magoun" 3) "ball" 4) "assembly" 5) "Union" 6) "Inman" 7) "Davis"

      Comme cette commande est destinée à l’utilisation avec les sets triés où chaque membre a le même score, zrangebylex n’accepte pas l’option WITHSCORES. Elle accepte toutefois l’option LIMIT.

      Pour savoir combien de membres se trouvent dans un set trié donné (ou, en d’autres termes, pour déterminer sa cardinalité), utilisez la commande zcard. L’exemple suivant montre combien de membres sont détenus dans la clé faveGuitarists de la première section de ce guide :

      Output

      (integer) 9

      zcount peut vous dire combien d’éléments conservés dans un set trié se situent dans une plage de scores. Le premier chiffre qui suit la clé est le début de la plage et le second est la fin de la plage :

      • zcount faveGuitarists 3 8

      Output

      (integer) 4

      zscore renvoie le score d’un membre spécifique d’un set trié :

      • zscore faveGuitarists "Bola Sete"

      Output

      "3"

      Si la clé ou le membre spécifié n’existe pas, zscore retournera (nil).

      zrank est semblable à zscore, mais au lieu de renvoyer le score du membre donné, il renvoie son rang. Dans Redis, un rang est un indice basé sur zéro des membres d’un set trié, ordonné par leur score. Par exemple, "Joe Pass" a un score de 1, mais comme c’est le score le plus bas de tous les membres de la clé, il a un rang de 0 :

      • zrank faveGuitarists "Joe Pass"

      Output

      (integer) 0

      Il existe une autre commande Redis appelé zrevrank qui remplit la même fonction que zrank, mais qui inverse les rangs des membres du set. Dans l’exemple suivant, le membre "Joe Pass" a le score le plus bas, et par conséquent le rang inversé le plus élevé :

      • zrevrank faveGuitarists "Joe Pass"

      Output

      (integer) 8

      La seule relation entre le score d’un membre et son rang est la position de son score par rapport à ceux des autres membres. S’il y a un écart de score entre deux membres successifs, cela ne se reflétera pas dans leur rang. Notez que si deux membres ont le même score, celui qui vient en premier dans l’ordre alphabétique aura le rang le plus bas.

      Comme zscore, zrank et zrevrank retourneront (nil) si la clé ou le membre n’existe pas.

      zlexcount peut vous dire combien de membres d’un set trié sont contenus dans une plage lexicographique. L’exemple suivant utilise le set trié SomervilleSquares de la section précédente :

      • zlexcount SomervilleSquares [M [t

      Output

      (integer) 5

      Cette commande suit la même syntaxe que la commande zrangebylex, reportez-vous donc à la section précédente pour savoir comment définir une plage de chaînes.

      Suppression de membres des sets triés

      La commande zrem permet de supprimer un ou plusieurs membres d’un set trié :

      • zrem faveGuitarists "Doug Martsch" "Bola Sete"

      zrem renverra un nombre entier indiquant combien de membres ont été retirés du set trié :

      Output

      (integer) 2

      Il existe trois commandes Redis qui vous permettent de supprimer les membres d’un set trié en fonction d’une plage. Par exemple, si chaque membre d’un set trié a le même score, vous pouvez supprimer des membres sur la base d’une plage lexicographique avec zremrangebylex. Cette commande utilise la même syntaxe que zrangebylex. L’exemple suivant permet de supprimer tout membre commençant par une majuscule de la clé SomervilleSquares créée dans la section précédente :

      • zremrangebylex SomervilleSquares [A [Z

      La commande zremrangebylex affichera un nombre entier indiquant le nombre de membres qu’elle a retirés :

      Output

      (integer) 3

      Vous pouvez également supprimer des membres sur la base d’une plage de scores avec la commande zremrangebyscore, qui utilise la même syntaxe que la commande zrangebyscore. L’exemple suivant permettra de supprimer tout membre détenu dans faveGuitarists avec un score de 4, 5 ou 6 :

      • zremrangebyscore faveGuitarists 4 6

      Output

      (integer) 1

      Vous pouvez retirer des membres d’un set basé sur une plage de rangs avec la commande zremrangebyrank, qui utilise la même syntaxe que zrangebyrank. La commande suivante supprimera les trois membres du set trié ayant les rangs les plus bas, qui sont définis par une série d’indices basés sur zéro :

      • zremrangebyrank faveGuitarists 0 2

      Output

      (integer) 3

      Notez que les chiffres transmis à remrangebyrank peuvent également être négatifs, avec -1 représentant le rang le plus élevé, -2 le rang suivant, et ainsi de suite.

      Création de nouveaux sets triés à partir de sets existants

      Redis comprend deux commandes qui vous permettent de comparer les membres de plusieurs sets triés et d’en créer de nouveaux sur la base de ces comparaisons : zinterstore et zunionstore. Pour expérimenter ces commandes, exécutez les commandes zadd suivantes pour créer des exemples de sets triés.

      • zadd NewKids 1 "Jonathan" 2 "Jordan" 3 "Joey" 4 "Donnie" 5 "Danny"
      • zadd Nsync 1 "Justin" 2 "Chris" 3 "Joey" 4 "Lance" 5 "JC"

      zinterstore trouve les membres partagés par deux ou plusieurs sets triés (leur intersection) et produit un nouveau set trié contenant uniquement ces membres. Cette commande doit inclure, dans l’ordre, le nom d’une clé de destination où les membres croisés seront stockés en tant que set trié, le nombre de clés transmises à zinterstore, et les noms des clés que vous voulez analyser :

      • zinterstore BoyBands 2 NewKids Nsync

      zinterstore renvoie un nombre entier indiquant le nombre d’éléments stockés dans le set trié de destination. Comme NewKids et Nsync ne partagent qu’un seul membre, "Joey", la commande renverra 1 :

      Output

      (integer) 1

      Sachez que si la clé de destination existe déjà, zinterstore écrasera son contenu.

      zunionstore va créer un nouveau set trié contenant tous les membres des clés qui lui ont été transmises. Cette commande utilise la même syntaxe que zinterstore, et nécessite le nom d’une clé de destination, le nombre de clés transmises à la commande et les noms des clés :

      • zunionstore SuperGroup 2 NewKids Nsync

      Comme zinterstore, zunionstore renvoie un nombre entier indiquant le nombre d’éléments stockés dans la clé de destination. Même si les deux sets triés originaux contenaient chacun cinq membres, puisque les sets triés ne peuvent pas avoir de membres répétés et que chaque clé a un membre nommé "Joey", l’entier résultant sera 9 :

      Output

      (integer) 9

      Comme zinterstore, zunionstore écrasera le contenu de la clé de destination si elle existe déjà.

      Pour vous donner plus de contrôle sur les scores des membres lors de la création de nouveaux sets triés avec zinterstore et zunionstore, ces deux commandes acceptent les options WEIGHTS et AGGREGATE.

      L’option WEIGHTS est suivie d’un chiffre pour chaque set trié inclus dans la commande qui pondère, ou multiplie, les scores de chaque membre. Le premier chiffre après l’option WEIGHTS pondère les scores de la première clé passée à la commande, le deuxième chiffre pondère la deuxième clé, et ainsi de suite.

      L’exemple suivant crée un nouveau set trié contenant les clés croisées des sets triés NewKids et Nsync. Il pondère les scores dans la clé NewKids par un facteur de trois, et pondère ceux dans la clé Nsync par un facteur de sept :

      • zinterstore BoyBandsWeighted 2 NewKids Nsync WEIGHTS 3 7

      Si l’option WEIGHTS n’est pas incluse, la pondération est par défaut de 1 pour zinterstore et zunionstore.

      AGGREGATE accepte trois sous-options. La première d’entre elles, SUM, implémente le comportement par défaut de zinterstore et zunionstore en ajoutant les scores des membres correspondants dans les sets combinés.

      Si vous exécutez une opération zinterstore ou zunionstore sur deux sets triés qui partagent un membre, mais que ce membre a un score différent dans chaque set, vous pouvez forcer l’opération à attribuer le plus bas des deux scores dans le nouveau set avec la sous-option MIN.

      • zinterstore BoyBandsWeightedMin 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MIN

      Comme les deux sets triés n’ont qu’un seul membre correspondant avec le même score (3), cette commande va créer un nouveau set avec un membre qui a le plus bas des deux scores pondérés :

      • zscore BoyBandsWeightedMin "Joey"

      Output

      "9"

      De même, AGGREGATE peut forcer zinterstore ou zunionstore à attribuer le score le plus élevé des deux avec l’option MAX :

      • zinterstore BoyBandsWeightedMax 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MAX

      Cette commande crée un nouveau set avec un membre, "Joey", qui a le plus haut des deux scores pondérés :

      • zscore BoyBandsWeightedMax "Joey"

      Output

      "21"

      Il peut être utile de considérer WEIGHTS comme un moyen de manipuler temporairement les scores des membres avant qu’ils ne soient analysés. De même, il est utile de considérer l’option AGGREGATE comme un moyen de décider comment contrôler les scores des membres avant qu’ils ne soient ajoutés à leurs nouveaux sets.

      Conclusion

      Ce guide détaille un certain nombre de commandes utilisées pour créer et gérer des sets triés dans Redis. S’il y a d’autres commandes, arguments ou procédures connexes que vous aimeriez voir décrits dans ce guide, n’hésitez pas à faire des suggestions dans les commentaires ci-dessous.

      Pour plus d’informations sur les commandes Redis, consultez notre série de tutoriels Comment gérer une base de données Redis.



      Source link