pexels_temp

Flask ile Mikroservis Geliştirme: Hızlı ve Esnek API’ler

by
with no comment
Teknoloji

Flask ile Mikroservis ve API Geliştirme: Basit ve Esnek Çözümler

Günümüzde yazılım geliştirme süreçleri, monolitik yapılardan mikroservislere doğru evrilmektedir. Mikroservis mimarisi, uygulamaların daha küçük, bağımsız ve ölçeklenebilir parçalara bölünmesini sağlayarak, geliştirme, test ve dağıtım süreçlerini kolaylaştırır. Python’ın popüler web framework’ü Flask, mikroservis ve API geliştirme için sunduğu basitlik ve esneklik sayesinde ideal bir seçenektir.

İçindekiler

  1. Mikroservisler Nedir?
  2. Flask Mikroservis Geliştirme İçin Neden Uygundur?
  3. Flask ile Basit Bir API Kurulumu
  4. Route Tanımlama ve İstek İşleme
  5. Veri Serileştirme (Serialization) ve JSON Kullanımı
  6. Veritabanı Entegrasyonu (SQLAlchemy)
  7. Hata Yönetimi ve İstisna Yakalama
  8. Test Yazma ve Sürekli Entegrasyon
  9. Docker ile Konteynırlaştırma
  10. API Dokümantasyonu Oluşturma (Swagger/OpenAPI)
  11. Güvenlik Önlemleri
  12. Ölçeklendirme Stratejileri
  13. Örnek Mikroservis Uygulaması
  14. Sonuç

Mikroservisler Nedir?

Mikroservis mimarisi, bir uygulamayı bağımsız olarak dağıtılabilen, küçük, özerk hizmetlere bölen bir yaklaşımdır. Her mikroservis, belirli bir işlevselliği yerine getirir ve kendi veritabanına sahip olabilir. Bu, farklı takımların farklı teknolojiler kullanarak mikroservisler geliştirmesine ve bağımsız olarak dağıtmasına olanak tanır.

Mikroservislerin temel avantajları şunlardır:

  • Bağımsız Dağıtım: Her servis bağımsız olarak dağıtılabilir ve güncellenebilir.
  • Teknoloji Çeşitliliği: Farklı servisler farklı teknolojilerle geliştirilebilir.
  • Ölçeklenebilirlik: Servisler, ihtiyaç duyulan ölçekte bağımsız olarak ölçeklendirilebilir.
  • Hata İzolasyonu: Bir servisteki hata, diğer servisleri etkilemez.
  • Geliştirme Hızı: Küçük takımlar, daha hızlı ve çevik bir şekilde geliştirme yapabilir.

Flask Mikroservis Geliştirme İçin Neden Uygundur?

Flask, Python tabanlı, hafif (lightweight) bir web framework’tür. Temel özellikleri şunlardır:

  • Basitlik: Öğrenmesi ve kullanması kolaydır.
  • Esneklik: İhtiyaçlarınıza göre özelleştirilebilir.
  • Minimalizm: Temel işlevsellikleri sunar ve ihtiyaç duyulan eklentilerle genişletilebilir.
  • Geniş Eklenti Desteği: Veritabanı entegrasyonu, API dokümantasyonu, güvenlik gibi birçok alanda eklentiler sunar.

Flask, mikroservis geliştirme için özellikle uygundur çünkü küçük, bağımsız servisler oluşturmak için gereken minimal altyapıyı sağlar. Ayrıca, RESTful API’ler oluşturmak için de idealdir.

Flask ile Basit Bir API Kurulumu

Flask ile basit bir API oluşturmak için öncelikle Flask’ı yüklememiz gerekir. Terminalde aşağıdaki komutu çalıştırarak Flask’ı yükleyebilirsiniz:

pip install Flask

Daha sonra, aşağıdaki Python kodunu kullanarak basit bir API oluşturabilirsiniz:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/v1/merhaba')
def merhaba():
    return jsonify({'mesaj': 'Merhaba, Dünya!'})

if __name__ == '__main__':
    app.run(debug=True)

Bu kod, ‘/api/v1/merhaba’ endpoint’ine gelen isteklere ‘Merhaba, Dünya!’ mesajını içeren bir JSON yanıtı döndüren bir API oluşturur. `debug=True` parametresi, geliştirme sırasında hataları daha kolay takip etmenizi sağlar. Üretim ortamında bu parametreyi `False` olarak ayarlamanız önemlidir.

Route Tanımlama ve İstek İşleme

Flask’ta route’lar, `@app.route()` dekoratörü ile tanımlanır. Bu dekoratör, bir fonksiyonu belirli bir URL ile ilişkilendirir. Örneğin:

@app.route('/api/v1/kullanicilar/')
def kullanici_getir(kullanici_id):
    # Kullanıcı ID'sine göre kullanıcıyı getir
    return jsonify({'kullanici_id': kullanici_id, 'ad': 'Ahmet', 'soyad': 'Yılmaz'})

Bu örnekte, `` ifadesi, URL’den bir tamsayı (integer) değerini alır ve `kullanici_id` değişkenine atar. Flask, HTTP metodlarını da destekler (GET, POST, PUT, DELETE vb.):

from flask import request

@app.route('/api/v1/kullanicilar', methods=['POST'])
def kullanici_olustur():
    data = request.get_json()
    # Gelen JSON verisi ile yeni kullanıcı oluştur
    return jsonify({'mesaj': 'Kullanıcı oluşturuldu', 'data': data}), 201

Bu örnekte, `/api/v1/kullanicilar` endpoint’ine sadece POST istekleri kabul edilir. `request.get_json()` fonksiyonu, gelen isteğin JSON verisini ayrıştırır.

Veri Serileştirme (Serialization) ve JSON Kullanımı

Mikroservisler genellikle JSON formatında veri alışverişinde bulunur. Flask’ta `jsonify()` fonksiyonu, Python nesnelerini JSON’a dönüştürmek için kullanılır. Karmaşık veri yapılarını serileştirmek için marshmallow gibi kütüphaneler kullanılabilir.

from marshmallow import Schema, fields

class KullaniciSchema(Schema):
    id = fields.Int(dump_only=True)
    ad = fields.Str()
    soyad = fields.Str()
    eposta = fields.Email()

@app.route('/api/v1/kullanicilar')
def kullanicilari_getir():
    kullanicilar = [
        {'id': 1, 'ad': 'Ayşe', 'soyad': 'Demir', 'eposta': '[email protected]'},
        {'id': 2, 'ad': 'Mehmet', 'soyad': 'Kaya', 'eposta': '[email protected]'}
    ]
    schema = KullaniciSchema(many=True)
    sonuc = schema.dump(kullanicilar)
    return jsonify(sonuc)

Bu örnekte, `KullaniciSchema` sınıfı, kullanıcı verilerini serileştirmek için kullanılır. `many=True` parametresi, birden fazla kullanıcıyı serileştireceğimizi belirtir.

Veritabanı Entegrasyonu (SQLAlchemy)

Flask, SQLAlchemy gibi ORM (Object-Relational Mapping) kütüphaneleri ile kolayca entegre edilebilir. SQLAlchemy, veritabanı işlemlerini Python nesneleri üzerinden yapmanızı sağlar.

from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///veritabani.db'
db = SQLAlchemy(app)

class Kullanici(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    ad = db.Column(db.String(80), nullable=False)
    soyad = db.Column(db.String(80), nullable=False)
    eposta = db.Column(db.String(120), unique=True, nullable=False)

    def __repr__(self):
        return f''

with app.app_context():
    db.create_all()

Bu kod, `Kullanici` adında bir veritabanı modeli tanımlar ve SQLite veritabanına bağlanır. `db.create_all()` fonksiyonu, veritabanında tabloları oluşturur.

Hata Yönetimi ve İstisna Yakalama

Mikroservislerde hata yönetimi kritik öneme sahiptir. Flask, hataları yakalamak ve uygun yanıtlar döndürmek için `errorhandler` dekoratörünü sunar.

from werkzeug.exceptions import NotFound

@app.errorhandler(NotFound)
def sayfa_bulunamadi(e):
    return jsonify({'hata': 'Sayfa bulunamadı'}), 404

@app.errorhandler(Exception)
def genel_hata_yonetimi(e):
    return jsonify({'hata': 'Bir hata oluştu'}), 500

Bu örnekte, 404 (Sayfa Bulunamadı) ve 500 (Sunucu Hatası) gibi hataları yakalayan hata yöneticileri tanımlanmıştır.

Test Yazma ve Sürekli Entegrasyon

Mikroservislerin güvenilirliğini sağlamak için test yazmak önemlidir. Flask, unittest ve pytest gibi test framework’leri ile kolayca entegre edilebilir.

import unittest
import json
from app import app  # Flask uygulamanızın bulunduğu dosya

class TestMerhabaAPI(unittest.TestCase):

    def setUp(self):
        self.app = app.test_client()
        self.app.testing = True

    def test_merhaba_endpoint(self):
        result = self.app.get('/api/v1/merhaba')
        self.assertEqual(result.status_code, 200)
        data = json.loads(result.data.decode('utf-8'))
        self.assertEqual(data['mesaj'], 'Merhaba, Dünya!')

if __name__ == '__main__':
    unittest.main()

Bu örnekte, ‘/api/v1/merhaba’ endpoint’ini test eden bir unittest örneği gösterilmektedir. Sürekli Entegrasyon (CI) araçları (Jenkins, GitLab CI vb.) kullanarak testleri otomatik olarak çalıştırabilirsiniz.

Docker ile Konteynırlaştırma

Docker, mikroservisleri paketlemek ve dağıtmak için ideal bir araçtır. Flask uygulamanızı Docker ile konteynırlaştırmak, bağımlılıkları yönetmenizi ve uygulamanızı farklı ortamlarda tutarlı bir şekilde çalıştırmanızı sağlar.

Öncelikle bir `Dockerfile` oluşturmanız gerekir:

FROM python:3.9-slim-buster

WORKDIR /app

COPY requirements.txt requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python", "app.py"]

Ardından, Docker görüntüsünü oluşturabilirsiniz:

docker build -t flask-mikroservis .

Ve Docker konteynerini çalıştırabilirsiniz:

docker run -p 5000:5000 flask-mikroservis

API Dokümantasyonu Oluşturma (Swagger/OpenAPI)

API dokümantasyonu, API’nizi kullanan geliştiriciler için önemlidir. Swagger/OpenAPI, API’nizi tanımlamak ve dokümante etmek için popüler bir standarttır. Flask’ta Flask-RESTplus veya Flask-Swagger gibi eklentiler kullanarak Swagger/OpenAPI dokümantasyonu oluşturabilirsiniz.

from flask import Flask
from flask_restplus import Api, Resource

app = Flask(__name__)
api = Api(app, version='1.0', title='Örnek API', description='Basit bir API dokümantasyonu')

ns = api.namespace('kullanicilar', description='Kullanıcı işlemleri')

@ns.route('/')
class Kullanici(Resource):
    '''Kullanıcı işlemleri'''
    @api.doc(responses={200: 'Başarılı', 404: 'Kullanıcı bulunamadı'})
    def get(self, kullanici_id):
        '''Kullanıcı getir'''
        return {'kullanici_id': kullanici_id, 'ad': 'Ali', 'soyad': 'Veli'}

if __name__ == '__main__':
    app.run(debug=True)

Bu örnek, Flask-RESTplus kullanarak basit bir API dokümantasyonu oluşturur. `/swagger` endpoint’ine giderek dokümantasyona erişebilirsiniz.

Güvenlik Önlemleri

Mikroservislerin güvenliğini sağlamak için aşağıdaki önlemler alınmalıdır:

  • Kimlik Doğrulama ve Yetkilendirme: API’lerinizi yetkisiz erişime karşı koruyun (OAuth 2.0, JWT vb.).
  • Veri Doğrulama: Gelen verileri doğrulayın ve güvenli olmayan verileri filtreleyin.
  • HTTPS Kullanımı: Veri iletimini şifreleyin.
  • Hız Sınırlaması (Rate Limiting): API’lerinizi kötü niyetli kullanıma karşı koruyun.
  • Güvenlik Açıklarını Düzenli Olarak Kontrol Edin: Uygulamanızı ve bağımlılıklarınızı güvenlik açıklarına karşı tarayın.

Ölçeklendirme Stratejileri

Mikroservislerin ölçeklenebilirliği, mimarinin temel avantajlarından biridir. Ölçeklendirme için aşağıdaki stratejiler kullanılabilir:

  • Yatay Ölçeklendirme: Servislerin birden fazla örneğini çalıştırmak.
  • Otomatik Ölçeklendirme: CPU kullanımı, bellek kullanımı gibi metrikleri izleyerek servisleri otomatik olarak ölçeklendirmek.
  • Yük Dengeleme (Load Balancing): Gelen istekleri servis örnekleri arasında dağıtmak.
  • Konteyner Orkestrasyonu (Kubernetes): Konteynerleri yönetmek ve ölçeklendirmek için Kubernetes gibi araçlar kullanmak.

Örnek Mikroservis Uygulaması

Örnek bir mikroservis uygulaması olarak, bir e-ticaret platformunun ürün kataloğu servisini düşünebiliriz. Bu servis, ürün bilgilerini yönetir ve API aracılığıyla diğer servislere sunar.

Temel Fonksiyonlar:

  • Ürünleri listeleme
  • Ürün detaylarını getirme
  • Yeni ürün oluşturma
  • Ürün güncelleme
  • Ürün silme

Bu servis, Flask ve SQLAlchemy kullanarak geliştirilebilir ve Docker ile konteynırlaştırılabilir. Diğer servisler (örneğin, sipariş servisi, ödeme servisi) bu servise API aracılığıyla erişerek ürün bilgilerini alabilir.

Sonuç

Flask, mikroservis ve API geliştirme için güçlü ve esnek bir araçtır. Basitliği, esnekliği ve geniş eklenti desteği sayesinde, küçük, bağımsız servisler oluşturmak için idealdir. Bu makalede, Flask ile mikroservis geliştirmenin temel prensiplerini ve en iyi uygulamalarını ele aldık. Mikroservis mimarisi, uygulamalarınızın ölçeklenebilirliğini, esnekliğini ve geliştirme hızını artırmanıza yardımcı olabilir. Flask ile mikroservis geliştirmeye başlayarak, modern yazılım geliştirme süreçlerine ayak uydurabilirsiniz.

Leave A Comment

Your email address will not be published. Required fields are marked *