Valkey თუ Redis: ლიცენზიის ცვლილება, ფორკი და თავსებადობა

Valkey არის Redis-ის ღია კოდის ფორკი, შექმნილი Linux Foundation-ის ქვეშ 2024 წლის მარტში Redis 7.2.4-იდან, მას შემდეგ რაც Redis-მა ლიცენზია შეცვალა. აპლიკაციისთვის ეს ორი ერთი და იგივეა: იგივე პროტოკოლი, იგივე ბრძანებები, იგივე კონფიგურაციის დირექტივები, იგივე ნაგულისხმევი პორტი 6379 და იგივე კლიენტის ბიბლიოთეკები - შენი Redis კლიენტი Valkey-ს კოდის შეცვლის გარეშე უკავშირდება. ფორკის შემდეგ ისინი ერთმანეთს დაშორდნენ 7.2-ის შემდეგ დამატებულ ფუნქციებში და ლიცენზირებაში, რაც ფორკის არსებობის მიზეზიცაა. თუ Redis-ს ქეშად, სესიების საცავად, რიგად ან rate limiter-ად იყენებ, Valkey-ზე გადასვლას ვერც შეამჩნევ. თუ რამეზე ხარ დამოკიდებული, რაც Redis-ს 7.2-ის შემდეგ დაემატა, მაგალითად Redis 8-ში შერწყმულ მოდულებზე, გადასვლამდე შეამოწმე.

რა მოხდა: ლიცენზიის ცვლილება#

Redis 2009 წლიდან სამპუნქტიანი BSD ლიცენზიით გამოდიოდა, და მისი ცხოვრების უდიდესი ნაწილი ამით ამბავი მთავრდებოდა. 2018 წელს Redis Ltd-მ თავისი დამატებითი მოდულების ნაწილი უფრო შემზღუდველ ლიცენზიებზე გადაიტანა, ბირთვი კი BSD-ზე დარჩა. 2024 წლის მარტში ბირთვიც შეიცვალა.

2024 წლის ორი ლიცენზია - Redis Source Available License v2 და Server Side Public License v1 - დამტკიცებული ღია კოდის ლიცენზიები არ არის. პრაქტიკაში ისინი ზღუდავს Redis-ის შეთავაზებას მართულ სერვისად Redis Ltd-თან კონკურენციაში, რასაც სწორედ დიდი cloud პროვაიდერები აკეთებდნენ. Valkey ამაზე პასუხი იყო: maintainer-ებმა, რომლებიც ამ კომპანიებში Redis-ზე მუშაობდნენ, ბოლო BSD რელიზი დაფორკეს, ხოლო პირველ მხარდამჭერებს შორის იყვნენ Amazon Web Services, Google Cloud, Oracle, Ericsson და Snap.

2025 წელს AGPLv3-ის დამატება Redis 8-ს ჩვეულებრივი განმარტებით ისევ ღია კოდად აქცევს. AGPL არის copyleft ლიცენზია ქსელური პუნქტით: თუ თვითონ Redis-ს შეცვლი და მომხმარებლებს ქსელით მასთან ურთიერთობის საშუალებას მისცემ, მათ შეცვლილი კოდი უნდა შესთავაზო. მათთვის, ვინც Redis-ს შეუცვლელად, კომპონენტად იყენებს, ეს ძალიან ცოტას ცვლის, მაგრამ ბევრ კომპანიას AGPL კოდის საწინააღმდეგო საერთო პოლიტიკა აქვს, და ფორკს იმ დროისთვის უკვე ერთი წლის უპირატესობა ჰქონდა.

რას ნიშნავს ლიცენზიები იმ ადამიანებისთვის, ვინც პროგრამას რეალურად იყენებს:

• საკუთარი აპლიკაციის უკან გაშვება - ქეში, სესიების საცავი, რიგი - ნებადართული იყო ყველა ლიცენზიით, რაც Redis-ს ოდესმე ჰქონია, RSALv2-ისა და SSPLv1-ის ჩათვლით. Redis-თან დაკავშირებისთვის ფულის გადახდას არავინ გთხოვს.
• სერვერის შეცვლა და შეცვლილი ვერსიის გაშვება - აქ AGPLv3 გთხოვს, შენი ცვლილებები იმ სერვისის მომხმარებლებს გამოუქვეყნო. შეუცვლელად გამოყენება შენგან არაფერს ითხოვს.
• თვითონ Redis-ის სერვისად გაყიდვა - სწორედ ამის აღსაკვეთად დაიწერა RSALv2 და SSPLv1, და ამიტომ გადავიდნენ Valkey-ზე პროვაიდერები, რომლებიც ამას აკეთებენ.
• გავრცელება Linux დისტრიბუციაში ან პროდუქტში ყველაზე მარტივია BSD-ით, და ამიტომ ამჯობინეს დისტრიბუციებმა ფორკი.

ასე რომ, დეველოპერისთვის, რომელიც აპლიკაციის უკან ერთ ინსტანციას უშვებს, ამ ლიცენზირებიდან არაფერი ცვლის იმას, რისი გაკეთებაც შეგიძლია. ეს მნიშვნელოვანია კომპანიებისთვის, რომლებიც ჰოსტინგ სერვისებს აშენებენ, და Linux დისტრიბუციებისთვის, რომლებიც წყვეტენ, რა მიაწოდონ. მაგალითად, Fedora-მ თავისი Redis პაკეტი Valkey-ით ჩაანაცვლა.

რა არის Valkey#

Valkey არის Linux Foundation-ის პროექტი ღია მართვის მოდელით, რამდენიმე კომპანიის წარმომადგენლებისგან შემდგარი ტექნიკური მმართველი კომიტეტით და BSD-3-Clause ლიცენზიით, რომელსაც ერთი ვენდორი ვერ შეცვლის. მისი ბინარები ჰქვია valkey-server, valkey-cli, valkey-benchmark, valkey-check-aof და valkey-check-rdb, კონფიგურაციის ფაილი არის valkey.conf, და პაკეტების უმეტესობა თავსებადობის სახელებსაც აყენებს, რომ სკრიპტებმა, რომლებიც redis-cli-ს იძახებს, მუშაობა გააგრძელონ.

პროექტი ერთ ადგილზე არ დგას. ფორკის შემდეგ მთავარი ცვლილებები:

• 8.0 გადააკეთა I/O threading, რომ ერთ ინსტანციას ქსელის დამუშავებისთვის რამდენიმე ბირთვის გამოყენება შეეძლოს, დაამატა ორარხიანი რეპლიკაცია და slot-ების მიხედვით მეტრიკები cluster რეჟიმში.
• 8.1 ძირითადი dictionary შეცვალა ქეშისა და მეხსიერების მხრივ უფრო ეფექტური hash ცხრილით, რამაც თითო გასაღების ზედნადები შეამცირა.
• 9.0 დაამატა hash-ებზე ველების მიხედვით ვადის გასვლა (HEXPIRE, HTTL და მათი მსგავსები), ატომური slot-ების მიგრაცია cluster რეჟიმში და დანომრილი ბაზები cluster რეჟიმში.

JSON-ის, Bloom ფილტრებისა და ძებნის მოდულები ცალკე Valkey პროექტებად არსებობს (valkey-json, valkey-bloom, valkey-search) და სერვერთან ერთად ნაკრებში ვრცელდება, ჩაშენებულის ნაცვლად.

რა არის Redis ახლა#

Redis 8-მა ის, რაც ადრე Redis Stack იყო - JSON დოკუმენტები, მოთხოვნებისა და ძებნის ძრავა, დროითი მწკრივები და ალბათური სტრუქტურები, მაგალითად Bloom ფილტრები - მთავარ დისტრიბუციაში შეაერთა და დაამატა vector set მონაცემთა ტიპი. თუ რომელიმე მათგანს იყენებ, Redis 8-ში ისინი ბირთვის ნაწილია, ნაგულისხმევ Valkey სერვერში კი არ არის.

Redis 7.4-მა ასევე შემოიტანა hash ველების ვადის გასვლა, რომელიც Valkey-მ 9.0-ში დაამატა, ხოლო Redis 8-მა მის გარშემო ბრძანებები დაამატა. ორივე პროექტი ბრძანებების დამატებას აგრძელებს, და 7.2-ის შემდეგ თანხვედრა ნაწილობრივია: ზოგი ფუნქცია ორივეში ერთი სახელით გაჩნდა, ზოგი მხოლოდ ერთში არსებობს. 7.2-ზე ახალი ნებისმიერი რამისთვის ბრძანების დოკუმენტაციის გვერდი შეამოწმე კონკრეტულად იმ სერვერისთვის, რომელსაც უშვებ, ვარაუდის ნაცვლად.

თავსებადობა პრაქტიკაში#

რა არის იდენტური და იდენტური დარჩება, რადგან ორივე პროექტი მას კონტრაქტად მიიჩნევს:

• პროტოკოლი. RESP2 და RESP3, იგივე ჩარჩოები, იგივე HELLO მოლაპარაკება.
• ყველა ბრძანება, რომელიც Redis 7.2-ში არსებობდა - strings, hashes, lists, sets, sorted sets, streams, pub/sub, ტრანზაქციები MULTI-ითა და EXEC-ით, Lua სკრიპტები EVAL-ით, ფუნქციები FCALL-ით, ACL, CLIENT, CONFIG, INFO.
• კონფიგურაცია. valkey.conf იღებს იგივე დირექტივებს, რასაც redis.conf - maxmemory, maxmemory-policy, appendonly, save, requirepass და დანარჩენი.
• შენახვის ფაილები. Valkey კითხულობს RDB snapshot-ებსა და append-only ფაილებს, რომლებიც Redis 7.2-მა და უფრო ძველმა ვერსიებმა დაწერა.

ერთი განზრახ დეტალი ძველ კლიენტებს ეხმარება: Valkey-ის INFO server გამოსავალი კვლავ შეიცავს redis_version:7.2.4-ს, server_name:valkey-სა და valkey_version-თან ერთად, რომელშიც ნამდვილი ვერსიაა. კლიენტის ბიბლიოთეკები, რომლებიც ფუნქციის გამოყენებამდე სერვერის ვერსიას ამოწმებენ, ხედავენ რიცხვს, რომელიც ესმით.

$ valkey-cli -h db.example.net -p 6379 --askpass INFO server | grep -E 'version|server_name'redis_version:7.2.4server_name:valkeyvalkey_version:8.1.1

სიფრთხილე გჭირდება იმ მონაცემებთან, რომლებიც Redis 7.4-მა და უფრო ახალმა ვერსიებმა დაწერა. მათი snapshot-ის ფორმატი შეიძლება უფრო ახალი იყოს, ვიდრე კონკრეტულ Valkey რელიზს შეუძლია წაიკითხოს, ამიტომ Redis 7.4+ dump ფაილის ჩატვირთვამდე Valkey-ის release notes შეამოწმე, ან მონაცემები ბრძანებების დონეზე გადაიტანე, როგორც ქვემოთაა აღწერილი.

კლიენტები და ბიბლიოთეკები#

კლიენტის ბიბლიოთეკებს ლიცენზია არასოდეს შეცვლია - ისინი ცალკე პროექტებია, ძირითადად MIT ლიცენზიით - და ყველა Valkey-სთან უცვლელად მუშაობს.

Valkey GLIDE პროექტის საკუთარი კლიენტია, Rust-ზე დაწერილი საერთო ბირთვით და რამდენიმე ენის binding-ებით. ის კარგი არჩევანია ახალი პროექტისთვის და ზედმეტი ცვლილება არსებულისთვის. ფრეიმვორკები, რომლებიც მათზე დგას - Sidekiq, BullMQ, Celery, Django-ს ქეშის backend, Laravel-ის Redis დრაივერი, Spring Data Redis - ქვედა კლიენტის მეშვეობით მუშაობს და მათთვის სულერთია, რომელი სერვერი პასუხობს.

კავშირის URL-იც იგივეა: redis://:password@host:port/0, ან rediss:// TLS-ისთვის. Valkey-ის ბრენდის ზოგიერთი კლიენტი valkey://-საც იღებს, მაგრამ redis:// ფორმა ყველგან მუშაობს და სწორედ მას ელოდება კონფიგურაციის ფაილები. Valkey-ის დაწყება ფარავს დაკავშირებას და პირველ ბრძანებებს.

გადასვლა Redis-იდან Valkey-ზე#

როგორ გადახვალ, დამოკიდებულია იმაზე, რა მონაცემებია.

ქეში. ნუ გადაიტან. აპლიკაცია ახალ სერვერზე მიმართე და დაელოდე, სანამ შეივსება. პირველი წუთები ცივი ქეშით მიდის, ამიტომ ეს პიკური საათების გარეთ გააკეთე, და თუ ცივი ქეში შენს ბაზას გადატვირთავს, ჯერ წაიკითხე stampede-ის ნაწილი პოსტში Valkey-ის ქეშირების პატერნები.

სესიები და რიგები. ჩვეულებრივ საკმარისად ხანმოკლეა, რომ დაცლა ჯობდეს კოპირებას: შეწყვიტე ძველ სერვერზე ამოცანების რიგში ჩაყენება, დაელოდე worker-ებს, გადართე და შეეგუე, რომ მომხმარებლები, რომლებსაც ძველ სერვერზე სესია ჰქონდათ, კიდევ ერთხელ შევლენ.

მონაცემები, რომლებიც უნდა შეინახო. Redis 7.2-იდან ან უფრო ძველიდან ყველაზე სუფთა გზა რეპლიკაა - გაუშვი Valkey, შეასრულე REPLICAOF old-host 6379 (დაყენებული masterauth-ით, თუ წყაროს პაროლი აქვს), დაელოდე სინქრონიზაციის დასრულებას, შემდეგ დააწინაურე REPLICAOF NO ONE-ით და აპლიკაცია ხელახლა მიმართე. სადაც ახალი სერვერი ძველს ვერ წვდება, გადაიტანე გასაღები გასაღებად SCAN-ით, DUMP-ითა და RESTORE-ით, რაც ტიპებსა და TTL-ებს ინარჩუნებს:

import redissrc = redis.Redis(host="old-host", port=6379, password="old-pass")dst = redis.Redis(host="new-host", port=6379, password="new-pass")for key in src.scan_iter(count=1000):    payload = src.dump(key)    if payload is None:        continue                        # expired between SCAN and DUMP    ttl = src.pttl(key)    dst.restore(key, ttl if ttl > 0 else 0, payload, replace=True)

DUMP payload-ს წყარო ვერსიის სერიალიზაციის ფორმატში ქმნის, ამიტომ ეს მუშაობს Redis 7.2-იდან და უფრო ძველიდან. Redis 7.4-იდან ან 8-იდან გამოიყენე ინსტრუმენტი, რომელიც მნიშვნელობებს ჩვეულებრივი ბრძანებებით კითხულობს და თავიდან წერს, ან აპლიკაციას ააშენებინე ხელახლა ის, რაც სჭირდება.

გადართვამდე ძველ სერვერზე გაუშვი INFO server და MODULE LIST. მოდული ამ სიაში - ReJSON, search, timeseries - არის დამოკიდებულება, რომელიც ჯერ უნდა გადაწყვიტო.

წარმადობა: რა განსხვავდება სინამდვილეში#

ორის შედარებით benchmark-ებს ძირითადად აქვეყნებენ ადამიანები, რომლებიც შედეგით დაინტერესებულები არიან, და უმეტესობა ზომავს დიდ მანქანას, რომელიც წამში მილიონობით მოთხოვნამდეა აყვანილი. რამდენიმე განსხვავება ნამდვილია, და სასარგებლოა იცოდე, რომელია მნიშვნელოვანი იმ ზომაზე, რომელზეც აპლიკაციების უმეტესობა მუშაობს.

ბრძანებების შესრულება ორივეში ერთ thread-ზეა. თითოეული ბრძანება ბოლომდე სრულდება, სანამ შემდეგი დაიწყება, და სწორედ ეს ხდის INCR-ს ატომურს და Lua სკრიპტებს უსაფრთხოს საკეტების გარეშე. არცერთ პროექტს ეს არ შეუცვლია და არც შეცვლის, რადგან მთელი პროგრამირების მოდელი ამაზეა დამოკიდებული. რისი გადანაწილებაც ორივეს შეუძლია thread-ებზე, ეს ბრძანებების გარშემო ქსელური სამუშაოა: სოკეტებიდან მოთხოვნების წაკითხვა, მათი პარსინგი და პასუხების ჩაწერა. Redis-მა threaded I/O მე-6 ვერსიაში დაამატა; Valkey 8-მა ის არსებითად გადააკეთა, ასე რომ ერთი Valkey ინსტანცია რამდენიმე ბირთვზე გაცილებით მეტ კავშირსა და მოთხოვნას ამუშავებს, სანამ მთავარი thread ზღვრად იქცევა. ორივეში მას io-threads დირექტივა აკონტროლებს, და ის მხოლოდ მაშინ გეხმარება, როცა თავისუფალი ბირთვები და ბევრი ერთდროული კლიენტი გაქვს.

თითო გასაღებზე მეხსიერება Valkey 8.1-ში შემცირდა. ახალი hash ცხრილი გასაღებებს ნაკლები ზედნადებით ინახავს. მონაცემთა ნაკრები რამდენიმე დიდი მნიშვნელობით ამას ვერ შეამჩნევს; მონაცემთა ნაკრები მილიონობით პატარა გასაღებით - სესიის ID-ები, rate-limit მთვლელები, რამდენიმე ათეული ბაიტის ქეშის ჩანაწერები - იმავე მეხსიერებაში შესამჩნევად მეტს ატევს. პატარა ინსტანციაზე, სადაც მეხსიერება ის ზღვარია, რომელსაც რეალურად ეჯახები, სწორედ ეს გაუმჯობესება ღირს ყურადღებად.

მცირე მასშტაბზე round trip-ები დომინირებს. აპლიკაციისთვის, რომელიც წამში რამდენიმე ასეულ ბრძანებას აგზავნის, სერვერის შიდა სისწრაფე უმნიშვნელოა: თითოეული ბრძანება ქსელურ round trip-ად ჯდება, და დრო სწორედ იქ მიდის. რამდენიმე ბრძანების pipelining ერთ round trip-ში, MGET-ის გამოყენება GET-ების ციკლის ნაცვლად და კავშირების ღიად შენახვა pool-ში შენი latency-ისთვის მეტს აკეთებს, ვიდრე ორ სერვერს შორის ნებისმიერი არჩევანი. valkey-benchmark (ან redis-benchmark, რომელიც ორივესთან მუშაობს) ზომავს, რას იძლევა შენი საკუთარი სერვერი და ქსელი, და ეს ერთადერთი benchmark-ია, რომელიც შენ გეხება:

$ valkey-benchmark -h db.example.net -p 6379 -a "$PASS" -t set,get -n 100000 -q$ valkey-benchmark -h db.example.net -p 6379 -a "$PASS" -t set,get -n 100000 -P 16 -q

მეორე ხაზი თექვსმეტ ბრძანებას აგზავნის pipeline-ით თითო round trip-ში. სხვაობა ორ შედეგს შორის, როგორც წესი, pipelining-ის სასარგებლოდ ყველაზე დამაჯერებელი არგუმენტია, რასაც ოდესმე ნახავ.

რომელი აირჩიო#

აპლიკაციების უმეტესობისთვის მნიშვნელობა არ აქვს, და გადამწყვეტი ფაქტორი ისაა, რას გთავაზობს შენი პლატფორმა. აირჩიე Valkey, როცა გინდა BSD ლიცენზიის სერვერი რამდენიმე ვენდორის მართვით, ან როცა სწორედ მას აწვდის შენი დისტრიბუცია ან ჰოსტი. აირჩიე Redis 8, როცა ერთ სერვერში გჭირდება მისი ჩაშენებული JSON, ძებნა, დროითი მწკრივები ან ვექტორული ფუნქციები და AGPL გაწყობს. ნებისმიერ შემთხვევაში, სადაც შეგიძლია, აპლიკაციის კოდი Redis 7.2-ის ბრძანებათა ნაკრებზე დაწერე, და ის ორივეზე წლების განმავლობაში იმუშავებს.

უფრო მნიშვნელოვანი კითხვა, როგორც წესი, ის კი არ არის, რომელი, არამედ გჭირდება თუ არა საერთოდ რომელიმე - Redis: როდის გჭირდება ამას ასაბუთებს - და რამდენი მეხსიერება და შენახვა სჭირდება საქმეს.

Valkey RE:NODE-ზე#

ბაზების ხაზი მოიცავს Valkey-ს და არა Redis-ს, და ასე განზრახ ჰქვია. ის Redis-ის პროტოკოლზე საუბრობს, ამიტომ ნებისმიერი Redis კლიენტი ან ბიბლიოთეკა მას უცვლელად უკავშირდება. თითოეული სერვერი პაროლით არის დაცული, მისთვის გენერირებული მონაცემებით, და მას გეგმისთვის ნაჩვენები ჰოსტითა და პორტით მიმართავ; proxy slot არ არის, ამიტომ აპლიკაცია პირდაპირ უკავშირდება. მონაცემები დისკზე ინახება AOF-ითაც და snapshot-ებითაც, ამიტომ restart მას არ ცლის. გეგმები 256 MB მეხსიერებით იწყება და 4 GB-მდე ადის. რომელი ბაზა გამოვიყენო მას PostgreSQL-ის, MySQL-ის, MongoDB-ისა და SQL Server-ის ხაზების გვერდით აყენებს.

FAQ#

არის Valkey Redis-ის პირდაპირი შემცვლელი?

Redis 7.2-ისა და უფრო ძველი ვერსიებისთვის - კი: იგივე პროტოკოლი, ბრძანებები, კონფიგურაცია და ფაილის ფორმატები. აპლიკაციები, რომლებიც Redis 7.4-ში ან 8-ში დამატებულ ფუნქციებს იყენებს - მაგალითად შერწყმულ JSON, ძებნისა და დროითი მწკრივების მოდულებს - გადართვამდე ბრძანება ბრძანებად შემოწმებას საჭიროებს.

უნდა შევცვალო ჩემი Redis კლიენტის ბიბლიოთეკა?

არა. redis-py, ioredis, node-redis, Jedis, Lettuce, go-redis, StackExchange.Redis და phpredis ყველა Valkey-ს ისე უკავშირდება, როგორც არის. Valkey-ის ბრენდის ფორკები და GLIDE კლიენტი არსებობს, მაგრამ მათზე გადასვლა არჩევითია.

Redis ისევ ღია კოდია?

2025 წლის Redis 8-იდან Redis-ის გამოყენება შეიძლება AGPLv3-ით, რომელიც OSI-ის მიერ დამტკიცებული ღია კოდის ლიცენზიაა, RSALv2-ისა და SSPLv1-ის ალტერნატივად. Redis 7.4 მხოლოდ ორი source-available ლიცენზიით გამოვიდა. Valkey მთელი ამ ხნის განმავლობაში BSD-3-Clause-ზე დარჩა.

რატომ აჩვენებს Valkey redis_version 7.2.4-ს?

თავსებადობისთვის. ზოგიერთი კლიენტის ბიბლიოთეკა ფუნქციის გამოყენებამდე სერვერის ვერსიას ამოწმებს, და მათ Redis-ის ვერსიის ნომრები იციან. Valkey ამ ველში იმ ვერსიას აჩვენებს, საიდანაც დაფორკდა, ხოლო საკუთარ ვერსიას ცალკე აჩვენებს valkey_version-ად.

შეუძლია Valkey-ს ჩემი Redis-ის dump.rdb ფაილის წაკითხვა?

Redis 7.2-ისა და უფრო ძველი ვერსიების დაწერილი ფაილების - კი. Redis 7.4-ის ან უფრო ახლის ფაილებმა შეიძლება უფრო ახალი ფორმატი გამოიყენოს; შეამოწმე Valkey-ის release notes შენი ვერსიისთვის, ან ფაილის კოპირების ნაცვლად ბრძანებების დონეზე გადაიტანე.