Ubuntu Üzerinde Python Web Uygulamanızı Pyramid Çerçevesi ile Oluşturmak: Kapsamlı Bir Rehber

Ubuntu Üzerinde Python Web Uygulamanızı Pyramid Çerçevesi ile Oluşturmak: Kapsamlı Bir Rehber

Giriş

Python ekosistemi, web uygulamaları geliştirmek için zengin bir çerçeve seçeneği sunar. Django ve Flask gibi popüler isimlerin yanı sıra, daha az bilinen ancak esnekliği ve gücüyle öne çıkan bir seçenek de Pyramid’dir. Pyramid, “opinionated” (belirli bir yol dayatan) olmaktan ziyade, geliştiriciye tam kontrol sağlayan, “unopinionated” (belirli bir yol dayatmayan) bir yapıya sahiptir. Bu, onu küçük prototiplerden büyük, karmaşık API’lere ve web hizmetlerine kadar her türlü proje için ideal bir seçim haline getirir.

Bu makalede, Pyramid çerçevesini kullanarak Ubuntu işletim sistemi üzerinde bir Python web uygulaması oluşturmanın tüm adımlarını baştan sona inceleyeceğiz. Temel kurulumdan veritabanı entegrasyonuna, görünümlerden şablonlara ve hatta dağıtım ipuçlarına kadar geniş bir yelpazeyi kapsayacağız. Amacımız, Pyramid’in gücünü ve esnekliğini anlamanıza yardımcı olmak ve kendi projelerinizi başlatmak için sağlam bir temel sunmaktır. Eğer Python biliyorsanız ve daha az “sihir” içeren, daha fazla kontrol sağlayan bir web çerçevesi arıyorsanız, Pyramid tam size göre olabilir.

Ön Koşullar ve Ortam Kurulumu

Herhangi bir yazılım geliştirme projesine başlamadan önce, çalışma ortamımızı doğru şekilde hazırlamak kritik öneme sahiptir. Bu bölümde, Ubuntu işletim sisteminizi Pyramid projeniz için hazır hale getirecek temel adımları ele alacağız.

Ubuntu Hazırlığı

Öncelikle, sisteminizin güncel olduğundan emin olalım ve gerekli temel geliştirme araçlarını kuralım:

sudo apt update
sudo apt upgrade -y
sudo apt install -y build-essential python3-dev python3-pip

* build-essential: Derleme araçları (GCC gibi) sağlar, bazı Python paketleri C uzantıları gerektirebilir.
* python3-dev: Python başlık dosyalarını ve statik kütüphaneleri içerir, bu da C uzantılarına sahip Python paketlerini derlemek için gereklidir.
* python3-pip: Python paket yöneticisi pip’i kurar.

Python ve Sanal Ortam Kurulumu

Python projeleri geliştirirken sanal ortam kullanmak iyi bir pratiktir. Sanal ortamlar, her projenin kendi bağımlılık setine sahip olmasını sağlayarak bağımlılık çakışmalarını önler ve sistem genelindeki Python kurulumunuzu temiz tutar.

Ubuntu’da Python 3 genellikle ön yüklü gelir. Python 3.8 veya daha yeni bir sürümünü kullandığınızdan emin olun. Sanal ortam oluşturmak için venv modülünü kullanacağız:

# Proje dizini oluşturun ve içine girin
mkdir my_pyramid_app
cd my_pyramid_app

Sanal ortam oluşturun (genellikle '.venv' veya 'venv' adıyla)
python3 -m venv .venv

Sanal ortamı etkinleştirin
source .venv/bin/activate

Sanal ortam etkinleştirildiğinde, komut satırı isteminizin başında (.venv) gibi bir ifade göreceksiniz. Artık yükleyeceğiniz tüm Python paketleri bu sanal ortamın içine kurulacak ve sistem genelindeki Python kurulumunuzu etkilemeyecektir.

PostgreSQL Kurulumu ve Yapılandırması

Çoğu web uygulaması bir veritabanına ihtiyaç duyar. Bu rehberde, güçlü ve güvenilir bir açık kaynak ilişkisel veritabanı yönetim sistemi olan PostgreSQL’i kullanacağız.

# PostgreSQL sunucusunu ve ek araçları kurun
sudo apt install -y postgresql postgresql-contrib

Kurulumdan sonra, PostgreSQL varsayılan olarak postgres adlı bir sistem kullanıcısı oluşturur. Bu kullanıcı ile veritabanı işlemleri yapabiliriz. Öncelikle, postgres kullanıcısına geçiş yapın:

sudo -i -u postgres

Şimdi, uygulamamız için bir veritabanı kullanıcısı ve bir veritabanı oluşturalım:

# Yeni bir veritabanı kullanıcısı oluşturun
createuser --pwprompt myuser # Şifre isteyecektir, güçlü bir şifre girin

Uygulamanız için bir veritabanı oluşturun ve sahibini belirleyin
createdb -O myuser myapp_db

postgres kullanıcısından çıkın
exit

Artık myuser adlı bir veritabanı kullanıcınız ve myapp_db adlı bir veritabanınız var. Uygulamanız bu kimlik bilgileriyle veritabanına bağlanabilecektir. Pyramid uygulamanızın PostgreSQL ile etkileşim kurabilmesi için psycopg2-binary paketini kurmamız gerekecek, ancak bunu Pyramid projesini oluşturduktan sonra yapacağız.

Pyramid Projesi Oluşturma

Ortamımız hazır olduğuna göre, artık bir Pyramid projesi oluşturmaya başlayabiliriz. Pyramid, proje iskeleti oluşturmak için kullanışlı araçlar sunar.

Pyramid Kurulumu

Sanal ortamınız etkinleştirilmişken, Pyramid çerçevesini kurun:

pip install pyramid

Bu komut, Pyramid’in kendisini ve temel bağımlılıklarını sanal ortamınıza yükleyecektir.

Proje İskeleti Oluşturma

Pyramid, pcreate adında bir komut satırı aracıyla proje iskeletleri oluşturmayı kolaylaştırır. pcreate‘i kullanabilmek için öncelikle pyramid_cookiecutter_starter paketini kurmamız gerekiyor:

pip install pyramid_cookiecutter_starter

Şimdi, pcreate komutuyla yeni bir Pyramid projesi oluşturalım. pyramid_cookiecutter_starter şablonu, modern Pyramid uygulamaları için iyi bir başlangıç noktası sunar:

pcreate -s pyramid_cookiecutter_starter mywebapp

Bu komut, mywebapp adında yeni bir dizin oluşturacak ve içine temel bir Pyramid uygulaması iskeletini yerleştirecektir. Proje oluşturulurken sizden bazı bilgiler (proje adı, açıklama vb.) isteyebilir. Varsayılan değerleri kabul edebilir veya kendi tercihlerinizi girebilirsiniz.

Proje yapısı genellikle şuna benzer olacaktır:

mywebapp/
├── .venv/
├── mywebapp/
│   ├── __init__.py
│   ├── models/
│   │   ├── __init__.py
│   │   └── mymodel.py
│   ├── views/
│   │   ├── __init__.py
│   │   └── default.py
│   ├── static/
│   │   ├── pyramid-logo.png
│   │   └── sample.css
│   ├── templates/
│   │   └── mytemplate.pt
│   └── tests/
│       └── test_mywebapp.py
├── development.ini
├── production.ini
├── setup.py
├── README.md
└── requirements.txt

* mywebapp/: Uygulamanızın Python modülleri burada bulunur.
* development.ini, production.ini: Uygulamanın geliştirme ve üretim ortamları için yapılandırma dosyaları.
* setup.py: Projenizin dağıtım ve bağımlılıklarını yöneten standart Python setup dosyası.
* requirements.txt: Projenizin Python bağımlılıklarını listeler.

Uygulamayı Çalıştırma

Proje iskeletini oluşturduktan sonra, uygulamayı çalıştırıp varsayılan çıktıyı görelim. Öncelikle, yeni oluşturulan proje dizinine gidin ve projenin bağımlılıklarını kurun:

cd mywebapp
pip install -e .

pip install -e . komutu, projenizi “düzenlenebilir” modda kurar. Bu, setup.py dosyasında belirtilen tüm bağımlılıkları yükler ve projenizin Python paketleri olarak erişilebilir olmasını sağlar.

Şimdi uygulamayı çalıştırabiliriz:

pserve development.ini --reload

* pserve: Pyramid uygulamalarını çalıştıran bir komut satırı aracıdır.
* development.ini: Uygulamanın geliştirme yapılandırmasını kullanmasını söyleriz.
* --reload: Kodunuzda yaptığınız değişikliklerde sunucunun otomatik olarak yeniden yüklenmesini sağlar, bu da geliştirme sürecini hızlandırır.

Uygulama başarıyla başlatıldığında, terminalinizde Serving on http://0.0.0.0:6543 (veya benzer bir adres) gibi bir mesaj görmelisiniz. Web tarayıcınızı açın ve http://localhost:6543/ adresine gidin. Pyramid’in varsayılan karşılama sayfasını görmelisiniz. Tebrikler, ilk Pyramid uygulamanız çalışıyor!

Pyramid Temelleri

Pyramid’in temel yapı taşlarını ve bir web uygulamasının nasıl çalıştığını anlamak için görünümler (views), rotalar (routes) ve şablonlar (templates) gibi kavramları inceleyelim.

Yapılandırma ve development.ini

development.ini dosyası, uygulamanızın nasıl çalıştığını kontrol eden önemli ayarları içerir. Bu dosya, uygulamanın ana yapılandırma dosyasıdır ve uygulamanın hangi Python modülünü başlatacağını, hangi portta dinleyeceğini ve çeşitli Pyramid ayarlarını belirtir.

Önemli bölümler şunlardır:
* [app:main]: Uygulamanızın ana yapılandırması. Burada Pyramid uygulamanızın başlatma işlevini (genellikle mywebapp.main gibi) ve çeşitli Pyramid ayarlarını tanımlarsınız. Örneğin, pyramid.reload_templates = true gibi ayarlar geliştirme sırasında şablon değişikliklerinin anında görünmesini sağlar.
* [server:main]: Uygulamanızın hangi adreste ve portta dinleyeceğini belirtir. Varsayılan olarak host = 0.0.0.0 ve port = 6543 olabilir.
* Diğer bölümler veritabanı bağlantı dizeleri, hata ayıklama ayarları ve diğer eklentilerin yapılandırmaları için kullanılabilir.

Görünümler (Views) ve Rotalar (Routes)

Pyramid’de bir web uygulamasının kalbi görünümler ve rotalardır.
* Rotasyon (Routing): Gelen bir HTTP isteğinin URL’sini bir görünümle eşleştirme sürecidir.
* Görünüm (View): Eşleşen URL’ye yanıt veren Python fonksiyonu veya sınıfıdır.

mywebapp/views/default.py dosyasına bakarsanız, aşağıdaki gibi bir yapı göreceksiniz:

from pyramid.view import view_config
from pyramid.response import Response

@view_config(route_name='home', renderer='../templates/mytemplate.pt')
def my_view(request):
    return {'project': 'mywebapp'}

@view_config(route_name='hello', renderer='json')
def hello_world(request):
    name = request.matchdict.get('name', 'World')
    return {'message': f'Hello, {name}!'}

* @view_config: Bu dekoratör, bir fonksiyonu veya sınıfı bir görünüm olarak kaydeder.
* route_name='home': Bu görünümün home adlı rota ile eşleşeceğini belirtir. Rotalar genellikle mywebapp/__init__.py içinde tanımlanır.
* renderer='../templates/mytemplate.pt': Görünümün döndürdüğü sözlüğün bu şablon kullanılarak HTML’e dönüştürüleceğini belirtir.
* renderer='json': Görünümün döndürdüğü sözlüğün otomatik olarak JSON yanıtına dönüştürüleceğini belirtir.
* request: Her görünüm fonksiyonu, gelen HTTP isteği hakkında bilgi içeren bir request nesnesi alır. Bu nesne, URL parametrelerine (request.matchdict), sorgu parametrelerine (request.GET), form verilerine (request.POST), oturum bilgilerine (request.session) ve daha fazlasına erişim sağlar.

Rotalar ise mywebapp/__init__.py dosyasında Configurator nesnesi kullanılarak tanımlanır:

from pyramid.config import Configurator

def main(global_config, settings):
    with Configurator(settings=settings) as config:
        config.include('pyramid_chameleon') # Eğer Chameleon şablon motoru kullanıyorsanız
        config.add_static_view('static', 'static', cache_max_age=3600)
        config.add_route('home', '/')
        config.add_route('hello', '/hello/{name}') # URL parametresi ile
        config.scan('.') # mywebapp modülündeki tüm @view_config'ları tarar
    return config.make_wsgi_app()

* config.add_route('home', '/'): / URL’sine home adını veren bir rota tanımlar.
* config.add_route('hello', '/hello/{name}'): /hello/ ile başlayan ve sonrasında bir parametre (name) alan bir rota tanımlar. Bu parametreye görünüm içinde request.matchdict['name'] ile erişilebilir.
* config.scan('.'): Pyramid’e, uygulamanın geçerli dizinindeki (ve alt dizinlerindeki) tüm Python dosyalarını taramasını ve @view_config dekoratörleri ile işaretlenmiş görünümleri kaydetmesini söyler.

Şablonlar (Templates)

Pyramid, HTML oluşturmak için çeşitli şablon motorlarını destekler. Varsayılan olarak pyramid_chameleon veya pyramid_jinja2 gibi eklentilerle gelir. Starter şablon genellikle Chameleon kullanır.

mywebapp/templates/mytemplate.pt dosyası şöyle görünebilir:

    
    
    


    
    
This is a basic Pyramid application.
    
Say Hello to PyramidUser

* ${project}: Görünümden gelen project anahtarının değerini buraya yerleştirir.
* ${request.static_url(...)}: Statik bir dosyanın (CSS, JS, resim) URL’sini oluşturur.
* ${request.route_url(...)}: Bir rotanın URL’sini oluşturur. Bu, URL’lerin dinamik olarak oluşturulmasını sağlar ve rota tanımları değiştiğinde kodunuzu güncellemenizi gerektirmez.

Varlıklar (Assets) ve Statik Dosyalar

CSS, JavaScript dosyaları ve resimler gibi statik varlıklar, mywebapp/static/ dizininde bulunur. Bu dosyaların tarayıcı tarafından erişilebilir olması için mywebapp/__init__.py içinde bir statik görünüm tanımlanır:

config.add_static_view('static', 'static', cache_max_age=3600)

* 'static': Bu, URL’de /static/ ön eki ile erişilebilecek bir adlandırmadır.
* 'static': Bu, uygulamanın static dizinindeki dosyaları sunar.
* cache_max_age=3600: Tarayıcıların bu dosyaları ne kadar süreyle önbelleğe alabileceğini belirtir (saniye cinsinden).

Bu yapılandırma sayesinde, şablonlarınızda request.static_url('mywebapp:static/sample.css') gibi ifadelerle statik dosyalara güvenli bir şekilde referans verebilirsiniz.

Veritabanı Entegrasyonu

Modern web uygulamalarının çoğu veritabanı etkileşimine ihtiyaç duyar. Pyramid, belirli bir ORM (Object-Relational Mapper) dayatmaz, ancak SQLAlchemy Python dünyasında en popüler ve güçlü ORM’lerden biridir ve Pyramid ile harika bir uyum içindedir. Bu bölümde, PostgreSQL veritabanımızı SQLAlchemy ve Alembic ile entegre edeceğiz.

SQLAlchemy ve Alembic

* SQLAlchemy: Python nesnelerini veritabanı tablolarına eşleyen ve veritabanı işlemlerini Python koduyla yapmamızı sağlayan bir ORM’dir. Ham SQL sorguları yazmak yerine Python sınıfları ve nesneleriyle çalışırız.
* Alembic: SQLAlchemy için bir veritabanı geçiş (migration) aracıdır. Veritabanı şemanızdaki değişiklikleri (yeni tablolar, sütun ekleme/çıkarma) yönetmenizi sağlar.

Öncelikle, gerekli paketleri sanal ortamımıza kuralım:

pip install sqlalchemy alembic psycopg2-binary

* psycopg2-binary: PostgreSQL veritabanı sürücüsüdür.

Şimdi Alembic’i projemize entegre edelim. Proje kök dizinindeyken (yani mywebapp dizininin içinde), Alembic yapılandırmasını başlatın:

alembic init alembic

Bu komut, alembic adında yeni bir dizin oluşturacak ve içine Alembic’in yapılandırma dosyalarını (özellikle alembic.ini ve env.py) yerleştirecektir.

alembic.ini dosyasında veritabanı bağlantı dizenizi ayarlamanız gerekir. Dosyayı açın ve sqlalchemy.url satırını bulun. Kendi PostgreSQL bağlantı dizenizle güncelleyin:

# alembic.ini
...
sqlalchemy.url = postgresql://myuser:your_password@localhost:5432/myapp_db
...

your_password kısmını PostgreSQL kullanıcınızı oluştururken belirlediğiniz şifre ile değiştirin.

Ardından, alembic/env.py dosyasını düzenlememiz gerekecek. Alembic’in SQLAlchemy modellerinizi otomatik olarak algılayabilmesi için bu dosyayı güncelleyeceğiz. env.py içinde target_metadata = None satırını bulun ve target_metadata = Base.metadata olarak değiştirin. Ayrıca, Base nesnesini mywebapp.models.mymodel dosyasından içe aktarmanız gerekecek.

alembic/env.py dosyasında yapılması gereken değişiklikler (sadece ilgili kısımlar):

# alembic/env.py
...
from logging.config import fileConfig

mywebapp projenizin kök dizininden Base'i içe aktarın
import os
import sys
sys.path.append(os.getcwd())
from mywebapp.models.mymodel import Base # Kendi model dosyanızın yolunu belirtin

...
target_metadata = None  # Bu satırı silin veya yorumlayın
target_metadata = Base.metadata # Bu satırı ekleyin
...

Model Tanımlama

mywebapp/models/mymodel.py dosyası genellikle uygulamanızın veritabanı modellerini içerir. Varsayılan olarak bir Page modeli içerebilir. Biz basit bir User modeli ekleyelim.

mywebapp/models/mymodel.py dosyasını düzenleyin:

from sqlalchemy import Column, Integer, Text
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import scoped_session, sessionmaker
from zope.sqlalchemy import ZopeTransactionExtension

Veritabanı oturumu ve temel sınıf tanımları
DBSession = scoped_session(sessionmaker(extension=ZopeTransactionExtension()))
Base = declarative_base()

Örnek bir User modeli
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    username = Column(Text, unique=True)
    email = Column(Text, unique=True)
    password_hash = Column(Text)

    def __init__(self, username, email, password_hash):
        self.username = username
        self.email = email
        self.password_hash = password_hash

    def __repr__(self):
        return f""

Veritabanı bağlantısını başlatan fonksiyon (genellikle __init__.py'den çağrılır)
def initialize_sql(engine):
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine
    Base.metadata.create_all(engine) # Bu sadece ilk kurulumda veya testlerde kullanılmalı

initialize_sql fonksiyonu, veritabanı bağlantısını kurmak için kullanılır. Bu fonksiyon genellikle mywebapp/__init__.py içindeki main fonksiyonunda çağrılır.

mywebapp/__init__.py dosyasını güncelleyin:

from pyramid.config import Configurator
from sqlalchemy import engine_from_config
from .models.mymodel import initialize_sql, DBSession # DBSession'ı da içe aktarın

def main(global_config, settings):
    with Configurator(settings=settings) as config:
        config.include('pyramid_chameleon')
        config.include('pyramid_tm') # İşlem yöneticisi için
        config.add_static_view('static', 'static', cache_max_age=3600)
        config.add_route('home', '/')
        config.add_route('hello', '/hello/{name}')
        config.scan('.')

        # Veritabanı bağlantısını başlat
        engine = engine_from_config(settings, 'sqlalchemy.')
        initialize_sql(engine)

        # request nesnesine DBSession'ı ekle
        config.add_request_method(lambda request: DBSession, 'dbsession', reify=True)

    return config.make_wsgi_app()

config.add_request_method ile DBSession‘ı request.dbsession olarak görünümlerinize ekliyoruz. pyramid_tm (transaction manager) eklentisi, veritabanı işlemlerini otomatik olarak yönetir (istek sonunda commit veya rollback).

Şimdi Alembic ile veritabanı şemamızı oluşturalım. Proje kök dizinindeyken:

# İlk geçiş dosyasını oluşturun
alembic revision -m "create user table"

Geçiş dosyasını düzenleyin (opsiyonel, Alembic otomatik olarak User tablosunu algılamalıdır)
alembic/versions/xxxx_create_user_table.py dosyasını açıp upgrade/downgrade metodlarını kontrol edin.
Alembic, Base.metadata'yı tarayarak tabloları otomatik olarak oluşturmaya çalışacaktır.

Veritabanı şemasını uygulayın
alembic upgrade head

Artık PostgreSQL veritabanınızda users adında bir tablo olmalı.

Veritabanı İşlemleri

Görünümlerinizde request.dbsession‘ı kullanarak veritabanı işlemleri yapabilirsiniz. Örneğin, yeni bir kullanıcı ekleyen bir görünüm oluşturalım:

mywebapp/views/default.py dosyasına ekleyin:

from pyramid.view import view_config
from pyramid.response import Response
from ..models.mymodel import User # User modelini içe aktarın

@view_config(route_name='add_user', renderer='json', request_method='POST')
def add_user_view(request):
    username = request.json_body.get('username')
    email = request.json_body.get('email')
    password_hash = "dummy_hash" # Gerçek uygulamada şifreyi hash'lemelisiniz

    if not username or not email:
        return Response(json_body={'error': 'Username and email are required'}, status=400)

    new_user = User(username=username, email=email, password_hash=password_hash)
    request.dbsession.add(new_user)
    # pyramid_tm sayesinde commit otomatik yapılır

    return {'message': f'User {username} added successfully!', 'user_id': new_user.id}

@view_config(route_name='list_users', renderer='json')
def list_users_view(request):
    users = request.dbsession.query(User).all()
    user_list = [{'id': u.id, 'username': u.username, 'email': u.email} for u in users]
    return {'users': user_list}

mywebapp/__init__.py dosyasına yeni rotaları ekleyin:

# ...
config.add_route('add_user', '/users')
config.add_route('list_users', '/users')
...

Uygulamanızı yeniden başlatın (pserve development.ini --reload). Artık curl gibi bir araçla test edebilirsiniz:

# Yeni kullanıcı ekle
curl -X POST -H "Content-Type: application/json" -d '{"username": "testuser", "email": "test@example.com"}' http://localhost:6543/users

Kullanıcıları listele
curl http://localhost:6543/users

Bu örnekler, Pyramid’de veritabanı işlemlerinin ne kadar kolay olduğunu göstermektedir.

Kimlik Doğrulama ve Yetkilendirme (İsteğe Bağlı ama Önemli)

Çoğu web uygulaması, kullanıcıları kimlik doğrulamadan geçirme (login) ve belirli kaynaklara erişimlerini yetkilendirme (izinler) ihtiyacı duyar. Pyramid, bu konuda esnek ve güçlü bir güvenlik modeli sunar.

Pyramid’in Güvenlik Modeli

Pyramid’in güvenlik modeli iki ana bileşene dayanır:
* Kimlik Doğrulama Politikası (authentication_policy): Gelen isteği inceleyerek bir kullanıcının kimliğini (genellikle bir kullanıcı kimliği veya bir dizi kimlik) belirler. Bu, HTTP Basic Auth, oturum tabanlı kimlik doğrulama veya JWT (JSON Web Token) gibi farklı yöntemlerle yapılabilir.
* Yetkilendirme Politikası (authorization_policy): Kimliği belirlenmiş bir kullanıcının belirli bir kaynağa veya işleme erişim izni olup olmadığını belirler. Pyramid, bu genellikle ACL’ler (Access Control Lists) veya grup tabanlı izinlerle yapılır.

Örnek olarak, basit bir oturum tabanlı kimlik doğrulama için pyramid_session ve pyramid_beaker veya pyramid_redis_sessions gibi eklentileri kullanabiliriz. Ancak bu, makalenin kapsamını genişleteceği için sadece temel kavramlara değinelim.

mywebapp/__init__.py içinde güvenlik politikalarını yapılandırabilirsiniz:

from pyramid.authentication import AuthTktAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
...

def main(global_config, settings):
    # ...
    with Configurator(settings=settings) as config:
        # ...
        # Güvenlik politikalarını yapılandırın
        authn_policy = AuthTktAuthenticationPolicy(
            settings['auth.secret'], # Güçlü bir gizli anahtar
            callback=None, # Kullanıcı kimliğini döndüren bir callback fonksiyonu
            hashalg='sha512'
        )
        authz_policy = ACLAuthorizationPolicy()
        config.set_authentication_policy(authn_policy)
        config.set_authorization_policy(authz_policy)
        # ...
    # ...

Daha sonra görünümlerinizde @view_config(permission='edit') gibi ifadelerle yetkilendirme gereksinimleri belirtebilir ve ACL’ler veya özel bir callback fonksiyonu ile bu izinleri yönetebilirsiniz.

Test Etme

Testler, uygulamanızın beklendiği gibi çalıştığından emin olmanın ve gelecekteki değişikliklerin mevcut işlevselliği bozmadığını doğrulamanın anahtarıdır. Pyramid, test yazmayı kolaylaştıran araçlarla birlikte gelir.

Pyramid’in Test Yaklaşımı

Pyramid projeleri genellikle pytest veya unittest ile test edilir. Starter şablonu genellikle pytest‘i kullanır ve mywebapp/tests/test_mywebapp.py içinde örnek testler bulunur.

mywebapp/tests/test_mywebapp.py dosyasına bakarsanız, şuna benzer testler göreceksiniz:

import unittest
from pyramid import testing

class ViewTests(unittest.TestCase):
    def setUp(self):
        self.config = testing.setUp()

    def tearDown(self):
        testing.tearDown()

    def test_my_view(self):
        from ..views.default import my_view
        request = testing.DummyRequest()
        info = my_view(request)
        self.assertEqual(info['project'], 'mywebapp')

class FunctionalTests(unittest.TestCase):
    def setUp(self):
        from mywebapp import main
        app = main({})
        from webtest import TestApp
        self.testapp = TestApp(app)

    def test_root(self):
        res = self.testapp.get('/', status=200)
        self.assertIn(b'Welcome to mywebapp!', res.body)

    def test_hello_view(self):
        res = self.testapp.get('/hello/TestUser', status=200)
        self.assertIn(b'Hello, TestUser!', res.body)

* Birim Testleri (Unit Tests): Tek tek fonksiyonları veya bileşenleri izole bir şekilde test eder. testing.DummyRequest() kullanarak sahte istek nesneleri oluşturulabilir.
* Fonksiyonel Testler (Functional Tests): Uygulamanın bir bütün olarak nasıl çalıştığını test eder. webtest kütüphanesi, uygulamanıza HTTP istekleri göndermenizi ve yanıtları kontrol etmenizi sağlar.

Testleri çalıştırmak için sanal ortamınız etkinleştirilmişken proje kök dizininde aşağıdaki komutu kullanın:

pytest

Bu komut, tests dizinindeki tüm testleri bulacak ve çalıştıracaktır. Veritabanı etkileşimi olan testler için, ayrı bir test veritabanı veya bellek içi SQLite veritabanı kullanmak iyi bir pratiktir.

Dağıtım (Deployment)

Uygulamanız geliştirme ortamında sorunsuz çalıştıktan sonra, onu canlı bir sunucuya dağıtma zamanı gelir. Pyramid uygulamalarını dağıtmak için standart Python WSGI (Web Server Gateway Interface) yöntemlerini kullanır.

Üretim Ortamı İçin Hazırlık

production.ini dosyası, uygulamanızın üretim ortamındaki yapılandırmasını içerir. Bu dosya, development.ini‘den farklı olarak hata ayıklama modunu kapatmalı, veritabanı bağlantılarını doğru şekilde yapılandırmalı ve güvenlik açısından hassas bilgileri (gizli anahtarlar gibi) ortam değişkenlerinden almalıdır.

Önemli ayarlar:
* pyramid.reload_templates = false
* debug_toolbar.enabled = false
* Veritabanı bağlantı dizeleri (genellikle postgresql://myuser:MY_PROD_PASSWORD@localhost:5432/myapp_db_prod gibi)

WSGI Sunucusu: Gunicorn veya uWSGI

Pyramid, bir WSGI uygulaması olduğu için, onu Gunicorn veya uWSGI gibi bir WSGI sunucusuyla çalıştırmanız gerekir. Bu sunucular, HTTP isteklerini uygulamanıza yönlendiren ve uygulamanızın eşzamanlı istekleri işlemesini sağlayan yüksek performanslı sunuculardır.

Gunicorn’u kuralım:

pip install gunicorn

Uygulamanızı Gunicorn ile çalıştırmak için:

gunicorn --paste production.ini

Bu komut, Gunicorn’u production.ini dosyasında belirtilen ayarlarla Pyramid uygulamanızı başlatmak için kullanır. Varsayılan olarak 8000 portunda dinleyecektir.

Nginx ile Ters Proxy

Üretim ortamında, genellikle Gunicorn gibi bir WSGI sunucusunun önüne Nginx gibi bir ters proxy sunucusu yerleştirilir. Nginx, statik dosyaları doğrudan sunar, SSL sonlandırmayı yönetir ve Gunicorn’a gelen istekleri yönlendirir.

Nginx’i kurun:

sudo apt install -y nginx

Nginx yapılandırma dosyası oluşturun (/etc/nginx/sites-available/mywebapp):

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

    location /static/ {
        alias /path/to/mywebapp/mywebapp/static/; # Statik dosyalarınızın yolu
    }

    location / {
        proxy_pass http://127.0.0.1:8000; # Gunicorn'un dinlediği adres ve port
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Bu dosyayı etkinleştirin ve Nginx’i yeniden başlatın:

sudo ln -s /etc/nginx/sites-available/mywebapp /etc/nginx/sites-enabled/
sudo nginx -t # Yapılandırmayı test et
sudo systemctl restart nginx

Artık your_domain.com adresine gelen istekler Nginx tarafından karşılanacak, statik dosyalar doğrudan Nginx’ten sunulacak ve diğer tüm istekler Gunicorn’a yönlendirilecektir.

Sistem Hizmeti Olarak Çalıştırma (systemd)

Uygulamanızın sunucu yeniden başlatıldığında otomatik olarak başlaması ve arka planda sürekli çalışması için systemd servisi olarak yapılandırmak iyi bir çözümdür.

/etc/systemd/system/mywebapp.service adında bir dosya oluşturun:

[Unit]
Description=Gunicorn instance to serve mywebapp
After=network.target

[Service]
User=myuser # Uygulamayı çalıştıracak kullanıcı
Group=www-data # İsteğe bağlı
WorkingDirectory=/path/to/mywebapp # Projenizin kök dizini
Environment="PATH=/path/to/mywebapp/.venv/bin" # Sanal ortamınızın bin dizini
ExecStart=/path/to/mywebapp/.venv/bin/gunicorn --workers 3 --bind unix:/tmp/mywebapp.sock --timeout 120 --paste production.ini
--bind unix:/tmp/mywebapp.sock yerine --bind 127.0.0.1:8000 de kullanabilirsiniz
Restart=always

[Install]
WantedBy=multi-user.target

Servisi etkinleştirin ve başlatın:

sudo systemctl daemon-reload
sudo systemctl start mywebapp
sudo systemctl enable mywebapp
sudo systemctl status mywebapp

Bu adımlarla, Pyramid uygulamanız üretim ortamında güvenilir bir şekilde çalışmaya başlayacaktır.

Sonuç ve İleri Adımlar

Bu kapsamlı rehberde, Ubuntu üzerinde bir Pyramid web uygulamasını sıfırdan kurmayı, temel bileşenlerini anlamayı, veritabanı entegrasyonunu yapmayı ve dağıtım için gerekli adımları atmayı öğrendiniz. Pyramid’in esnekliği, geliştiriciye tam kontrol sağlaması ve güçlü eklenti ekosistemi, onu her boyutta proje için cazip bir seçenek haline getirir.

Pyramid, karmaşık API’ler, mikro hizmetler veya özel iş mantığı gerektiren web uygulamaları oluşturmak isteyen geliştiriciler için mükemmel bir araçtır. Daha az “sihir” ve daha fazla açıklık sunarak, uygulamanızın her katmanını tam olarak anlamanıza ve kontrol etmenize olanak tanır.

İleri adımlar olarak şunları düşünebilirsiniz:
* Kimlik Doğrulama ve Yetkilendirme: pyramid_auth_toolkit, pyramid_jwt gibi eklentileri araştırarak uygulamanıza sağlam bir güvenlik katmanı ekleyin.
* Form İşleme ve Doğrulama: colander veya marshmallow gibi kütüphanelerle form verilerini daha etkili bir şekilde yönetin.
* Hata Ayıklama Araçları: Geliştirme sırasında pyramid_debugtoolbar gibi araçları kullanarak uygulamanızın performansını ve davranışını izleyin.
* Test Kapsamı: Uygulamanızın tüm kritik bölümlerini kapsayan sağlam bir test paketi oluşturun.
* Asenkron İşlemler: Uzun süren görevleri (e-posta gönderme, resim işleme) arka planda çalıştırmak için Celery gibi bir görev kuyruğu entegre edin.
* API Geliştirme: Pyramid’in RESTful API’ler oluşturmak için ne kadar uygun olduğunu keşfedin.

Pyramid topluluğu aktif ve dokümantasyonları oldukça kapsamlıdır. Resmi Pyramid web sitesi ve GitHub depoları, daha fazla bilgi edinmek ve karşılaştığınız sorunlara çözüm bulmak için harika kaynaklardır. Kendi Python web uygulamalarınızı Pyramid ile inşa etme yolculuğunuzda başarılar dileriz!