تصلك رسالة نصية من متجر فيها رابط قصير من سبعة أحرف، فتضغط عليه، وخلال جزء من الثانية يفتح المتصفح صفحة العرض الطويلة بكل معاملاتها. ولو كتب المتجر الرابط الأصلي لأخذ وحده نصف الرسالة، لأن الرسالة النصية بالعربية تتسع لـ 70 حرفاً فقط في المقطع الواحد كما تشرح صفحة ترميز UCS-2 عند Twilio، وكل مقطع إضافي يدفع ثمنه. ولذلك تطلب كثير من الشركات خدمة تقصير روابط خاصة بها، على نطاقها هي، تعرف كم شخصاً ضغط على كل رابط، ولا تتوقف لأن مزوداً خارجياً قرر أن يغلق خدمته. والخدمة تبدو أبسط نظام يمكن أن تصممه: جدول فيه عمودان، رمز قصير ورابط طويل. ولكن عندما تبدأ في التفاصيل تظهر أسئلة حقيقية: كيف تولد رمزاً قصيراً لا يتكرر ولا يمكن تخمينه؟ وهل يرد السيرفر بالتحويل 301 أم 302، ولماذا يهم ذلك للإحصاءات؟ وماذا يحدث عندما يمر برنامج على كل الرموز الممكنة ليجد الروابط الخاصة؟
ولهذا السبب تبدأ أغلب كتب ومقابلات تصميم الأنظمة بهذه الخدمة، فهي صغيرة بما يكفي لتصممها كاملة في ساعة، وفيها في نفس الوقت أغلب أفكار التصميم: التقدير والمعرفات والتخزين المؤقت وتحديد المعدل والإساءة. وهذا المقال هو أول دراسة حالة في هذا القسم، وسوف نطبق فيه طريقة التصميم من سبع خطوات التي شرحناها في مقال طريقة تصميم أي نظام، خطوة بخطوة، ثم نبني الخدمة فعلاً بـ PostgreSQL وValkey، ونختبرها بأداة k6، ونجد فيها خطأين حقيقيين ونصلحهما.
وسوف نناقش في هذا المقال ما يلي:
- ماذا يحدث بالضبط بين الضغط على الرابط القصير وفتح الصفحة.
- المتطلبات والتقدير السريع، وكم حرفاً يحتاج الرمز القصير لعشرات المليارات من الروابط.
- الواجهة API ومخطط قاعدة البيانات.
- أربع طرق لتوليد الرمز: العداد مع Base62، والهاش المقطوع، والرمز العشوائي، والعداد المخلوط بمفتاح، مع حساب التصادم Collision وقياسه.
- التحويل 301 أم 302، وما يعنيه كل منهما للمتصفح والإحصاءات.
- التخزين المؤقت Caching ونسبة الإصابة Hit Ratio، وتحديد المعدل Rate Limiting، والإساءة Abuse.
- تجربة عملية كاملة: البناء واختبار الضغط بقياس p50 وp99، وثغرة تعداد الرموز Enumeration، وتعطل ال Cache، والإصلاح.
- هل تبني خدمتك أم تستخدم أداة مفتوحة المصدر جاهزة.
ماذا يحدث عندما تضغط على الرابط القصير؟
الرابط القصير عنوان HTTP عادي على نطاق الخدمة، مثل https://s.example/8XP0tVV، والجزء بعد الشرطة هو الرمز Code. وعندما تضغط عليه يحدث ما يلي:
- المتصفح يسأل DNS عن عنوان النطاق، ثم يفتح اتصال HTTPS مع سيرفر الخدمة ويرسل
GET /8XP0tVV. - السيرفر يبحث عن الرمز، أولاً في التخزين المؤقت Cache في الذاكرة، ثم في قاعدة البيانات إذا لم يجده.
- إذا وجده رد برمز حالة من عائلة التحويل Redirect، 301 أو 302، ومعه الترويسة
Locationوفيها الرابط الطويل، ولا يوجد في الرد أي جسم تقريباً. - المتصفح يقرأ
Locationويطلب الرابط الطويل من موقعه الأصلي، فتفتح الصفحة. - الخدمة تسجل الضغطة Click في الخلفية للإحصاءات، دون أن تؤخر التحويل.
أي أن الخدمة لا ترسل الصفحة نفسها أبداً، وكل ما ترسله بضع مئات من البايتات، وهذا ما يجعلها تتحمل أعداداً كبيرة من الطلبات على سيرفرات قليلة، ويجعل زمن الاستجابة Latency هو المقياس الأهم فيها، لأن كل ملي ثانية تضيفها يدفعها المستخدم قبل أن يرى الصفحة التي يريدها. وقد شرحنا تفاصيل الطلب والرد ورموز الحالة في مقال ما هي واجهة API.

الخطوة الأولى: المتطلبات Requirements
المتطلبات الوظيفية Functional Requirements كما اتفقنا عليها:
- المستخدم يرسل رابطاً طويلاً فيحصل على رابط قصير على نطاقنا.
- من يفتح الرابط القصير يصل إلى الرابط الطويل.
- صاحب الرابط يرى عدد الضغطات.
- يمكن تعطيل رابط مسيء أو تحديد تاريخ انتهاء لرابط.
- خارج النطاق الآن: الرموز المخصصة التي يختارها المستخدم، مثل
/sale2026، وتعديل الرابط الطويل بعد إنشائه، والإحصاءات التفصيلية حسب الدولة والجهاز.
والمتطلبات غير الوظيفية Non-functional Requirements هي التي تحدد التصميم فعلاً:
- التحويل سريع: أقل من 50 ملي ثانية داخل السيرفر في p99، لأن المستخدم ينتظره قبل أي شيء آخر.
- التحويل متاح دائماً: الرابط مطبوع في رسائل وإعلانات ووثائق لا يمكن تعديلها، فتوقف التحويل يعني آلاف الروابط المعطلة في نفس اللحظة. أما إنشاء الروابط فيحتمل توقفاً قصيراً.
- الرابط يعيش للأبد: لا يمكن أن يتغير الرابط الطويل خلف رمز موجود، ولا يمكن أن يعاد استخدام رمز لرابط آخر.
- الرمز قصير ولا يمكن تخمينه: بعض الروابط تؤدي إلى مستندات خاصة لا يجب أن يصل إليها غير من أرسلت له.
- الإحصاءات تقريبية: لا يضر أن يضيع عدد قليل من الضغطات، ولكن يضر كثيراً أن يتأخر التحويل بسببها.
الخطوة الثانية: التقدير Estimation
نفترض خدمة متوسطة الحجم: مليون رابط جديد في اليوم، وكل رابط يفتح في المتوسط مئة مرة، أي أن القراءة مئة ضعف الكتابة، والذروة خمسة أضعاف المتوسط، ونحتفظ بالروابط خمس سنوات على الأقل. والحساب كما يلي:
| ماذا نحسب | الحساب | النتيجة |
|---|---|---|
| إنشاء في الثانية، متوسط وذروة | 1,000,000 ÷ 86,400 × 5 | 12 و58 في الثانية |
| تحويل في الثانية، متوسط وذروة | 100,000,000 ÷ 86,400 × 5 | 1,157 و5,787 في الثانية |
| روابط بعد خمس سنوات | 1,000,000 × 365 × 5 | 1.825 مليار رابط |
| حجم الرابط الواحد في PostgreSQL | قسناه في التجربة مع روابط طولها 52 حرفاً | 170.6 بايتاً |
| حجم البيانات بعد خمس سنوات | 1.825 مليار × 171 بايتاً | حوالي 312 جيجابايت |
| الروابط الساخنة في الذاكرة | 20% من روابط آخر شهر × 171 بايتاً | حوالي 1 جيجابايت |
والأرقام أعلاه تقول أشياء واضحة: الكتابة قليلة جداً ولا تحتاج أي تصميم خاص، والقراءة حوالي ستة آلاف في الثانية في الذروة، وكل البيانات بعد خمس سنوات تتسع على قرص سيرفر واحد، والروابط الساخنة تتسع في ذاكرة Valkey صغير. أي أن هذا نظام يعتمد على القراءة Read-heavy، والمشكلة الحقيقية فيه هي سرعة التحويل وتوفره، وليس حجم البيانات. ولاحظ أن حجم الرابط الواحد يعتمد على طول الرابط الطويل، وروابط الحملات التسويقية بمعاملات UTM أطول غالباً من 52 حرفاً، فقس على بياناتك الحقيقية.
كم حرفاً يحتاج الرمز؟
إذا استخدمنا الأرقام والحروف الإنجليزية الكبيرة والصغيرة فعندنا 62 رمزاً لكل خانة، وهذا ما يسمى Base62، وعدد الرموز الممكنة بطول n هو 62 أس n. فبستة أحرف عندنا حوالي 56.8 مليار رمز، وبسبعة أحرف 3.52 تريليون رمز. ورقم 1.825 مليار رابط يتسع في ستة أحرف، فلماذا تستخدم أغلب الخدمات سبعة أو أكثر؟ والإجابة في المتطلب الذي يقول إن الرمز لا يجب أن يخمن: إذا كان في الخدمة 1.825 مليار رابط من 56.8 مليار رمز ممكن، فإن كل تخمين عشوائي يصيب رابطاً حقيقياً بنسبة واحد من 31 تقريباً، وبسبعة أحرف تصبح النسبة واحداً من 1,930، وهذا ما زال قريباً جداً لمن يملك برنامجاً يرسل آلاف الطلبات. لذلك طول الرمز قرار أمني قبل أن يكون قرار مساحة، وسوف نعود إليه في قسم الإساءة.
الخطوة الثالثة: الواجهة API
| العملية | الطلب | الرد |
|---|---|---|
| إنشاء رابط | POST /api/links مع {"url": "https://…"} | 201 مع الرمز والرابط القصير، أو 422 لرابط مرفوض، أو 429 عند تجاوز الحد |
| التحويل | GET /{code} | 302 مع Location، أو 404 |
| الإحصاءات | GET /api/links/{code}/stats | عدد الضغطات |
ولاحظ أن مسار التحويل في أعلى النطاق مباشرة وليس تحت /api، لأن كل حرف في الرابط القصير له ثمن، وهذا يعني أن الرموز لا يجب أن تتعارض مع مسارات الخدمة نفسها، فلا يمكن أن يكون الرمز api مثلاً، والتحقق من صيغة الرمز في أول سطر من دالة التحويل يحل ذلك.
الخطوة الرابعة: نموذج البيانات Data Model
نمط الوصول الأهم واحد: ابحث عن رمز واحد بالضبط وأرجع رابطه، وهذا نمط مفتاح وقيمة Key-Value يخدمه أي نوع من قواعد البيانات، والكتابة قليلة، ولا يوجد استعلام يجمع بين الروابط في المسار السريع. لذلك اخترنا PostgreSQL لأنه يكفي الحجم كما رأينا، ويعطينا القيود Constraints التي تضمن أن الرمز لا يتكرر، ويعرفه الفريق، وقد ناقشنا هذا الاختيار في مقال PostgreSQL لكل شيء. والمخطط كما يلي:
CREATE SEQUENCE link_id_seq AS bigint;
CREATE TABLE links (
id bigint PRIMARY KEY DEFAULT nextval('link_id_seq'),
code text NOT NULL UNIQUE,
long_url text NOT NULL CHECK (long_url ~ '^https?://' AND length(long_url) <= 2048),
owner_id bigint,
created_at timestamptz NOT NULL DEFAULT now(),
expires_at timestamptz,
disabled boolean NOT NULL DEFAULT false
);
ALTER SEQUENCE link_id_seq OWNED BY links.id;
-- domains we refuse to shorten (abuse reports, phishing feeds)
CREATE TABLE blocked_domains (domain text PRIMARY KEY);
INSERT INTO blocked_domains VALUES ('bad.example'), ('phish.example');في المخطط أعلاه لاحظ التالي:
- القيد
UNIQUEعلى العمودcodeهو الضمان الحقيقي أن الرمز لا يتكرر، فحتى لو أخطأ الكود في التوليد ترفض قاعدة البيانات الرمز المكرر، وهو أيضاً الفهرس الذي يخدم التحويل. - القيد
CHECKعلى الرابط يرفض أي رابط لا يبدأ بـ http أو https، فلا يمكن أن يدخلjavascript:أوdata:حتى لو نسي الكود التحقق. - العمودان
disabledوexpires_atيسمحان بإيقاف رابط مسيء دون حذفه، لأن الحذف يحرر الرمز ليعاد استخدامه، وهذا ممنوع في متطلباتنا. - الجدول
blocked_domainsقائمة النطاقات المرفوضة، وفي الإنتاج تتغذى من بلاغات الإساءة وقوائم التصيد.
كيف تولد الرمز القصير؟ ID Generation
هذا هو القسم الذي تدور حوله أغلب نقاشات هذا التصميم، وهناك أربع طرق معروفة، ولكل منها نقاط قوة ونقاط ضعف، وقد شرحنا المعرفات الفريدة بأنواعها، UUID وULID وSnowflake وSqids، في مقال المعرفات الفريدة، وهنا نركز على ما يخص الرمز القصير.
الطريقة الأولى: العداد مع Base62
تأخذ رقماً من عداد Sequence في قاعدة البيانات، وتكتبه بالأساس 62، فالرقم 1 هو 1، والرقم 62 هو 10، والرقم 1,000,001 هو 4C93. ونقاط القوة أن الرمز لا يتكرر أبداً بدون أي فحص، لأن العداد لا يعطي نفس الرقم مرتين، وأن الرموز تبدأ قصيرة جداً وتطول ببطء، فأول 56.8 مليار رابط تأخذ ستة أحرف أو أقل. ونقطة الضعف القاتلة أن الرموز متتالية، فمن يعرف أن رابطه 4C93 يعرف أن 4C94 موجود، ويستطيع برنامج بسيط أن يمر على كل الروابط بالترتيب، كما سوف نرى في التجربة. وهي أيضاً تكشف حجم عملك، فمن ينشئ رابطين بينهما أسبوع يعرف كم رابطاً أنشأت في الأسبوع.
الطريقة الثانية: الهاش المقطوع Truncated Hash
تحسب هاش الرابط الطويل، مثل SHA-256، وتأخذ أول سبعة أحرف منه بعد تحويله إلى Base62. ونقطة القوة أن نفس الرابط يعطي نفس الرمز دائماً، فلا تحتاج أن تحفظ الرابط مرتين. ولكن الهاش المقطوع إلى سبعة أحرف ليس فريداً، فرابطان مختلفان قد يعطيان نفس الرمز، وهذا ما يسمى التصادم Collision، ومتى يحدث؟ هنا تأتي مسألة عيد الميلاد Birthday Problem: في غرفة فيها 23 شخصاً فقط، احتمال أن يتشارك اثنان نفس يوم الميلاد أكثر من 50%، مع أن السنة فيها 365 يوماً. والسبب أنك لا تقارن شخصاً واحداً بالباقين، وإنما كل زوج بكل زوج. ونفس الحساب على الرموز يقول إن أول تصادم يحدث باحتمال 50% بعد حوالي الجذر التربيعي لعدد الرموز الممكنة، أي بعد حوالي 2.2 مليون رمز من أصل 3.52 تريليون، وهذا رقم تصل إليه الخدمة في يومين ونصف حسب تقديرنا.
ولكي لا نعتمد على المعادلة وحدها قسناها: البرنامج collide.py يولد رموزاً حتى يجد أول تكرار، عشر مرات بالرموز العشوائية وعشر مرات بهاش روابط مختلفة كلها:
# How many 7-character codes until the first collision? Random codes and truncated hashes of distinct URLs.
# python collide.py RUNS
import hashlib, math, random, statistics, sys
N = 62 ** 7
RUNS = int(sys.argv[1])
ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
def b62(n):
s = ""
for _ in range(7):
n, r = divmod(n, 62)
s = ALPHABET[r] + s
return s
def first_collision(make):
seen = set()
i = 0
while True:
c = make(i)
if c in seen:
return i
seen.add(c)
i += 1
print(f"space 62^7 = {N:,}")
print(f"birthday estimate for 50%: sqrt(2 ln2 N) = {math.sqrt(2 * math.log(2) * N):,.0f}")
for name, make_factory in [
("random", lambda run: (lambda i, r=random.Random(run): b62(r.randrange(N)))),
("sha256[:7]", lambda run: (lambda i: b62(int.from_bytes(hashlib.sha256(
f"https://example.com/p/{run}/{i}".encode()).digest()[:8], "big") % N)))]:
hits = [first_collision(make_factory(run)) for run in range(RUNS)]
print(f"{name:<11} runs={RUNS} first collision after: min={min(hits):,} median={statistics.median(hits):,.0f} max={max(hits):,}")space 62^7 = 3,521,614,606,208
birthday estimate for 50%: sqrt(2 ln2 N) = 2,209,524
random runs=10 first collision after: min=946,811 median=2,299,532 max=4,378,380
sha256[:7] runs=10 first collision after: min=684,492 median=2,090,723 max=4,165,771الوسيط في التجارب العشر 2.3 مليون للرموز العشوائية و2.09 مليون للهاش، قريب جداً من المعادلة، وفي أسوأ تجربة حدث التصادم بعد 684 ألف رمز فقط. وهذا يعني أن خدمة تعتمد على الهاش المقطوع دون فحص التصادم سوف تعطي في أسبوعها الأول رابطاً لشخص يفتح صفحة شخص آخر. لذلك الهاش المقطوع يحتاج دائماً فحصاً وحلاً عند التصادم، مثل إضافة حرف أو ملح Salt وإعادة الحساب، وعندها تكون فقدت ميزته الأساسية وهي أن الرمز يحسب دون أن تسأل قاعدة البيانات.
الطريقة الثالثة: الرمز العشوائي Random
تولد سبعة أحرف عشوائية من مولد آمن تشفيرياً، وتحاول إدراجها، فإذا رفضها القيد UNIQUE لأنها موجودة تولد غيرها. والتصادم هنا محاولة ثانية وليس خطأً، واحتمالها صغير جداً: مع 1.825 مليار رابط تصادم المحاولة الأولى بنسبة 1 من 1,930 تقريباً. ونقطة القوة أن الرمز لا يكشف شيئاً ولا يمكن توقعه، ونقطة الضعف أن كل إنشاء قد يحتاج أكثر من محاولة، وأن الرموز العشوائية تدخل الفهرس في أماكن عشوائية فتتوزع الكتابة على صفحاته، وهذا لا يهم مع 58 إنشاء في الثانية.
الطريقة الرابعة: العداد المخلوط بمفتاح Feistel
هذه الطريقة تجمع ميزة العداد، أي أن الرمز لا يتكرر دون فحص، وميزة العشوائي، أي أن الرمز لا يمكن توقعه. والفكرة أن تأخذ رقم العداد وتمرره على دالة تبديل Permutation بمفتاح سري، تحول كل رقم من 0 إلى 2 أس 40 إلى رقم آخر في نفس المجال، دون أن يتحول رقمان إلى نفس الرقم أبداً. وأشهر طريقة لبناء دالة كهذه هي شبكة Feistel، وهي نفس البنية التي بني عليها التشفير DES: تقسم الرقم إلى نصفين، وفي كل جولة تخلط نصفاً بهاش النصف الآخر مع المفتاح، وتبدل النصفين. والجميل فيها أنها قابلة للعكس دائماً مهما كانت دالة الهاش، فلا يمكن أن تعطي نفس الناتج لرقمين مختلفين. والناتج رقم بين 0 وحوالي 1.1 تريليون، يكتب بسبعة أحرف Base62.
ولاحظ أن هذه ليست Sqids، فمكتبة Sqids تخفي الرقم ولكن يمكن فكها إلى الرقم الأصلي إذا عرفت الأبجدية كما يقول المشروع نفسه، أما Feistel مع مفتاح سري بطول كاف فلا يمكن عكسها دون المفتاح. ولكن تذكر أنها لا تجعل المجال أكبر، فمع 1.825 مليار رابط من 1.1 تريليون رقم ممكن ما زال التخمين العشوائي يصيب بنسبة 1 من 600 تقريباً. لذلك تحمي هذه الطريقة من المرور بالترتيب، ولا تغني عن تحديد المعدل ولا عن رمز أطول للروابط الخاصة.
| الطريقة | نقاط القوة | نقاط الضعف | متى تختارها |
|---|---|---|---|
| العداد مع Base62 | لا تكرار دون فحص، رموز قصيرة جداً | متتالية، يمكن المرور عليها، تكشف حجم العمل | روابط عامة غير حساسة في نظام داخلي فقط |
| الهاش المقطوع | نفس الرابط يعطي نفس الرمز | تصادم بعد حوالي مليوني رابط، يحتاج فحصاً وحلاً | نادراً، وعند الحاجة لمنع تكرار نفس الرابط فقط |
| الرمز العشوائي | لا يكشف شيئاً، بسيط | محاولة إضافية نادرة، كتابة عشوائية في الفهرس | الخيار الافتراضي المعقول لأغلب الخدمات |
| العداد المخلوط Feistel | لا تكرار دون فحص، لا يمكن توقعه دون المفتاح | المفتاح سر يجب حمايته ولا يمكن تغييره، المجال محدود بـ 2 أس 40 | عندما تريد رموزاً غير متتالية دون أي فحص |
وماذا عن Snowflake؟ معرف Snowflake من 64 بت فيه الوقت ورقم السيرفر وعداد، وهو ممتاز كمفتاح داخلي في نظام موزع، ولكنه بالأساس 62 يأخذ 11 حرفاً، وهذا طويل لرابط قصير، كما أن نصفه الأول وقت معروف فيكشف متى أنشئ الرابط. لذلك لا تستخدمه للرمز نفسه، ويمكن أن يبقى المفتاح الداخلي للصف إذا كانت الخدمة موزعة على عدة مناطق.

الخطوة الخامسة: التصميم عالي المستوى High-level Design
التصميم بسيط لأن الأرقام بسيطة: موزع الطلبات Load Balancer أمام نسختين أو أكثر من التطبيق، لأن التحويل يجب أن يبقى متاحاً، والتطبيق نفسه بلا حالة Stateless، وأمامه Valkey للتخزين المؤقت وعداد الضغطات وعداد تحديد المعدل، وخلفه PostgreSQL مع نسخة متماثلة للتوفر. ولا يوجد طابور ولا خدمات مصغرة ولا قاعدة بيانات موزعة، لأن لا شيء في التقدير يطلبها. والصورة التالية تبين التصميم مع المسارين:

الخطوة السادسة، التعمق Deep Dives: التحويل 301 أم 302؟
أول نقطة نتعمق فيها هي رمز الحالة، وهو قرار يبدو تفصيلاً صغيراً ويؤثر في الإحصاءات والتكلفة والمرونة. فالمعيار RFC 9110 يعرف 301 Moved Permanently بأنه تحويل دائم، والرد يمكن أن يخزنه المتصفح مؤقتاً حتى لو لم يحمل ترويسة مدة صريحة، كما يسمح معيار التخزين RFC 9111 بما يسميه التخزين التقديري Heuristic Freshness لهذا الرمز. أما 302 Found فتحويل مؤقت، والمتصفح يعود إلى السيرفر في كل مرة ما لم يقل له السيرفر غير ذلك. وهناك 307 و308 بنفس المعنى مع فرق واحد، أنهما يمنعان المتصفح من تحويل طلب POST إلى GET، وهذا لا يهم في روابط تفتح بـ GET دائماً.
- مع 301: المتصفح الذي فتح الرابط مرة يذهب مباشرة إلى الصفحة في المرة الثانية دون أن يسأل خدمتك، فيقل الضغط على سيرفراتك ويسرع الفتح الثاني، ولكنك لا ترى الضغطة الثانية في الإحصاءات، ولا تستطيع أن توقف رابطاً مسيئاً عند من فتحه من قبل حتى تنتهي مدة التخزين.
- مع 302: كل ضغطة تمر بخدمتك، فتعدها وتستطيع أن توقف الرابط في أي لحظة، والثمن طلب إضافي لكل ضغطة على سيرفراتك.
ولأن الإحصاءات والقدرة على إيقاف الروابط المسيئة من متطلباتنا، اخترنا 302 مع Cache-Control: private, no-store. وفي التجربة سوف نفتح نفس الرابط مرتين في Chrome بكل رمز ونعد الطلبات التي وصلت إلى الخدمة.
التعمق الثاني: التخزين المؤقت Caching
القراءة مئة ضعف الكتابة، والرابط لا يتغير أبداً بعد إنشائه، وهذه أفضل حالة ممكنة للتخزين المؤقت، فلا توجد مشكلة إبطال Invalidation إلا عند تعطيل رابط مسيء، وعندها تحذف مفتاحه من ال Cache. والنمط المستخدم هو القراءة الجانبية Cache-aside: ابحث في Valkey، فإذا لم تجد اقرأ من قاعدة البيانات واحفظ النتيجة مع مدة صلاحية TTL. وقد شرحنا الأنماط والإبطال والاندفاع إلى قاعدة البيانات Cache Stampede عند انتهاء مفتاح ساخن في مقال استراتيجيات التخزين المؤقت، وهنا ثلاث نقاط تخص هذه الخدمة:
- نسبة الإصابة Hit Ratio تعتمد على توزيع الضغطات: إذا كانت الضغطات مركزة على روابط قليلة، مثل رابط حملة أرسل لمليون شخص، فالنسبة عالية حتى مع Cache صغير، وإذا كانت موزعة على ملايين الروابط القديمة فالنسبة منخفضة مهما كبر. وسوف نقيسها في التجربة بتوزيعين مختلفين.
- احفظ عدم الوجود أيضاً Negative Caching: الرمز غير الموجود يحفظ دقيقة واحدة بقيمة فارغة، حتى لا يصل برنامج يجرب رموزاً عشوائية إلى قاعدة البيانات في كل طلب.
- ال Cache ليس مصدر الحقيقة: إذا توقف Valkey يجب أن يستمر التحويل من قاعدة البيانات، وهذا ما لم يفعله الإصدار الأول من الكود كما سوف نرى.
التعمق الثالث: تحديد المعدل Rate Limiting والإساءة Abuse
خدمة تقصير الروابط العامة هي أداة مفضلة للمحتالين، لأن الرابط القصير يخفي النطاق الحقيقي، فالمستخدم يرى نطاق خدمتك المعروف ولا يرى صفحة التصيد Phishing خلفه. وإذا استخدمت خدمتك لذلك فسوف تضع شركات المتصفحات والبريد نطاقك كله في قوائم الحظر، فتتعطل روابط عملائك الشرعية معه. لذلك الإساءة جزء من التصميم وليست مهمة دعم فني، وفيما يلي ما يحمي الخدمة:
- تحديد معدل الإنشاء: عدد محدود من الروابط لكل مستخدم أو عنوان IP في الدقيقة، لأن المحتال يحتاج آلاف الروابط وصاحب المتجر يحتاج عشرات. وقد شرحنا الخوارزميات والرد الصحيح 429 مع
Retry-Afterفي مقال تحديد معدل الطلبات. - فحص الرابط عند الإنشاء: http وhttps فقط، وطول أقصى، ونطاق غير محظور، ولا يشير إلى خدمتنا نفسها، لأن الرابط الذي يشير إلى رابط قصير آخر يصنع سلسلة تحويلات تخفي الهدف أو حلقة لا تنتهي.
- قوائم التصيد: افحص الروابط الجديدة بخدمة مثل Google Safe Browsing، وأعد فحص الروابط النشطة دورياً، لأن صفحة سليمة اليوم قد تصبح صفحة تصيد بعد أسبوع.
- الإيقاف دون الحذف: الرابط المسيء يعطل بالعمود
disabled، ويحذف مفتاحه من ال Cache فوراً، ولا يحذف الصف حتى لا يعاد استخدام رمزه. - تحديد معدل التحويل لكل عنوان: من يطلب آلاف الرموز المختلفة في الدقيقة، وأغلبها غير موجود، يمسح الرموز ولا يضغط روابط، فاحظره.
الخطوة السابعة: المفاضلات Trade-offs
| القرار | ما نكسبه | ما ندفعه |
|---|---|---|
| 302 بدلاً من 301 | كل ضغطة محسوبة، وإيقاف فوري للروابط المسيئة | طلب على سيرفراتنا لكل ضغطة |
| سبعة أحرف مخلوطة بدلاً من عداد قصير | لا يمكن المرور على الروابط بالترتيب | رموز أطول بحرف أو حرفين في البداية |
| عداد الضغطات في Valkey | التحويل لا ينتظر كتابة في قاعدة البيانات | ضغطات قليلة قد تضيع إذا توقف Valkey قبل نقلها |
| PostgreSQL واحد مع نسخة متماثلة | بساطة وقيود تضمن عدم التكرار | الكتابة في منطقة واحدة، ويضاف التقسيم إذا تجاوزنا الأرقام بكثير |
| التحويل يستمر عند توقف Valkey | الروابط لا تتعطل مع ال Cache | ضغط مفاجئ على قاعدة البيانات يجب أن تتحمله |
تجربة عملية Lab: نبني الخدمة ونختبرها
الآن سوف نبني الخدمة كما صممناها: تطبيق Python بإطار FastAPI بأربعة عمال Workers، وPostgreSQL 18 للروابط، وValkey 9 للتخزين المؤقت وعدادات الضغطات وتحديد المعدل، وكلها في Docker Compose. ثم نملأ قاعدة البيانات بمليون رابط، ونرسل إليها ضغطات بأداة k6 بمعدل ثابت، ثم نتصرف كمخترق يبحث عن الروابط، ونوقف Valkey لنرى ماذا يحدث. والأرقام في هذا القسم من جهاز واحد تعمل عليه كل الأجزاء ومعها أداة الضغط، فهي للمقارنة بين الإعدادات وليست سعة الخدمة في الإنتاج.
ملفات التجربة
المخطط هو الملف schema.sql الذي رأيته في خطوة نموذج البيانات، ويحمله PostgreSQL عند أول تشغيل. والتطبيق في نسخته الأولى app_v1.py، وهي النسخة التي كتبناها مباشرة من التصميم، وسوف نجد فيها خطأين:
# A small URL shortener: PostgreSQL holds the links, Valkey caches redirects and counts clicks and requests.
import hashlib, os, re, secrets, time
from contextlib import asynccontextmanager
from urllib.parse import urlsplit
import asyncpg, valkey.asyncio as valkey
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, RedirectResponse, Response
ID_MODE = os.environ.get("ID_MODE", "counter") # counter | permuted | random
CACHE = os.environ.get("CACHE", "1") == "1"
REDIRECT = int(os.environ.get("REDIRECT", "302")) # 301 or 302
TTL = int(os.environ.get("CACHE_TTL", "86400"))
LIMIT = int(os.environ.get("CREATE_LIMIT", "20")) # new links per client per minute
OUR_HOST = os.environ.get("OUR_HOST", "s.example")
KEY = os.environ.get("ID_KEY", "change-me").encode()
ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
CODE_RE = re.compile(r"[0-9A-Za-z]{1,11}")
def b62(n, width=0):
s = ""
while n:
n, r = divmod(n, 62)
s = ALPHABET[r] + s
return (s or "0").rjust(width, "0")
def permute(n):
"""Feistel network: a keyed one-to-one shuffle of the numbers 0 .. 2^40-1."""
left, right = n >> 20, n & 0xFFFFF
for rnd in range(4):
f = hashlib.blake2b(right.to_bytes(4, "big") + bytes([rnd]), key=KEY, digest_size=4)
left, right = right, left ^ (int.from_bytes(f.digest(), "big") & 0xFFFFF)
return (left << 20) | right
db = cache = None
@asynccontextmanager
async def lifespan(app):
global db, cache
db = await asyncpg.create_pool(os.environ["DATABASE_URL"], min_size=2, max_size=10)
cache = valkey.Valkey(host="valkey", decode_responses=True)
yield
await db.close()
app = FastAPI(lifespan=lifespan)
def bad(status, msg, **headers):
return JSONResponse({"error": msg}, status_code=status, headers=headers)
@app.post("/api/links", status_code=201)
async def create(body: dict, request: Request):
# 1. rate limit per client: fixed window of one minute in Valkey
window = int(time.time() // 60)
key = f"rl:{request.client.host}:{window}"
used = await cache.incr(key)
if used == 1:
await cache.expire(key, 61)
if used > LIMIT:
return bad(429, "too many links, slow down", **{"Retry-After": str(60 - int(time.time()) % 60)})
# 2. validate the target
url = str(body.get("url", "")).strip()
parts = urlsplit(url)
if parts.scheme not in ("http", "https") or not parts.hostname or len(url) > 2048:
return bad(422, "only http and https URLs up to 2048 characters")
host = parts.hostname.lower()
if host == OUR_HOST:
return bad(422, "a short link cannot point to another short link")
if await db.fetchval("SELECT 1 FROM blocked_domains WHERE $1 = domain OR $1 LIKE '%.' || domain", host):
return bad(422, "this domain is blocked")
# 3. make the code
for attempt in range(5):
if ID_MODE == "random":
code = "".join(secrets.choice(ALPHABET) for _ in range(7))
row = await db.fetchrow("INSERT INTO links (code, long_url) VALUES ($1, $2) "
"ON CONFLICT (code) DO NOTHING RETURNING id", code, url)
if row:
break
else:
n = await db.fetchval("SELECT nextval('link_id_seq')")
code = b62(n) if ID_MODE == "counter" else b62(permute(n), 7)
await db.execute("INSERT INTO links (id, code, long_url) VALUES ($1, $2, $3)", n, code, url)
break
else:
return bad(503, "could not find a free code")
return {"code": code, "short_url": f"https://{OUR_HOST}/{code}", "attempts": attempt + 1}
@app.get("/{code}")
async def follow(code: str):
if not CODE_RE.fullmatch(code):
return Response(status_code=404)
url = None
if CACHE:
async with cache.pipeline(transaction=False) as p:
url, _ = await p.get(f"l:{code}").incr(f"c:{code}").execute()
if url is None:
row = await db.fetchrow("SELECT long_url FROM links WHERE code = $1 AND NOT disabled "
"AND (expires_at IS NULL OR expires_at > now())", code)
url = row["long_url"] if row else ""
if CACHE: # remember misses too, for one minute, so scans do not reach the database
await cache.set(f"l:{code}", url, ex=TTL if url else 60)
if not url:
return Response(status_code=404)
cc = "public, max-age=86400" if REDIRECT == 301 else "private, no-store"
return RedirectResponse(url, status_code=REDIRECT, headers={"Cache-Control": cc})
@app.get("/api/links/{code}/stats")
async def stats(code: str):
return {"code": code, "clicks": int(await cache.get(f"c:{code}") or 0)}في الكود أعلاه لاحظ التالي:
- الدالة
b62تكتب الرقم بالأساس 62، والدالةpermuteشبكة Feistel من أربع جولات على 40 بت، كل جولة تخلط النصف الأيمن بهاش BLAKE2b بالمفتاح السري، وناتجها رقم آخر في نفس المجال لا يتكرر. - المتغير
ID_MODEيختار طريقة توليد الرمز، والنسخة الأولى تبدأ بالعداد، وهو ما يكتبه أغلب الناس أولاً. - تحديد المعدل نافذة ثابتة من دقيقة لكل عنوان IP، بالأمر
INCRثمEXPIREعند أول طلب في النافذة، وهي أبسط خوارزمية شرحناها في مقال تحديد المعدل. - الإنشاء يتحقق من الرابط قبل أي كتابة: الصيغة والطول ونطاقنا والنطاقات المحظورة، ومعها النطاقات الفرعية لها بالشرط
LIKE '%.' || domain. - التحويل يرسل إلى Valkey أمرين معاً في طلب واحد عبر Pipeline: قراءة الرابط وزيادة العداد، ثم يذهب إلى قاعدة البيانات فقط إذا لم يجد الرابط، ويحفظ عدم الوجود دقيقة.
والملف seed.py يملأ الجدول بعدد من الروابط بنفس طريقة التطبيق في توليد الرموز، بالأمر COPY لأنه أسرع كثيراً من الإدراج سطراً سطراً، ويكتب الرموز في ملف تقرأ منه أداة الضغط:
# python seed.py N MODE: adds N links with codes made the same way the app makes them
import asyncio, os, sys
import asyncpg
from app import b62, permute
async def main(n, mode):
con = await asyncpg.connect(os.environ["DATABASE_URL"])
start = await con.fetchval("SELECT nextval('link_id_seq')")
rows = []
for i in range(start, start + n):
code = b62(i) if mode == "counter" else b62(permute(i), 7)
rows.append((i, code, f"https://example.com/articles/{i}?utm_source=short"))
await con.copy_records_to_table("links", records=rows, columns=["id", "code", "long_url"])
await con.execute("SELECT setval('link_id_seq', $1)", start + n - 1)
with open("/out/codes.txt", "w") as f:
f.write("\n".join(r[1] for r in rows))
print(f"seeded {n} links, ids {start}..{start + n - 1}, first codes {[r[1] for r in rows[:3]]}")
await con.close()
asyncio.run(main(int(sys.argv[1]), sys.argv[2]))وسكربت k6 للضغطات redirect.js يرسل الطلبات بمعدل ثابت بالمنفذ constant-arrival-rate كما يشرح توثيق k6، أي أن الطلبات لا تنتظر بعضها مثل المستخدمين الحقيقيين، ويختار الرابط بتوزيع غير متساو، فالقيمة SKEW كلما كبرت تركزت الضغطات على روابط أقل:
// k6: follow short links at a fixed rate; a few links get most of the clicks, like real traffic
import http from 'k6/http';
import { check } from 'k6';
import { SharedArray } from 'k6/data';
const codes = new SharedArray('codes', () => open('/out/codes.txt').split('\n'));
const RATE = Number(__ENV.RATE || 1000);
const SKEW = Number(__ENV.SKEW || 4); // 1 = uniform, higher = more clicks on the top links
export const options = {
summaryTrendStats: ['p(50)', 'p(90)', 'p(99)', 'max'],
scenarios: { clicks: { executor: 'constant-arrival-rate', rate: RATE, timeUnit: '1s',
duration: __ENV.DURATION || '30s', preAllocatedVUs: 200, maxVUs: 1000 } },
};
export default function () {
const i = Math.floor(codes.length * Math.pow(Math.random(), SKEW));
const res = http.get(`http://app:8000/${codes[i]}`, { redirects: 0 });
check(res, { 'redirect': (r) => r.status === 301 || r.status === 302 });
}والسكربت k6.sh يشغل k6 على شبكة التجربة ويطبع الأسطر المهمة من الملخص:
#!/usr/bin/env bash
# k6.sh SCRIPT [k6 -e options]: runs a k6 script on the lab network and prints the summary
S=$1; shift
docker run --rm -i --network sw5-us_default -v "${LAB_DIR:-$PWD}/out":/out:ro \
${K6_IMAGE:-grafana/k6:1.8.3} run --quiet "$@" - < "$S" 2>&1 | grep -E 'msg=|http_req_duration|http_reqs|checks_succeeded|dropped_iterations|http_req_failed'وملفا requirements.txt وDockerfile:
fastapi==0.121.2
uvicorn[standard]==0.38.0
asyncpg==0.30.0
valkey==6.1.1
httpx==0.28.1FROM python:3.13.18-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY *.py ./
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "4", "--log-level", "warning", "--no-access-log"]وأخيراً compose.yaml، ولاحظ فيه أن التطبيق لا يبدأ حتى يجيب PostgreSQL على فحص pg_isready، لأن أول تشغيل لنا فشل بالخطأ ConnectionRefusedError عندما بدأ التطبيق وقاعدة البيانات ما زالت تنشئ الجداول:
name: sw5-us
services:
db:
image: postgres:18-alpine
container_name: sw5-us-db
environment: { POSTGRES_PASSWORD: lab, POSTGRES_DB: short }
volumes: ["./schema.sql:/docker-entrypoint-initdb.d/schema.sql:ro"]
command: ["postgres", "-c", "shared_buffers=256MB", "-c", "max_connections=100"]
healthcheck: { test: ["CMD", "pg_isready", "-U", "postgres", "-d", "short"], interval: 2s, retries: 30 }
valkey:
image: valkey/valkey:9.0.6-alpine
container_name: sw5-us-valkey
command: ["valkey-server", "--maxmemory", "256mb", "--maxmemory-policy", "allkeys-lru", "--save", ""]
app:
image: sw5-us-app:lab
build: .
container_name: sw5-us-app
depends_on:
db: { condition: service_healthy }
valkey: { condition: service_started }
environment:
DATABASE_URL: postgresql://postgres:lab@db/short
ID_MODE: ${ID_MODE:-permuted}
CACHE: ${CACHE:-1}
REDIRECT: ${REDIRECT:-302}
CREATE_LIMIT: ${CREATE_LIMIT:-20}
command: ["uvicorn", "${APP:-app}:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "4", "--log-level", "warning", "--no-access-log"]
ports: ["127.0.0.1:18090:8000"]التشغيل والطلبات الأولى
mkdir -p out
APP=app_v1 ID_MODE=counter docker compose up -d --build
docker compose run --rm -T -v ./out:/out app python seed.py 1000000 counterseeded 1000000 links, ids 1..1000000, first codes ['1', '2', '3']مليون رابط برموز من 1 إلى 4C92، والرابط التالي سوف يأخذ الرمز 4C93. الآن ننشئ رابطاً ونفتحه ونقرأ إحصاءاته، ثم نجرب ثلاثة روابط مرفوضة:
$ curl -s -X POST localhost:18090/api/links -H 'content-type: application/json' -d '{"url": "https://arabroot.io/articles/"}'
{"code":"4C94","short_url":"https://s.example/4C94","attempts":1}
$ curl -si localhost:18090/4C94
HTTP/1.1 302 Found
date: Wed, 18 Nov 2026 12:32:29 GMT
server: uvicorn
cache-control: private, no-store
content-length: 0
location: https://arabroot.io/articles/
$ curl -s localhost:18090/api/links/4C94/stats
{"code":"4C94","clicks":1}
$ curl -s -X POST localhost:18090/api/links -H 'content-type: application/json' -d '{"url": "javascript:alert(1)"}'
{"error":"only http and https URLs up to 2048 characters"}
$ curl -s -X POST localhost:18090/api/links -H 'content-type: application/json' -d '{"url": "https://s.example/4C93"}'
{"error":"a short link cannot point to another short link"}
$ curl -s -X POST localhost:18090/api/links -H 'content-type: application/json' -d '{"url": "https://login.phish.example/reset"}'
{"error":"this domain is blocked"}في المخرج أعلاه لاحظ التالي:
- التحويل رجع
302 Foundوالترويسةlocationفيها الرابط الطويل، وcontent-length: 0، أي أن الرد كله ترويسات. - الترويسة
cache-control: private, no-storeتمنع المتصفح وأي Proxy في الطريق من حفظ التحويل، فتمر كل ضغطة بالخدمة. - الروابط الثلاثة المرفوضة رجعت ثلاث رسائل مختلفة، والسبب أن من يرسل رابط
javascript:يحتاج أن يعرف أن المشكلة في الصيغة، وليس في الحظر.
ثم نرسل 25 طلب إنشاء متتالياً لنرى تحديد المعدل:
$ for i in $(seq 1 25); do curl -s -o /dev/null -w "%{http_code} " -X POST localhost:18090/api/links -H "content-type: application/json" -d "{\"url\": \"https://example.org/$i\"}"; done
201 201 201 201 201 201 201 201 201 201 201 201 201 201 201 429 429 429 429 429 429 429 429 429 429
$ curl -si -X POST localhost:18090/api/links -H "content-type: application/json" -d '{"url": "https://example.org/26"}'
HTTP/1.1 429 Too Many Requests
retry-after: 7
{"error":"too many links, slow down"}نجح 15 طلباً فقط وليس 20 كما في الإعداد، والسبب أن الطلبات الخمسة السابقة في نفس الدقيقة حسبت أيضاً، ومنها الثلاثة المرفوضة، لأن العد يحدث قبل التحقق من الرابط، وهذا مقصود، فمن يرسل روابط مرفوضة بكثرة يجب أن يتوقف أيضاً. والرد 429 يحمل retry-after: 7، أي الثواني الباقية في النافذة الحالية.
كم يأخذ الرابط الواحد في قاعدة البيانات؟
الرقم الذي استخدمناه في التقدير، 170.6 بايتاً للرابط، جاء من هذا الاستعلام على المليون رابط:
SELECT count(*) AS links,
round(avg(length(long_url)), 1) AS avg_url_chars,
pg_size_pretty(pg_relation_size('links')) AS heap,
pg_size_pretty(pg_relation_size('links_pkey')) AS pkey,
pg_size_pretty(pg_relation_size('links_code_key')) AS code_idx,
round(pg_total_relation_size('links')::numeric / count(*), 1) AS bytes_per_link
FROM links; links | avg_url_chars | heap | pkey | code_idx | bytes_per_link
---------+---------------+--------+-------+----------+----------------
1000001 | 51.9 | 112 MB | 21 MB | 29 MB | 170.6
(1 row)الجدول 112 ميجابايت والفهرسان 50 ميجابايت معاً، والروابط هنا متوسط طولها 52 حرفاً، وكل حرف إضافي في الروابط الحقيقية يضيف بايتاً للصف، فرابط حملة طوله 200 حرف يجعل الصف حوالي ضعف هذا الحجم، وما زالت الأرقام بعد خمس سنوات في حدود سيرفر واحد.
اختبار الضغط Load Test: 500 تحويل في الثانية مع ال Cache ودونه
نرسل 500 ضغطة في الثانية لمدة دقيقة، بتوزيعين: ضغطات موزعة على روابط كثيرة SKEW=4، وضغطات مركزة على روابط قليلة SKEW=8، وكل توزيع مرة دون Cache ومرة معه بعد دقيقة تسخين. ونقرأ مع كل تشغيل عدد المعاملات في PostgreSQL من pg_stat_database، ونسبة الإصابة من عدادي keyspace_hits وkeyspace_misses في Valkey كما يشرح توثيق الأمر INFO، بعد أن نصفرهما بالأمر CONFIG RESETSTAT. والسكربت الذي شغلناه:
V="docker exec sw5-us-valkey valkey-cli"
q(){ docker exec sw5-us-db psql -U postgres -d short -tAc "SELECT xact_commit FROM pg_stat_database WHERE datname='short'"; }
for skew in 4 8; do
echo "### CACHE=0 SKEW=$skew"; CACHE=0 docker compose up -d app; sleep 6
a=$(q); bash k6.sh redirect.js -e RATE=500 -e DURATION=60s -e SKEW=$skew; b=$(q); echo "postgres transactions: $((b-a))"
echo "### CACHE=1 SKEW=$skew (after one warm-up run)"; CACHE=1 docker compose up -d app; sleep 6
$V flushall; bash k6.sh redirect.js -e RATE=500 -e DURATION=60s -e SKEW=$skew >/dev/null; $V config resetstat
a=$(q); bash k6.sh redirect.js -e RATE=500 -e DURATION=60s -e SKEW=$skew; b=$(q); echo "postgres transactions: $((b-a))"
$V info stats | grep -E 'keyspace_(hits|misses)'
done### CACHE=0 SKEW=4
checks_succeeded...: 100.00% 29955 out of 29955
http_req_duration..............: p(50)=2.45ms p(90)=17.08ms p(99)=121.23ms max=704.65ms
http_req_failed................: 0.00% 0 out of 29955
http_reqs......................: 29955 499.310914/s
dropped_iterations.............: 46 0.76676/s
postgres transactions: 59973
### CACHE=1 SKEW=4 (after one warm-up run)
checks_succeeded...: 100.00% 30001 out of 30001
http_req_duration..............: p(50)=6.09ms p(90)=57.59ms p(99)=196.8ms max=512.3ms
http_req_failed................: 0.00% 0 out of 30001
http_reqs......................: 30001 499.741605/s
postgres transactions: 42757
keyspace_hits:8989
keyspace_misses:21011
### CACHE=0 SKEW=8
checks_succeeded...: 100.00% 29938 out of 29938
http_req_duration..............: p(50)=2.64ms p(90)=16.21ms p(99)=120.7ms max=803.75ms
http_req_failed................: 0.00% 0 out of 29938
http_reqs......................: 29938 499.001108/s
dropped_iterations.............: 63 1.050072/s
postgres transactions: 59266
### CACHE=1 SKEW=8 (after one warm-up run)
checks_succeeded...: 100.00% 30001 out of 30001
http_req_duration..............: p(50)=1.96ms p(90)=5.97ms p(99)=42.53ms max=235.82ms
http_req_failed................: 0.00% 0 out of 30001
http_reqs......................: 30001 500.062371/s
postgres transactions: 28817
keyspace_hits:15540
keyspace_misses:14461في المخرج أعلاه لاحظ التالي:
- الخدمة خدمت 500 تحويل في الثانية في كل الحالات دون خطأ واحد، والسطر
dropped_iterationsفي حالتي عدم وجود ال Cache يعني أن k6 لم يجد مستخدماً افتراضياً فارغاً لعشرات الطلبات، أي أن الخدمة كانت قريبة من حدها على هذا الجهاز. - دون Cache كان الوسيط حوالي 2.5 ملي ثانية والنسبة p99 حوالي 121 ملي ثانية في التوزيعين، لأن البحث برمز في فهرس فريد في جدول يتسع كله في ذاكرة PostgreSQL سريع جداً.
- مع الضغطات الموزعة كانت نسبة الإصابة 30% فقط، 8,989 من 30,000، وأصبح الزمن أسوأ: الوسيط 6.09 والنسبة p99 حوالي 197 ملي ثانية. والسبب أن 70% من الطلبات أصبحت تسأل Valkey أولاً ثم PostgreSQL ثم تكتب في Valkey، أي ثلاث رحلات على الشبكة بدلاً من واحدة، وال Cache الذي لا يصيب يضيف عملاً ولا يوفره.
- مع الضغطات المركزة ارتفعت نسبة الإصابة إلى 52%، فنزلت النسبة p99 من 121 إلى 42.5 ملي ثانية، ونزلت معاملات PostgreSQL من 59,266 إلى 28,817، أي إلى النصف تقريباً.
- عدد المعاملات في PostgreSQL حوالي ضعف عدد الطلبات التي وصلته، لأن مجمع الاتصالات في asyncpg ينفذ أمر إعادة ضبط على الاتصال عند إرجاعه إلى المجمع، فقارن الأرقام بين التشغيلات ولا تقرأها كعدد استعلامات.
والنتيجة أن ال Cache ليس تحسيناً مضموناً، فقيمته تعتمد على توزيع الضغطات أكثر من حجمه. وفي خدمة حقيقية تتركز الضغطات على روابط الحملات الجديدة، فتكون النسبة أعلى من تجربتنا، ولكن لا تفترض ذلك، وقس نسبة الإصابة في الإنتاج وراقبها، فإذا كانت منخفضة فإما أن مدة الصلاحية قصيرة، أو أن ال Cache يكلفك أكثر مما يوفر. وقد شرحنا أدوات اختبار الضغط وكيف تقرأ نتائجه في مقال اختبار الضغط.

أما الإنشاء فنختبره بسكربت create.js بمعدل 100 رابط في الثانية، أي حوالي ضعف ذروة التقدير، بعد أن نرفع حد الإنشاء لأن كل الطلبات تأتي من عنوان واحد:
// k6: create new short links at a fixed rate
import http from 'k6/http';
import { check } from 'k6';
export const options = {
summaryTrendStats: ['p(50)', 'p(90)', 'p(99)', 'max'],
scenarios: { create: { executor: 'constant-arrival-rate', rate: Number(__ENV.RATE || 200), timeUnit: '1s',
duration: __ENV.DURATION || '20s', preAllocatedVUs: 100, maxVUs: 500 } },
};
export default function () {
const body = JSON.stringify({ url: `https://example.org/report/${__VU}-${__ITER}?q=${Math.random()}` });
const res = http.post('http://app:8000/api/links', body, { headers: { 'Content-Type': 'application/json' } });
if (!check(res, { 'created': (r) => r.status === 201 })) console.log(`status ${res.status} ${res.body}`);
}$ bash k6.sh create.js -e RATE=100 -e DURATION=30s
checks_succeeded...: 100.00% 3001 out of 3001
http_req_duration..............: p(50)=5.32ms p(90)=16.05ms p(99)=75.03ms max=147.25ms
http_req_failed................: 0.00% 0 out of 3001
http_reqs......................: 3001 100.020804/sكل الروابط أنشئت، والوسيط 5.32 ملي ثانية، وهو أبطأ من التحويل لأن الإنشاء فيه أربع رحلات: عداد المعدل، وفحص النطاق المحظور، والعداد، والإدراج. وفي أول تشغيل لهذا الاختبار، مباشرة بعد إعادة تشغيل التطبيق، فشل طلبان من 3001 دون أن يظهر سببهما في الملخص، لذلك أضفنا إلى السكربت طباعة رمز الحالة والجسم لكل طلب فاشل، ولم يتكرر الفشل في التشغيل التالي. والدرس أن تبدأ القياس بعد أن يستقر التطبيق، وأن تجعل أداة الضغط تقول لك لماذا فشل الطلب وليس فقط كم طلباً فشل.
مشكلة حقيقية: برنامج يمر على الرموز Enumeration
الآن نتصرف كمن يبحث عن روابط ليست له. البرنامج enumerate.py يجرب عدداً من الرموز، إما بالترتيب من 1 أو عشوائية من سبعة أحرف، ويعد كم منها رابط حقيقي:
# What an attacker does: python enumerate.py sequential N | random N
# Asks for N codes, counts how many are real links, and prints a few of the targets it found.
import secrets, sys
from concurrent.futures import ThreadPoolExecutor
import httpx
ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
mode, n = sys.argv[1], int(sys.argv[2])
def b62(x):
s = ""
while x:
x, r = divmod(x, 62)
s = ALPHABET[r] + s
return s
codes = ([b62(i) for i in range(1, n + 1)] if mode == "sequential"
else ["".join(secrets.choice(ALPHABET) for _ in range(7)) for _ in range(n)])
client = httpx.Client(base_url="http://app:8000", follow_redirects=False)
found = []
def probe(code):
r = client.get(f"/{code}")
if r.status_code in (301, 302):
found.append((code, r.headers["location"]))
with ThreadPoolExecutor(20) as ex:
list(ex.map(probe, codes))
print(f"{mode}: tried {n} codes, found {len(found)} links")
for code, url in sorted(found)[:3]:
print(f" /{code} -> {url}")$ docker compose run --rm -T app python enumerate.py sequential 5000
sequential: tried 5000 codes, found 5000 links
/1 -> https://example.com/articles/1?utm_source=short
/10 -> https://example.com/articles/62?utm_source=short
/100 -> https://example.com/articles/3844?utm_source=short
$ docker compose run --rm -T app python enumerate.py random 20000
random: tried 20000 codes, found 0 links
$ docker exec sw5-us-valkey valkey-cli dbsize
49603
$ docker exec sw5-us-valkey sh -c "valkey-cli --scan --pattern 'c:*' | wc -l"
25000
$ docker exec sw5-us-valkey valkey-cli ttl c:x5gYcqs
-1في المخرج أعلاه مشكلتان، الأولى متوقعة والثانية لم نتوقعها:
- 5000 رمز بالترتيب أعطت 5000 رابط من 5000، أي أن أي شخص يستطيع أن يقرأ كل روابط الخدمة واحداً بعد الآخر، ومعها كل رابط مستند أو عرض خاص أرسله أحد العملاء لشخص واحد. وهذه بالضبط الثغرة التي وصفتها ورقة Gone in Six Characters.
- الرموز العشوائية لم تجد شيئاً، وهذا متوقع مع مليون رابط في 3.52 تريليون رمز. ولكن عدد المفاتيح في Valkey أصبح 49,603، منها 25,000 مفتاح عداد
c:، أي مفتاح لكل رمز جربه البرنامج، سواءً كان موجوداً أم لا، ومدة صلاحيته-1، أي أنه لا ينتهي أبداً. والسبب في سطر واحد: النسخة الأولى تزيد العداد في نفس ال Pipeline مع القراءة، قبل أن تعرف هل الرابط موجود. فكل برنامج يمسح الرموز يملأ ذاكرة Valkey بمفاتيح لا تحذف، حتى تمتلئ ويبدأ Valkey بإخراج مفاتيح الروابط الحقيقية حسب سياسةallkeys-lru.
مشكلة ثانية: Valkey يتوقف
ال Cache في التصميم تحسين وليس مصدر الحقيقة، فماذا يحدث للتحويل إذا توقف؟
$ docker stop sw5-us-valkey
$ curl -s -o /dev/null -w "%{http_code} %{time_total}s\n" localhost:18090/4C94
500 4.005716sالرابط موجود في PostgreSQL، وقاعدة البيانات تعمل، ومع ذلك رجع التحويل بالخطأ 500 بعد 4 ثوان، والسجل يقول valkey.exceptions.ConnectionError: Error -5 connecting to valkey:6379. أي أن توقف ال Cache أوقف كل الروابط، وهذا عكس المتطلب الذي يقول إن التحويل لا يتوقف. والثواني الأربع أسوأ من الخطأ نفسه، لأن الطلبات تتراكم خلالها في العمال، كما رأينا في السقوط المتتالي في مقال أنماط الحماية.
الإصلاح: النسخة الثانية
النسخة الثانية app.py تغير أربعة أشياء، والفرق بين النسختين كما يلي:
@@ -1,13 +1,16 @@
# A small URL shortener: PostgreSQL holds the links, Valkey caches redirects and counts clicks and requests.
+# Second version: codes are not sequential, clicks are counted only for real links, and redirects keep working
+# when Valkey is down.
import hashlib, os, re, secrets, time
from contextlib import asynccontextmanager
from urllib.parse import urlsplit
import asyncpg, valkey.asyncio as valkey
+from valkey.exceptions import ValkeyError
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, RedirectResponse, Response
-ID_MODE = os.environ.get("ID_MODE", "counter") # counter | permuted | random
+ID_MODE = os.environ.get("ID_MODE", "permuted") # counter | permuted | random
CACHE = os.environ.get("CACHE", "1") == "1"
REDIRECT = int(os.environ.get("REDIRECT", "302")) # 301 or 302
TTL = int(os.environ.get("CACHE_TTL", "86400"))
@@ -39,7 +42,9 @@
async def lifespan(app):
global db, cache
db = await asyncpg.create_pool(os.environ["DATABASE_URL"], min_size=2, max_size=10)
- cache = valkey.Valkey(host="valkey", decode_responses=True)
+ # short timeouts: a slow cache must cost milliseconds, not seconds
+ cache = valkey.Valkey(host="valkey", decode_responses=True,
+ socket_connect_timeout=0.1, socket_timeout=0.1)
yield
await db.close()
@@ -53,9 +58,12 @@
# 1. rate limit per client: fixed window of one minute in Valkey
window = int(time.time() // 60)
key = f"rl:{request.client.host}:{window}"
- used = await cache.incr(key)
- if used == 1:
- await cache.expire(key, 61)
+ try:
+ used = await cache.incr(key)
+ if used == 1:
+ await cache.expire(key, 61)
+ except ValkeyError: # without the counter we cannot limit, so we refuse new links for now
+ return bad(503, "try again in a minute", **{"Retry-After": "60"})
if used > LIMIT:
return bad(429, "too many links, slow down", **{"Retry-After": str(60 - int(time.time()) % 60)})
# 2. validate the target
@@ -85,22 +93,27 @@
return bad(503, "could not find a free code")
return {"code": code, "short_url": f"https://{OUR_HOST}/{code}", "attempts": attempt + 1}
+async def cached(op, *args, **kw):
+ """Run one Valkey command; when Valkey is down return None and let the database answer."""
+ try:
+ return await getattr(cache, op)(*args, **kw)
+ except ValkeyError:
+ return None
+
@app.get("/{code}")
async def follow(code: str):
if not CODE_RE.fullmatch(code):
return Response(status_code=404)
- url = None
- if CACHE:
- async with cache.pipeline(transaction=False) as p:
- url, _ = await p.get(f"l:{code}").incr(f"c:{code}").execute()
+ url = await cached("get", f"l:{code}") if CACHE else None
if url is None:
row = await db.fetchrow("SELECT long_url FROM links WHERE code = $1 AND NOT disabled "
"AND (expires_at IS NULL OR expires_at > now())", code)
url = row["long_url"] if row else ""
if CACHE: # remember misses too, for one minute, so scans do not reach the database
- await cache.set(f"l:{code}", url, ex=TTL if url else 60)
+ await cached("set", f"l:{code}", url, ex=TTL if url else 60)
if not url:
return Response(status_code=404)
+ await cached("incr", f"c:{code}") # only real links are counted
cc = "public, max-age=86400" if REDIRECT == 301 else "private, no-store"
return RedirectResponse(url, status_code=REDIRECT, headers={"Cache-Control": cc})في الفرق أعلاه لاحظ التالي:
- الطريقة الافتراضية لتوليد الرمز أصبحت العداد المخلوط
permuted. - كل أمر إلى Valkey في التحويل يمر بالدالة
cachedالتي تعيدNoneعند أي خطأ، فيذهب التحويل إلى قاعدة البيانات، ومهلة الاتصال والقراءة 100 ملي ثانية بدلاً من الانتظار الافتراضي. - تحديد المعدل يفعل العكس: إذا توقف Valkey يرفض الإنشاء بالرمز 503، لأن الإنشاء دون حد هو ما ينتظره المحتال، ولأن الإنشاء يحتمل التوقف في متطلباتنا.
- العداد يزيد بعد أن نعرف أن الرابط حقيقي، فالرموز غير الموجودة لا تترك شيئاً في Valkey إلا مفتاح عدم الوجود الذي ينتهي بعد دقيقة.
ونعيد التجربة بقاعدة بيانات فيها مليون رابط برموز مخلوطة:
docker exec sw5-us-db psql -U postgres -d short -c "TRUNCATE links" -c "ALTER SEQUENCE link_id_seq RESTART"
docker exec sw5-us-valkey valkey-cli flushall
docker compose up -d app
docker compose run --rm -T -v ./out:/out app python seed.py 1000000 permutedseeded 1000000 links, ids 1..1000000, first codes ['EYPNYZm', 'C1MCMpw', 'C4eKL87']$ curl -s -X POST localhost:18090/api/links -H "content-type: application/json" -d '{"url": "https://arabroot.io/articles/"}'
{"code":"8XP0tVV","short_url":"https://s.example/8XP0tVV","attempts":1}
$ docker compose run --rm -T app python enumerate.py sequential 5000
sequential: tried 5000 codes, found 0 links
$ docker compose run --rm -T app python enumerate.py random 20000
random: tried 20000 codes, found 0 links
$ docker exec sw5-us-valkey sh -c "valkey-cli --scan --pattern 'c:*' | wc -l"
0الرموز الأولى EYPNYZm وC1MCMpw وC4eKL87 لا يدل أي منها على الذي بعده، والمرور بالترتيب لم يجد شيئاً، ولم يبق في Valkey أي مفتاح عداد. ثم نوقف Valkey من جديد:
$ docker stop sw5-us-valkey
$ curl -s -o /dev/null -w "%{http_code} %{time_total}s\n" localhost:18090/8XP0tVV
302 0.307745s
$ curl -s -o /dev/null -w "%{http_code} %{time_total}s\n" localhost:18090/8XP0tVV
302 0.307959s
$ curl -s -o /dev/null -w "%{http_code} %{time_total}s\n" localhost:18090/8XP0tVV
302 0.335311s
$ curl -s -X POST localhost:18090/api/links -H "content-type: application/json" -d '{"url": "https://example.org/x"}'
{"error":"try again in a minute"} -> 503 0.105093sالتحويل استمر بالرمز 302 من قاعدة البيانات، والإنشاء رفض بالرمز 503 كما قررنا. ولكن لاحظ الزمن: حوالي 0.31 ثانية لكل تحويل، لأن الطلب يحاول ثلاثة أوامر في Valkey، القراءة والحفظ والعداد، وكل منها ينتظر مهلته 100 ملي ثانية قبل أن يتجاوزه. والتحسين التالي هو قاطع دائرة Circuit Breaker أمام Valkey، فبعد عدة أخطاء متتالية يتجاوزه التطبيق تماماً لعدة ثوان دون أن ينتظر أي مهلة، وهو نفس النمط الذي رأيناه بين الخدمات.

301 أم 302 في متصفح حقيقي
أداة curl لا تحفظ التحويلات، لذلك اختبرنا الفرق في Chrome بوضع Headless: أنشأنا رابطاً، وفتحناه مرتين في نفس المتصفح، ثم سألنا الخدمة كم ضغطة وصلتها، مرة والخدمة ترد بالرمز 302 ومرة بالرمز 301:
### REDIRECT=302, link /IBMzcjB
visit 1: browser is at https://example.com/
visit 2: browser is at https://example.com/
clicks that reached the server: 2
### REDIRECT=301, link /44v3FEe
visit 1: browser is at https://example.com/
visit 2: browser is at https://example.com/
clicks that reached the server: 1مع 302 وصلت الضغطتان إلى الخدمة، ومع 301 وصلت الأولى فقط، والزيارة الثانية ذهبت مباشرة إلى example.com من ذاكرة المتصفح، لأن الرد حمل Cache-Control: public, max-age=86400. أي أن الإحصاءات مع 301 تعد الأشخاص تقريباً وليس الضغطات، وأن تعطيل رابط مسيء لن يصل إلى من فتحه قبل ذلك حتى تنتهي مدة التخزين. ولاحظ أن المتصفح يستطيع أن يحفظ 301 حتى دون ترويسة مدة صريحة، لذلك إذا اخترت 301 فحدد المدة بنفسك ولا تتركها للمتصفح.
حذف المختبر Cleanup
docker compose down -v
docker rmi sw5-us-app:lab
rm -rf outهل تبني خدمتك أم تستخدم أداة جاهزة؟
بنينا الخدمة في هذا المقال لنفهم التصميم، وليس لأنك يجب أن تكتبها بنفسك. فهناك أدوات مفتوحة المصدر ناضجة تفعل ما فعلناه وأكثر، وتستطيع أن تشغلها على سيرفرك:
- YOURLS: أقدم الأدوات المعروفة، مكتوبة بلغة PHP مع MySQL، وفيها واجهة إدارة وإحصاءات وإضافات كثيرة، ومناسبة لاستخدام فرد أو فريق صغير على نطاقه الخاص.
- Shlink: مبنية حول واجهة API وأداة سطر أوامر، وتدعم عدة نطاقات وقواعد بيانات مختلفة، وتعطي إحصاءات بالدولة والجهاز، ولها واجهة ويب منفصلة، وهي الأقرب إلى ما يحتاجه مطور يريد أن يدمج التقصير في نظامه.
- Kutt: مكتوبة بـ Node.js، وفيها حسابات للمستخدمين ونطاقات مخصصة وإحصاءات.
ومتى تبني بنفسك؟ عندما يكون التقصير جزءاً من منتجك ويحتاج منطقاً لا تعطيه الأدوات، مثل رموز مرتبطة بعملاء ومستأجرين Tenants، أو قواعد خاصة لانتهاء الروابط، أو أرقام أكبر بكثير مما صممت له الأدوات. وفي غير ذلك، شغل أداة جاهزة وطبق عليها ما تعلمته هنا: رمز لا يمكن تخمينه، وتحديد المعدل، وفحص الروابط، وقرار واع بين 301 و302، ونسخ احتياطي لقاعدة البيانات، لأن الرابط المطبوع لا يمكن إصلاحه بعد أن تضيع بياناته.
أخطاء شائعة Common Mistakes
- العداد المتتالي في الرمز: رأيت كيف وجد برنامج بسيط 5000 رابط من 5000 محاولة.
- الهاش المقطوع دون فحص التصادم: التصادم الأول حدث في تجاربنا بعد 684 ألف رابط في أسوأ حالة، وليس بعد مليارات.
- رمز قصير لمحتوى خاص: إذا كان الرابط يفتح مستنداً خاصاً فهو كلمة مرور، ويحتاج طولاً أكبر ومدة انتهاء وتحديداً للمعدل.
- ال Cache كمصدر للحقيقة: النسخة الأولى أوقفت كل الروابط عندما توقف Valkey، مع أن البيانات كلها في PostgreSQL.
- كتابة في ال Cache لكل طلب حتى للرموز غير الموجودة: كل برنامج يمسح الرموز يملأ الذاكرة بمفاتيح لا تنتهي.
- 301 دون قرار واع: تخسر الضغطات المتكررة في الإحصاءات، وتخسر القدرة على إيقاف رابط مسيء عند من فتحه.
- إضافة Cache دون قياس نسبة الإصابة: مع 30% إصابة أصبح الزمن أسوأ مما كان دون Cache.
- الإنشاء دون تحديد معدل وفحص للنطاقات: الخدمة تصبح أداة للتصيد، ثم يحظر نطاقك كله.
- حذف الروابط المسيئة بدلاً من تعطيلها: الحذف يحرر الرمز، وقد يعاد استخدامه لرابط آخر يصل إليه من حفظ الرابط القديم.
قائمة تحقق Checklist
- الرمز من سبعة أحرف أو أكثر، ولا يمكن توقعه، والقيد
UNIQUEيضمن عدم تكراره. - الروابط التي تفتح محتوى خاصاً لها رمز أطول ومدة انتهاء.
- التحويل يستمر عند توقف ال Cache، مع مهلة قصيرة لكل أمر إليه.
- عدم الوجود يحفظ في ال Cache لمدة قصيرة، والعدادات تزيد للروابط الحقيقية فقط.
- رمز التحويل 301 أو 302 قرار مكتوب، ومعه ترويسة
Cache-Controlصريحة. - الإنشاء محدود المعدل لكل مستخدم وعنوان، والروابط تفحص بالصيغة والنطاق وقوائم التصيد.
- الروابط المسيئة تعطل ولا تحذف، وتحذف من ال Cache فوراً.
- نسبة الإصابة وp99 للتحويل وعدد الرموز غير الموجودة لكل عنوان مراقبة في الإنتاج.
- قاعدة البيانات لها نسخ احتياطي مجرب، لأن الروابط المطبوعة لا يمكن إعادة إنشائها.
ماذا تقرأ بعد ذلك؟ Next Steps
هذه أول دراسة حالة بالطريقة التي شرحناها في مقال طريقة تصميم أي نظام، والدراسات التالية تطبق نفس الخطوات على أنظمة أكبر، وفي كل منها نقطة صعبة مختلفة:
دليلطريقة تصميم أي نظام System Design في سبع خطواتطريقة ثابتة من المتطلبات والتقدير إلى التعمق والمفاضلات، نطبقها على نظام تتبع شحنات ونتحقق من أرقامها بنموذج صغير على PostgreSQL.
دليلكيف بنى Stack Overflow موقعه بسيرفرات قليلة؟كيف خدم Stack Overflow أكثر من مئتي مليون طلب يومياً بعدد قليل من السيرفرات، وما الدروس التي تأخذها منه لمشروعك.
دليلكيف تبني نظام إشعارات يصل إلى ملايين المستخدمينكيف تصل الرسالة الصحيحة إلى المستخدم مرة واحدة وفي وقتها عبر الإشعار والرسائل والبريد، حتى عندما يتعطل المزود.
دليلكيف تبني نظام حجز تذاكر يتحمل لحظة فتح البيعكيف تمنع بيع المقعد الواحد مرتين، وكيف يصمد نظام الحجز عندما يدخل الجميع في الدقيقة نفسها لشراء التذاكر.
دليلكيف تبني تطبيق محادثة مثل WhatsApp لملايين المستخدمينكيف تصل الرسالة من هاتف إلى آخر عبر سيرفرات مختلفة، وكيف تحفظ لمن انقطع اتصاله وتظهر علامات التسليم والقراءة.
دليلالمحفظة الرقمية من الداخل: دفتر القيد المزدوج Ledgerكيف تبني محفظة رقمية لا يضيع فيها ريال ولا يخصم مرتين، بالقيد المزدوج والمعاملات والمطابقة مع مزود الدفع.والمقالات التي يعتمد عليها هذا التصميم:
دليلالرقم المتسلسل أم UUID؟ كيف تختار المعرف الفريدلماذا يفشل الرقم المتسلسل في الروابط وعند تعدد السيرفرات، وكيف يؤثر نوع المعرف الذي تختاره على فهرس قاعدة البيانات.
دليلالتخزين المؤقت Caching بالتفصيل: الاستراتيجيات والإبطالكيف تختار نمط التخزين المؤقت المناسب، ومتى تبطل القيمة، وكيف تمنع انهيار قاعدة البيانات عندما ينتهي مفتاح مشهور.
دليلتحديد معدل الطلبات Rate Limiting وخوارزمياتهكيف تعمل خوارزميات تحديد معدل الطلبات، وأيها يناسب واجهتك، وكيف تطبقها على عدة سيرفرات وترد بالرمز 429 الصحيح.
دليلاختبار الضغط Load Testing للمبتدئينلماذا يعمل تطبيقك مع خمسة مستخدمين وينهار مع خمسمئة، وكيف تكتشف ذلك وتصلحه قبل يوم الإطلاق.
دليلRedis وبديله المفتوح Valkey: التخزين المؤقت والجلساتكيف تستخدم Redis للجلسات والعدادات دون أن تمتلئ الذاكرة، وماذا تعني رخصته الجديدة، ومتى يكفيك Valkey بدلاً منه.
دليلPostgreSQL لكل شيء: متى يكفيك ومتى تحتاج غيره؟كم عملاً يستطيع PostgreSQL واحد أن يقوم به في شركتك الناشئة قبل أن تحتاج Redis أو Elasticsearch، وما الإشارة التي تقول لك إن الوقت قد حان.الخلاصة Summary
وصلنا لنهاية الموضوع، وأهم ما فيه:
- خدمة تقصير الروابط نظام يعتمد على القراءة، مئة تحويل لكل إنشاء في تقديرنا، والمشكلة الحقيقية فيها سرعة التحويل وتوفره، وليس حجم البيانات، فمليار وثمانمئة مليون رابط تتسع في حوالي 312 جيجابايت.
- طول الرمز قرار أمني: سبعة أحرف تعطي 3.52 تريليون رمز، ولكن مع مليار وثمانمئة مليون رابط يصيب كل تخمين عشوائي رابطاً بنسبة 1 من 1,930.
- العداد لا يتكرر ولكنه متتال، والهاش المقطوع يتكرر بعد حوالي مليوني رابط كما قسنا، والعشوائي والعداد المخلوط بشبكة Feistel لا يمكن توقعهما.
- 302 يعد كل ضغطة ويسمح بإيقاف الرابط فوراً، و301 يوفر الطلبات ولكن المتصفح لا يعود، كما رأينا في Chrome: ضغطتان مع 302 وضغطة واحدة مع 301.
- ال Cache حسن p99 من 121 إلى 42.5 ملي ثانية ونصف معاملات PostgreSQL عندما تركزت الضغطات، وجعل الزمن أسوأ عندما كانت نسبة الإصابة 30%.
- النسخة الأولى سمحت بالمرور على كل الروابط، وملأت Valkey بمفاتيح لا تنتهي، وتوقفت كلها مع توقف Valkey، وأصلحتها النسخة الثانية بأربعة تغييرات صغيرة.
سجل التحديثات Changelog
- 18 نوفمبر 2026: كتابة المقال، وتنفيذ التجارب على Docker Engine 29.8.0 مع PostgreSQL 18.6 وValkey 9.0.6 وPython 3.13.18 وFastAPI 0.121.2 وk6 1.8.3 وGoogle Chrome 157.