2026'da Django Channels: WebSocketler, Gercek Zamanli Iletisim ve Mulakat Sorulari

Django Channels 4.x, Django'yu HTTP'nin otesine tasiyarak WebSocketleri destekler ve sohbet, bildirimler, canli panolar gibi gercek zamanli ozellikler olusturmayi mumkun kilar. Bu egitim, consumer kaliplarini, Redis ile kanal katmanlarini ve orta seviye adaylari senior'lardan ayiran mulakat sorularini kapsar.

Django Neden WebSocketler Icin Channels'a Ihtiyac Duyar

Django'nun mimarisi, senkron bir istek-yanit protokolu olan WSGI uzerine kuruludur. WSGI'nin kalici baglanti kavrami yoktur. Django 4.1 async viewlar ekledi, ancak async viewlar hala istek-yanit modelini takip eder ve her yanittan sonra baglanti kapatilir.

WebSocket destegi, uzun sureli baglantilar ve cift yonlu iletisim isleyen ASGI gerektirir. Django Channels 4.x, Django'nun yerel async destegini routing ve consumer soyutlamalariyla sararak bu ASGI katmanini saglar.

# asgi.py
import os
from django.core.asgi import get_asgi_application
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
import chat.routing

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "project.settings")

application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    "websocket": AuthMiddlewareStack(
        URLRouter(
            chat.routing.websocket_urlpatterns
        )
    ),
})

ProtocolTypeRouter, gelen baglantiları protokol turune gore yonlendirir. HTTP istekleri Django'nun standart ASGI handler'ina giderken, WebSocket baglantiları URLRouter uzerinden uygun consumer'a yonlendirilir.

AsyncWebsocketConsumer: Temel Yapi Tasi

Consumer'lar, WebSocket'lerin Django view karsiliklaridir. AsyncWebsocketConsumer sinifi uc hook saglar: connect, disconnect ve receive. Her biri, engellemeyen I/O islemlerine izin veren bir coroutine olarak calisir.

# consumers.py
import json
from channels.generic.websocket import AsyncWebsocketConsumer

class NotificationConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        # AuthMiddlewareStack uzerinden oturumdan kullaniciyi al
        self.user = self.scope["user"]
        if self.user.is_anonymous:
            await self.close()
            return
        
        # Kullaniciya ozel kanal grubu olustur
        self.group_name = f"notifications_{self.user.id}"
        await self.channel_layer.group_add(
            self.group_name,
            self.channel_name
        )
        await self.accept()

    async def disconnect(self, close_code):
        # Grup uyeligini temizle
        await self.channel_layer.group_discard(
            self.group_name,
            self.channel_name
        )

    async def receive(self, text_data):
        # Istemciden gelen mesajlari isle
        data = json.loads(text_data)
        await self.send(text_data=json.dumps({
            "type": "ack",
            "id": data.get("id")
        }))

    async def notification_message(self, event):
        # Kanal katmani uzerinden gonderilen mesajlar icin handler
        await self.send(text_data=json.dumps({
            "type": "notification",
            "payload": event["payload"]
        }))

scope sozlugu, AuthMiddlewareStack kullanildiginda kimlik dogrulanmis kullanici dahil baglanti meta verilerini icerir. channel_name, bu belirli baglanti icin benzersiz bir tanimlayicidir, gruplar ise birden fazla baglantiya yayin yapmayi saglar.

WebSocket Baglanti Yonlendirmesi

Yonlendirme, Django'nun URL yapilandirmasina benzer sekilde URL yollarini consumer'lara esler. as_asgi() metodu, her consumer sinifi icin bir ASGI uygulama ornegi dondurur.

# routing.py
from django.urls import re_path
from . import consumers

websocket_urlpatterns = [
    re_path(
        r"ws/notifications/$",
        consumers.NotificationConsumer.as_asgi()
    ),
    re_path(
        r"ws/chat/(?P<room_name>\w+)/$",
        consumers.ChatConsumer.as_asgi()
    ),
]

Regex gruplari tarafindan yakalanan URL parametreleri self.scope["url_route"]["kwargs"] icerisinde gorunur. Bu, URL yoluna gore farkli sohbet odalarina katilma gibi dinamik yonlendirmeyi mumkun kilar.

Uretim Icin Redis Kanal Katmani

Bellekteki kanal katmani gelistirme icin calisir ancak uretimde basarisiz olur. Her islem kendi katmanini korur, islemler arasi iletisimi engeller. channels-redis paketi, uretim duzeyi cozum saglar.

# settings.py
CHANNEL_LAYERS = {
    "default": {
        "BACKEND": "channels_redis.core.RedisChannelLayer",
        "CONFIG": {
            "hosts": [("redis", 6379)],
            "capacity": 1500,
            "expiry": 10,
        },
    },
}

capacity ayari, kanal basina mesaj kuyruğunu sinirlar (varsayilan: 100). expiry ayari, mesajlarin dusurulmeden once ne kadar bekleyecegini kontrol eder (varsayilan: 60 saniye). Yuksek verimli uygulamalar icin, bellek birikimini onlemek icin capacity arttirilmali ve expiry azaltilmalidir.

Django View'lardan Mesaj Gonderme

Kanal katmanlari, senkron Django viewlari ve Celery gorevleri dahil olmak uzere uygulamanin herhangi bir yerinden WebSocket mesajlari gondermeyi mumkun kilar.

# views.py
from channels.layers import get_channel_layer
from asgiref.sync import async_to_sync

def create_order(request):
    order = Order.objects.create(user=request.user, **form.cleaned_data)
    
    # Kullanicinin WebSocket baglantisina bildirim gonder
    channel_layer = get_channel_layer()
    async_to_sync(channel_layer.group_send)(
        f"notifications_{request.user.id}",
        {
            "type": "notification_message",
            "payload": {
                "title": "Order Created",
                "order_id": order.id
            }
        }
    )
    return redirect("order_detail", pk=order.id)

type alani, consumer uzerindeki bir handler metoduna eslenir. notification_message, noktalar alt cizgilerle degistirildikten sonra notification_message() olur.

Async Consumer'larda Veritabani Erisimi

Django'nun ORM'si varsayilan olarak senkrondur. Async consumer'dan senkron ORM metodlarini cagirmak event loop'u engeller ve performansi dusurur. Iki cozum vardir: database_sync_to_async ve Django'nun yerel async ORM metodlari.

# consumers.py
from channels.db import database_sync_to_async
from .models import Message

class ChatConsumer(AsyncWebsocketConsumer):
    @database_sync_to_async
    def save_message(self, content):
        return Message.objects.create(
            room=self.room,
            user=self.user,
            content=content
        )
    
    async def receive(self, text_data):
        data = json.loads(text_data)
        message = await self.save_message(data["content"])
        
        await self.channel_layer.group_send(
            self.room_group_name,
            {
                "type": "chat_message",
                "content": data["content"],
                "user_id": self.user.id,
                "message_id": message.id
            }
        )

Django 4.1+, a onekiyle async ORM metodlari saglar: aget(), acreate(), afilter(). Bunlar, birçok durumda database_sync_to_async ihtiyacini ortadan kaldirir.

# Django'nun yerel async ORM'sini kullanma (Django 4.1+)
async def receive(self, text_data):
    data = json.loads(text_data)
    message = await Message.objects.acreate(
        room=self.room,
        user=self.user,
        content=data["content"]
    )

Uvicorn ve Nginx ile Dagitim

Daphne, Channels icin orijinal ASGI sunucusuydu. uvloop ile Uvicorn, WebSocket is yukleri icin daha iyi performans sunar ve daha buyuk bir topluluga sahiptir.

# Uretim dagitimi
uvicorn project.asgi:application \
    --host 0.0.0.0 \
    --port 8000 \
    --workers 4 \
    --ws websockets \
    --loop uvloop

Nginx, WebSocket proxy'lemesi icin ozel yapilandirma gerektirir. Upgrade ve Connection basliklarinin, HTTP'den WebSocket'e protokol degisimini etkinlestirmek icin iletilmesi gerekir.

# nginx.conf
upstream channels {
    server 127.0.0.1:8000;
}

server {
    listen 80;
    server_name example.com;

    location /ws/ {
        proxy_pass http://channels;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_read_timeout 86400;
    }

    location / {
        proxy_pass http://channels;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

proxy_read_timeout ayari, Nginx'in bosta kalan WebSocket baglantılarini kapatmasini onler. Uygulamanin beklenen baglanti suresine uygun olarak ayarlanmalidir.

Mulakat Sorulari: Django Channels

Bu sorular, kidemli Python gelistirici mulakatlarinda siklikla ortaya cikar. Beklenen yanitlar, yuzeysel tanimlarin otesine gecer.

Django neden WebSocket'leri yerel olarak isleyemiyor?

Django, her istegin bir yanit aldigi ve baglantiyin kapandigi senkron bir protokol olan WSGI kullanir. WebSocket'ler kalici, cift yonlu baglanti gerektirir. WSGI'nin bunun icin bir spesifikasyonu yoktur. Django'nun async viewlari (4.1'de eklendi) hala istek-yanit semantigini takip eder. Channels, uzun sureli baglantiları ve olay odakli iletisimi isleyen ASGI destegi ekler.

Kanal ile kanal katmani arasindaki fark nedir?

Kanal, mesajlarin consumer icin bekledigi adlandirilmis bir kuyruktur. Her WebSocket baglantisi benzersiz bir kanal adi alir. Kanal katmani, kanallar arasinda mesajlari yonlendiren tasima backend'idir (Redis, bellek ici). Katman, islemler arasi iletisimi, grup uyeligini ve mesaj serializasyonunu yonetir.

database_sync_to_async ve Django'nun async ORM'si ne zaman kullanilmalidir?

Basit islemler icin Django'nun async ORM metodlari (aget, acreate, afilter) kullanilmalidir, cunku async kodla temiz entegre olurlar. Kolayca donusturulemeyen senkron kodu cagirirken database_sync_to_async kullanilir; ucuncu parti kutuphaneler, karmasik QuerySet zincirleri veya sinyaller gibi ek senkron islemler tetikleyen metodlar buna ornektir.

WebSocket baglantilari yatay olarak nasil olceklendirilir?

Redis kanal katmani yatay olceklendirmeyi mumkun kilar. Tum Uvicorn worker'lar ve tum sunucu ornekleri Redis uzerinden iletisim kurar. Her baglantiinin kanal adi benzersizdir ve Redis grup uyeligini izler. Yapiskan oturumlar gerekli degildir cunku baglanti durumunu sunucu degil kanal katmani korur. Consumer'in mesaj gondermek icin yalnizca kanal adina ihtiyaci vardir.

Redis cokerse ne olur?

Yeni baglantılar basarili olur cunku connect(), grup uyeliginden once calisir. Mevcut baglantılar acik kalir ancak grup mesajlasmasi kaybolur. group_send, yapilandirmaya bagli olarak bir istisna firlatir veya sessizce basarisiz olur. Kritik uygulamalar icin, istemci tarafinda baglanti saglik kontrolleri ve graceful reconnection uygulanmalidir. Yuksek kullanilabilirlik icin Redis Sentinel veya Redis Cluster dusunulebilir.

Daha fazla Django mulakat hazirligi icin SharpSkill'deki Django middleware modulu ve Django signals modulu incelenebilir.

Django Channels Icin Uretim Kontrol Listesi

• Kanal katmani icin Redis 6+ ile channels-redis kullanilmalidir. Bellek ici katman yalnizca gelistirme icindir.
• capacity, beklenen mesaj verimi temelinde ayarlanmalidir. 100 (varsayilan) cogu uygulama icin calisir.
• Uvicorn birden fazla worker ile calistirilmalidir: 4 cekirdekli sunucu icin --workers 4.
• Nginx, en uzun beklenen baglantinizla eslesen proxy_read_timeout ile yapilandirilmalidir.
• Ustel geri cekilme ile istemci tarafinda yeniden baglanti mantigi uygulanmalidir.
• Redis bellek kullanimi izlenmelidir. Yavas consumer'lar ile yuksek mesaj hacimleri bellek buyumesine neden olur.
• Thread pool ek yukunden kacinmak icin mumkun oldugunda Django'nun async ORM metodlari kullanilmalidir.
• Gercekci baglanti sayilariyla test edilmelidir. WebSocket baglantilari, HTTP isteklerinden daha fazla kaynak yogundur.