CSV dosyalarından bir dashboarda kadar uzanan kapsamlı bir veri hattını Python, MySQL ve Airflow kullanarak nasıl kuracağınızı adım adım öğrenin. Otomasyon ve veri mühendisliği sırları burada! Günümüz iş dünyasında, veriler her zamankinden daha değerli hale geldi. Ancak bu verileri anlamlı içgörülere dönüştürmek, genellikle karmaşık ve zaman alıcı bir süreçtir. Şirketler, satış raporlarından müşteri etkileşimlerine kadar farklı formatlarda ve çeşitli kaynaklardan gelen devasa veri yığınlarıyla mücadele ederken, manuel veri işleme yöntemleri artık yetersiz kalmaktadır. Peki, dağınık haldeki CSV dosyalarından başlayarak, bu verileri temizleyip işleyerek güvenilir bir veritabanına aktarmak ve sonrasında otomatik bir şekilde görselleştirilebilir hale getirmek mümkün mü? Elbette!
İşte bu teknik makalede, bu sorunun cevabını adım adım keşfedeceğiz. Python’ın esnekliği, MySQL’in güvenilirliği ve Apache Airflow’un otomasyon gücünü bir araya getirerek, sıfırdan uçtan uca eksiksiz bir veri hattı inşa etmeyi öğreneceksiniz. Bu yolculukta, veri alımından dönüşüme, depolamadan iş akışı otomasyonuna kadar her aşamayı pratik örneklerle ele alacak ve kendi veri projeleriniz için sağlam bir temel oluşturmanıza yardımcı olacağız. Haydi başlayalım!
Veri Hattı Nedir ve Neden Hayati Önem Taşır?
Veri hattı, ham veriyi kaynağından alıp, belirli dönüşümlerden geçirerek analiz veya raporlama için uygun bir hedefe (genellikle bir veri ambarı veya veri gölü) taşıyan bir dizi otomatikleştirilmiş adımdan oluşan bir süreçtir. Daha teknik bir ifadeyle, bir veri hattı genellikle “ETL” (Extract, Transform, Load – Çıkart, Dönüştür, Yükle) veya “ELT” (Extract, Load, Transform – Çıkart, Yükle, Dönüştür) prensiplerini takip eder. Amacı, farklı sistemlerde dağınık halde bulunan veriyi standartlaştırılmış, temizlenmiş ve erişilebilir bir formatta bir araya getirmektir. Bu sayede, işletmelerin veri odaklı kararlar alması, iş süreçlerini optimize etmesi ve rekabet avantajı elde etmesi mümkün olur.
Peki, bu kadar karmaşık görünen bir yapı neden bu kadar hayati önem taşır? Bir e-ticaret şirketinin günlük satış, müşteri ve envanter verilerini düşündüğümüz zaman, bu veriler genellikle farklı sistemlerde, farklı formatlarda (CSV, Excel, JSON vb.) ve düzensiz bir yapıda bulunur. Eğer bu veriler manuel olarak toplanır, temizlenir ve analiz edilmeye çalışılırsa, bu süreç hem inanılmaz derecede zaman alıcı hem de insan hatasına açık olacaktır. Veri tutarlılığı sağlanamaz, raporlar gecikir ve yöneticiler zamanında doğru kararlar alamaz. İşte tam da bu noktada, iyi tasarlanmış bir veri hattı devreye girer. Veri hattı, bu süreci tamamen otomatize ederek, verilerin doğru zamanda, doğru formatta ve doğru hedefe ulaşmasını sağlar. Bu otomasyon, yalnızca zaman ve maliyet tasarrufu sağlamakla kalmaz, aynı zamanda veri kalitesini artırır ve işletmelerin çevik bir şekilde hareket etmesine olanak tanır.
Bu makalede inşa edeceğimiz veri hattında Python, veri alımı ve dönüşümü aşamalarında sunduğu zengin kütüphaneler (özellikle Pandas) sayesinde bizim ana silahımız olacak. MySQL, temizlenmiş ve yapılandırılmış verilerin güvenli, erişilebilir ve performansı yüksek bir şekilde depolanacağı bir veri ambarı görevi görecektir. Son olarak, Apache Airflow, tüm bu adımların belirlenen zamanlarda, belirli bir sırayla ve hatasız bir şekilde otomatik olarak çalışmasını sağlayacak olan orkestrasyon motorumuz olacak. Airflow sayesinde, bir görevin başarısız olması durumunda otomatik yeniden deneme, bildirimler ve iş akışının genel izlenebilirliği gibi kritik yeteneklere sahip olacağız. Bu üçlünün sinerjisi, güçlü ve esnek bir veri altyapısı kurmamızı mümkün kılacaktır.
Python ile CSV Verilerini Okuma, Dönüştürme ve Hazırlama
Veri hattımızın ilk adımı, ham veriyi kaynaktan almaktır. Genellikle iş süreçlerinde karşılaştığımız en yaygın veri kaynaklarından biri CSV (Comma Separated Values) dosyalarıdır. Bu bölümde, Python’ın güçlü veri işleme kütüphanesi Pandas’ı kullanarak bir CSV dosyasını nasıl okuyacağımızı, temel temizlik ve dönüşüm işlemlerini nasıl yapacağımızı adım adım inceleyeceğiz. Bu işlemler, verilerimizi analiz ve depolama için uygun hale getirecektir. Bir senaryo düşünelim: Bir şirket, günlük sipariş verilerini içeren ‘siparisler.csv’ adında bir dosya oluşturuyor. Bu dosyada siparis_id, musteri_adi, urun_adi, adet, birim_fiyat ve siparis_tarihi gibi bilgiler yer alıyor. Ancak bazı sütunlarda boş değerler olabilir veya veri tipleri yanlış olabilir.
Bir CSV Dosyası Nasıl Okunur?
Öncelikle, örnek bir CSV dosyası oluşturalım. Kendi sisteminizde bir siparisler.csv dosyası oluşturup aşağıdaki içeriği ekleyebilirsiniz:
siparis_id,musteri_adi,urun_adi,adet,birim_fiyat,siparis_tarihi
1001,Ayşe Yılmaz,Laptop,2,1500.00,2023-01-05
1002,Mehmet Demir,Klavye,1,150.50,2023-01-05
1003,Zeynep Kaya,Fare,3,50.25,2023-01-06
1004,Ali Can,Monitör,1,300.00,2023-01-06
1005,Fatma Güneş,Webcam,1,75.00,2023-01-07
1006,Can Yılmaz,Kulaklık,NaN,120.00,2023-01-07
1007,Pınar Deniz,Router,,200.00,2023-01-08
1008,Cem Ak,Yazıcı,1,NaN,2023-01-08
Şimdi Python ile bu dosyayı okuyalım:
import pandas as pd
# CSV dosyasını oku
try:
df = pd.read_csv('siparisler.csv')
print("CSV dosyası başarıyla okundu. İlk 5 satır:")
print(df.head())
print("\nVeri tipleri ve boş değerler:")
print(df.info())
except FileNotFoundError:
print("Hata: 'siparisler.csv' dosyası bulunamadı. Lütfen doğru yolda olduğunuzdan emin olun.")
df.head() komutu DataFrame'in ilk birkaç satırını gösterirken, df.info() DataFrame'in genel yapısı, sütunları, veri tipleri ve her sütundaki boş olmayan değer sayıları hakkında bilgi verir. Bu, veri temizliğine başlamadan önce genel bir resim elde etmek için kritik bir adımdır.
Veri Temizleme ve Dönüştürme Nasıl Yapılır?
Ham veriler genellikle hatalı, eksik veya yanlış formatta olabilir. Bu yüzden, depolama ve analiz öncesi temizlik ve dönüşüm işlemleri yapmak elzemdir. Örnek CSV dosyamızda eksik değerler (NaN) ve belki de yanlış veri tipleri (örneğin, siparis_tarihi bir obje olarak okunabilir) bulunmaktadır. Şimdi bu sorunları ele alalım:
# 1. Eksik değerleri temizle veya doldur
# 'adet' ve 'birim_fiyat' sütunlarındaki boş değerleri 0 ile dolduralım.
# Veya daha sağlam bir yaklaşım olarak, bu tür satırları tamamen silebiliriz.
# Bu örnekte, 'adet' ve 'birim_fiyat' sıfır olamayacağından, o satırları düşürmeyi tercih edelim.
df.dropna(subset=['adet', 'birim_fiyat'], inplace=True)
# 'urun_adi' sütunundaki boş değerleri 'Bilinmiyor' olarak dolduralım.
df['urun_adi'].fillna('Bilinmiyor', inplace=True)
print("\nBoş değerler temizlendikten sonra DataFrame:")
print(df.info())
# 2. Veri tiplerini dönüştür
# 'adet' ve 'birim_fiyat' sütunlarının doğru sayısal tiplere sahip olduğundan emin olalım.
# 'siparis_tarihi' sütununu datetime objesine dönüştür.
df['adet'] = df['adet'].astype(int)
df['birim_fiyat'] = df['birim_fiyat'].astype(float)
df['siparis_tarihi'] = pd.to_datetime(df['siparis_tarihi'])
# 3. Yeni sütunlar oluştur
# Her siparişin toplam tutarını hesaplayan yeni bir sütun ekleyelim.
df['toplam_tutar'] = df['adet'] * df['birim_fiyat']
print("\nDönüşümlerden sonra DataFrame'in ilk 5 satırı:")
print(df.head())
print("\nDönüşümlerden sonra veri tipleri:")
print(df.info())
Bu adımlar sayesinde, ham CSV verisini temiz, tutarlı ve analiz edilebilir bir yapıya dönüştürdük. dropna() ile kritik eksik verileri içeren satırları sildik, fillna() ile daha az kritik eksik verileri doldurduk ve astype() ile pd.to_datetime() kullanarak veri tiplerini doğru formata getirdik. Son olarak, mevcut sütunlardan yeni ve anlamlı bir sütun (toplam_tutar) türettik. Bu işlemler, verilerin MySQL veritabanına sorunsuz bir şekilde yüklenebilmesi için zemin hazırlar.
pd.read_csv() fonksiyonundaki dtype parametresini kullanarak sütunların veri tiplerini önceden belirleyebilirsiniz. Ayrıca, chunksize parametresi ile dosyayı parça parça okuyarak bellekte aşırı yüklenmeyi önleyebilirsiniz. Bu teknik, özellikle GB'larca büyüklükteki dosyalar için hayati önem taşır ve performansı %40'a kadar artırabilir.
Bu bölüm, veri hattımızın "Extract" ve "Transform" aşamalarını kapsıyor. Bir sonraki bölümde, bu temizlenmiş ve dönüştürülmüş verileri MySQL veritabanına nasıl yükleyeceğimizi ele alacağız.
MySQL Veritabanı Altyapısının Kurulumu ve Şema Tasarımı
Verilerimizi Python ile başarıyla temizleyip dönüştürdükten sonra, onları kalıcı ve yapılandırılmış bir şekilde saklayabileceğimiz güvenilir bir yere ihtiyacımız var: Bir veritabanı. İlişkisel veritabanları arasında en popüler ve yaygın kullanılanlardan biri olan MySQL, bu ihtiyacı karşılamak için mükemmel bir seçimdir. Hem açık kaynak olması hem de geniş bir topluluk desteğine sahip olması, projelerimizde onu tercih etmemizin başlıca nedenlerindendir.
Neden MySQL ve Nasıl Kurulur?
MySQL, özellikle yapılandırılmış veriler için tasarlanmıştır ve ACID özelliklerini (Atomicity, Consistency, Isolation, Durability) destekleyerek veri bütünlüğünü garanti eder. Kolay yönetilebilir olması, yüksek performans sunması ve ölçeklenebilirliği, onu veri ambarı veya operasyonel veritabanı olarak kullanmak için ideal kılar. Kurulum açısından, MySQL'i sisteminize doğrudan kurabilir veya daha modern ve izole bir yaklaşım olan Docker konteynerlerini kullanabilirsiniz. Eğer Docker tercih ediyorsanız, aşağıdaki komutla basit bir MySQL sunucusu ayağa kaldırabilirsiniz:
docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -p 3306:3306 -d mysql:latest
Bu komut, my-secret-pw şifresiyle bir MySQL sunucusu başlatır ve port 3306 üzerinden erişilebilir hale getirir.
Veri Modeli ve Şema Tasarımı Nasıl Yapılır?
Veritabanı tasarımında en kritik adımlardan biri, verilerimizin nasıl depolanacağını belirleyen şema tasarımıdır. Doğru bir şema, veri bütünlüğünü sağlar, sorgu performansını artırır ve gelecekteki değişikliklere uyum sağlamayı kolaylaştırır. Python ile işlediğimiz sipariş verileri için aşağıdaki gibi bir tablo yapısı tasarlayabiliriz:
| Sütun Adı | Veri Tipi | Açıklama |
|---|---|---|
id |
INT PRIMARY KEY AUTO_INCREMENT |
Benzersiz sipariş kaydı kimliği |
siparis_id |
VARCHAR(50) |
Orijinal sipariş kimliği |
musteri_adi |
VARCHAR(100) |
Müşterinin adı |
urun_adi |
VARCHAR(150) |
Sipariş edilen ürünün adı |
adet |
INT |
Sipariş edilen ürün adedi |
birim_fiyat |
DECIMAL(10, 2) |
Ürünün birim fiyatı |
siparis_tarihi |
DATETIME |
Siparişin verildiği tarih ve saat |
toplam_tutar |
DECIMAL(10, 2) |
Siparişin toplam tutarı |
yukleme_zamani |
DATETIME DEFAULT CURRENT_TIMESTAMP |
Kaydın veritabanına yüklendiği zaman |
Bu tablo yapısı için MySQL üzerinde aşağıdaki SQL komutlarını çalıştırarak veritabanı ve tabloyu oluşturabiliriz. Bu işlem genellikle bir veritabanı yönetim aracı (örneğin MySQL Workbench, DBeaver) veya komut satırı aracılığıyla yapılır:
-- Veritabanını oluştur
CREATE DATABASE IF NOT EXISTS data_pipeline;
-- Veritabanını kullan
USE data_pipeline;
-- Tabloyu oluştur
CREATE TABLE IF NOT EXISTS siparisler (
id INT AUTO_INCREMENT PRIMARY KEY,
siparis_id VARCHAR(50) NOT NULL UNIQUE,
musteri_adi VARCHAR(100) NOT NULL,
urun_adi VARCHAR(150) NOT NULL,
adet INT NOT NULL,
birim_fiyat DECIMAL(10, 2) NOT NULL,
siparis_tarihi DATETIME NOT NULL,
toplam_tutar DECIMAL(10, 2) NOT NULL,
yukleme_zamani DATETIME DEFAULT CURRENT_TIMESTAMP
);
IF NOT EXISTS komutu, veritabanının veya tablonun zaten var olup olmadığını kontrol ederek tekrar çalıştırmalarda hata vermesini engeller. UNIQUE kısıtlaması, siparis_id'nin her zaman benzersiz olmasını sağlar, bu da veri tekrarını önler. NOT NULL kısıtlaması ise ilgili sütunlarda boş değerlere izin vermez. DEFAULT CURRENT_TIMESTAMP, yukleme_zamani sütununun varsayılan olarak kaydın eklendiği zamanı almasını sağlar, bu da veri yükleme takibi için oldukça faydalıdır.
Python ile MySQL Bağlantısı
Veritabanı altyapımız hazır olduğuna göre, Python uygulamamızdan bu veritabanına nasıl bağlanacağımızı öğrenmeliyiz. Bunun için mysql-connector-python kütüphanesini kullanacağız. Eğer yüklü değilse, pip install mysql-connector-python komutu ile kurabilirsiniz:
import mysql.connector
# Veritabanı bağlantı bilgileri
db_config = {
'host': 'localhost',
'user': 'root',
'password': 'my-secret-pw', # Docker komutunda belirlediğiniz şifre
'database': 'data_pipeline'
}
try:
# Veritabanına bağlan
conn = mysql.connector.connect(**db_config)
if conn.is_connected():
print("MySQL veritabanına başarıyla bağlanıldı!")
cursor = conn.cursor()
cursor.execute("SELECT DATABASE();")
db_name = cursor.fetchone()[0]
print(f"Aktif veritabanı: {db_name}")
except mysql.connector.Error as err:
print(f"Veritabanı bağlantı hatası: {err}")
finally:
# Bağlantıyı kapat
if 'conn' in locals() and conn.is_connected():
cursor.close()
conn.close()
print("MySQL bağlantısı kapatıldı.")
Bu kod bloğu, Python'dan MySQL veritabanına nasıl bağlantı kuracağınızı ve temel bir sorgu çalıştırarak bağlantıyı test edeceğinizi gösterir. Bağlantı nesnesi (conn) ve imleç nesnesi (cursor), veritabanı ile etkileşim kurmak için kullanılacak ana araçlardır. Bir sonraki adımda, bu bağlantıyı kullanarak temizlediğimiz verileri veritabanına nasıl yükleyeceğimizi detaylandıracağız.
Python'dan MySQL'e Veri Yükleme Stratejileri
Veri hattımızın "Load" (Yükle) aşamasına geldik. Python ile hazırladığımız temiz ve dönüştürülmüş verileri, MySQL veritabanımızdaki siparisler tablosuna etkili bir şekilde aktarmamız gerekiyor. Bu bölümde, Python'ın mysql.connector kütüphanesini kullanarak verileri nasıl yükleyeceğimizi ve özellikle büyük veri setleri için performans optimizasyonu stratejilerini ele alacağız.
Veri Yükleme Mantığı: Toplu İşlem (Batch Insert)
Tek tek INSERT sorguları çalıştırmak küçük veri setleri için uygun olabilirken, binlerce veya milyonlarca satır içeren büyük veri setleri için performansı oldukça düşüktür. Her bir INSERT sorgusu, veritabanı sunucusu ile ayrı bir iletişim ve işlem gerektirir. Bu yükü azaltmak için, verileri toplu halde göndermek (batch insert) çok daha verimli bir yaklaşımdır. mysql.connector kütüphanesi, bu toplu işlemleri executemany() metodu ile destekler.
import pandas as pd
import mysql.connector
from datetime import datetime
# Örnek DataFrame (önceki bölümlerde temizlediğimiz ve dönüştürdüğümüz df'i temsil eder)
# Gerçek senaryoda bu df, 'Python ile CSV Verilerini Okuma, Dönüştürme ve Hazırlama' bölümünden gelmeli.
data = {
'siparis_id': ['1001', '1002', '1003', '1004', '1005'],
'musteri_adi': ['Ayşe Yılmaz', 'Mehmet Demir', 'Zeynep Kaya', 'Ali Can', 'Fatma Güneş'],
'urun_adi': ['Laptop', 'Klavye', 'Fare', 'Monitör', 'Webcam'],
'adet': [2, 1, 3, 1, 1],
'birim_fiyat': [1500.00, 150.50, 50.25, 300.00, 75.00],
'siparis_tarihi': ['2023-01-05', '2023-01-05', '2023-01-06', '2023-01-06', '2023-01-07']
}
df = pd.DataFrame(data)
# Dönüşüm adımları (önceki bölümdeki gibi)
df.dropna(subset=['adet', 'birim_fiyat'], inplace=True)
df['urun_adi'].fillna('Bilinmiyor', inplace=True)
df['adet'] = df['adet'].astype(int)
df['birim_fiyat'] = df['birim_fiyat'].astype(float)
df['siparis_tarihi'] = pd.to_datetime(df['siparis_tarihi'])
df['toplam_tutar'] = df['adet'] * df['birim_fiyat']
# Veritabanı bağlantı bilgileri
db_config = {
'host': 'localhost',
'user': 'root',
'password': 'my-secret-pw',
'database': 'data_pipeline'
}
def load_data_to_mysql(dataframe, config):
conn = None
cursor = None
try:
conn = mysql.connector.connect(**config)
cursor = conn.cursor()
# INSERT sorgusu
insert_query = """
INSERT INTO siparisler (siparis_id, musteri_adi, urun_adi, adet, birim_fiyat, siparis_tarihi, toplam_tutar)
VALUES (%s, %s, %s, %s, %s, %s, %s)
ON DUPLICATE KEY UPDATE
musteri_adi = VALUES(musteri_adi),
urun_adi = VALUES(urun_adi),
adet = VALUES(adet),
birim_fiyat = VALUES(birim_fiyat),
siparis_tarihi = VALUES(siparis_tarihi),
toplam_tutar = VALUES(toplam_tutar),
yukleme_zamani = CURRENT_TIMESTAMP;
"""
# DataFrame'i tuple listesine dönüştürme
# Sütun sırasının INSERT sorgusu ile aynı olmasına dikkat edin!
data_to_insert = [
(row['siparis_id'], row['musteri_adi'], row['urun_adi'], row['adet'],
row['birim_fiyat'], row['siparis_tarihi'].strftime('%Y-%m-%d %H:%M:%S'),
row['toplam_tutar'])
for index, row in dataframe.iterrows()
]
# Toplu ekleme işlemi
cursor.executemany(insert_query, data_to_insert)
conn.commit() # Değişiklikleri kaydet
print(f"{len(data_to_insert)} satır başarıyla eklendi/güncellendi.")
except mysql.connector.Error as err:
print(f"Veritabanı hatası: {err}")
if conn:
conn.rollback() # Hata durumunda değişiklikleri geri al
print("İşlem geri alındı.")
finally:
if cursor:
cursor.close()
if conn and conn.is_connected():
conn.close()
print("MySQL bağlantısı kapatıldı.")
# Verileri MySQL'e yükle
load_data_to_mysql(df, db_config)
# Yüklenen verileri doğrulamak için (isteğe bağlı)
try:
conn = mysql.connector.connect(**db_config)
cursor = conn.cursor()
cursor.execute("SELECT COUNT(*) FROM siparisler;")
count = cursor.fetchone()[0]
print(f"\nVeritabanındaki toplam sipariş sayısı: {count}")
except mysql.connector.Error as err:
print(f"Doğrulama hatası: {err}")
finally:
if 'conn' in locals() and conn.is_connected():
cursor.close()
conn.close()
Performans Optimizasyonu ve Hata Yönetimi
Yukarıdaki kodda ON DUPLICATE KEY UPDATE ifadesini kullandık. Bu, siparis_id sütunu UNIQUE olduğu için, aynı siparis_id'ye sahip bir kayıt gelirse yeni bir satır eklemek yerine mevcut satırı güncellemesini sağlar. Bu, idempotency (aynı işlemin birden fazla kez çalıştırılsa bile aynı sonucu vermesi) için önemlidir ve veri hattınızın hataya dayanıklılığını artırır.
- Toplu Boyutlandırma (Batch Sizing):
executemany()ile gönderilecek veri bloğunun boyutu önemlidir. Çok büyük bloklar bellek sorunlarına yol açabilirken, çok küçük bloklar performansı düşürebilir. Genellikle 1000-10000 satırlık bloklar iyi bir başlangıç noktasıdır. Pandas DataFrame'i parçalara bölerek bu kontrolü sağlayabilirsiniz. - İşlem Yönetimi (Transaction Management): Kodda gördüğünüz gibi,
conn.commit()ile değişiklikleri onaylıyor veconn.rollback()ile bir hata durumunda değişiklikleri geri alıyoruz. Bu, veri bütünlüğünü korumak için hayati önem taşır. Eğer toplu yüklemenin ortasında bir hata olursa, tüm işlem geri alınarak veritabanında tutarsız bir durum oluşması engellenir. - İndeksleme: Veritabanı tarafında, sıkça arama yapılacak veya birleştirme yapılacak sütunlara (örneğin
siparis_id) uygun indeksler eklemek,INSERTişlemlerini yavaşlatabilse de, genel sorgu performansını büyük ölçüde artırır.ON DUPLICATE KEY UPDATEdurumunda, benzersiz indeksin varlığı zaten zorunludur. - Veri Tipi Eşleşmesi: Python'dan gönderilen verilerin tiplerinin MySQL tablosundaki sütun tipleriyle eşleştiğinden emin olun. Tarih ve saat gibi özel tipler için
strftime('%Y-%m-%d %H:%M:%S')kullanarak doğru formatta göndermek önemlidir.
LOAD DATA INFILE gibi MySQL'in yerel toplu yükleme araçları genellikle Python tabanlı executemany'den bile daha hızlıdır. Eğer performans kritikse ve dosya erişimi mümkünse, bu yöntemi değerlendirebilirsiniz. Ancak esneklik ve veri dönüşümü ihtiyacı varsa, Python ve executemany daha uygun bir seçenek olabilir.
Bu bölüm, veri hattımızın en önemli adımlarından biri olan "Load" aşamasını tamamlıyor. Verilerimiz artık güvenilir bir şekilde MySQL veritabanımızda bulunuyor. Bir sonraki adımda, tüm bu işlemleri otomatikleştirerek düzenli aralıklarla çalışmasını sağlayacak olan Apache Airflow'u devreye sokacağız.
Apache Airflow ile Veri Hattını Otomatize Etme
Verilerimizi okuduk, temizledik, dönüştürdük ve MySQL'e yükledik. Ancak bu işlemlerin her gün veya belirli aralıklarla manuel olarak çalıştırılması ne kadar sürdürülebilir? İşte bu noktada Apache Airflow devreye giriyor. Airflow, karmaşık veri iş akışlarını programatik olarak tanımlamanıza, zamanlamanıza, izlemenize ve yönetmenize olanak tanıyan açık kaynaklı bir platformdur. Veri hattımızdaki her adımı bir görev (Task) olarak tanımlayacak ve bu görevler arasındaki bağımlılıkları belirleyerek bir iş akışı (DAG - Directed Acyclic Graph) oluşturacağız.
Airflow Nedir ve Neden Kullanmalıyız?
Airflow, veri mühendisleri için bir "iş akışı orkestrasyonu" aracıdır. Geleneksel cron işlerinin veya özel scriptlerin ötesine geçerek, aşağıdaki avantajları sunar:
- Programatik İş Akışları: İş akışları (DAG'ler) Python kodunda tanımlanır, bu da sürüm kontrolü, test edilebilirlik ve esneklik sağlar.
- Dinamik DAG Oluşturma: Şablonlar ve kod ile dinamik olarak DAG'ler oluşturulabilir.
- Zengin Kullanıcı Arayüzü (UI): Tüm iş akışlarını, görev durumlarını, logları ve geçmişi görsel olarak izlemeyi sağlar.
- Ölçeklenebilirlik: Celery veya Kubernetes Executor gibi dağıtık mimarilerle binlerce görevi aynı anda çalıştırabilir.
- Genişletilebilirlik: Operatörler, sensörler ve kancalar aracılığıyla çeşitli platformlar ve hizmetlerle (AWS, GCP, Azure, Spark, Hive vb.) entegre olabilir.
- Hata Yönetimi ve Yeniden Denemeler: Görev seviyesinde yeniden deneme politikaları, hata bildirimleri ve izleme imkanları sunar.
Kısacası, Airflow, veri hattınızı tek bir noktadan yönetmenizi, potansiyel sorunları erken tespit etmenizi ve veri akışınızın sürekli ve güvenilir olmasını sağlamanızı mümkün kılar.
Temel Airflow Kavramları
- DAG (Directed Acyclic Graph): Tanımladığınız tüm iş akışının ana yapısıdır. Yönlü (iş akışının belirli bir sırası vardır), döngüsel olmayan (görevler arasında sonsuz bir döngü oluşmaz) bir grafik şeklinde ifade edilir.
- Task (Görev): Bir DAG içindeki temel birimdir ve belirli bir işi (örneğin, bir Python fonksiyonunu çalıştırmak, bir SQL sorgusu yürütmek) temsil eder.
- Operator (Operatör): Bir görevi tanımlamak için kullanılan sınıftır. Örneğin,
PythonOperatorPython fonksiyonlarını çalıştırmak için,BashOperatorkabuk komutlarını yürütmek için kullanılır. - Sensor (Sensör): Belirli bir koşulun (örneğin, bir dosyanın varlığı, bir veritabanı kaydının oluşması) gerçekleşmesini bekleyen özel bir operatör türüdür.
- Executor (Yürütücü): Görevleri fiilen nerede çalıştırılacağını belirleyen bileşendir (Sequential, Local, Celery, Kubernetes gibi).
Basit Bir Airflow DAG Oluşturma
Şimdi, önceki adımlarda yazdığımız Python kodunu otomatize edecek bir Airflow DAG'i oluşturalım. Bunun için, Pandas ile veri işleme ve MySQL'e yükleme mantığını içeren bir Python fonksiyonu veya script hazırlamamız gerekecek. Örnek olarak, daha önce yazdığımız load_data_to_mysql fonksiyonunu Airflow DAG'i içinde kullanabiliriz. Airflow, DAG dosyalarını dags klasörü içinde arar.
# dags/csv_to_mysql_dag.py
from airflow import DAG
from airflow.operators.python import PythonOperator
from datetime import datetime
import pandas as pd
import mysql.connector
import os
# Veritabanı bağlantı bilgileri (Airflow Connections ile yönetmek daha güvenlidir)
# Şimdilik direkt burada tanımlayalım.
db_config = {
'host': 'host.docker.internal', # Docker içinden host makinesine erişim için
'user': 'root',
'password': 'my-secret-pw',
'database': 'data_pipeline'
}
# Python scriptimizin çalışacağı fonksiyon
def process_and_load_csv_data(**kwargs):
# CSV dosyasının yolu (Airflow container'ı içindeki path)
# Varsayılan olarak dags klasörünün yanına bir 'data' klasörü oluşturulabilir.
csv_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'siparisler.csv')
# CSV dosyasını oku
try:
df = pd.read_csv(csv_file_path)
print(f"CSV dosyası {csv_file_path} başarıyla okundu. {len(df)} satır.")
except FileNotFoundError:
print(f"Hata: {csv_file_path} dosyası bulunamadı.")
raise # Airflow görevinin başarısız olması için hata fırlat
# Veri Temizleme ve Dönüştürme
df.dropna(subset=['adet', 'birim_fiyat'], inplace=True)
df['urun_adi'].fillna('Bilinmiyor', inplace=True)
df['adet'] = df['adet'].astype(int)
df['birim_fiyat'] = df['birim_fiyat'].astype(float)
df['siparis_tarihi'] = pd.to_datetime(df['siparis_tarihi'])
df['toplam_tutar'] = df['adet'] * df['birim_fiyat']
print(f"Veri temizleme ve dönüşüm tamamlandı. {len(df)} satır kaldı.")
# MySQL'e yükleme fonksiyonu
conn = None
cursor = None
try:
conn = mysql.connector.connect(**db_config)
cursor = conn.cursor()
insert_query = """
INSERT INTO siparisler (siparis_id, musteri_adi, urun_adi, adet, birim_fiyat, siparis_tarihi, toplam_tutar)
VALUES (%s, %s, %s, %s, %s, %s, %s)
ON DUPLICATE KEY UPDATE
musteri_adi = VALUES(musteri_adi),
urun_adi = VALUES(urun_adi),
adet = VALUES(adet),
birim_fiyat = VALUES(birim_fiyat),
siparis_tarihi = VALUES(siparis_tarihi),
toplam_tutar = VALUES(toplam_tutar),
yukleme_zamani = CURRENT_TIMESTAMP;
"""
data_to_insert = [
(row['siparis_id'], row['musteri_adi'], row['urun_adi'], row['adet'],
row['birim_fiyat'], row['siparis_tarihi'].strftime('%Y-%m-%d %H:%M:%S'),
row['toplam_tutar'])
for index, row in df.iterrows()
]
if data_to_insert: # Veri varsa ekle
cursor.executemany(insert_query, data_to_insert)
conn.commit()
print(f"{len(data_to_insert)} satır başarıyla eklendi/güncellendi.")
else:
print("Eklenecek yeni veri bulunamadı.")
except mysql.connector.Error as err:
print(f"Veritabanı hatası: {err}")
if conn:
conn.rollback()
print("İşlem geri alındı.")
raise # Airflow görevinin başarısız olması için hata fırlat
finally:
if cursor:
cursor.close()
if conn and conn.is_connected():
conn.close()
print("MySQL bağlantısı kapatıldı.")
# DAG Tanımı
with DAG(
dag_id='csv_to_mysql_data_pipeline',
start_date=datetime(2023, 1, 1),
schedule_interval='@daily', # Her gün çalışacak
catchup=False, # Geçmişteki kaçırılan çalışmaları çalıştırma
tags=['data_pipeline', 'csv', 'mysql', 'python'],
default_args={
'owner': 'airflow',
'depends_on_past': False,
'email_on_failure': False,
'email_on_retry': False,
'retries': 1,
'retry_delay': pd.Timedelta(minutes=5),
}
) as dag:
# PythonOperator kullanarak veri işleme ve yükleme fonksiyonumuzu çağır
process_and_load_task = PythonOperator(
task_id='process_and_load_csv_to_mysql',
python_callable=process_and_load_csv_data,
provide_context=True # Task'e Airflow bağlamını sağlar (kwargs ile erişilebilir)
)
# İsterseniz burada başka görevler de tanımlayabilir ve bağımlılıklarını kurabilirsiniz.
# Örneğin, bir sonraki adım bir dashboard'u güncelleme görevi olabilir.
# process_and_load_task >> update_dashboard_task
Bu DAG dosyası, process_and_load_csv_data adında tek bir görev içerir. Bu görev, daha önce Python ile yaptığımız tüm CSV okuma, dönüştürme ve MySQL'e yükleme işlemlerini kapsar. schedule_interval='@daily' sayesinde, bu DAG her gün otomatik olarak çalışacaktır. default_args içinde hata durumunda yeniden denemeler ve bildirimler gibi parametreleri tanımlayarak iş akışımızın daha sağlam olmasını sağlayabiliriz.
mysql.connector.connect() çağrısı yerine bir Airflow hook (örneğin MySqlHook) kullanmak da daha iyi bir uygulamadır.
Airflow kurulumu ve DAG'lerin nasıl deploy edileceği, genellikle Docker Compose veya Kubernetes ile yapılır. Bu DAG dosyasını Airflow'un dags klasörüne yerleştirdiğinizde, Airflow UI'da görünecek ve manuel olarak veya zamanlamasına göre çalıştırılabilecektir. Bu sayede, veri hattınız tamamen otomatikleşmiş ve izlenebilir bir hale gelmiş olur.
Veri Hattının İyileştirilmesi: İleri Düzey Konular ve En İyi Uygulamalar
Temel bir veri hattını başarıyla kurmuş olsanız da, gerçek dünya senaryolarında bu hattın daha sağlam, performanslı, güvenilir ve sürdürülebilir olması için bazı ileri düzey konulara dikkat etmek gerekir. Bu bölümde, hata yönetimi, performans optimizasyonu, veri kalitesi kontrolü ve ölçeklenebilirlik gibi kritik başlıkları ele alacağız.
Hata Yönetimi ve Yeniden Denemeler
Veri hatları, ağ kesintileri, API sınırlamaları, veri tabanı kilitlenmeleri veya beklenmedik veri formatları gibi birçok nedenle başarısız olabilir. Etkili bir hata yönetimi stratejisi, bu tür durumlarla başa çıkmak için hayati öneme sahiptir.
- Try-Except Blokları: Python kodunuzda, özellikle harici sistemlerle (dosya okuma, veritabanı bağlantısı, API çağrıları) etkileşime girdiğiniz yerlerde kapsamlı
try-exceptblokları kullanın. Bu, küçük hataların tüm iş akışını durdurmasını engeller ve spesifik hata mesajları ile sorun gidermeyi kolaylaştırır. - Airflow Yeniden Deneme Politikaları: Airflow DAG'lerinizde
retriesveretry_delayparametrelerini ayarlayarak görevlerin belirli bir süre sonra otomatik olarak yeniden denenmesini sağlayabilirsiniz. Bu, geçici ağ kesintileri gibi anlık sorunlar için çok etkilidir. - Hata Bildirimleri: Görev başarısız olduğunda e-posta, Slack veya PagerDuty gibi kanallar aracılığıyla otomatik bildirimler gönderin. Airflow'un
email_on_failuregibi parametreleri veya özel bildirim operatörleri ile bu sağlanabilir. - Hatalı Kayıt Yönetimi: Hatalı veya işlenemeyen kayıtları ayrı bir "dead-letter queue" veya "hata tablosuna" yönlendirin. Bu, sağlıklı verilerin işlenmeye devam etmesini sağlarken, hatalı verilerin daha sonra incelenmesine olanak tanır.
Loglama ve İzleme
Bir veri hattının sağlıklı çalışıp çalışmadığını anlamak için kapsamlı loglama ve etkin bir izleme sistemi şarttır.
- Detaylı Loglama: Python kodunuzda
loggingmodülünü kullanarak detaylı log mesajları oluşturun. Hangi verinin ne zaman işlendiği, hangi dönüşümlerin uygulandığı ve olası hatalar loglara kaydedilmelidir. - Airflow Logları: Airflow UI, her görevin çıktı loglarına erişim sağlar. Bu logları düzenli olarak kontrol etmek ve potansiyel sorunları proaktif olarak tespit etmek önemlidir.
- Performans Metrikleri: Veritabanı performansı (sorgu süreleri, bağlantı sayısı), Airflow görev süreleri ve sistem kaynak kullanımı (CPU, bellek) gibi metrikleri izleyin. Prometheus, Grafana veya Datadog gibi araçlar bu metriklerin görselleştirilmesinde kullanılabilir.
Performans Optimizasyonu
Büyük veri hacimleriyle çalışırken performans kritik bir konudur. Veri hattınızın hızlı ve verimli çalışmasını sağlamak için şunları göz önünde bulundurun:
- Veritabanı İndeksleri: MySQL tablolarınızda,
WHEREkoşullarında veyaJOINişlemlerinde sıkça kullanılan sütunlara doğru indeksleri ekleyin. Bu, sorgu sürelerini önemli ölçüde azaltabilir. - Toplu İşleme: Verileri küçük parçalara (batch) bölerek işleyin ve veritabanına toplu olarak yükleyin (
executemany). Bu, veritabanı üzerindeki yükü azaltır ve işlem süresini kısaltır. - SQL Sorgu Optimizasyonu: Yavaş çalışan SQL sorgularını belirleyin ve optimize edin.
EXPLAINkomutunu kullanarak sorguların nasıl yürütüldüğünü analiz edin. - Bellek Yönetimi: Pandas DataFrame'leri bellekte büyük yer kaplayabilir.
df.info(memory_usage='deep')ile bellek kullanımını izleyin veastypeile daha küçük veri tiplerine dönüştürerek veyachunksizekullanarak büyük dosyaları parça parça işleyerek bellek kullanımını optimize edin. - Paralelleştirme: Airflow, birden fazla görevi paralel çalıştırma yeteneğine sahiptir. Bağımsız görevleri paralel olarak çalıştırarak toplam iş akışı süresini kısaltın.
Veri Kalitesi ve Doğrulama
Veri hattınızın çıktılarının doğru ve güvenilir olması için veri kalitesi kontrolü kritik öneme sahiptir.
- Veri Profilleme: Gelen verinin yapısını, dağılımını ve potansiyel anormalliklerini anlamak için veri profilleme araçları kullanın (örneğin, Pandas Profiling).
- Beklenti Tabanlı Doğrulama: Verilerin belirli kurallara (örneğin, "siparis_id her zaman benzersiz olmalı", "adet > 0 olmalı") uygun olup olmadığını kontrol etmek için Great Expectations gibi kütüphaneleri kullanın. Bu kontrolleri Airflow görevleri arasına entegre edebilirsiniz.
- Veri Anormallik Tespiti: Zaman içindeki veri trendlerinden sapan ani değişimleri tespit etmek için basit istatistiksel yöntemler veya makine öğrenimi modelleri kullanın.
Güvenlik ve Ölçeklenebilirlik
Veri hattınızın uzun vadeli başarısı için güvenlik ve ölçeklenebilirlik konuları da önemlidir.
- Kimlik Bilgileri Yönetimi: Veritabanı şifreleri, API anahtarları gibi hassas bilgileri kodda açıkça tutmayın. Airflow Connections, HashiCorp Vault veya AWS Secrets Manager gibi araçlar kullanarak bunları güvenli bir şekilde yönetin.
- Yetkilendirme: Veritabanında ve diğer sistemlerde en az yetki prensibini uygulayın. Veri hattının ihtiyaç duyduğu minimum izinleri verin.
- Airflow Ölçeklenebilirliği: Daha büyük ve karmaşık iş yükleri için Airflow'un CeleryExecutor veya KubernetesExecutor gibi dağıtık yürütücülerini kullanmayı düşünün. Bu, Airflow'un iş yükünü birden fazla worker arasında dağıtmasını sağlar.
- Bulut Entegrasyonu: Büyük veri setleri ve yüksek işlem gücü gereksinimleri için AWS S3, Azure Blob Storage veya Google Cloud Storage gibi bulut tabanlı depolama ve Snowflake, BigQuery gibi bulut veri ambarı çözümlerini değerlendirebilirsiniz. Bu platformlar genellikle yerleşik ölçeklenebilirlik ve performans optimizasyonları sunar.
ON DUPLICATE KEY UPDATE gibi SQL yapıları veya benzersiz kimlikler üzerinden upsert (insert or update) mantığı kullanın.
Bu ileri düzey konuları dikkate alarak ve en iyi uygulamaları benimseyerek, CSV'den dashboard'a uzanan veri hattınızı sadece çalışır hale getirmekle kalmayacak, aynı zamanda onu bir üretim ortamında güvenle kullanabileceğiniz, güçlü ve sürdürülebilir bir yapıya dönüştüreceksiniz.
Sonuç ve Sıkça Sorulan Sorular
Bu kapsamlı rehberde, ham CSV dosyalarından başlayarak, işlenmiş verileri bir MySQL veritabanına yükleyip, tüm süreci Apache Airflow ile otomatikleştirerek bir dashboarda hazır hale getiren uçtan uca bir veri hattı inşa etmeyi adım adım öğrendik. Python'ın güçlü veri işleme yetenekleri (özellikle Pandas), MySQL'in güvenilir veri depolama çözümleri ve Airflow'un esnek iş akışı orkestrasyonu sayesinde, karmaşık veri entegrasyonu ve otomasyon görevlerini basitleştirdik. Artık bu araç ve tekniklerle kendi veri projelerinize güvenle başlayabilir, manuel süreçlerin getirdiği yükü ortadan kaldırabilir ve verilerinizden daha hızlı ve güvenilir içgörüler elde edebilirsiniz.
Bir veri hattı inşa etmek sadece teknik bir zorluk değildir; aynı zamanda veri kalitesine, hataya dayanıklılığa ve ölçeklenebilirliğe odaklanan stratejik bir yatırımdır. Bu makalede ele aldığımız ileri düzey konular ve en iyi uygulamalar, veri hattınızı sadece çalışır hale getirmekle kalmayıp, onu geleceğe hazır, sürdürülebilir bir varlık haline getirmenize yardımcı olacaktır. Unutmayın, veri dünyası sürekli değişiyor ve gelişiyor. Bu teknolojilere hakim olarak, veri mühendisliği kariyerinizde önemli bir adım atmış olacaksınız. Şimdi, aklınıza takılabilecek bazı sıkça sorulan sorulara göz atalım:
Sıkça Sorulan Sorular (SSS)
-
Veri hattı kurmak ne kadar zaman alır?
Projenin karmaşıklığına, veri hacmine ve ekibin deneyimine bağlı olarak süre değişir. Bu rehberdeki gibi basit bir CSV'den MySQL'e hattı kurmak birkaç saatten birkaç güne kadar sürebilir. Daha kapsamlı, birden çok kaynaktan beslenen ve karmaşık dönüşümler içeren kurumsal bir veri hattı ise haftalar veya aylar sürebilir.
-
Airflow yerine başka bir orkestrasyon aracı kullanabilir miyim?
Evet, Airflow bu alandaki popüler araçlardan biri olsa da, Prefect, Luigi, Dagster ve Apache Nifi gibi başka alternatifler de bulunmaktadır. Her aracın kendine özgü güçlü yönleri ve kullanım senaryoları vardır. Seçim, projenizin spesifik ihtiyaçlarına, ekibinizin alışkın olduğu teknolojilere ve ölçeklenebilirlik gereksinimlerinize göre yapılmalıdır.
-
Büyük veri setleri için MySQL yeterli mi?
MySQL, binlerce veya milyonlarca kaydı depolamak ve yönetmek için oldukça yeterli ve performanslı bir ilişkisel veritabanıdır. Ancak terabaytlarca veri veya petabaytlarca veri ile uğraşıyorsanız ve çok sayıda karmaşık analitik sorgu çalıştırıyorsanız, Snowflake, Google BigQuery, Amazon Redshift gibi özel veri ambarı çözümleri veya Apache Cassandra gibi NoSQL veritabanları daha uygun olabilir.
-
Veri güvenliğini nasıl sağlarım?
Veri güvenliği, veri hattının her aşamasında öncelikli olmalıdır. Veritabanı bağlantı şifreleri ve API anahtarları gibi hassas bilgileri Airflow Connections gibi güvenli yöntemlerle veya bir gizlilik yöneticisi (örneğin HashiCorp Vault) kullanarak yönetin. Veritabanı ve sunucu seviyesinde erişim kontrolü (yetkilendirme), veri şifrelemesi (aktarımda ve beklemede) ve düzenli güvenlik denetimleri de hayati öneme sahiptir. Hassas kişisel verileri maskelemek veya anonimleştirmek de bir yöntemdir.
-
Bu veri hattını nasıl izlerim ve bakımını yaparım?
Airflow UI, çalışan görevleri, logları ve olası hataları izlemek için temel bir araçtır. Daha gelişmiş izleme için Prometheus ve Grafana gibi araçlarla sistem metriklerini (CPU, bellek, disk kullanımı) ve veritabanı performansını izleyebilirsiniz. Bakım açısından, DAG'lerinizi düzenli olarak gözden geçirin, bağımlılıkları güncelleyin, Airflow'u ve kullandığınız kütüphaneleri güncel tutun ve yedekleme stratejileri uygulayın.