Django Uygulamasını Docker, Nginx ve Let’s Encrypt ile Ölçeklendirme ve Güvenliğini Sağlama

Django Uygulamasını Docker, Nginx ve Let’s Encrypt ile Ölçeklendirme ve Güvenliğini Sağlama

Giriş

Modern web uygulamaları, kullanıcı beklentilerinin ve iş gereksinimlerinin sürekli artmasıyla birlikte, yüksek performans, ölçeklenebilirlik, güvenlik ve hızlı dağıtım gibi temel özelliklere sahip olmak zorundadır. Python tabanlı popüler web çerçevesi Django, hızlı geliştirme yetenekleriyle öne çıksa da, üretim ortamında bu beklentileri karşılamak için doğru mimari ve teknoloji yığınına ihtiyaç duyar. Bu makale, bir Django uygulamasını Docker ile konteynerize ederek, Nginx’i ters proxy ve statik dosya sunucusu olarak kullanarak ve Let’s Encrypt ile ücretsiz SSL/TLS güvenliği sağlayarak nasıl ölçeklenebilir ve güvenli hale getirebileceğimizi detaylı bir şekilde ele alacaktır. Bu entegre yaklaşım, uygulamanızın dağıtımını kolaylaştırmakla kalmayacak, aynı zamanda yüksek trafik yüklerini yönetme ve hassas verileri koruma yeteneğini de önemli ölçüde artıracaktır.

Temel Bileşenler

Başarılı bir dağıtım ve ölçeklendirme stratejisi için kullanacağımız temel teknolojileri ve rollerini tanıyalım:

Docker

Docker, uygulamaları ve bağımlılıklarını izole edilmiş, hafif ve taşınabilir “konteynerler” içinde paketlemeyi sağlayan bir platformdur. Bu, “benim makinemde çalışıyordu” sorununu ortadan kaldırır ve geliştirme, test ve üretim ortamları arasında tutarlılık sağlar. Dockerfile ile konteyner imajları oluşturulur, docker-compose ile birden fazla servisi (uygulama, veritabanı, Nginx vb.) tanımlayıp yönetmek kolaylaşır.

Django

Django, “The web framework for perfectionists with deadlines” sloganıyla bilinen, Python ile yazılmış yüksek seviyeli bir web çerçevesidir. Hızlı geliştirme, güvenlik ve ölçeklenebilirlik için birçok yerleşik özellik sunar.

Gunicorn / uWSGI

Gunicorn (Green Unicorn) veya uWSGI, Python WSGI (Web Server Gateway Interface) uygulamaları için bir HTTP sunucusudur. Django gibi Python web uygulamalarının web sunucuları (Nginx gibi) ile iletişim kurmasını sağlar. Nginx gelen istekleri Gunicorn’a iletir, Gunicorn Django uygulamasını çalıştırır ve yanıtı Nginx’e geri gönderir.

Nginx

Nginx (Engine-X), yüksek performanslı, açık kaynaklı bir web sunucusu, ters proxy, yük dengeleyici ve HTTP önbelleğidir. Django uygulamamızın önünde yer alarak gelen tüm istekleri karşılar. Statik dosyaları (CSS, JS, resimler) doğrudan sunar, dinamik istekleri Gunicorn’a yönlendirir ve SSL/TLS sonlandırmasını yönetir.

Let’s Encrypt & Certbot

Let’s Encrypt, ücretsiz, otomatik ve açık bir sertifika yetkilisidir (CA). Web siteleri için SSL/TLS sertifikaları sağlayarak HTTPS’i yaygınlaştırmayı hedefler. Certbot ise Let’s Encrypt sertifikalarını almak ve yönetmek için kullanılan bir yazılım istemcisidir. Kolay kurulum ve otomatik yenileme özellikleri sunar.

PostgreSQL

PostgreSQL, güçlü, açık kaynaklı, ilişkisel bir veritabanı yönetim sistemidir. Django uygulamaları için popüler ve güvenilir bir seçimdir. Docker ile konteynerize edilerek kolayca dağıtılabilir ve yönetilebilir.

Redis

Redis, bellek içi bir veri yapısı deposudur. Önbellekleme, oturum yönetimi, mesaj kuyrukları (Celery ile birlikte) ve gerçek zamanlı veri depolama gibi çeşitli amaçlar için kullanılabilir. Uygulamanın performansını artırmak için kritik bir bileşendir.

Docker ile Django Uygulamasını Konteynerize Etme

Uygulamamızı Docker ile konteynerize etmek, tüm bağımlılıkları tek bir pakette toplayarak dağıtımı ve yönetimi basitleştirir.

Dockerfile Oluşturma

Dockerfile, Docker imajımızı oluşturmak için adım adım talimatları içeren bir metin dosyasıdır. Django uygulamamız için temel bir Dockerfile şöyle görünebilir:

# Temel imaj olarak Python 3.9'un slim versiyonunu kullan
FROM python:3.9-slim-buster

Ortam değişkenlerini ayarla
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

Çalışma dizinini ayarla
WORKDIR /app

Bağımlılıkları kopyala ve yükle
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt

Django proje dosyalarını kopyala
COPY . /app/

Statik dosyaları topla (Gunicorn'dan önce)
Bu adım, Django'nun statik dosyaları STATIC_ROOT'a kopyalamasını sağlar
RUN python manage.py collectstatic --noinput

Uygulama portunu açığa çıkar
EXPOSE 8000

Gunicorn ile Django uygulamasını başlat
manage.py'nin bulunduğu dizinde olmalı ve projenizin adı mysite ise mysite.wsgi:application olmalı
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "3", "mysite.wsgi:application"]

Açıklamalar:
* FROM python:3.9-slim-buster: Küçük boyutlu ve gerekli kütüphaneleri içeren bir Python imajı seçiyoruz.
* ENV PYTHONDONTWRITEBYTECODE 1 ve ENV PYTHONUNBUFFERED 1: Python’ın .pyc dosyaları oluşturmasını engeller ve çıktıların arabelleğe alınmamasını sağlar, bu da günlükleri anında görmemizi sağlar.
* WORKDIR /app: Konteyner içinde çalışma dizinini /app olarak ayarlar.
* COPY requirements.txt /app/ ve RUN pip install --no-cache-dir -r requirements.txt: Önce bağımlılık dosyasını kopyalayıp kurarız. Bu, requirements.txt değişmediği sürece pip install adımının Docker katman önbelleğinden yararlanmasını sağlar.
* COPY . /app/: Projenin geri kalanını çalışma dizinine kopyalar.
* RUN python manage.py collectstatic --noinput: Django’nun statik dosyalarını (STATIC_ROOT ayarında belirtilen dizine) toplar. Bu, Nginx’in bu dosyalara kolayca erişmesini sağlar. --noinput kullanıcı etkileşimini engeller.
* EXPOSE 8000: Konteynerin 8000 numaralı portu dinleyeceğini belirtir.
* CMD ["gunicorn", ...]: Konteyner başlatıldığında çalıştırılacak varsayılan komutu tanımlar. Gunicorn’u 0.0.0.0:8000 adresinde 3 worker ile mysite.wsgi:application uygulamasını çalıştırmak üzere yapılandırırız.

docker-compose.yml ile Servisleri Tanımlama

docker-compose.yml dosyası, uygulamanın tüm servislerini (Django, PostgreSQL, Nginx, Redis, Certbot) tek bir dosya içinde tanımlamamızı sağlar. Bu, çoklu konteynerli uygulamaları yönetmek için idealdir.

version: '3.8'

services:
  web:
    build: .
    command: gunicorn mysite.wsgi:application --bind 0.0.0.0:8000 --workers 3
    volumes:
      - .:/app
      - static_volume:/app/staticfiles
      - media_volume:/app/mediafiles
    expose:
      - 8000
    env_file:
      - .env
    depends_on:
      - db
      - redis
    networks:
      - app_network

  nginx:
    image: nginx:latest
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/conf.d/default.conf
      - static_volume:/app/staticfiles
      - media_volume:/app/mediafiles
      - certbot_conf:/etc/letsencrypt
      - certbot_www:/var/www/certbot
    depends_on:
      - web
    networks:
      - app_network

  db:
    image: postgres:13
    environment:
      POSTGRES_DB: ${DB_NAME}
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data/
    networks:
      - app_network

  redis:
    image: redis:6
    networks:
      - app_network

  certbot:
    image: certbot/certbot
    volumes:
      - certbot_conf:/etc/letsencrypt
      - certbot_www:/var/www/certbot
    # Certbot'u sadece manuel olarak çalıştırmak için, otomatik başlatmayı engeller
    entrypoint: "/bin/sh -c 'trap exit TERM; while :; do sleep 1d & wait $!; done;'"
    networks:
      - app_network

volumes:
  postgres_data:
  static_volume:
  media_volume:
  certbot_conf:
  certbot_www:

networks:
  app_network:
    driver: bridge

Açıklamalar:
* web: Django uygulamamızı içeren servis. build: . ile mevcut dizindeki Dockerfile‘ı kullanır. volumes ile kodumuzu, statik ve medya dosyalarını konteyner ile eşleştiririz. expose ile 8000 portunu diğer servislere açarız. .env dosyasından ortam değişkenlerini yükleriz. db ve redis servislerine bağımlıdır.
* nginx: Nginx web sunucusu. 80 ve 443 portlarını host makineye açar. Nginx yapılandırma dosyamızı, statik/medya dosyalarını ve Let’s Encrypt sertifikalarını konteynere bağlar. web servisine bağımlıdır.
* db: PostgreSQL veritabanı. Ortam değişkenleri ile veritabanı adı, kullanıcı ve şifre ayarlanır. postgres_data volume’u ile veritabanı verilerinin kalıcılığı sağlanır.
* redis: Redis önbellek/mesaj kuyruğu servisi.
* certbot: Let’s Encrypt sertifikalarını almak için kullanılan Certbot istemcisi. certbot_conf ve certbot_www volume’ları ile sertifikaların ve geçici doğrulama dosyalarının kalıcılığı sağlanır. entrypoint komutu, Certbot’un otomatik olarak çalışmasını engeller, böylece manuel olarak veya cron job ile kontrol edebiliriz.
* volumes: Verilerin konteynerler arasında ve host makinede kalıcı olmasını sağlar.
* networks: Servislerin birbirleriyle güvenli bir şekilde iletişim kurmasını sağlar. app_network adında özel bir ağ tanımlarız.

Veritabanı ve Önbellek Yönetimi

PostgreSQL Konfigürasyonu

docker-compose.yml dosyasında db servisi ile PostgreSQL’i kolayca kurduk. Django uygulamasının bu veritabanına bağlanması için settings.py dosyasında aşağıdaki gibi bir yapılandırma yapmalıyız:

# mysite/settings.py
import os

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.environ.get('DB_NAME'),
        'USER': os.environ.get('DB_USER'),
        'PASSWORD': os.environ.get('DB_PASSWORD'),
        'HOST': 'db',  # docker-compose.yml'deki servis adı
        'PORT': '5432',
    }
}

HOST: 'db' kısmı önemlidir; Docker ağında servisler birbirlerini servis adlarıyla görebilirler. Veritabanı kimlik bilgileri .env dosyasından ortam değişkenleri olarak alınır.

Redis Konfigürasyonu

Redis, Django’da önbellekleme, oturum yönetimi veya Celery gibi görev kuyrukları için kullanılabilir. Django’da Redis’i önbellek olarak kullanmak için django-redis kütüphanesini kurup settings.py‘de yapılandırmanız gerekir:

# requirements.txt
django-redis

# mysite/settings.py
CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://redis:6379/1", # docker-compose.yml'deki servis adı
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}

Oturumları Redis'te saklamak isterseniz:
SESSION_ENGINE = "django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "default"

Burada LOCATION: "redis://redis:6379/1" ifadesi, Redis servisinin adının redis olduğunu belirtir.

Gunicorn ile Django Uygulamasını Sunma

Gunicorn, Django uygulamanız ile Nginx arasında bir arayüz görevi görür. Nginx’ten gelen istekleri alır, Django’ya iletir, Django’dan gelen yanıtları Nginx’e geri gönderir.

Gunicorn’un Rolü

Gunicorn, tek bir süreci birden fazla worker sürecine bölerek eşzamanlı istekleri işleyebilir. Bu, uygulamanızın daha fazla kullanıcıya hizmet vermesini sağlar. Nginx, statik dosyaları doğrudan sunarak Gunicorn’un yalnızca dinamik isteklerle ilgilenmesini sağlar, bu da Gunicorn’un verimliliğini artırır.

Gunicorn Yapılandırması

Dockerfile ve docker-compose.yml içinde Gunicorn’u nasıl başlattığımızı gördük. --workers parametresi, Gunicorn’un kaç worker süreci çalıştıracağını belirler. Genellikle (2 * CPU_çekirdek_sayısı) + 1 formülü önerilir. Örneğin, 2 çekirdekli bir sunucuda 5 worker uygun olabilir.
--bind 0.0.0.0:8000 komutu, Gunicorn’un tüm ağ arayüzlerinde 8000 portunu dinlemesini sağlar. Bu, Nginx’in aynı Docker ağında Gunicorn’a erişebilmesi için gereklidir.

Nginx ile Ters Proxy ve Statik Dosya Sunumu

Nginx, uygulamanızın dış dünyaya açılan kapısıdır. Gelen tüm web isteklerini karşılar ve bunları uygun servislere yönlendirir.

Nginx’in Rolü

* Ters Proxy: İstemcilerden gelen dinamik istekleri Django’nun Gunicorn servisine iletir ve yanıtları geri gönderir.
* Statik Dosya Sunumu: CSS, JavaScript, resimler gibi statik dosyaları doğrudan kendi üzerinden sunar. Bu, Gunicorn ve Django’nun bu yükten kurtulmasını sağlar ve performansı artırır.
* SSL Sonlandırma: Let’s Encrypt sertifikalarını kullanarak HTTPS trafiğini şifreler ve şifresini çözer.
* Yük Dengeleme: Birden fazla Django uygulama konteyneri varsa, gelen istekleri bunlar arasında dağıtabilir.

Nginx Yapılandırması (nginx/nginx.conf)

Nginx yapılandırması, docker-compose.yml dosyasında nginx servisine bağladığımız nginx/nginx.conf dosyasında yapılır.

# nginx/nginx.conf
upstream django {
    server web:8000; # docker-compose.yml'deki web servisinin adı ve portu
}

server {
    listen 80;
    server_name your_domain.com www.your_domain.com; # Kendi alan adınızı buraya yazın

    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }

    location / {
        return 301 https://$host$request_uri; # HTTP'den HTTPS'ye yönlendirme
    }
}

server {
    listen 443 ssl;
    server_name your_domain.com www.your_domain.com; # Kendi alan adınızı buraya yazın

    ssl_certificate /etc/letsencrypt/live/your_domain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your_domain.com/privkey.pem;

    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

    location /static/ {
        alias /app/staticfiles/; # Django'nun collectstatic ile topladığı dosyalar
    }

    location /media/ {
        alias /app/mediafiles/; # Kullanıcı tarafından yüklenen medya dosyaları
    }

    location / {
        proxy_pass http://django;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $host;
        proxy_redirect off;
    }
}

Açıklamalar:
* upstream django: Nginx’in istekleri ileteceği Django uygulamasının adresini tanımlar. web:8000, Docker ağında web servisinin 8000 portunu ifade eder.
* İlk server bloğu (port 80):
* listen 80: Gelen HTTP isteklerini dinler.
* server_name: Alan adlarınızı belirtin.
* location /.well-known/acme-challenge/: Certbot’un alan adı doğrulaması için kullandığı özel yolu tanımlar. Bu yol, Certbot’un geçici dosyalarını bulabilmesi için certbot_www volume’una bağlanır.
* return 301 https://$host$request_uri;: Tüm HTTP isteklerini HTTPS’ye yönlendirir.
* İkinci server bloğu (port 443):
* listen 443 ssl: Gelen HTTPS isteklerini dinler.
* ssl_certificate ve ssl_certificate_key: Let’s Encrypt tarafından sağlanan SSL sertifika ve anahtar dosyalarının yollarını belirtir.
* include /etc/letsencrypt/options-ssl-nginx.conf; ve ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;: Certbot’un güvenli SSL yapılandırma ayarlarını içerir.
* location /static/ ve location /media/: Statik ve medya dosyalarını doğrudan Nginx üzerinden sunar. alias yönergesi, bu yolların gerçek dosya sistemindeki karşılıklarını belirtir.
* location /: Diğer tüm istekleri django upstream’ine (yani Gunicorn’a) proxy_pass ile iletir. proxy_set_header yönergeleri, orijinal istemci bilgilerini (IP adresi, host adı) Gunicorn’a iletmek için önemlidir.

Let’s Encrypt ile SSL/TLS Güvenliği

HTTPS, modern web uygulamaları için bir zorunluluktur. Let’s Encrypt, bu güvenliği ücretsiz ve kolayca sağlamanın en popüler yoludur.

Neden SSL/TLS?

* Veri Şifrelemesi: Kullanıcı ile sunucu arasındaki tüm iletişimi şifreleyerek hassas verilerin (şifreler, kredi kartı bilgileri) güvenliğini sağlar.
* Kimlik Doğrulama: Web sitesinin gerçekten iddia ettiği site olduğunu doğrular, man-in-the-middle saldırılarını önler.
* SEO Faydaları: Google, HTTPS kullanan siteleri arama sonuçlarında daha üst sıralara çıkarır.
* Tarayıcı Güvenliği: Modern tarayıcılar, HTTPS kullanmayan siteleri “Güvenli Değil” olarak işaretler.

Certbot ile Sertifika Alma

Sertifika almak için docker-compose.yml dosyasındaki certbot servisini kullanacağız. İlk sertifika alma işlemi, Nginx’in 80 portunu kullanarak Certbot’un alan adı sahipliğini doğrulamasına izin vermelidir.

Adım 1: Nginx’i sadece 80 portunu dinleyecek şekilde başlatın (geçici olarak HTTPS yönlendirmesi olmadan).
Yukarıdaki nginx.conf dosyasında 80 portu için location /.well-known/acme-challenge/ bloğu ve return 301 https://... yönlendirmesi zaten mevcut. Bu, Certbot’un doğrulama yaparken HTTP’den HTTPS’ye yönlendirilmesini engeller.

Adım 2: Certbot ile sertifika alın.
İlk sertifikayı almak için docker-compose.yml dosyasındaki certbot servisini kullanın:

docker-compose run --rm certbot certonly --webroot --webroot-path /var/www/certbot -d your_domain.com -d www.your_domain.com

* --rm: Komut bittikten sonra konteyneri kaldırır.
* certonly: Sadece sertifika alır, Nginx yapılandırmasını otomatik değiştirmez.
* --webroot: Webroot doğrulama yöntemini kullanır.
* --webroot-path /var/www/certbot: Certbot’un doğrulama dosyalarını yerleştireceği dizini belirtir. Bu dizin nginx servisi ile de paylaşılır.
* -d your_domain.com -d www.your_domain.com: Sertifika almak istediğiniz alan adlarını belirtin.

Bu komutu çalıştırdıktan sonra e-posta adresinizi girmeniz ve hizmet şartlarını kabul etmeniz istenecektir. Sertifikalar /etc/letsencrypt/live/your_domain.com/ dizinine kaydedilecektir.

Adım 3: Nginx’i sertifikalarla birlikte yeniden başlatın.
Sertifikalar alındıktan sonra, nginx.conf dosyanızdaki SSL ayarlarının doğru olduğundan emin olun ve tüm servisleri yeniden başlatın:

docker-compose down
docker-compose up -d

Artık siteniz HTTPS üzerinden erişilebilir olmalıdır.

Otomatik Yenileme

Let’s Encrypt sertifikaları 90 gün geçerlidir. Otomatik yenileme, sertifikalarınızın süresi dolmadan önce güncellenmesini sağlar. Bunu bir cron işi veya docker-compose komutu ile yapabiliriz.

docker-compose.yml dosyasında certbot servisi için entrypoint komutunu değiştirerek Certbot’un otomatik olarak yenileme yapmasını sağlayabiliriz:

certbot:
    image: certbot/certbot
    volumes:
      - certbot_conf:/etc/letsencrypt
      - certbot_www:/var/www/certbot
    entrypoint: "/bin/sh -c 'trap exit TERM; while :; do certbot renew --webroot -w /var/www/certbot --post-hook \"nginx -s reload\"; sleep 12h & wait $!; done;'"
    networks:
      - app_network

Bu entrypoint komutu, her 12 saatte bir certbot renew komutunu çalıştırır. renew komutu sadece sertifikaların süresi dolmak üzereyse yenileme yapar. --post-hook "nginx -s reload" komutu ise yenileme başarılı olduğunda Nginx’i yeniden yükleyerek yeni sertifikaların devreye girmesini sağlar.

Ölçeklendirme Stratejileri

Uygulamanız büyüdükçe, daha fazla isteği işlemek için ölçeklendirmeye ihtiyaç duyacaksınız. Docker ve Nginx bu konuda önemli avantajlar sunar.

Django Uygulamasını Ölçeklendirme

docker-compose ile Django uygulama konteynerlerini kolayca ölçeklendirebilirsiniz:

docker-compose up -d --scale web=3

Bu komut, web servisi için 3 adet konteyner örneği başlatır. Nginx’in upstream yapılandırması, varsayılan olarak bu birden fazla web servisi örneği arasında yük dengeleme yapacaktır. Ancak daha gelişmiş yük dengeleme stratejileri için Nginx yapılandırmasında least_conn veya ip_hash gibi yöntemler kullanılabilir.

Uygulamanızın birden fazla örneğinin sorunsuz çalışması için “stateless” (durumsuz) olması önemlidir. Oturum verilerini, önbellekleri ve diğer durum bilgilerini uygulama konteynerinde değil, veritabanı veya Redis gibi harici, paylaşımlı bir depolama sisteminde tutmalısınız.

Veritabanı Ölçeklendirme

PostgreSQL gibi ilişkisel veritabanları dikey olarak (daha güçlü bir sunucuya geçerek) veya yatay olarak ölçeklenebilir. Yatay ölçeklendirme genellikle şunları içerir:
* Okuma Replikaları (Read Replicas): Okuma yoğun uygulamalar için ana veritabanının kopyalarını oluşturarak okuma isteklerini bu replikalara yönlendirmek.
* Sharding: Veritabanını daha küçük, bağımsız parçalara bölmek ve her parçayı ayrı bir sunucuda barındırmak. Bu, daha karmaşık bir çözümdür ve uygulamanın mimarisinde değişiklikler gerektirebilir.

Önbellek Ölçeklendirme

Redis, zaten bellek içi ve hızlı bir çözümdür. Tek bir Redis konteyneri genellikle çoğu uygulama için yeterlidir. Ancak çok yüksek trafikli senaryolarda Redis Cluster gibi dağıtık çözümler düşünülebilir.

Güvenlik En İyi Uygulamaları

Ölçeklenebilirlik kadar güvenlik de kritik öneme sahiptir.

Hassas Bilgilerin Yönetimi

* Ortam Değişkenleri: Django SECRET_KEY, veritabanı kimlik bilgileri, API anahtarları gibi hassas bilgileri doğrudan kodda veya sürüm kontrol sisteminde saklamayın. Bunları .env dosyaları aracılığıyla ortam değişkenleri olarak yönetin ve .env dosyasını .gitignore‘a ekleyin.
* Docker Secrets: Üretim ortamında daha güvenli bir yöntem olarak Docker Secrets veya Kubernetes Secrets kullanmayı düşünün.

Ağ İzolasyonu

docker-compose tarafından oluşturulan özel ağlar, servislerin birbirleriyle güvenli bir şekilde iletişim kurmasını sağlar. Servisleri sadece ihtiyaç duydukları portlardan ve diğer servislerden erişilebilir hale getirin. Örneğin, PostgreSQL’in dış dünyaya açılmasına izin vermeyin, sadece web servisi tarafından erişilebilir olsun.

Güvenlik Duvarı (Firewall)

Sunucunuzda bir güvenlik duvarı (örn. UFW veya iptables) etkinleştirin ve sadece gerekli portlara (80, 443, SSH) dışarıdan erişime izin verin. Diğer tüm portları kapatın.

Günlükleme ve İzleme

Uygulama, Nginx ve veritabanı günlüklerini düzenli olarak izleyin. Merkezi bir günlükleme sistemi (ELK Stack, Grafana Loki vb.) kullanarak tüm günlükleri tek bir yerden toplayıp analiz etmek, sorunları tespit etmek ve güvenlik olaylarını izlemek için çok önemlidir. Prometheus ve Grafana gibi araçlarla performans metriklerini izlemek de proaktif bir güvenlik ve performans yönetimi sağlar.

Güncel Tutma

Kullandığınız tüm yazılımları ve bağımlılıkları (Python, Django, Nginx, PostgreSQL, Redis, Docker imajları, kütüphaneler) düzenli olarak güncelleyin. Güvenlik açıkları genellikle eski sürümlerde bulunur ve güncellemelerle giderilir.

Dağıtım ve Otomasyon

Üretim ortamına dağıtım süreci, otomasyon ile çok daha verimli ve hatasız hale getirilebilir.

Üretim Ortamına Dağıtım

Dağıtım yapmadan önce docker-compose.prod.yml gibi ayrı bir dosya kullanarak üretim ortamına özel ayarları (örneğin, geliştirme için kullanılan bind mount’ları kaldırmak, daha güvenli imajlar kullanmak) tanımlayabilirsiniz.
Dağıtım sırasında çalıştırmanız gereken önemli komutlar:
* docker-compose exec web python manage.py migrate: Veritabanı şeması güncellemelerini uygular.
* docker-compose exec web python manage.py collectstatic --noinput: Statik dosyaları tekrar toplar (eğer kodda değişiklikler varsa).

Sürekli Entegrasyon/Sürekli Dağıtım (CI/CD)

CI/CD işlem hatları, kod değişikliklerinin otomatik olarak test edilmesini, Docker imajlarının oluşturulmasını ve üretim ortamına dağıtılmasını sağlar. GitHub Actions, GitLab CI/CD, Jenkins veya CircleCI gibi araçlar bu süreçleri otomatikleştirerek insan hatasını azaltır ve dağıtım hızını artırır. Bu, özellikle büyük ekipler ve sık güncellemeler için vazgeçilmezdir.

Sonuç

Bu makalede, bir Django uygulamasını Docker, Nginx ve Let’s Encrypt kullanarak nasıl ölçeklenebilir ve güvenli hale getireceğimizi ayrıntılı bir şekilde inceledik. Docker ile uygulamanızı ve bağımlılıklarını izole ettik, docker-compose ile servislerin koordinasyonunu sağladık. Gunicorn’u Django için bir WSGI sunucusu olarak yapılandırdık. Nginx’i ters proxy, yük dengeleyici ve statik dosya sunucusu olarak konumlandırdık. Let’s Encrypt ve Certbot ile ücretsiz ve otomatik SSL/TLS sertifikaları sağlayarak uygulamanın güvenliğini artırdık. Ayrıca, ölçeklendirme stratejileri ve güvenlik en iyi uygulamaları hakkında önemli bilgiler paylaştık.

Bu mimari, Django uygulamanız için sağlam, esnek ve güvenli bir temel oluşturur. Uygulamanız büyüdükçe, bu yapılandırma sayesinde kolayca ölçeklenebilir ve performansını koruyabilir. Gelecekte, daha büyük ölçekli ve karmaşık dağıtımlar için Docker Swarm veya Kubernetes gibi konteyner orkestrasyon araçlarını keşfedebilirsiniz. Unutmayın ki sürekli izleme, düzenli güncellemeler ve güvenlik denetimleri, uygulamanızın uzun vadeli sağlığı ve güvenliği için kritik öneme sahiptir.