Docker Kullanarak Bir Uygulama Nasıl Konteynerleştirilir

Makine öğrenimi uygulamaları daha karmaşık hale geldikçe, modellerimizi geliştirmeden üretime taşımak sadece iyi kod yazmaktan ibaret değildir. Uygulamamızın farklı ortamlarda tutarlı şekilde çalışmasını sağlamak gerekir. Tam da burada konteynerleştirme devreye girer. Peki konteynerleştirme tam olarak nedir ve makine öğrenimi iş akışları için neden oyunun kurallarını değiştirir?

Konteynerleştirme, bir uygulamayı tüm bağımlılıkları, kütüphaneleri ve yapılandırmalarıyla birlikte bir konteyner adı verilen tek bir birim halinde paketlemenin hafif ve taşınabilir bir yoludur. Geleneksel sanal makinelerden (VM) farklı olarak konteynerler ana sistemin işletim sistemini paylaşır; bu da onları daha hızlı, daha verimli ve ölçeklendirmesi daha kolay hale getirir. 

Veri bilimciler ve ML mühendisleri için bu, yerel makinenizde bir model oluşturup uyumluluk sorunlarını dert etmeden bulutta, bir sunucuda veya bir çalışma arkadaşınızın dizüstü bilgisayarında her yerde dağıtabileceğiniz anlamına gelir.

Bu öğreticide Docker ve Kubernetes kullanarak bir makine öğrenimi uygulamasını konteynerleştirmeye bakacağız. Sonunda şunları yapmayı biliyor olacaksınız:

1. ML uygulamanız için bir Docker konteyneri oluşturmak.
2. Konteynerleştirilmiş uygulamanızı Kubernetes ile dağıtmak ve yönetmek.
3. Üretim ortamında ML uygulamanızı ölçeklendirmek ve izlemek.

Docker'a yeniyseniz, Sıfırdan Docker Öğrenme rehberimize göz atın. Ayrıca şu kursumuzu da alabilirsiniz: Docker ve Kubernetes ile Konteynerleştirme ve Sanallaştırma.  

Önkoşullar

Başlamadan önce Python, makine öğrenimi iş akışları ve komut satırıyla çalışma konusunda temel bir anlayışa sahip olmalısınız. Docker kavramlarına (ör. imajlar, konteynerler, temel komutlar) aşinalık tavsiye edilir; Kubernetes hakkında temel bilgi dağıtım ve ölçeklendirme için zorunlu olmasa da faydalıdır. 

Konteynerleştirilmiş Uygulama Nedir?

Konteynerleştirilmiş bir uygulama, tüm bağımlılıkları, kütüphaneleri ve yapılandırmalarıyla birlikte bir konteyner adı verilen tek, hafif bir birim halinde paketlenmiş bir yazılım uygulamasıdır. Makine öğrenimi uygulamaları için bu; eğitilmiş modelinizden, bağlı olduğu Python kütüphanelerine kadar her şeyi paketleyerek uygulamanızın her yerde aynı şekilde çalışmasını sağlamak demektir.

Geleneksel uygulama ve Konteynerleştirilmiş uygulama karşılaştırması

Makine öğrenimi uygulamaları için konteynerleştirme neden önemlidir

Makine öğrenimi uygulamaları geliştirirken muhtemelen “benim makinemde çalışıyor” sorunuyla karşılaştınız. Belki modeliniz dizüstü bilgisayarınızda kusursuz çalışıyor ama buluta dağıtınca başarısız oluyor ya da bir çalışma arkadaşınız, farklı scikit-learn veya TensorFlow sürümleri yüklü olduğu için sonuçlarınızı tekrarlayamıyor. 

Konteynerleştirme, uygulamanız için tutarlı ve izole bir ortam oluşturarak bu sorunları çözer. Makine öğrenimi için konteynerleştirilmiş uygulamaları iyi yapan noktalar şunlardır:

1. Tutarlılık: Uygulamanız geliştirmeden test ve üretime kadar farklı ortamlarda aynı şekilde davranır.
2. İzolasyon: Her konteyner kendi ortamında çalışır; farklı uygulamalar veya bağımlılıklar arasındaki çatışmaları önler.
3. Taşınabilirlik: Konteynerler, yerel makineniz, bir bulut hizmeti veya şirket içi bir sunucu gibi konteynerleştirmeyi destekleyen her platformda çalışabilir.
4. Ölçeklenebilirlik: Daha fazla isteği karşılamanız mı gerekiyor? Birden fazla örnek çalıştırarak uygulamanızı yatayda kolayca ölçeklendirebilirsiniz.

Konteynerler ve sanal makineler

Hem konteynerler hem de sanal makineler (VM) uygulamaları izole etmek için kullanılır; ancak çalışma şekilleri ve kullanım senaryoları bakımından önemli ölçüde farklıdır. İşte temel farkların ve avantajların bir özeti:

Makine öğrenimi uygulamaları için bu farklar önemlidir. Daha fazla tahmini karşılamak için modelinizi ölçeklendirmeniz gerektiğinde veya A/B testi için modelinizin birden çok sürümünü dağıtmak istediğinizde, konteynerler ihtiyaç duyduğunuz çevikliği ve kaynak verimliliğini sağlar.

Konteynerleştirme ve sanallaştırma hakkında daha fazla bilgi edinmek için şu öğrenme yoluna göz atın: Docker ve Kubernetes ile Konteynerleştirme ve Sanallaştırma.

Bir Makine Öğrenimi Uygulaması Nasıl Konteynerleştirilir 

Aşağıdaki bölümlerde bir uygulamanın nasıl konteynerleştirileceğine dair adım adım bir rehber sunduk: 

1. Ortamınızı hazırlama

Makine öğrenimi uygulamamızı konteynerleştirmeye başlamadan önce gerekli araçları kurmamız ve ortamımızı hazırlamamız gerekir. Bu bölümde Docker'ı kurma ve basit bir makine öğrenimi uygulamasını konteynerleştirmeye hazırlama konusunda size yol göstereceğiz.

İhtiyacınız olacak araçlar

Bir makine öğrenimi uygulamasını konteynerleştirmek için şu araçlara ihtiyacınız olacak:

1. Docker: Konteyner oluşturma, dağıtma ve çalıştırma platformu.
2. Kubernetes (opsiyonel): Ölçekte konteynerleri yönetmeye yarayan bir orkestrasyon aracı. (Bunu öğreticinin ilerleyen kısımlarında ele alacağız.)

Docker'ı kurarak başlayalım.

Adım 1: Docker'ı kurma

Docker; Windows, macOS ve Linux için mevcuttur. Aşağıda sisteminize Docker kurmanın adımları yer almaktadır.

Windows/macOS için:

1. Docker web sitesine gidin.
2. Docker Desktop'ı indirin ve kurun.
3. Yükleyicinin sunduğu talimatları izleyin.

Linux (Ubuntu/Debian) için:

Docker'ı kurmak için terminalinizi açıp aşağıdaki komutları çalıştırın:

# Update your package list
sudo apt-get update

# Install required packages to allow apt to use a repository over HTTPS
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common

# Add Docker’s official GPG key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add the Docker repository to your system
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Update your package list again
sudo apt-get update

# Install Docker
sudo apt-get install -y docker-ce docker-ce-cli containerd.io

# Verify Docker installation
sudo docker --versionAltyapı:

Bu kurulum süreci, sisteminize Docker deposunu ekler, GPG anahtarıyla doğrular ve Docker motorunu komut satırı araçlarıyla birlikte kurar.

Adım 2: Docker kurulumunu doğrulama 

Docker kurulduktan sonra, komut isteminde aşağıdaki komutu çalıştırarak doğru şekilde çalıştığını doğrulayın:

# Check Docker version
docker --version

# Run hello-world container
docker run hello-worldAltyapı:

Bu, hafif bir test imajını indirir ve bir konteyner olarak çalıştırır. Başarılı olursa, aşağıda gösterildiği gibi kurulumunuzun düzgün çalıştığını doğrulayan bir karşılama mesajı görürsünüz:

Hello from Docker!Altyapı:

2. Makine öğrenimi uygulamanızı hazırlama

Artık Docker kurulduğuna göre, basit bir makine öğrenimi uygulamasını konteynerleştirmeye hazırlayalım. Bu öğreticide, önceden eğitilmiş bir modeli yükleyen ve bir Flask API üzerinden tahmin sunan temel bir Python betiği kullanacağız.

Adım 1: Basit bir ML uygulaması oluşturun

Projeniz için yeni bir dizin oluşturun ve aşağıdaki dosyaları ekleyin:

1. app.py: Flask API aracılığıyla tahmin sunan bir Python betiği.
2. requirements.txt: Python bağımlılıklarını listeleyen bir dosya.

app.py için kod burada:

# Import required libraries
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from flask import Flask, request, jsonify
import numpy as np

# Initialize Flask app
app = Flask(__name__)

# Load and prepare the model
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

@app.route('/predict', methods=['POST'])
def predict():
    # Get features from request
    features = request.json['features']
    
    # Make prediction
    prediction = model.predict([features])
    
    return jsonify({'prediction': int(prediction[0]),
                   'class_name': iris.target_names[prediction[0]]})

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

Kod, Iris veri kümesini yükler, bir Rastgele Orman sınıflandırıcısı eğitir ve özellik değerlerini kabul edip tahminleri döndüren bir Flask API uç noktası kurar. Bunu konteynerleştirmeye uygun hale getirmek için bir web hizmeti olarak oluşturuyoruz.

Adım 2: requirements.txt oluşturun

requirements.txt dosyası, betiği çalıştırmak için gereken Python kütüphanelerini listeler. Bu dosyayı app.py ile aynı dizinde oluşturun:

# requirements.txt
scikit-learn==1.3.0
numpy==1.24.3
flask==2.0.1Altyapı:

Bu, uygulamamızın ihtiyaç duyduğu Python paketlerinin tam sürümlerini belirtir. Sürümlerin sabitlenmesi, konteynerleştirilmiş uygulamamızın tutarlı ve tekrarlanabilir olmasını sağlar.

Artık ortamımız kuruldu ve ML uygulamamız hazır, ilk Docker konteynerimizi oluşturmaya geçebiliriz. Bir sonraki bölümde bir Dockerfile yazacak ve Flask tabanlı ML uygulamamız için bir Docker imajı oluşturacağız.

3. İlk Docker konteynerinizi oluşturma

Makine öğrenimi uygulamamız hazır olduğuna göre sıradaki adım Docker kullanarak onu konteynerleştirmektir. Bu, bir Docker imajı oluşturma talimatlarını içeren bir Dockerfile oluşturmayı içerir. İmaj oluşturulduktan sonra, bunu bir konteyner olarak çalıştırabiliriz.

Dockerfile örneği: Bir Dockerfile yazma

Bir Dockerfile, bir imajı birleştirmek için gereken tüm komutları içeren bir metin belgesidir. Flask tabanlı ML uygulamamız için nasıl oluşturulacağı şöyle:

1. app.py ve requirements.txt ile aynı dizinde, Dockerfile adlı (dosya uzantısı olmayan) yeni bir dosya oluşturun.
2. Aşağıdaki içeriği Dockerfile dosyasına ekleyin:

# Use an official Python runtime as the base image
FROM python:3.9-slim

# Set the working directory in the container
WORKDIR /app

# Copy the requirements file into the container
COPY requirements.txt .

# Install the Python dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the application code into the container
COPY . .

# Expose port 5000 for the Flask app
EXPOSE 5000

# Define the command to run the Flask app
CMD ["python", "app.py"]Altyapı:

Açıklama:

• FROM python:3.9-slim: Resmi Python 3.9 slim imajını temel imaj olarak kullanıyoruz. Slim sürümü hafiftir ve konteynerleştirilmiş uygulamalar için idealdir.
• WORKDIR /app: Konteyner içinde çalışma dizinini /app olarak ayarlar. Sonraki tüm komutlar bu dizinden çalışır.
• COPY requirements.txt .: requirements.txt dosyasını yerel makinenizden konteynere kopyalar.
• RUN pip install --no-cache-dir -r requirements.txt: requirements.txt'te listelenen Python bağımlılıklarını kurar. --no-cache-dir bayrağı, önbelleği saklamayarak imaj boyutunu küçültür.
• COPY . .: Yerel makinenizdeki geçerli dizindeki tüm dosyaları konteynerdeki /app dizinine kopyalar.
• EXPOSE 5000: Flask uygulamamızın dinlediği 5000 portunu dışa açar.
• CMD ["python", "app.py"]: Konteyner başladığında Flask uygulamasını çalıştıracak komutu tanımlar.

Docker imajını oluşturma ve test etme

Dockerfile hazır olduğuna göre, artık Docker imajını oluşturup bir konteyner olarak çalıştırabiliriz. 

Adım 1: Docker imajını oluşturun

Docker imajını oluşturmak için terminalde aşağıdaki komutu çalıştırın:

docker build -t ml-flask-app .Altyapı:

Bu komut, geçerli dizindeki Dockerfile'dan bir Docker imajı oluşturur. -t ml-flask-app bayrağı, imajı ml-flask-app adıyla etiketler; böylece daha sonra referans vermek kolaylaşır.

Adım 2: Docker konteynerini çalıştırın

İmaj oluşturulduktan sonra, aşağıdaki komutla bir konteyner olarak çalıştırın:

docker run -p 5000:5000 ml-flask-appAltyapı:

Bu komut, ml-flask-app imajından bir konteyner başlatır. -p 5000:5000 bayrağı, yerel makinenizdeki 5000 portunu konteynerdeki 5000 portuna eşler; böylece Flask uygulamasına tarayıcıdan veya curl gibi bir araçla erişebilirsiniz.

Adım 3: Konteynerleştirilmiş uygulamayı test edin

Yeni bir terminal penceresi açın ve konteyner içinde çalışan Flask uygulamasına bir test isteği gönderin:

curl -X POST -H "Content-Type: application/json" -d '{"input": [5.1, 3.5, 1.4, 0.2]}' http://localhost:5000/predictAltyapı:

Şuna benzer bir yanıt görmelisiniz:

{
  "prediction": 0
}Altyapı:

Bu, konteynerleştirilmiş Flask uygulamasının başarıyla çalıştığı ve tahmin sunmaya hazır olduğu anlamına gelir.

Yaygın sorunları ayıklama

Konteyneri oluştururken veya çalıştırırken sorun yaşarsanız, işte sorun gidermenize yardımcı olacak bazı ipuçları:

Docker günlüklerini kontrol edin:Çalışan bir konteynerin günlüklerini görmek için şu komutu kullanın:

docker logs <container_id>Altyapı:

Dockerfile söz dizimini doğrulayın:Dockerfile'da yazım ya da söz dizimi hatası olmadığını iki kez kontrol edin.

Port çatışmalarını kontrol edin:Yerel makinenizde 5000 portunun zaten kullanımda olmadığından emin olun. Eğer öyleyse, konteyneri farklı bir porta şu şekilde eşleyebilirsiniz:

docker run -p 5001:5000 ml-flask-appAltyapı:

İmajı yeniden oluşturun:

Dockerfile veya uygulama kodunda değişiklik yaparsanız, şu komutla imajı yeniden oluşturun:

docker build -t ml-flask-app .Altyapı:

Docker konteynerimizi başarıyla oluşturup test ettiğimize göre sıradaki adım konteynerleştirilmiş uygulamayı yönetmeyi ve ölçeklendirmeyi öğrenmektir. Bir sonraki bölümde, ML uygulamamızı dağıtmak ve ölçeklendirmek için Kubernetes'i nasıl kullanacağımızı inceleyeceğiz.

Daha fazla Docker projesi için Başlangıçtan İleri Seviyeye 10 Docker Proje Fikri rehberimize göz atın.

Konteynerleştirilmiş Uygulamanızı Çalıştırma

Docker konteynerimizi oluşturduğumuza göre, onu etkili bir şekilde nasıl yöneteceğimize bakalım. Bu bölüm, konteynerleri başlatma, durdurma ve inceleme için temel Docker komutlarının yanı sıra günlükler ve portlarla çalışma adımlarında size yol gösterecek.

Konteynerleri yönetmek için Docker kullanma

Docker, konteynerleri yönetmek için güçlü bir komut seti sağlar. En yaygın kullanılanlara göz atalım.

Bir konteyner başlatma

Bir imajdan konteyner başlatmak için docker run komutunu kullanın. Örneğin:

docker run -p 5000:5000 ml-flask-appAltyapı:

Bu komut, ml-flask-app imajından bir konteyner başlatır ve yerel makinenizdeki 5000 portunu konteynerdeki 5000 portuna eşler.

Konteyneri arka planda (detached mode) çalıştırmak isterseniz -d bayrağını ekleyin:

docker run -d -p 5000:5000 ml-flask-appAltyapı:

Bu, konteynerin arka planda çalışmasına olanak tanır ve terminalinizi serbest bırakır.

Bir konteyneri durdurma

Çalışan bir konteyneri durdurmak için önce şu komutla konteyner kimliğini bulun:

docker psAltyapı:

Bu, kimlikleri, adları ve diğer ayrıntılarla birlikte tüm çalışan konteynerleri listeler. Konteyner kimliğine sahip olduğunuzda, şu komutla konteyneri durdurun:

docker stop <container_id>Altyapı:

Örneğin:

docker stop a1b2c3d4e5f6Altyapı:

Bir konteyneri inceleme

Bir konteyner hakkında ayrıntılı bilgi görmek için docker inspect komutunu kullanın:

docker inspect <container_id>Altyapı:

Bu komut; konteynerin ağ ayarları, bağlı birimler ve ortam değişkenleri gibi ayrıntıları içeren JSON çıktısı sağlar.

Konteynerleri listeleme

Tüm konteynerleri (hem çalışan hem durdurulmuş) görmek için şunu kullanın:

docker ps -aAltyapı:

Bu, konteynerlerinizin durumunu kontrol etmek ve konteyner kimliklerini bulmak için faydalıdır.

Günlükler ve portlarla çalışma

Günlükler ve portlar, konteynerleştirilmiş uygulamamızı hata ayıklama ve erişim için kritik öneme sahiptir. Nasıl çalışılacağına bakalım.

Konteyner günlüklerini görüntüleme

Çalışan bir konteynerin günlüklerini görüntülemek için şunu kullanın:

docker logs <container_id>Altyapı:

Örneğin:

docker logs a1b2c3d4e5f6Altyapı:

Bu, uygulamanızın çıktısını; konsola yazdırılan hata ve iletiler dahil olmak üzere gösterir. Günlükleri gerçek zamanlı olarak izlemek isterseniz (tail -f gibi), -f bayrağını ekleyin:

docker logs -f <container_id>Altyapı:

Port eşleme

Bir konteyneri çalıştırırken, konteyner portlarını yerel makinenize -p bayrağıyla eşleyebilirsiniz. Örneğin:

docker run -p 5000:5000 ml-flask-appAltyapı:

Bu, konteynerdeki 5000 portunu yerel makinenizdeki 5000 portuna eşler. 5000 portu zaten kullanımda ise, şu şekilde farklı bir porta eşleyebilirsiniz:

docker run -p 5001:5000 ml-flask-appAltyapı:

Artık Flask uygulamanız http://localhost:5001 adresinden erişilebilir olacaktır.

Port bağlarını kontrol etme

Çalışan bir konteynere hangi portların eşlendiğini görmek için şunu kullanın:

docker port <container_id>Altyapı:

Bu, konteynerin port eşlemelerini listeler ve bağlantı sorunlarının hata ayıklamasında yardımcı olur. Bir sonraki bölümde, konteynerleştirilmiş ML uygulamamızı Kubernetes üzerinde nasıl dağıtacağımıza ve ölçekte nasıl yöneteceğimize bakacağız.

Kubernetes ile Ölçeklendirme

Uygulamamız konteynerleştirildiğinde, onu Kubernetes ile dağıtabiliriz. Kubernetes, konteynerleştirilmiş uygulamaların dağıtımını, ölçeklendirilmesini ve yönetimini otomatikleştirir; büyük ölçekli iş yüklerini ele almayı kolaylaştırır. Bu bölümde ML uygulamamızı bir Kubernetes kümesine nasıl dağıtacağımıza bakacağız.

Konteynerleri Kubernetes üzerinde dağıtma

Kubernetes, uygulamanızın istenen durumunu tanımlamak için YAML dosyaları kullanır. Bu dosyalar, konteynerlerinizin nasıl dağıtılacağını, ölçeklendirileceğini ve yönetileceğini açıklar. Flask tabanlı ML uygulamamız için bir Kubernetes dağıtımı oluşturarak başlayalım.

Adım 1: Bir Kubernetes deployment YAML dosyası yazın

ml-flask-app-deployment.yaml adlı bir dosya oluşturun ve aşağıdaki içeriği ekleyin:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-flask-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-flask-app
  template:
    metadata:
      labels:
        app: ml-flask-app
    spec:
      containers:
      - name: ml-flask-app
        image: ml-flask-app
        ports:
        - containerPort: 5000Altyapı:

Bu YAML dosyası şunları tanımlar:

• ml-flask-app adlı bir Deployment.
• Yüksek erişilebilirlik sağlayan üç kopya.
• Daha önce oluşturduğumuz ml-flask-app imajını kullanan bir konteyner.
• Flask uygulamamızın dinlediği 5000 containerPort.

Adım 2: Uygulamayı dağıtın

Uygulamayı Kubernetes üzerinde dağıtmak için kubectl apply komutunu kullanın:

kubectl apply -f ml-flask-app-deployment.yamlAltyapı:

Bu komut, YAML dosyasında tanımlanan kaynakların oluşturulmasını Kubernetes'e bildirir. Dağıtımın durumunu şu komutla kontrol edebilirsiniz:

kubectl get deploymentsAltyapı:

Bu, dağıtımınızın durumunu ve çalışan kopya sayısı gibi bilgileri gösterir.

Adım 3: Uygulamayı dışa açın

Uygulamayı Kubernetes kümesinin dışından erişilebilir kılmak için bir Service oluşturun. ml-flask-app-service.yaml adlı bir dosya oluşturup aşağıdaki içeriği ekleyin:

apiVersion: v1
kind: Service
metadata:
  name: ml-flask-app-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 5000
  selector:
    app: ml-flask-appAltyapı:

Bu YAML dosyası şunları tanımlar:

• ml-flask-app-service adlı bir Service.
• Uygulamayı internete açan LoadBalancer türü.
• 80 (harici) portundan 5000 (dahili) portuna eşleme.

Servisi şu komutla uygulayın:

kubectl apply -f ml-flask-app-service.yamlAltyapı:

Servisin durumunu şu komutla kontrol edebilirsiniz:

kubectl get servicesAltyapı:

Bu, uygulamanıza erişilebilen harici IP adresini gösterir.

Ölçeklendirme ve izleme

Kubernetes, uygulamanızı ölçeklendirmeyi ve performansını izlemeyi kolaylaştırır. Nasıl yapılacağına bakalım.

Uygulamayı ölçeklendirme

Uygulamanızı ölçeklendirmek için dağıtımdaki kopya sayısını güncelleyin. Örneğin 5 kopyaya ölçeklendirmek için şu komutu çalıştırın:

kubectl scale deployment ml-flask-app --replicas=5Altyapı:

Ayrıca YAML dosyasındaki replicas alanını güncelleyip tekrar uygulayabilirsiniz:

spec:
  replicas: 5Altyapı:

Sonra şunu çalıştırın:

kubectl apply -f ml-flask-app-deployment.yamlAltyapı:

Uygulamayı izleme

Kubernetes, uygulamamızı izlemek için çeşitli araçlar sunar. Uygulamamızı izlemek için bazı araçlara bakalım.

Belirli bir pod'un günlüklerini görüntülemek için kubectl logs kullanın:

kubectl logs <pod_name>
 Altyapı:

Pod'larınızın durumunu kontrol etmek için kubectl get pods kullanın:

kubectl get podsAltyapı:

CPU ve bellek kullanımını görmek için kubectl top kullanın:

kubectl top podsAltyapı:

Otomatik ölçeklendirme

Kubernetes, CPU veya bellek kullanımına göre pod sayısını otomatik olarak ölçeklendiren Yatay Pod Otomatik Ölçekleyici'yi (HPA) de destekler. Otomatik ölçeklendirmeyi etkinleştirmek için şunu çalıştırın:

kubectl autoscale deployment ml-flask-app --cpu-percent=50 --min=3 --max=10Altyapı:

Bu, dağıtımın CPU kullanımına göre 3 ile 10 kopya arasında ölçeklenmesini sağlar.

Kubernetes dağıtımları için en iyi uygulamalar

Uygulamaları Kubernetes üzerinde dağıtırken izlenmesi gereken bazı en iyi uygulamalar şunlardır.

Kaynak limitleri kullanın

Kaynak tükenmesini önlemek için konteynerleriniz için CPU ve bellek limitleri tanımlayın:

resources:
   limits:
     cpu: "1"
     memory: "512Mi"Altyapı:

Liveness ve readiness probe'ları kullanın

Uygulamanızın doğru şekilde çalıştığından emin olmak için sağlık kontrolleri ekleyin:

livenessProbe:
  httpGet:
    path: /health
    port: 5000
  initialDelaySeconds: 5
  periodSeconds: 10
readinessProbe:
  httpGet:
    path: /ready
    port: 5000
  initialDelaySeconds: 5
  periodSeconds: 10
   Altyapı:

Ad alanları (namespace) kullanın

Çakışmaları önlemek için kaynaklarınızı ad alanları kullanarak düzenleyin:

kubectl create namespace ml-app
kubectl apply -f ml-flask-app-deployment.yaml -n ml-appAltyapı:

Bir sonraki bölümde, Dockerfile'ları optimize etme, bağımlılıkları yönetme ve güvenliği sağlama ipuçlarını ele alacağız.

ML Uygulamalarını Konteynerleştirmek için En İyi Uygulamalar

Makine öğrenimi uygulamalarını konteynerleştirmek; büyük bağımlılıkları yönetme, tekrarlanabilirliği sağlama ve güvenliği sürdürme gibi kendine özgü zorluklarla birlikte gelir. Bu zorlukların üstesinden gelmenize ve sağlam konteynerleştirilmiş ML uygulamaları oluşturmanıza yardımcı olacak bazı en iyi uygulamalar aşağıdadır.

Dockerfile'ları optimize etme

İyi optimize edilmiş bir Dockerfile, derleme sürelerini ve imaj boyutlarını önemli ölçüde azaltabilir. Dockerfile'larınızı optimize etmek için bazı ipuçları:

Çok aşamalı derlemeler kullanın

Çok aşamalı derlemeler, tek bir Dockerfile içinde birden fazla FROM ifadesi kullanmamıza olanak tanır. Bu, ara aşamalardaki gereksiz dosya ve bağımlılıkları atarak nihai imaj boyutunu küçültmeye yardımcı olur. Örneğin:

# Stage 1: Build the application
FROM python:3.9-slim as builder

WORKDIR /app
COPY requirements.txt .
RUN pip install --user -r requirements.txt

COPY . .

# Stage 2: Create the final image
FROM python:3.9-slim

WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY --from=builder /app .

ENV PATH=/root/.local/bin:$PATH
EXPOSE 5000
CMD ["python", "app.py"]Altyapı:

Bu Dockerfile:

• Bağımlılıkları kurmak ve uygulamayı derlemek için bir builder aşaması kullanır.
• Yalnızca gerekli dosyaları (örn. kurulu bağımlılıklar ve uygulama kodu) nihai imaja kopyalayarak boyutu küçültür.

Katmanları en aza indirin

Dockerfile'daki her talimat yeni bir katman oluşturur. Katman sayısını en aza indirmek ve imaj boyutunu azaltmak için:

• Birden fazla RUN komutunu && kullanarak tek bir komutta birleştirin.
• ADD'in ekstra işlevine ihtiyaç duymadığınız sürece ADD yerine COPY kullanın.

Örneğin:

RUN apt-get update && \
    apt-get install -y --no-install-recommends build-essential && \
    rm -rf /var/lib/apt/lists/*Altyapı:

Hafif temel imajlar kullanın

python:3.9 gibi daha büyükler yerine python:3.9-slim gibi hafif temel imajları tercih edin. Slim imajlar yalnızca gerekli paketleri içerir ve toplam imaj boyutunu azaltır.

Bağımlılıkları ve tekrarlanabilirliği yönetme

Tekrarlanabilirlik, makine öğrenimi iş akışlarında kritiktir. Konteynerleştirilmiş uygulamalarınızda bağımlılıkları nasıl yöneteceğiniz ve tekrarlanabilirliği nasıl sağlayacağınız aşağıdadır.

requirements.txt veya pipenv kullanın

Tüm Python bağımlılıklarınızı bir requirements.txt dosyasında listeleyin veya bunları yönetmek için pipenv kullanın. Örneğin:

# requirements.txt
scikit-learn==1.3.0
numpy==1.24.3
Flask==2.3.2Altyapı:

Bağımlılıkları Dockerfile içinde kurun:

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

Bağımlılık sürümlerini sabitleyin

Beklenmedik değişiklikleri önlemek için bağımlılıklarınızın sürümlerini her zaman sabitleyin. Örneğin:

scikit-learn==1.3.0
numpy==1.24.3
Flask==2.3.2Altyapı:

Yapılandırma için ortam değişkenleri kullanın

Değerleri kodun içine gömmek yerine uygulamayı yapılandırmak için ortam değişkenlerini kullanın. Bu, konteynerinizi daha esnek hale getirir ve farklı ortamlarda yapılandırmayı kolaylaştırır. Örneğin:

ENV MODEL_PATH=/app/models/model.pklAltyapı:

Daha sonra uygulamanızda ortam değişkenine erişin:

import os
model_path = os.getenv('MODEL_PATH')Altyapı:

Güvenlik hususları

Güvenlik, konteynerleştirilmiş uygulamaların kritik bir yönüdür. ML uygulamalarınızı güvenli hale getirmek için bazı en iyi uygulamalar:

Kök kullanıcı (root) olarak çalıştırmaktan kaçının

Konteynerleri root kullanıcısı olarak çalıştırmak sisteminizi güvenlik risklerine maruz bırakabilir. Bunun yerine, root olmayan bir kullanıcı oluşturun ve konteyneri o kullanıcıyla çalıştırın. Örneğin:

# Create a non-root user
RUN useradd -m myuser

# Switch to the non-root user
USER myuser

# Set the working directory
WORKDIR /home/myuser/app

# Copy the application code
COPY --chown=myuser:myuser . .

# Run the application
CMD ["python", "app.py"]Altyapı:

İmajları güvenlik açıklarına karşı tarayın

Docker imajlarınızı güvenlik açıklarına karşı taramak için Trivy veya Clair gibi araçlar kullanın. Örneğin, bir imajı Trivy ile taramak için:

trivy image ml-flask-appAltyapı:

Gizli bilgileri güvenli yönetin

API anahtarları veya veritabanı kimlik bilgileri gibi hassas bilgileri asla Dockerfile'ınıza veya uygulama kodunuza gömmeyin. Bunun yerine, hassas verileri yönetmek için Kubernetes Secrets veya Docker Secrets kullanın. Örneğin Kubernetes'te:

apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
data:
  api_key: <base64-encoded-api-key>Altyapı:

Ardından, dağıtımınızda gizliyi bir ortam değişkeni olarak bağlayın:

env:
- name: API_KEY
  valueFrom:
    secretKeyRef:
      name: my-secret
      key: api_keyAltyapı:

Test ve hata ayıklama

Konteynerleştirilmiş uygulamanızın beklendiği gibi çalıştığından emin olmak için test ve hata ayıklama esastır. İşte bazı ipuçları:

Yerelde test edin

Kubernetes'e dağıtmadan önce, Docker kullanarak konteynerinizi yerelde test edin. Örneğin:

docker run -p 5000:5000 ml-flask-appAltyapı:

Hata ayıklama için günlükleri kullanın

Konteynerleştirilmiş uygulamanızdaki sorunları ayıklamak için docker logs veya kubectl logs kullanın. Örneğin:

docker logs <container_id>
kubectl logs <pod_name>Altyapı:

Testleri otomatikleştirin

Konteynerleştirilmiş uygulamalarınızın test ve dağıtımını otomatikleştirmek için CI/CD boru hatları kullanın. GitHub Actions, GitLab CI veya Jenkins gibi araçlar otomatik iş akışları kurmamıza yardımcı olabilir.

Bu en iyi uygulamaları izleyerek verimli, tekrarlanabilir ve güvenli konteynerleştirilmiş makine öğrenimi uygulamaları oluşturabiliriz. Dockerfile'ları optimize etmekten bağımlılıkları yönetmeye ve güvenliği sağlamaya kadar bu stratejiler, ML iş akışlarımızı düzene sokmamıza ve modelleri güvenle dağıtmamıza yardımcı olacaktır.

Sonuç

Docker ve Kubernetes ile makine öğrenimi uygulamalarını konteynerleştirmek; dağıtımı kolaylaştırır, tekrarlanabilirliği garanti eder ve ölçeklenebilirliği artırır. Dockerfile'ları optimize etmek, bağımlılıkları yönetmek ve güvenliği önceliklendirmek gibi en iyi uygulamaları izleyerek sağlam, verimli ve güvenli ML iş akışları oluşturabiliriz.

Konteynerleştirme hakkında öğrenmeye devam etmek ve makine öğrenimi iş akışlarınızı geliştirmek için şu kurslara göz atın:

• Introduction to Docker Kursu
• Intermediate Docker Kursu
• Introduction to Kubernetes Kursu
• Veri Bilimi için Docker: Bir Giriş
• Python ile Bir Makine Öğrenimi Bilim İnsanı Olun
• Python ile Makine Öğrenimi Temelleri Öğrenme Yolu