Github Dockerfile ve Yapay Zeka Entegrasyonu: Başlangıç

Yapay zeka (YZ) projelerini geliştirme süreçleri heyecan verici olsa da, bu projeleri tutarlı ve güvenilir bir şekilde dağıtmak çoğu zaman büyük bir zorluk teşkil eder. Geliştirme ortamınızda sorunsuz çalışan bir modelin, üretim ortamına alındığında beklenmedik hatalar vermesi veya bağımlılık çakışmalarıyla karşılaşılması oldukça yaygındır. Peki, bu karmaşık YZ modellerini farklı sunuculara veya bulut ortamlarına taşırken aynı performansı ve istikrarı nasıl garantileyebiliriz? İşte bu noktada Docker ve onun temel yapı taşı olan Dockerfile, YZ servislerinizi standartlaştırma, izole etme ve kolayca dağıtma konusunda devreye giriyor. Bu makalede, GitHub üzerinde Dockerfile kullanarak YZ projelerinizi nasıl uçtan uca yönetebileceğinizi, temelden ileri düzeye adım adım keşfedeceğiz. YZ uygulamalarınızın dağıtımını basitleştirerek geliştirme süreçlerinizi hızlandırmak ve MLOps (Makine Öğrenimi Operasyonları) prensiplerini benimsemek için gelin bu yolculuğa birlikte çıkalım.

Yapay zeka modelleri genellikle karmaşık bağımlılıklara, belirli kütüphane versiyonlarına ve bazen özel donanım gereksinimlerine (GPU gibi) ihtiyaç duyar. Bir geliştirici olarak, projenizi yerel makinenizde kusursuz bir şekilde çalışırken bulut ortamında veya başka bir ekip üyesinin bilgisayarında aynı performansla çalıştıramama sorunuyla sık sık karşılaşabilirsiniz. Bu “benim makinemde çalışıyor” sendromu, YZ projelerinin geliştirme ve dağıtım döngülerini uzatan, maliyetleri artıran ve işbirliğini zorlaştıran önemli bir engeldir.

Docker, bu sorunlara kapsamlı bir çözüm sunar. Konteynerleştirme teknolojisi sayesinde, YZ uygulamanızı tüm bağımlılıkları, çalışma zamanı ortamı ve kodunuzla birlikte tek bir taşınabilir birim içinde paketleyebilirsiniz. Bu birime “Docker imajı” denir. Docker imajı, bir kere oluşturulduğunda, Docker’ın yüklü olduğu herhangi bir yerde, aynı tutarlılıkla çalıştırılabilir. Bu, bir YZ modelini yerel makinenizden bir test sunucusuna, oradan da üretim ortamına taşırken ortam tutarsızlığı riskini ortadan kaldırır. Özellikle büyük ölçekli YZ projelerinde, ekibin farklı üyelerinin aynı ortamda çalışmasını sağlamak, bağımlılık yönetimi karmaşasını azaltmak ve model versiyonlama süreçlerini basitleştirmek için Docker vazgeçilmez bir araç haline gelmiştir. Bu sayede, geliştiriciler modelin kendisini iyileştirmeye odaklanabilirken, operasyon ekipleri dağıtımın sorunsuzluğundan emin olabilirler. Ayrıca, ölçeklenebilirlik açısından da Docker büyük avantajlar sunar; bir modelin daha fazla kullanıcıya hizmet vermesi gerektiğinde, aynı Docker imajından birden çok konteyner kolayca başlatılabilir. Dolayısıyla, YZ projelerinizin yaşam döngüsünü daha öngörülebilir, verimli ve ölçeklenebilir hale getirmek istiyorsanız, Docker’ı benimsemek stratejik bir adımdır.

Temel Kavramlar: Docker, Dockerfile ve Yapay Zeka İlişkisi Nedir?

Yapay zeka projelerinizi konteynerleştirmeden önce, temel kavramları anlamak kritik öneme sahiptir.

Docker nedir? Docker, uygulamaları ve bağımlılıklarını konteyner adı verilen hafif, taşınabilir ve izole edilmiş ortamlarda paketlemenize ve çalıştırmanıza olanak tanıyan bir platformdur. Sanal makinelerin aksine, Docker konteynerleri işletim sistemini tam olarak içermez; bunun yerine ana bilgisayarın çekirdeğini paylaşır ve bu da onları çok daha hızlı ve kaynak açısından daha verimli yapar. Her konteyner, kendi izole dosya sistemine, işlem alanına ve ağ arabirimlerine sahip olduğundan, birbiriyle çakışmadan farklı uygulamaları aynı sunucuda çalıştırabilirsiniz. Bu izolasyon özelliği, YZ projelerinde özellikle önemlidir, çünkü farklı modellerin farklı Python versiyonlarına veya kütüphane sürümlerine ihtiyaç duyması yaygındır.

Dockerfile nedir? Dockerfile, bir Docker imajı oluşturmak için gerekli tüm adımları içeren metin tabanlı bir betiktir. Bu betik, temel bir işletim sistemi imajından başlayarak, gerekli yazılımların (örneğin Python, pip), bağımlılıkların (örneğin TensorFlow, PyTorch, scikit-learn) yüklenmesini, uygulama kodunuzun kopyalanmasını ve uygulamanın nasıl başlatılacağını adım adım tanımlar. Dockerfile, bir tarif defteri gibidir; ona ne istediğinizi söylersiniz (örneğin “Python 3.9 tabanlı bir Ubuntu”, “numpy ve pandas yükle”, “şu kodu kopyala”), o da size çalışan bir Docker imajı üretir. Bu sayede, aynı Dockerfile ile her zaman aynı imajı oluşturabilir, bu da ortam tutarlılığını garantiler.

Yapay Zeka ve Docker İlişkisi: YZ projeleri, özellikle makine öğrenimi modelleri, genellikle büyük veri kümeleri, karmaşık matematiksel kütüphaneler (örneğin CUDA, cuDNN), özel donanım hızlandırması (GPU) ve belirli yazılım çerçeveleri (TensorFlow, PyTorch) gerektirir. Bu bileşenlerin kurulumu ve yönetimi zorlu olabilir. Docker, bu zorlukları şu şekilde aşar:

• Bağımlılık Yönetimi: Dockerfile, tüm YZ bağımlılıklarını tek bir yerde tanımlamanızı ve yalıtmanızı sağlar. Bu, “pip install” çakışmalarının veya sistem genelindeki kütüphane sorunlarının önüne geçer.
• Ortam Tutarlılığı: Geliştirmeden teste, testten üretime kadar tüm aşamalarda aynı ortamın kullanılmasını garantiler. Bu, modelin farklı ortamlarda farklı davranma riskini ortadan kaldırır.
• Ölçeklenebilirlik: Eğitilmiş bir YZ modelini bir konteyner içinde çalıştırarak, talebe göre kolayca birden çok konteyneri ayağa kaldırabilir ve yükü dağıtabilirsiniz.
• Donanım Hızlandırma: Özellikle GPU tabanlı YZ modelleri için Docker, NVIDIA Container Toolkit gibi araçlarla sorunsuz GPU entegrasyonu sağlar. Dockerfile içerisinde özel GPU tabanlı temel imajlar kullanılarak (örneğin nvidia/cuda), donanım hızlandırmanın avantajlarından kolayca yararlanılabilir.
• Versiyonlama: Her Docker imajı bir versiyonla etiketlenebilir, bu da modelin farklı versiyonlarının izlenmesini ve kolayca geri alınabilmesini sağlar.

Kısacası, Docker ve Dockerfile, YZ projelerinizi geliştirme ve dağıtma şeklinizi dönüştürerek, MLOps süreçlerinin temelini oluşturur ve geliştiricilerin daha verimli olmasına olanak tanır. Bu araçlar sayesinde, YZ uygulamalarınızı herhangi bir ortamda güvenle ve tutarlılıkla çalıştırabilirsiniz.

Yapay Zeka Uygulaması için Temel Bir Dockerfile Nasıl Oluşturulur?

Şimdi, basit bir yapay zeka uygulamasını Dockerize etmek için adım adım bir Dockerfile nasıl oluşturulur ona bakalım. Bu örnekte, Python tabanlı küçük bir metin sınıflandırma modeli kullanacağımızı varsayalım. Amacımız, uygulamanın çalışması için gerekli tüm ortamı, kütüphaneleri ve kodu tek bir Docker imajında paketlemek.

Öncelikle, projenizin kök dizininde aşağıdaki dosyalara sahip olduğunuzu varsayalım:

• app.py: YZ uygulamasının ana kodu.
• requirements.txt: Python bağımlılıklarını listeleyen dosya.
• Dockerfile: Oluşturacağımız Dockerfile dosyası.

1. requirements.txt Dosyası:


scikit-learn==1.0.2
flask==2.0.2
gunicorn==20.1.0


2. app.py Dosyası (Basit bir Flask API):


from flask import Flask, request, jsonify
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import SVC
import joblib

app = Flask(__name__)

# Basit bir model eğitimi (gerçek uygulamada model önceden eğitilmiş olurdu)
# Bu kısmı sadece örnek amaçlı dahil ettik.
corpus = [
"bu harika bir film",
"çok kötü bir deneyimdi",
"yemekler lezzetliydi",
"hizmet berbattı"
]
labels = ["pozitif", "negatif", "pozitif", "negatif"]

vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(corpus)
model = SVC(kernel='linear')
model.fit(X, labels)

# Modeli ve vektörizörü kaydedelim (gerçekte bu dışarıda yapılırdı)
joblib.dump(model, 'model.pkl')
joblib.dump(vectorizer, 'vectorizer.pkl')

# Yükleme (Uygulama başladığında yüklenecek)
loaded_model = joblib.load('model.pkl')
loaded_vectorizer = joblib.load('vectorizer.pkl')

@app.route('/predict', methods=['POST'])
def predict():
data = request.get_json(force=True)
text = data['text']
text_vectorized = loaded_vectorizer.transform([text])
prediction = loaded_model.predict(text_vectorized)[0]
return jsonify({'prediction': prediction})

if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)

3. Dockerfile Oluşturma:
Şimdi bu uygulamanın nasıl paketleneceğini tanımlayalım. İşte temel bir Dockerfile:

# Python'ın hafif bir versiyonunu temel imaj olarak kullanıyoruz.
# -slim-buster etiketi, daha küçük bir imaj boyutu için gerekli olmayan bileşenleri çıkarır.
FROM python:3.9-slim-buster

# Konteyner içinde çalışma dizinini belirliyoruz. Tüm işlemler bu dizin altında yapılacak.
WORKDIR /app

# requirements.txt dosyasını ana bilgisayardan /app dizinine kopyalıyoruz.
# Bu adım, bağımlılıkları yüklemeden önce gereklidir.
COPY requirements.txt .

# requirements.txt içinde belirtilen Python bağımlılıklarını yüklüyoruz.
# --no-cache-dir, pip'in indirme önbelleğini temizleyerek imaj boyutunu azaltır.
RUN pip install --no-cache-dir -r requirements.txt

# model.pkl ve vectorizer.pkl dosyalarını ana bilgisayardan /app dizinine kopyalıyoruz.
# Bu, eğitilmiş modelimizin konteyner içinde erişilebilir olmasını sağlar.
COPY model.pkl .
COPY vectorizer.pkl .

# app.py ve diğer tüm uygulama dosyalarını ana bilgisayardan /app dizinine kopyalıyoruz.
# . . ifadesi, mevcut dizindeki her şeyi çalışma dizinine kopyalar.
COPY . .

# Flask uygulamasının 5000 numaralı port üzerinden dış dünyaya hizmet vereceğini belirtiyoruz.
# Bu, Docker'a sadece bir ipucudur, portun dışarıya açılması için -p parametresi kullanılmalıdır.
EXPOSE 5000

# Konteyner başlatıldığında çalıştırılacak varsayılan komutu belirliyoruz.
# Gunicorn, üretim ortamları için önerilen bir WSGI sunucusudur.
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]
  

Dockerfile Açıklaması:

• FROM python:3.9-slim-buster: Bu satır, Dockerfile'ın temel imajını tanımlar. Python 3.9'un Debian tabanlı, daha hafif bir sürümünü kullanıyoruz. Bu, imaj boyutunu optimize etmek için önemlidir.
• WORKDIR /app: Konteyner içinde tüm komutların çalışacağı dizini /app olarak ayarlar. Bu, dosya yollarını yönetmeyi kolaylaştırır.
• COPY requirements.txt .: Proje dizinimizdeki requirements.txt dosyasını konteynerin /app dizinine kopyalar. Bu, bağımlılıkların doğru bir şekilde yüklenmesi için kritiktir.
• RUN pip install --no-cache-dir -r requirements.txt: requirements.txt dosyasında listelenen tüm Python paketlerini yükler. --no-cache-dir parametresi, ara önbellek dosyalarını temizleyerek nihai imajın boyutunu küçültmeye yardımcı olur.
• COPY model.pkl . ve COPY vectorizer.pkl .: Eğer önceden eğitilmiş bir model ve vektörizörünüz varsa, bunları da konteynere kopyalamalısınız.
• COPY . .: Geri kalan tüm proje dosyalarını (örneğin app.py) mevcut çalışma dizininden konteynerin /app dizinine kopyalar.
• EXPOSE 5000: Konteynerin 5000 numaralı porttan dışarıya hizmet vereceğini belirtir. Bu sadece bir belgedir; gerçek port yönlendirmesi docker run -p 5000:5000 gibi bir komutla yapılır.
• CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]: Konteyner başlatıldığında çalıştırılacak varsayılan komuttur. Bu örnekte, gunicorn adlı bir üretim sınıfı WSGI sunucusunu kullanarak Flask uygulamasını 5000 numaralı portta başlatıyoruz. app:app ifadesi, app.py dosyasındaki app değişkenini (Flask uygulamasını) referans alır.

Bu Dockerfile ile, yapay zeka uygulamanızı tutarlı ve taşınabilir bir konteyner imajına dönüştürmek için sağlam bir temele sahip olursunuz.

GitHub ve Dockerfile Entegrasyonu: CI/CD Süreçleri İçin Adımlar

Yapay zeka projelerimizi Dockerfile ile konteynerleştirdikten sonra, bu süreçleri otomatikleştirmek ve sürdürülebilir hale getirmek için GitHub'ın gücünden yararlanmak oldukça önemlidir. GitHub, sadece kod depolama platformu olmanın ötesinde, GitHub Actions ile CI/CD (Sürekli Entegrasyon/Sürekli Teslimat) iş akışları oluşturarak projelerinizin otomatik olarak derlenmesini, test edilmesini ve dağıtılmasını sağlayabilir. Bu, YZ projeleri için özellikle değerli çünkü model güncellemeleri veya bağımlılık değişiklikleri olduğunda hızlı ve hatasız bir şekilde yeni versiyonları dağıtabilmenizi sağlar.

GitHub Üzerinde Dockerfile Depolama:
İlk adım, oluşturduğunuz Dockerfile'ı ve diğer tüm uygulama kodunu GitHub deponuza yüklemektir. Dockerfile genellikle projenin kök dizininde bulunur. Bu sayede, her kod değişikliğinde, Dockerfile da versiyon kontrolü altında olur ve projenin o anki haliyle hangi imajın nasıl oluşturulduğu her zaman takip edilebilir.

GitHub Actions ile Otomatik Docker İmajı Oluşturma ve Dağıtma:
Şimdi en heyecan verici kısma geçelim: GitHub Actions kullanarak her kod gönderme (push) işleminde otomatik olarak Docker imajınızı derleyip bir konteyner kayıt defterine (örneğin Docker Hub veya GitHub Container Registry) nasıl gönderebileceğinizi görelim.

Bu işlem için, GitHub deponuzun .github/workflows/ dizini altına bir YAML dosyası (örneğin docker-ci.yml) oluşturmanız gerekir:

# İş akışının adı
name: Docker YZ Servis CI

# İş akışının ne zaman tetikleneceğini tanımlar
on:
  push:
    # Sadece 'main' dalına yapılan push işlemlerinde çalışır
    branches: [ "main" ]
  pull_request:
    # 'main' dalına yapılan pull request'lerde de çalışır (isteğe bağlı)
    branches: [ "main" ]

# Çalıştırılacak işler (jobs)
jobs:
  build_and_push_image:
    # İşin çalışacağı ortam
    runs-on: ubuntu-latest

    # İşin adımları
    steps:
    - name: Depoyu Çıkart (Checkout Repository)
      uses: actions/checkout@v4 # Depoyu runner'a kopyalar

    - name: Docker Hub'a Giriş Yap (Log in to Docker Hub)
      uses: docker/login-action@v3
      with:
        username: ${{ secrets.DOCKER_USERNAME }} # GitHub Secrets'tan Docker Hub kullanıcı adı
        password: ${{ secrets.DOCKER_TOKEN }} # GitHub Secrets'tan Docker Hub erişim tokenı

    - name: Docker İmajını Oluştur ve Gönder (Build and Push Docker Image)
      uses: docker/build-push-action@v5
      with:
        context: . # Dockerfile'ın bulunduğu dizin (mevcut dizin)
        push: true # İmajı kayıt defterine gönderme
        tags: | # Oluşturulacak imajın etiketleri
          ${{ secrets.DOCKER_USERNAME }}/my-ai-app:latest
          ${{ secrets.DOCKER_USERNAME }}/my-ai-app:${{ github.sha }} # Commit SHA ile versiyonlama
        cache-from: type=gha # GitHub Actions önbelleğini kullanır
        cache-to: type=gha,mode=max # GitHub Actions önbelleğine kaydeder
  

Bu GitHub Actions İş Akışının Açıklaması:

• name: Docker YZ Servis CI: İş akışına anlaşılır bir isim verir.
• on: push: branches: ["main"]: Bu iş akışının, deponuzun main dalına yeni bir kod gönderildiğinde otomatik olarak tetiklenmesini sağlar. Bu, her yeni değişiklikte YZ servisinizin yeni bir imajının oluşturulacağı anlamına gelir.
• jobs: build_and_push_image:: İş akışının ana bileşeni olan bir "iş" tanımlar.
• runs-on: ubuntu-latest: Bu işin Ubuntu işletim sistemine sahip bir GitHub Actions çalıştırıcısı üzerinde çalışacağını belirtir.
• steps:: İşin içinde gerçekleştirilecek adımları sıralar.
  • uses: actions/checkout@v4: İlk adım olarak, projenizin kodunu çalışan ortama kopyalar.
  • uses: docker/login-action@v3: Docker Hub'a veya başka bir konteyner kayıt defterine giriş yapmayı sağlar. Kullanıcı adı ve parola bilgileri GitHub Secrets üzerinden güvenli bir şekilde alınmalıdır (DOCKER_USERNAME ve DOCKER_TOKEN adında gizli değişkenler oluşturmanız gerekir). Bu, hassas bilgilerin kodunuzda görünmesini engeller.
  • uses: docker/build-push-action@v5: Docker imajını oluşturan (build) ve belirtilen kayıt defterine gönderen (push) temel aksiyondur.
    • context: .: Dockerfile'ın mevcut dizinde olduğunu belirtir.
    • push: true: İmajı kayıt defterine gönderme işlemini etkinleştirir.
    • tags:: Oluşturulan imaja birden fazla etiket (tag) atamanızı sağlar. Burada hem latest etiketi hem de ilgili commit'in SHA değeri ile versiyonlanmış bir etiket kullanıyoruz. Bu, geçmişe dönük versiyonları takip etmek için harikadır.
    • cache-from: type=gha ve cache-to: type=gha,mode=max: GitHub Actions önbelleğini kullanarak Docker katmanlarını önbelleğe almayı sağlar. Bu, tekrarlayan derleme sürelerini önemli ölçüde kısaltır.

Bu entegrasyon sayesinde, YZ projenizde her kod değişikliği yaptığınızda ve bunu GitHub'a gönderdiğinizde, yeni bir Docker imajı otomatik olarak oluşturulacak ve seçtiğiniz kayıt defterine yüklenecektir. Bu, MLOps dünyasında "Sürekli Entegrasyon" (CI) adımıdır ve YZ servislerinizin her zaman güncel, test edilebilir ve dağıtıma hazır olmasını sağlar. Daha sonra, bu imajları üretim ortamına otomatik olarak dağıtmak için "Sürekli Teslimat/Dağıtım" (CD) adımlarına geçilebilir.

Yapay Zeka Servisleri İçin İleri Düzey Dockerfile Optimizasyonları ve İpuçları

Basit bir Dockerfile ile YZ uygulamanızı konteynerleştirmeyi öğrendik. Ancak, özellikle büyük ve karmaşık YZ modelleriyle çalışırken, performans, güvenlik ve kaynak verimliliği açısından Dockerfile'ınızı optimize etmek kritik hale gelir. İşte YZ servisleriniz için ileri düzey Dockerfile ipuçları ve en iyi uygulamalar:

1. Çok Aşamalı Yapılar (Multi-stage Builds) Kullanın:
YZ modellerinin eğitimi sırasında genellikle derleyiciler, test araçları veya büyük geliştirme kütüphaneleri gibi sadece derleme aşamasında gerekli olan birçok araca ihtiyaç duyulur. Bu araçların hepsi nihai üretim imajında yer alırsa, imaj boyutu gereksiz yere şişer. Çok aşamalı yapılar, farklı aşamalar tanımlayarak bu sorunu çözer. İlk aşamada (build stage) tüm derleme ve test işlemleri yapılır, ikinci aşamada (runtime stage) ise sadece uygulamanın çalışması için gerekli olan minimum bileşenler kopyalanır.

# AŞAMA 1: Derleme Aşaması
FROM python:3.9-slim-buster AS builder

WORKDIR /app

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

# Model eğitim kodunu veya testlerini çalıştır (isteğe bağlı)
# RUN python train_model.py

# Eğitilmiş modeli kaydet
# COPY . . # Diğer dosyaları da kopyalayabiliriz
# RUN python build_assets.py # Modeli veya varlıkları oluşturur

# AŞAMA 2: Çalışma Zamanı Aşaması
# Daha minimal bir temel imaj kullanabiliriz
FROM python:3.9-slim-buster

WORKDIR /app

# Sadece üretimde gerekli olan bağımlılıkları kopyala
# Eğer üretim için farklı bir requirements.txt varsa
COPY --from=builder /app/requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Model ve uygulama kodunu derleme aşamasından kopyala
COPY --from=builder /app/model.pkl .
COPY --from=builder /app/vectorizer.pkl .
COPY --from=builder /app/app.py .

EXPOSE 5000
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]
  

Bu yaklaşım, nihai imajın boyutunu önemli ölçüde azaltır, güvenlik risklerini düşürür ve dağıtımı hızlandırır.

2. GPU Desteği Entegrasyonu:
Derin öğrenme modelleri genellikle GPU hızlandırmasından faydalanır. Docker konteynerlerinin GPU'lara erişebilmesi için NVIDIA Container Toolkit (önceden nvidia-docker olarak biliniyordu) kullanmanız gerekir. Dockerfile'ınızda, CUDA ve cuDNN gibi NVIDIA kütüphanelerini içeren özel NVIDIA temel imajlarını kullanmanız önemlidir.

# NVIDIA CUDA ve cuDNN desteği olan bir temel imaj kullanın
FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04

# Python'ı ve pip'i bu imaj üzerine kurun
RUN apt-get update && apt-get install -y python3 python3-pip && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY requirements.txt .

# GPU destekli TensorFlow veya PyTorch gibi kütüphaneleri yükleyin
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 5000
CMD ["python3", "app_gpu.py"]
  

Bu imajı çalıştırırken docker run --gpus all ... komutunu kullanarak konteynerin GPU'lara erişmesini sağlamalısınız. Unutmayın ki ana bilgisayarınızda NVIDIA sürücülerinin ve Docker'ın NVIDIA Container Toolkit eklentisinin doğru şekilde kurulmuş olması gerekmektedir.

3. Güvenlik En İyi Uygulamaları:

• Ayrıcalıklı Olmayan Kullanıcı Kullanımı: Konteynerleri varsayılan olarak root kullanıcısıyla çalıştırmak güvenlik riski taşır. Dockerfile içinde özel bir kullanıcı oluşturup uygulamayı bu kullanıcıyla çalıştırmak iyi bir uygulamadır:

  
  # ... (önceki adımlar)
  RUN adduser --disabled-password --gecos "" appuser
  USER appuser
  # ... (sonraki adımlar)
        

• En Az Ayrıcalık Prensibi: Sadece uygulamanın çalışması için gerekli olan paketleri ve izinleri ekleyin. Gereksiz bağımlılıklar ve araçlar güvenlik açıklarına yol açabilir.
• .dockerignore Dosyası: Gereksiz dosyaları (örneğin .git dizini, .env dosyaları, büyük veri kümeleri) Docker imajınıza kopyalamamak için bir .dockerignore dosyası kullanın. Bu, imaj boyutunu küçültür ve hassas bilgilerin yanlışlıkla imaja dahil edilmesini engeller.

4. Ortam Değişkenleri ile Yapılandırma:
YZ modellerinin hiperparametreleri, API anahtarları veya veritabanı bağlantı dizeleri gibi yapılandırma parametrelerini doğrudan Dockerfile'a gömmek yerine ortam değişkenleri olarak tanımlamak daha esnektir. Bu, aynı imajı farklı ortamlar (geliştirme, test, üretim) için farklı konfigürasyonlarla çalıştırmanıza olanak tanır.

FROM python:3.9-slim-buster
WORKDIR /app
# ... diğer adımlar
ENV MODEL_VERSION=v1.0
ENV DB_HOST=localhost
CMD ["python", "app.py"]
  

Daha sonra konteyneri çalıştırırken docker run -e MODEL_VERSION=v2.0 ... şeklinde bu değişkenleri geçersiz kılabilirsiniz.

Dockerfile Optimizasyonları Tablosu:

Bu ileri düzey optimizasyonları uygulayarak, YZ servisleriniz için daha verimli, güvenli ve performanslı Docker imajları oluşturabilirsiniz. Unutmayın, iyi bir Dockerfile, YZ projenizin başarılı bir şekilde dağıtılmasının anahtarlarından biridir.

Gerçek Dünya Senaryosu: Bir NLP Modelini Docker ile Dağıtma

Şimdi öğrendiklerimizi somut bir gerçek dünya senaryosunda uygulayalım: Hugging Face kütüphanesini kullanarak önceden eğitilmiş bir Doğal Dil İşleme (NLP) modelini Docker ile nasıl dağıtacağımızı inceleyelim. Bu tür modeller genellikle büyük boyutludur ve spesifik Python kütüphaneleri (transformers, torch veya tensorflow) gerektirir. Modelin indirilmesi ve yüklenmesi de dikkate alınması gereken bir faktördür.

Bu senaryoda, bir metin sınıflandırma görevini yerine getiren bir BERT modeli kullanacağız. Uygulamamız, kullanıcıdan gelen bir metni alıp model aracılığıyla analiz edecek ve bir sınıflandırma sonucu döndürecek basit bir Flask API olarak tasarlanacak.

1. Proje Yapısı ve Dosyalar:

• app.py: Flask uygulamasını ve model yükleme/çıkarım mantığını içerir.
• requirements.txt: Gerekli Python bağımlılıklarını listeler.
• Dockerfile: Modelin konteynerleştirilmesi için talimatlar.

2. requirements.txt Dosyası:


transformers==4.35.2
torch==2.1.0
flask==2.0.2
gunicorn==20.1.0


3. app.py Dosyası (Basit bir NLP Flask API):

from flask import Flask, request, jsonify
from transformers import pipeline
import torch
import os

app = Flask(__name__)

# Model ve tokenizer'ı yüklemek için bir NLP pipeline'ı oluştur
# Bu işlem biraz zaman alabilir, bu yüzden uygulama başlangıcında yapılır.
# Modeli indirmek için ortam değişkeni kullanabiliriz.
MODEL_NAME = os.getenv("MODEL_NAME", "distilbert-base-uncased-finetuned-sst-2-english")
classifier = pipeline("sentiment-analysis", model=MODEL_NAME, tokenizer=MODEL_NAME)

@app.route('/classify', methods=['POST'])
def classify_text():
    data = request.get_json(force=True)
    text = data.get('text', '')

    if not text:
        return jsonify({'error': 'Metin boş olamaz!'}), 400

    # Metni sınıflandır
    result = classifier(text)[0]
    return jsonify(result)

if __name__ == '__main__':
    # PyTorch'un CPU'da mı yoksa GPU'da mı çalıştığını kontrol edelim
    print(f"CUDA mevcut mu: {torch.cuda.is_available()}")
    print(f"Kullanılan cihaz: {'cuda' if torch.cuda.is_available() else 'cpu'}")
    
    # Gunicorn ile çalıştırma, Flask'ın dahili sunucusunu kullanmaktan daha iyidir
    # Gunicorn, 0.0.0.0:5000 üzerinde app'i dinler.
    app.run(host='0.0.0.0', port=5000)
  

4. Dockerfile Oluşturma (Çok Aşamalı Yapı ile):
Büyük NLP modelleri ve bağımlılıkları nedeniyle, çok aşamalı bir yapı ve potansiyel GPU desteği bu senaryoda idealdir.

# AŞAMA 1: Bağımlılıkları kurma ve modeli önbelleğe alma
FROM python:3.9-slim-buster AS builder

# Sistem bağımlılıklarını yükle (eğer özel bir şeye ihtiyaç duyulursa)
RUN apt-get update && apt-get install -y --no-install-recommends \
    git \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# requirements.txt dosyasını kopyala
COPY requirements.txt .

# Bağımlılıkları yükle
# --no-cache-dir ve -U pip'i güncelleyip önbellek olmadan yükleme yapar
RUN pip install --no-cache-dir -r requirements.txt

# Modelin indirilmesini ve önbelleğe alınmasını sağlayan geçici bir script çalıştır
# Bu, nihai imajda modelin zaten var olmasını sağlar ve ilk çalıştırmayı hızlandırır.
# Ortam değişkeni ile model adını belirleyebiliriz.
ENV MODEL_NAME=distilbert-base-uncased-finetuned-sst-2-english
RUN python -c "from transformers import pipeline; pipeline('sentiment-analysis', model='${MODEL_NAME}', tokenizer='${MODEL_NAME}')"

# AŞAMA 2: Üretim Aşaması
# Daha da hafif bir Python imajı kullanabiliriz, veya aynı slim-buster devam edebiliriz
FROM python:3.9-slim-buster

WORKDIR /app

# Önceki aşamadan sadece gerekli bağımlılıkları kopyala
COPY --from=builder /app/requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Önceden indirilmiş modeli ve tokenizer'ı kopyala
# transformers kütüphanesi modelleri genellikle ~/.cache/huggingface/hub dizinine kaydeder
COPY --from=builder /root/.cache/huggingface/ /root/.cache/huggingface/

# Uygulama kodunu kopyala
COPY app.py .

# Flask uygulamasının 5000 numaralı port üzerinden hizmet vereceğini belirtiyoruz
EXPOSE 5000

# Model adını ortam değişkeni olarak ayarla
ENV MODEL_NAME=distilbert-base-uncased-finetuned-sst-2-english

# Konteyner başlatıldığında çalıştırılacak varsayılan komut
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]
  

Senaryoya Özel Dockerfile İpuçları:

• Model Önbellekleme: AŞAMA 1'de transformers pipeline'ını çalıştırarak modelin ve tokenizer'ın Docker imajı oluşturulurken indirilmesini ve önbelleğe alınmasını sağlıyoruz. Bu sayede konteyner ilk kez başlatıldığında model indirme süresini ortadan kaldırır. Hugging Face modelleri genellikle /root/.cache/huggingface/ dizinine kaydedilir ve bu dizini AŞAMA 2'ye kopyalarız.
• GPU Desteği (Opsiyonel): Eğer bu modelin GPU'da çalışmasını isteseydik, FROM satırını nvidia/cuda:... tabanlı bir imajla değiştirmemiz ve requirements.txt içine torch yerine torch-cuda veya uygun TensorFlow GPU versiyonunu eklememiz gerekirdi.
• Ortam Değişkeni Kullanımı: MODEL_NAME gibi model adlarını ortam değişkenleri aracılığıyla yönetmek, Dockerfile'ı farklı modelleri dağıtmak için daha esnek hale getirir.
• Minimal İmaj Boyutu: slim-buster Python imajı ve çok aşamalı yapı, nihai imaj boyutunu mümkün olduğunca küçük tutmaya yardımcı olur. Model dosyaları hala bir miktar yer kaplasa da, gereksiz derleme araçlarından kaçınırız.

Bu senaryo, karmaşık YZ modellerinin bile Docker ile nasıl güvenilir, tutarlı ve optimize edilmiş bir şekilde dağıtılabileceğini göstermektedir. GitHub Actions ile birleştirildiğinde, bu süreç tamamen otomatikleştirilebilir ve YZ projelerinizin yaşam döngüsünü modern MLOps uygulamalarına uygun hale getirir.

Sonuç ve Sıkça Sorulan Sorular

Yapay zeka projelerinin geliştirilmesi kadar, onların güvenilir ve verimli bir şekilde dağıtılması da büyük önem taşır. Bu makale boyunca, Docker ve Dockerfile'ın bu süreçteki kritik rolünü, GitHub Actions ile entegrasyonunu ve ileri düzey optimizasyon tekniklerini detaylı bir şekilde ele aldık. Geliştirme ortamındaki "benim makinemde çalışıyor" sorunsalından, üretim ortamında ölçeklenebilir ve tutarlı YZ servisleri sunmaya kadar uzanan bu yolculukta, konteynerleştirmenin ne denli güçlü bir araç olduğunu gördük. Çok aşamalı yapılarla imaj boyutunu küçültmekten, GPU desteğini entegre etmeye ve güvenli uygulamalar geliştirmeye kadar birçok farklı başlık altında pratik bilgiler edindik. GitHub ile CI/CD iş akışları oluşturarak, YZ model güncellemelerinizin otomatik olarak derlenip dağıtılmasını sağlayabilir, böylece MLOps prensiplerini etkin bir şekilde uygulayabilirsiniz.

Kısacası, Docker ve GitHub entegrasyonu, YZ projelerinizin tüm yaşam döngüsünü basitleştirir, hızlandırır ve standartlaştırır. Bu sayede, geliştirme ekipleri daha verimli çalışabilir, operasyonel yük azalır ve kullanıcılarınıza sürekli olarak güncel ve güvenilir YZ servisleri sunabilirsiniz. Umarız bu makale, yapay zeka projelerinizi konteynerleştirme ve dağıtma yolculuğunuzda size sağlam bir başlangıç noktası sunmuştur.

Sıkça Sorulan Sorular