Valkey სერვერის გამოსაყენებლად სამი რამ გჭირდება: ჰოსტი, პორტი და პაროლი. მათით valkey-cli -h <host> -p <port> --askpass ინტერაქტიულ სესიას ხსნის, PING პასუხობს PONG-ს, ხოლო შენი აპლიკაცია უკავშირდება redis://default:<password>@<host>:<port>/0 ფორმის URL-ით. რადგან Valkey Redis-ის პროტოკოლზე საუბრობს, redis-cli ზუსტად ისევე კარგად მუშაობს, როგორც valkey-cli, და ყველა Redis კლიენტის ბიბლიოთეკა უცვლელად უკავშირდება. პოსტის დანარჩენი ნაწილი დეტალებია: როგორ მოიტანო ბრძანების ხაზის კლიენტი შენს მანქანაზე, როგორ გაიარო ავთენტიფიკაცია პაროლის გაჟონვის გარეშე, როგორ ააწყო URL-ები, რომლებიც სპეციალურ სიმბოლოებს უძლებს, ოცი ბრძანება, რომელსაც ყოველდღე გამოიყენებ, კოდიდან დაკავშირება და რას ნიშნავს გავრცელებული შეცდომის შეტყობინებები.
რა გჭირდება დაწყებამდე#
ვინც სერვერს უშვებს, გაძლევს:
- ჰოსტს: სახელს ან IP მისამართს, მაგალითად
db.example.net. - პორტს: შეთანხმებით
6379, თუმცა ჰოსტინგზე მყოფი სერვერი ხშირად სხვა ნომერზე უსმენს. - პაროლს: Valkey-ის
requirepass-ს ან ACL მომხმარებლის პაროლს. მომხმარებლის სახელის გარეშე ავთენტიფიკაციას გადიხარ ჩაშენებული მომხმარებლით, რომელსაცdefaultჰქვია. - TLS-ს ან მის არარსებობას: ელოდება თუ არა სერვერი დაშიფრულ კავშირს. თუ ელოდება, URL-ის სქემაა
rediss://და CLI-ს--tlsსჭირდება; თუ არა, TLS კლიენტი handshake-ზე ჩავარდება.
ჩაწერე ისინი პაროლების მენეჯერში და არა სამუშაო მაგიდაზე ტექსტურ ფაილში. Valkey-ს ნაგულისხმევად არც შესვლის დაყოვნება აქვს და არც დაბლოკვა; პაროლი ერთადერთია, რაც პორტსა და შენს მონაცემებს შორის დგას, ამიტომ გრძელი და შემთხვევითი უნდა იყოს. Valkey-ის უსაფრთხოება და ACL-ები ეხება ექსპოზიციას, ACL მომხმარებლებსა და საშიშ ბრძანებებს.
ბრძანების ხაზის კლიენტის მოპოვება
ლოკალურად დაყენებული სერვერი არ გჭირდება, მხოლოდ კლიენტი.
| პლატფორმა | როგორ მიიღო კლიენტი |
|---|---|
| Debian, Ubuntu | redis-tools პაკეტი (redis-cli); ახალი რელიზები Valkey-ის ინსტრუმენტებსაც აპაკეტებს |
| Fedora | valkey პაკეტი, რომელიც valkey-cli-ს შეიცავს |
| macOS | brew install valkey |
| Windows | WSL Linux-ის პაკეტით, ან Docker |
| ნებისმიერ ადგილას, სადაც Docker-ია | docker run --rm -it valkey/valkey valkey-cli -h <host> -p <port> |
redis-cli Redis 6-ის ან 7-ის ნებისმიერი რელიზიდან Valkey-სთან უპრობლემოდ საუბრობს. Redis-ისთვის შექმნილი გრაფიკული ინსტრუმენტები - RedisInsight, Another Redis Desktop Manager და სხვები - ზოგადად Valkey-სთანაც მუშაობს, რადგან იგივე პროტოკოლზე საუბრობს; გასაღებების დასათვალიერებლად სასიამოვნოა, მაგრამ CLI-ის ცოდნას ვერ ჩაანაცვლებს.
დაკავშირება და ავთენტიფიკაცია#
აშკარა გზა ამავდროულად გამჟონიცაა:
$ valkey-cli -h db.example.net -p 6380 -a 'the-password'Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe.გაფრთხილება დამსახურებულია. ბრძანების ხაზზე პაროლი ჩანს ყველასთვის, ვისაც ამ მანქანაზე პროცესების სიის ნახვა შეუძლია, და შენს shell-ის ისტორიაში ხვდება. უკეთესი ვარიანტები, უპირატესობის მიხედვით:
# Prompt for it$ valkey-cli -h db.example.net -p 6380 --askpass# Or pass it through the environment$ export VALKEYCLI_AUTH='the-password' # redis-cli reads REDISCLI_AUTH$ valkey-cli -h db.example.net -p 6380# Or authenticate inside the session$ valkey-cli -h db.example.net -p 6380db.example.net:6380> AUTH the-passwordOKAUTH password ავთენტიფიკაციას default მომხმარებლად გადის; AUTH username password - ACL მომხმარებლად. CLI მომხმარებლის სახელისთვის --user-საც იღებს. თუ სერვერი TLS-ს იყენებს, დაამატე --tls, ხოლო კერძო სერტიფიკატის ავტორიტეტისთვის - --cacert ca.pem.
პირველი სესია ოთხი ბრძანებისგან უნდა შედგებოდეს:
db.example.net:6380> PINGPONGdb.example.net:6380> INFO server# Serverredis_version:7.2.4server_name:valkeyvalkey_version:8.1.1...db.example.net:6380> DBSIZE(integer) 0db.example.net:6380> QUITINFO server ზუსტად გეუბნება, რას დაუკავშირდი. Valkey ძველი კლიენტების გულისთვის აჩვენებს redis_version:7.2.4-ს, ხოლო ნამდვილ ვერსიას - valkey_version-ში. დაიმახსოვრე ეს ვერსია: ფორკის შემდეგ დამატებული ბრძანებები მხოლოდ იმ რელიზებში არსებობს, რომლებიც მათ შეიცავს.
კავშირის URL-ები#
კლიენტის ბიბლიოთეკებისა და ფრეიმვორკების უმეტესობა ერთ URL-ს იღებს, რაც კონფიგურაციას ერთ გარემოს ცვლადამდე ამცირებს.
redis://[username]:[password]@[host]:[port]/[database]| URL | მნიშვნელობა |
|---|---|
redis://:s3cret@db.example.net:6380/0 | მხოლოდ პაროლი, default მომხმარებელი, ბაზა 0 |
redis://default:s3cret@db.example.net:6380/0 | იგივე, მომხმარებლის სახელით |
redis://app:s3cret@db.example.net:6380/2 | ACL მომხმარებელი app, ბაზა 2 |
rediss://:s3cret@db.example.net:6380/0 | იგივე TLS-ით |
მახე სპეციალური სიმბოლოებია. პაროლი, რომელიც შეიცავს @, :, /, #, ? ან % სიმბოლოს, URL-ის პარსერს ამტვრევს, ჩვეულებრივ შეცდომაში შემყვანი "connection refused" ან "invalid port" შეცდომით. გააკეთე მათი percent-encoding - @ ხდება %40, / ხდება %2F, # ხდება %23 - ან პაროლები მხოლოდ ასოებითა და ციფრებით შექმენი, რაც ორმოცი სიმბოლოს სიგრძისას ისეთივე ძლიერია, როგორიც ოდესმე დაგჭირდება.
$ python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' 'p@ss/w#rd'p%40ss%2Fw%23rdValkey-ს სპეციფიკური ზოგიერთი კლიენტი valkey://-სა და valkeys://-საც იღებს, მაგრამ redis:// ყველა კლიენტსა და ფრეიმვორკს ესმის, ამიტომ ის უფრო უსაფრთხო ნაგულისხმევია. URL შეინახე გარემოს ცვლადში, მაგალითად VALKEY_URL-ში ან REDIS_URL-ში - გარემოს ცვლადები და საიდუმლოები ხსნის, რატომ არ ეკუთვნის ის რეპოზიტორიას.
ბრძანებები, რომლებსაც ყოველდღე გამოიყენებ#
Valkey არის გასაღები-მნიშვნელობის საცავი, სადაც თითოეულ მნიშვნელობას ტიპი აქვს, და ბრძანებები ტიპზეა მორგებული. სესია, რომელიც მთავარ მათგანს ეხება:
> SET greeting "hello" EX 60OK> GET greeting"hello"> TTL greeting(integer) 57> INCR page:views(integer) 1> HSET user:42 name "Anna" plan "pro"(integer) 2> HGETALL user:421) "name"2) "Anna"3) "plan"4) "pro"> LPUSH jobs "send-email:913"(integer) 1> RPOP jobs"send-email:913"> SADD online:users 42 57(integer) 2> ZADD leaderboard 3100 anna 2800 ben(integer) 2> ZREVRANGE leaderboard 0 9 WITHSCORES1) "anna"2) "3100"3) "ben"4) "2800"> TYPE user:42hash> EXPIRE user:42 3600(integer) 1> UNLINK greeting(integer) 1| ბრძანება | რას აკეთებს |
|---|---|
SET key value EX 60 | ინახავს სტრიქონს 60-წამიანი ვადით |
SET key value NX | ინახავს მხოლოდ მაშინ, თუ გასაღები არ არსებობს (საკეტები, დუბლიკატების მოშორება) |
GET, MGET | კითხულობს ერთ ან ბევრ სტრიქონს ერთ round trip-ში |
INCR, INCRBY | ატომური მთვლელები |
EXPIRE, TTL, PERSIST | ვადის დაყენება, წაკითხვა და მოხსნა |
HSET, HGET, HGETALL | ველი-მნიშვნელობის ჩანაწერები |
LPUSH, RPOP, BRPOP | სიები რიგებად, ბლოკირებადი pop worker-ებისთვის |
SADD, SISMEMBER | უნიკალური წევრების სიმრავლეები |
ZADD, ZRANGE | დალაგებული სიმრავლეები: ლიდერბორდები, დროით დალაგებული ინდექსები |
DEL, UNLINK | წაშლა; UNLINK მეხსიერებას ფონურად ათავისუფლებს |
SCAN | გასაღებების უსაფრთხო გავლა, გვერდ-გვერდ |
Valkey-ის მონაცემთა ტიპები ახსნილი უფრო სიღრმისეულად ფარავს, როდის რომელი ტიპი გამოიყენო.
კოდიდან დაკავშირება#
შექმენი ერთი კლიენტი აპლიკაციის გაშვებისას და ხელახლა გამოიყენე. ყოველ მოთხოვნაზე კავშირის გახსნა round trip-ს ხარჯავს handshake-სა და AUTH-ზე, და კავშირებს აჟონებს, როცა რამე exception-ს ისვრის.
Node.js `ioredis`-ით:
import Redis from "ioredis";const valkey = new Redis(process.env.VALKEY_URL, { maxRetriesPerRequest: 3,});await valkey.set("greeting", "hello", "EX", 60);console.log(await valkey.get("greeting"));Python `redis-py`-ით:
import osimport redisvalkey = redis.Redis.from_url(os.environ["VALKEY_URL"], decode_responses=True)valkey.set("greeting", "hello", ex=60)print(valkey.get("greeting"))decode_responses=True აბრუნებს str-ს bytes-ის ნაცვლად, რაც გინდა, თუ ბინარულ მნიშვნელობებს არ ინახავ.
.NET StackExchange.Redis-ით, რომელიც URL-ის ნაცვლად კავშირის სტრიქონის საკუთარ ფორმატს იყენებს:
db.example.net:6380,password=s3cret,abortConnect=falseგადაეცი ეს ConnectionMultiplexer.Connect-ს ერთხელ და multiplexer მთელ აპლიკაციაში გააზიარე; ის singleton-ად არის შექმნილი. abortConnect=false აპლიკაციას საშუალებას აძლევს, გაეშვას და ცდა გააგრძელოს, თუ სერვერი მოკლე დროით მიუწვდომელია, ჩატვირთვისას ჩავარდნის ნაცვლად.
კავშირების რაოდენობა იმაზე მეტად მნიშვნელოვანია, ვიდრე ადამიანები ელიან: ყოველი პროცესი, worker და cron job საკუთარ კავშირებს ინახავს. კავშირების pool-ები და ლიმიტები ფარავს მათი ზომის შერჩევას.
გასაღებების დასახელება და ვადის მიცემა#
გასაღებების სახელები და დანომრილი ბაზები
Valkey-ს ცხრილები არ აქვს, ამიტომ სტრუქტურა გასაღებების სახელებში ცხოვრობს. შეთანხმება ორწერტილით გამოყოფილი სეგმენტებია ზოგადიდან კონკრეტულისკენ: user:42, session:9f2c..., cache:v3:report:team:7:2026-10-08. პრეფიქსი თითო აპლიკაციაზე (shop:, api:) ერთ სერვერზე მყოფ ორ აპლიკაციას შეჯახებისგან იცავს, ხოლო ვერსიის სეგმენტი ქეშის გასაღებებში ნიშნავს, რომ მნიშვნელობის ფორმის შეცვლა პრეფიქსის შეცვლაა და არა flush.
ცალკე მდგომ სერვერს დანომრილი ბაზებიც აქვს, ნაგულისხმევად 0-დან 15-მდე, რომლებსაც SELECT 2-ით ან URL-ის ბოლოს /2-ით ირჩევ. ისინი იზიარებენ მეხსიერებას, შენახვასა და პაროლს, და FLUSHALL ყველას ცლის, ამიტომ ისინი უფრო სუსტ იზოლაციას იძლევა, ვიდრე ჩანს. პრეფიქსი ჩვეულებრივ უფრო გასაგებია; ცალკე სერვერი კი ნამდვილი იზოლაციაა.
როგორ მუშაობს ვადის გასვლა
ნებისმიერ გასაღებს შეიძლება სიცოცხლის დრო ჰქონდეს. SET key value EX 60 მას ჩაწერისას აყენებს; EXPIRE key 60 არსებულ გასაღებს უმატებს; TTL key კითხულობს, რამდენი დარჩა წამებში, PTTL - მილიწამებში. TTL-ის ორი დაბრუნებული მნიშვნელობა ადამიანებს აბნევს: -1 ნიშნავს, რომ გასაღები არსებობს ვადის გარეშე, ხოლო -2 ნიშნავს, რომ გასაღები საერთოდ არ არსებობს.
ვადაგასული გასაღებები ორი გზით იშლება. როცა კლიენტი ეხება გასაღებს, რომლის დროც გავიდა, ის ადგილზევე იშლება და კლიენტი ვერაფერს ხედავს. ცალკე, სერვერი ფონურად ამოწმებს ვადიანი გასაღებების ნიმუშებს და შლის ვადაგასულებს, რომლებსაც პოულობს. ამ ორს შორის ვადაგასული გასაღებების მეხსიერება თანდათან ბრუნდება და არა მყისიერად, და ამიტომ შეუძლია DBSIZE-ს ხანმოკლედ ჩათვალოს გასაღებები, რომელთა წაკითხვაც ვერცერთ კლიენტს ვერ შეუძლია.
წესი, რომელიც სიურპრიზების უმეტესობას იწვევს: უბრალო SET არსებულ გასაღებზე მის ვადას შლის. თუ კოდი ქეშირებულ მნიშვნელობას SET key newvalue-ით და EX-ის გარეშე ანახლებს, გასაღები ახლა სამუდამოდ ცოცხლობს. ან ვადა ყოველ ჩაწერაზე გადაეცი, ან გამოიყენე SET key newvalue KEEPTTL, რომ ძველი შეინარჩუნოს. EXPIRE ასევე იღებს NX, XX, GT და LT ოფციებს, რომ ვადა დააყენოს მხოლოდ მაშინ, როცა არ არსებობს, მხოლოდ მაშინ, როცა არსებობს, ან მხოლოდ მაშინ, როცა ახალი უფრო გვიანია ან უფრო ადრე - მოსახერხებელია მცოცავი სესიის timeout-ებისთვის. PERSIST key ვადას განზრახ მოხსნის.
მიეცი ვადა ყველაფერს, რაც ქეშია ან სესია. გასაღები ვადის გარეშე დაპირებაა, რომ ვიღაც მას წაშლის, და არავინ შლის.
Pipeline-ები და ტრანზაქციები#
ყოველი ბრძანება ქსელურ round trip-ად ჯდება, და აპლიკაციის სერვერიდან ბაზამდე ეს, როგორც წესი, მილიწამის ნაწილიდან რამდენიმე მილიწამამდეა. ციკლი, რომელიც ათას GET ბრძანებას სათითაოდ აგზავნის, თითქმის მთელ დროს ლოდინში ატარებს. ამას ორი ინსტრუმენტი ასწორებს.
მრავალგასაღებიანი ბრძანებები რამდენიმე ოპერაციას ერთ round trip-ში ასრულებს: MGET და MSET სტრიქონებისთვის, HMGET hash-ის რამდენიმე ველისთვის, და SADD-ის, LPUSH-ისა და DEL-ის მრავალარგუმენტიანი ფორმები.
Pipelining ბევრ ბრძანებას აგზავნის თითოეულ პასუხზე ლოდინის გარეშე, შემდეგ კი ყველა პასუხს ერთად კითხულობს. ყველა კლიენტის ბიბლიოთეკა მას მხარს უჭერს - pipeline() ioredis-სა და redis-py-ში, batch-ები StackExchange.Redis-ში - და ის მასობრივ სამუშაოს ჩვეულებრივ ათჯერ ან მეტჯერ აჩქარებს. Pipeline ატომური არ არის; სხვა კლიენტების ბრძანებები შენს ბრძანებებს შორის შეიძლება შესრულდეს.
როცა ატომურობა გჭირდება, MULTI ბრძანებებს რიგში აყენებს, ხოლო EXEC მათ ერთად უშვებს, ისე რომ სხვა კლიენტებისგან შუაში არაფერი ერევა. Rollback არ არსებობს: თუ ბლოკში ერთი ბრძანება ჩავარდება, დანარჩენები მაინც შესრულდება. WATCH key MULTI-მდე ტრანზაქციას აუქმებს, თუ დაკვირვებული გასაღები ამასობაში შეიცვალა, რაც ოპტიმისტურ დაბლოკვას გაძლევს. ლოგიკისთვის, რომელმაც ჯერ უნდა წაიკითხოს და მერე გადაწყვიტოს, Lua სკრიპტი EVAL-ით სერვერზე ერთ ატომურ ნაბიჯად სრულდება და ხშირად უფრო მარტივია, ვიდრე WATCH - Valkey-ით rate limiting შეიცავს გარჩეულ მაგალითს.
Valkey RE:NODE-ზე#
ბაზების ხაზზე თითოეულ Valkey სერვერს გენერირებული პაროლი მოჰყვება და მას მიმართავ პანელში იმ გეგმისთვის ნაჩვენები ჰოსტითა და პორტით, შუაში proxy slot-ის გარეშე - შენი აპლიკაცია ამ მისამართს პირდაპირ უკავშირდება, redis://default:<password>@<host>:<port>/0-ით ან მისი ეკვივალენტით შენს კლიენტში. მონაცემები დისკზე AOF-ითა და snapshot-ებით ინახება, ამიტომ restart მას არ ცლის. გეგმები 256 MB მეხსიერებით იწყება, საიდანაც გეგმა დაახლოებით 200 MB-ს მონაცემებისთვის გამოსაყენებლად აღნიშნავს. თუ აპლიკაცია app გეგმაზე მუშაობს, URL ჩადე გარემოს ცვლადში მის Startup ჩანართზე.
როცა კავშირი ვერ ხერხდება#
`NOAUTH Authentication required.` დაუკავშირდი, მაგრამ ავთენტიფიკაცია არ გაიარე. დაამატე პაროლი URL-ში ან CLI-ში.
`WRONGPASS invalid username-password pair or user is disabled.` პაროლი არასწორია, ან URL-ის პარსინგმა დაამახინჯა. შეამოწმე იგივე პაროლი CLI-ში --askpass-ით; თუ მუშაობს, პრობლემა URL-ში კოდირებაა.
`Connection refused` ან timeout. არასწორი ჰოსტი ან პორტი, firewall შენსა და სერვერს შორის, ან TLS-ის შეუსაბამობა. valkey-cli -h <host> -p <port> PING იმავე მანქანიდან, სადაც აპლიკაციაა, ქსელის პრობლემებს აპლიკაციის პრობლემებისგან გამოყოფს.
`OOM command not allowed when used memory > 'maxmemory'.` სერვერი სავსეა და მისი eviction პოლიტიკა არაფრის გაძევების საშუალებას არ იძლევა. Valkey-ის მეხსიერება და eviction ფარავს გამოსწორებას.
`ERR max number of clients reached`. რაღაც კავშირებს აჟონებს, ჩვეულებრივ ყოველ მოთხოვნაზე შექმნილი კლიენტი. CLIENT LIST აჩვენებს, ვინაა დაკავშირებული და საიდან.
`LOADING` ... მონაცემთა ნაკრების ჩატვირთვა მეხსიერებაში. სერვერი ახლახან გაეშვა და თავის snapshot-ს კითხულობს ან append-only ფაილს თავიდან ასრულებს. ბრძანებები უარყოფილია, სანამ არ დაასრულებს, რასაც პატარა მონაცემთა ნაკრებისთვის წამები სჭირდება, დიდისთვის კი მეტი. კარგი კლიენტები ამ შეცდომაზე თავისით იმეორებენ ცდას; თუ შენი არ იმეორებს, გაშვების ირგვლივ დაამატე მოკლე განმეორება backoff-ით.
`READONLY You can't write against a read only replica.` primary-ის ნაცვლად რეპლიკას დაუკავშირდი. შეამოწმე ჰოსტი და პორტი - ეს ჩვეულებრივ სხვა გარემოდან გადმოწერილ კონფიგურაციას ნიშნავს.
კავშირები რამდენიმე წუთის უმოქმედობის შემდეგ წყდება. რაღაც კლიენტსა და სერვერს შორის - firewall, NAT gateway, load balancer - უმოქმედო TCP კავშირებს ივიწყებს. სერვერის მხარეს არის timeout (უმოქმედო კლიენტების დახურვა N წამის შემდეგ, ნაგულისხმევად 0, ანუ არასოდეს) და tcp-keepalive (keepalive შემოწმებების გაგზავნა, ნაგულისხმევად 300 წამი). კლიენტის მხარეს ჩართე keepalive ბიბლიოთეკის პარამეტრებში და დარწმუნდი, რომ ის ავტომატურად ხელახლა უკავშირდება, რასაც ioredis, redis-py და StackExchange.Redis ყველა აკეთებს, თუ ასე დააკონფიგურირებ.
`MISCONF` ... დისკზე შენახვა ვერ ხერხდება. ბოლო ფონური შენახვა ჩავარდა, და სერვერი ჩანაწერების მიღებას წყვეტს, რომ შეამჩნიო. ჩვეულებრივ დისკი სავსეა ან შენახვისთვის გაკეთებულ fork-ს მეხსიერება არ ეყო.
FAQ#
შემიძლია redis-cli გამოვიყენო Valkey-სთან?
კი. redis-cli Redis 6-იდან ან 7-იდან იგივე პროტოკოლზე საუბრობს და მუშაობს ყველა ბრძანებისთვის, რომელიც Valkey-სა და Redis-ს საერთო აქვთ. ერთადერთი განსხვავება კოსმეტიკურია: valkey-cli პაროლს VALKEYCLI_AUTH-იდან კითხულობს, ხოლო redis-cli - REDISCLI_AUTH-იდან.
რა მომხმარებლის სახელი გამოვიყენო, თუ მხოლოდ პაროლი მომცეს?
default. Valkey-ის ჩაშენებულ მომხმარებელს default ჰქვია, და AUTH password მომხმარებლის სახელის გარეშე სწორედ მისით გადის ავთენტიფიკაციას. URL-ში ან მომხმარებლის სახელი ცარიელი დატოვე (redis://:password@host), ან default მკაფიოდ ჩაწერე.
უსაფრთხოა MONITOR-ის გაშვება, რომ ვნახო, რას აკეთებს ჩემი აპი?
დებაგინგისას რამდენიმე წამით - კი. MONITOR სტრიმავს ყველა ბრძანებას, რომელსაც სერვერი იღებს, რაც დატვირთულ სერვერზე გამტარუნარიანობის შესამჩნევ ნაწილს ჯდება და ბეჭდავს ყველა მნიშვნელობას, სესიის მონაცემებისა და ნებისმიერი მგრძნობიარე ინფორმაციის ჩათვლით. არასოდეს დატოვო გაშვებული და არასოდეს ჩასვა მისი გამოსავალი საჯარო ადგილას.
როგორ ვნახო, რამდენ მეხსიერებას იყენებს ჩემი მონაცემები?
INFO memory აჩვენებს used_memory_human-ს მთელი სერვერისთვის, ხოლო MEMORY USAGE keyname - ერთი გასაღებისთვის. valkey-cli --bigkeys და --memkeys გასაღებების სივრციდან ნიმუშებს იღებს, რომ სერვერის დაბლოკვის გარეშე იპოვოს ყველაზე დიდი გასაღებები.
რატომ მუშაობს ჩემი პაროლი CLI-ში, მაგრამ არა ჩემს აპში?
თითქმის ყოველთვის URL-ის კოდირების გამო. პაროლში სიმბოლო, მაგალითად @, / ან #, იკითხება როგორც URL-ის სტრუქტურის ნაწილი. გააკეთე მისი percent-encoding, ან ხელახლა შექმენი პაროლი მხოლოდ ასოებითა და ციფრებით.
კომენტარები
სრულიად ანონიმურად: ანგარიშის, ელფოსტის და cookie-ის გარეშე. ინახება მხოლოდ სახელი, ტექსტი და დრო - სხვა არაფერი. ბმულების რაოდენობა ლიმიტირებულია.