المقدمة

تخيل إنك في مطعم:

  • إنت = العميل (Client)
  • المطعم = السيرفر (Server)
  • الطلب = Request
  • الأكل اللي بيجيلك = Response

إنت بتطلب (Request)، والمطعم بيرد عليك بالأكل (Response). ده بالظبط نموذج Client-Server.

يعني إيه Client-Server Model؟

التعريف

نموذج معماري بيقسم المهام بين طرفين:

  • Client (العميل): اللي بيطلب الخدمة
  • Server (الخادم): اللي بيقدم الخدمة

المبدأ الأساسي

Client  ──────[Request]──────→  Server
        ←─────[Response]──────

العميل دايماً هو اللي يبدأ الاتصال، والسيرفر ينتظر ويرد.

مكونات النموذج

1. Client (العميل)

التعريف

أي تطبيق أو جهاز بيطلب خدمة من سيرفر.

أمثلة على Clients

✓ المتصفح (Chrome, Firefox)
✓ تطبيق الموبايل (WhatsApp, Instagram)
✓ برنامج البريد (Outlook, Gmail App)
✓ لعبة Online
✓ سطر الأوامر (curl, wget)

وظائف الـ Client

1. إرسال Requests
2. استقبال Responses
3. عرض البيانات للمستخدم
4. التعامل مع الأخطاء

مثال بسيط - Client في Python

import requests

# Client بيطلب صفحة من Server
response = requests.get('https://example.com')

print(f"Status Code: {response.status_code}")
print(f"Content: {response.text[:100]}")

2. Server (الخادم)

التعريف

برنامج أو جهاز بيستنى Requests ويرد عليها.

أمثلة على Servers

✓ Web Server (Apache, Nginx)
✓ Database Server (MySQL, PostgreSQL)
✓ Mail Server (Postfix, Exchange)
✓ File Server (FTP, Samba)
✓ Game Server
✓ API Server

وظائف الـ Server

1. الاستماع (Listening) على منفذ معين
2. استقبال Requests
3. معالجة الطلبات
4. إرسال Responses
5. إدارة الموارد
6. التعامل مع عدة Clients في نفس الوقت

مثال بسيط - Server في Python

from http.server import HTTPServer, BaseHTTPRequestHandler

class SimpleHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        # السيرفر بيرد على أي Request
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()
        self.wfile.write(b'Hello from Server!')

# السيرفر يستنى على المنفذ 8080
server = HTTPServer(('localhost', 8080), SimpleHandler)
print("Server listening on port 8080...")
server.serve_forever()

جربه:

# شغل السيرفر
python server.py

# في Terminal تاني، اعمل Request
curl http://localhost:8080

# النتيجة:
Hello from Server!

دورة حياة Request-Response

الخطوات الكاملة

1. Client يفتح اتصال مع Server
         ↓
2. Client يرسل Request
         ↓
3. Server يستقبل Request
         ↓
4. Server يعالج الطلب
         ↓
5. Server يرسل Response
         ↓
6. Client يستقبل Response
         ↓
7. Client يعرض البيانات
         ↓
8. الاتصال يتقفل (أو يفضل مفتوح)

مثال عملي - فتح موقع

السيناريو: إنت بتفتح https://example.com

┌───────────────────────────────────┐
│ Step 1: DNS Lookup                      
│ Client: "فين example.com?"               
│ DNS: "ده 93.184.216.34"                  
└───────────────────────────────────┘
         ↓
┌────────────────────────────────────┐
│ Step 2: TCP Connection (3-Way Handshake)  
│ Client → Server: SYN                     
│ Server → Client: SYN-ACK                 
│ Client → Server: ACK                     
└────────────────────────────────────┘
         ↓
┌────────────────────────────────────┐
│ Step 3: TLS Handshake (للـ HTTPS)           
│ Client: "عايز اتصال مشفر"                     
│ Server: "تبادل المفاتيح والشهادات                 
└────────────────────────────────────┘
         ↓
┌────────────────────────────────────┐
  Step 4: HTTP Request                      
   Client → Server:                         
    GET / HTTP/1.1                          
    Host: example.com                       
    User-Agent: Mozilla/5.0                 
    Accept: text/html                       
└────────────────────────────────────┘
         ↓
┌────────────────────────────────────┐
  Step 5: Server Processing                               
│ -x السيرفر يقرأ الطلب                                  
│ -x يجهز الصفحة المطلوبة                                
│ -x يشغل PHP/Python إذا لازم                            
│ -x يجيب بيانات من Database لو محتاج                   
└────────────────────────────────────┘
         ↓
┌────────────────────────────────────┐
│ Step 6: HTTP Response                                   
│ Server → Client:                                        
│   HTTP/1.1 200 OK                                       
│   Content-Type: text/html                               
│   Content-Length: 1234                                  
│                                                          
│   <!DOCTYPE html>                                       
│   <html>                                                
│   ...                                                   
└────────────────────────────────────┘
         ↓
┌────────────────────────────────────┐
│ Step 7: Client Rendering                                
│ -x المتصفح يستلم HTML                                   
│ -x يطلب CSS, JS, Images                                 
│ -x يرسم الصفحة                                        
│ -x الصفحة تظهر لك                                       
└────────────────────────────────────┘

أنواع Client-Server Architectures

1. Two-Tier (طبقتين)

Client يتكلم مع Server مباشرة.

┌───────┐         ┌─────────┐
│ Client    ← →      Database  
│ (App)                Server    
└───────┘         └─────────┘

مثال: برنامج محاسبة Desktop يتصل بـ Database مباشرة.

المشاكل:

  • صعب التحديث (لازم تحدث كل Client)
  • أمان أقل (كل Client متصل بالـ Database)

2. Three-Tier (ثلاث طبقات)

في طبقة وسيطة (Application Server).

┌─────────┐     ┌─────────────┐     ┌──────────┐
│ Client      ←→   Application     ←→    Database    
│(Browser)            Server                 Server    
└─────────┘     └─────────────┘     └──────────┘

مثال: موقع ويب.

  • Client: المتصفح
  • Application Server: PHP/Python يشغل الكود
  • Database: MySQL يخزن البيانات

المميزات:

  • سهل التحديث (مرة واحدة على السيرفر)
  • أمان أفضل (Clients مش متصلين بالـ Database مباشرة)
  • Scalability أفضل

3. N-Tier (متعدد الطبقات)

طبقات أكتر للتعقيد الكبير.

┌─────────┐   ┌──────┐   ┌────────┐   ┌──────┐   ┌──────┐
│ Client     ←→  Load   ←→   App     ←→  Cache  ←→    DB    
│                Balancer      Server        Server       Server 
└─────────┘   └──────┘   └────────┘   └──────┘   └──────┘

مثال: موقع كبير زي Facebook.

بروتوكولات Client-Server

1. HTTP/HTTPS (Web)

Client Request:
GET /index.html HTTP/1.1
Host: example.com

Server Response:
HTTP/1.1 200 OK
Content-Type: text/html

<html>...</html>

2. FTP (File Transfer)

Client → Server: "USER admin"
Server → Client: "331 Password required"
Client → Server: "PASS 12345"
Server → Client: "230 Login successful"
Client → Server: "RETR file.txt"
Server → Client: [file content]

3. SMTP (Email Sending)

Client → Server: "HELO client.com"
Server → Client: "250 Hello"
Client → Server: "MAIL FROM: <user@client.com>"
Client → Server: "RCPT TO: <user@server.com>"
Client → Server: "DATA"
Client → Server: [email content]
Client → Server: "."
Server → Client: "250 Message accepted"

4. DNS (Domain Name System)

Client → DNS Server: "What's google.com?"
DNS Server → Client: "It's 142.250.185.46"

5. SSH (Secure Shell)

Client → Server: [connection request]
Server → Client: [public key]
Client → Server: [encrypted authentication]
Server → Client: "Welcome to server!"

مثال عملي كامل

السيناريو: نظام تسجيل دخول بسيط

Server (Flask - Python)

from flask import Flask, request, jsonify

app = Flask(__name__)

# Database مزيفة
users = {
    'admin': 'password123',
    'user1': 'mypass'
}

@app.route('/login', methods=['POST'])
def login():
    # السيرفر يستقبل Request
    data = request.get_json()
    username = data.get('username')
    password = data.get('password')
    
    # السيرفر يعالج الطلب
    if username in users and users[username] == password:
        # Success Response
        return jsonify({
            'status': 'success',
            'message': 'Login successful',
            'token': 'abc123xyz789'
        }), 200
    else:
        # Error Response
        return jsonify({
            'status': 'error',
            'message': 'Invalid credentials'
        }), 401

# السيرفر يستنى على المنفذ 5000
if __name__ == '__main__':
    app.run(port=5000)

Client (Python)

import requests
import json

# Client يرسل Request
url = 'http://localhost:5000/login'
data = {
    'username': 'admin',
    'password': 'password123'
}

response = requests.post(url, json=data)

# Client يعالج Response
if response.status_code == 200:
    result = response.json()
    print(f"✓ {result['message']}")
    print(f"Token: {result['token']}")
else:
    result = response.json()
    print(f"✗ {result['message']}")

تشغيل المثال

# Terminal 1: شغل السيرفر
python server.py
# Server listening on port 5000...

# Terminal 2: شغل الـ Client
python client.py
# ✓ Login successful
# Token: abc123xyz789

اللي بيحصل كالآتي

1. Client يفتح TCP connection على localhost:5000
2. Client يرسل HTTP POST request:
   POST /login HTTP/1.1
   Content-Type: application/json
   
   {"username": "admin", "password": "password123"}

3. Server يستقبل Request
4. Server يفحص Username & Password
5. Server يرد بـ Response:
   HTTP/1.1 200 OK
   Content-Type: application/json
   
   {"status": "success", "message": "Login successful", ...}

6. Client يستقبل Response ويطبعها

خلاصة

نموذج Client-Server ببساطة

Client: "عايز حاجة"
Server: "اتفضل"

الأساسيات

  • Client: اللي بيطلب (Browser, App, CLI)
  • Server: اللي بيرد (Web Server, API, Database)
  • Request: الطلب من Client
  • Response: الرد من Server

الأنواع

Two-Tier:   Client ←→ Server
Three-Tier: Client ←→ App Server ←→ Database
N-Tier:     طبقات متعددة للتعقيد الكبير

البروتوكولات الشائعة

  • HTTP/HTTPS: المواقع
  • FTP: نقل الملفات
  • SMTP/POP3/IMAP: البريد الإلكتروني
  • DNS: ترجمة الأسماء
  • SSH: الدخول الآمن