MLOps için Jenkins: Eksiksiz Bir CI/CD Eğitimi

Windows 11 Üzerinde Jenkins Kurulumu

Jenkins’i Linux ve macOS’a kolayca kurabiliriz. Ancak Windows’a kurulum birkaç adım gerektirir. Bu adımlar; Java Geliştirme Seti’nin kurulmasını, yerel güvenlik ilkesinin ayarlanmasını, Jenkins’in bir etki alanı kullanıcısı ile kurulmasını ve Jenkins sunucusunun başlatılmasını içerir.

OpenJDK’nın kurulması

Önce Java’yı kuralım. Adoptium sitesine gidip Windows 11 için en güncel LTS sürümünü indirmemiz gerekiyor.

Neden OpenJDK kurmalıyız? Jenkins, çalışmak için bir Java Çalışma Ortamı’na (JRE) veya Java Geliştirme Seti’ne (JDK) ihtiyaç duyan Java tabanlı bir uygulamadır.

Görsel kaynağı: Adoptium

OpenJDK’yı varsayılan değerlerle kurun; yalnızca “JAVA_HOME değişkenini ayarla veya geçersiz kıl” seçeneğini işaretlememiz gerekir.

Kurulum tamamlandıktan sonra, terminal penceresinde java -version yazarak doğru kurulduğunu kontrol edebiliriz:

“Hizmet olarak oturum aç” için bir kullanıcı hesabı ayarlama

Jenkins’i kurmak için, yükleyiciye kullanıcı oturumu açma erişimi vermek üzere “Yerel Güvenlik İlkesi”ni değiştirmeniz gerekir. Bunun için klavyenizde Win + R tuşlarına basın, “secpol.msc” yazın ve Enter’a basın. Ardından “Yerel İlkeler” > “Kullanıcı Hakları Ataması” > “Hizmet olarak oturum aç” yolunu izleyin.

Yeni bir pencereye yönlendirileceğiz; burada Windows kullanıcı adımızı yazıp “Adları Denetle” düğmesine tıklayacağız. Sonrasında “Tamam”a basıp “Yerel Güvenlik İlkesi” penceresinden çıkın.

Jenkins’in kurulması

jenkins.io web sitesine gidip Jenkins için Windows Yükleyici paketini indirin.  

Görsel kaynağı: jenkins.io

“Hizmeti yerel veya etki alanı kullanıcısı olarak çalıştır” penceresine geldiğimizde Windows kullanıcı adınızı ve parolanızı yazın, ardından “Kimlik Bilgilerini Sına” düğmesine basın. Onaylanırsa “İleri”ye tıklayın.

Diğer her şeyi varsayılan bırakın ve kurulumu tamamlayın. Yapılandırmanın tamamlanması birkaç dakika sürebilir.

Jenkins sunucusunu başlatma

Jenkins sunucusunu başlatmak basittir. Windows tuşuna tıklayıp “Hizmetler”i aratmamız yeterli. Hizmetler penceresinde Jenkins’i bulun ve üstteki oynat düğmesine tıklayın.

Varsayılan olarak Jenkins https://localhost:8080/ adresinde çalışır. Panoya erişmek için bu URL’yi tarayıcıya yapıştırmanız yeterlidir. Jenkins panosuna girmek için yönetici parolasını yazmanız gerekir.

Varsayılan yönetici parolasını almak için Jenkins dizinine gidin ve Jenkins.err.log dosyasını bulun ve açın.

Oluşturulan parolayı bulmak için Jenkins hata dosyasını aşağı kaydırın. Kopyalayıp yönetici parolası giriş kutusuna yapıştırın.

Bundan sonra sunucu, gerekli araç ve uzantıları kurmak için birkaç dakika alacaktır.

Sunucu kurulumu tamamlandıktan sonra bizden yeni bir kullanıcı oluşturmamızı isteyecek. Gerekli bilgileri girin ve “Kaydet ve Devam Et” düğmesine tıklayın.

Farklı Jenkins ardışık düzenleri oluşturup görüntüleyip çalıştıracağımız panele yönlendirileceğiz. 

Jenkins’te Bir Aracı Oluşturma

Düğümler (nodes) olarak da bilinen aracı (agent) lar, Jenkins ana sunucusunun gönderdiği işleri yürütmek üzere yapılandırılmış makinelerdir. Bu aracıların görevi, ardışık düzenleri çalıştıracak ortamı ve hesaplama gücünü sağlamaktır. Varsayılan olarak bir Windows 11 aracı mevcuttur; ancak her zaman özelleştirilmiş seçeneklerle kendi aracımızı oluşturabiliriz.

Aracıları ayarlama

Ana panoda “Jenkins’i Yönet” seçeneğine tıklayın ve ardından aşağıda gösterildiği gibi “Aracı ayarla” düğmesine tıklayın. Alternatif olarak, aracı oluşturup yönetmek için “Düğümler” düğmesine de tıklayabilirsiniz.

Aracının adını yazın ve “Kalıcı Aracı” türünü seçin. 

Lütfen aracının dosya ve günlüklerinin kaydedileceği bir dizin sağladığınızdan emin olun. Bir etiket ekleyin ve kalan ayarları varsayılan bırakın. Ardışık düzeni oluştururken görevleri çalıştırmak için aracı etiketini kullanacağız.

Aracıyı yerelde çalıştırma

“Kaydet” düğmesine basıldığında, işletim sistemimize bağlı olarak uygun komutu kopyalayıp terminale yapıştırmamızı söyleyen bir uyarı görünecek.

curl.exe -sO http://localhost:8080/jnlpJars/agent.jar & java -jar agent.jar -url http://localhost:8080/ -secret 1a30c62de92630dbcc1e2f19aaf482057e6170ced6835355447bc4ba4eefb76a -name "DC Agent 1" -webSocket -workDir "/home/Jenkins"Altyapı:

Komutu terminale yapıştırıp çalıştırdıktan sonra, benim örneğimde DC Agent 1 olan aracımızın arka planda çalıştığını belirten bir başarı mesajı göreceğiz.

Aracının çalışıp çalışmadığını ve bir işi yürütmeye hazır olup olmadığını kontrol etmek için Jenkins panosuna gidin, “Jenkins’i Yönet”e tıklayın ve ardından aracının durumunu görmek için “Düğümler” düğmesine tıklayın.

Basit Bir Jenkins Ardışık Düzeni Oluşturma 

Jenkins ardışık düzeni, modellerin eğitimine, değerlendirilmesine ve dağıtımına yardımcı olan bir dizi otomatik adımdır. Bu süreçleri basit bir betik diliyle tanımlar, böylece proje iş akışlarını yönetmek ve otomatikleştirmek kolaylaşır.

Bu bölümde örnek bir Jenkins ardışık düzeni oluşturacak ve yeni oluşturduğumuz aracıları yürütücü olarak kullanacağız.

Bir Jenkins ardışık düzeni ayarlama 

Panoda “Yeni Öğe” düğmesine tıklayın, öğenin adını yazın, “Ardışık Düzen” seçeneğini işaretleyin ve “Tamam”a tıklayın.

Ardından, bizden ardışık düzeni yapılandırmamız istenecek. “Ardışık Düzen” bölümüne kaydırın; Jenkins ardışık düzen betiğini burada yazmamız gerekiyor.

Jenkins ardışık düzen betiğinde ortama ve aracıya ayar çekerek başlarız. Bizim örneğimizde, daha önce tanımladığımız aracının etiketini vererek agent değerini ayarlıyoruz.

Bundan sonra, ardışık düzenin tüm çeşitli adımlarının (Build, Test, Deploy) ekleneceği bir stages bölümü yazacağız. Bizim örneğimizde yalnızca echo komutuyla çıktı basıyor ve bat komutuyla terminal komutlarını çalıştırıyoruz.

• bat Windows 11 için kullanılır
• sh Linux içindir

Hepsi bu. Oldukça basit. İşte betik kodu:

pipeline {
    agent {
        label 'MLAgent' // Ensure this label matches your Windows 11 agent
    }

    stages {
        stage('Build') {
            steps {
                echo 'Building...'
                // Add your Windows build commands here
                bat 'echo Running build commands'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing...'
                // Add your Windows test commands here
                bat 'echo Running test commands'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying...'
                // Add your Windows deploy commands here
                bat 'echo Running deploy commands'
            }
        }
    }
}Altyapı:

Betik eklendikten sonra “Uygula” ve “Kaydet” düğmelerine tıklayın.

Jenkins ardışık düzenini çalıştırma

Ardışık düzeni test edip çalıştırmak için “Şimdi Derle” düğmesine tıklayın. Durumunu görmek için “Durum” düğmesine tıklayın. 

Çalıştırma tamamlandıktan sonra, “Durum” menüsünde ilgili çalıştırmaya tıklayarak günlükleri görüntüleyebiliriz. 

“Son derleme (#2)” bağlantısına tıklayın ve ardından “Konsol Çıkışı” düğmesine basın. Bu, bizi ardışık düzenin günlüklerini ve sonuçlarını bulabileceğimiz konsol çıktı penceresine götürecektir.

Hatta “Ardışık Düzen Konsolu” düğmesine tıklayarak ardışık düzende yer alan her adımı ayrıntılı şekilde görüntüleyebiliriz. Buna çıktı, başlama ve bitiş süreleri, ardışık düzen komutları ve günlükler dâhildir. 

Bir MLOps Projesi için Jenkins Ardışık Düzeni Oluşturma

Jenkins’e ilk girişin ardından şimdi ciddileşip MLOps projesi üzerinde çalışmanın zamanı geldi. 

İki ardışık düzen oluşturacağız: İlk ardışık düzen CI olacaktır; verileri yükleyip işleyecek, modeli eğitip değerlendirecek ve ardından model sunucusunu test edecektir. Sonrasında CD ardışık düzenini başlatarak model çıkarım sunucusunu çalıştıracaktır.

Süreci ayrıntılı olarak anlamak için, makine öğrenmesi geliştirme süreçlerini nasıl yalınlaştıracağınızı öğreten Makine Öğrenmesi için CI/CD kursunu alın.

Proje dosyaları

Her projede olduğu gibi; veri yükleme, model eğitimi, model değerlendirme ve model sunma Python dosyalarını içeren proje dosyalarını oluşturmamız gerekiyor. Gerekli Python paketlerini kurmak için bir requirements .txt dosyasına da ihtiyacımız var.

data_loading.py:

Bu betikte, scikit-learn’ün Wine veri setini yükleyip bir pandas DataFrame’ine dönüştüreceğiz. Ardından veri setini eğitim ve test olarak böleceğiz. Son olarak, işlenmiş verileri bir pickle dosyası olarak kaydedeceğiz.

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
import pandas as pd
import joblib

def load_data():
    # Load the wine dataset
    wine = load_wine(as_frame=True)
    data = pd.DataFrame(data=wine.data, columns=wine.feature_names)
    data["target"] = wine.target
    print(data.head())
    return data

def split_data(data, target_column="target"):
    X = data.drop(columns=[target_column])
    y = data[target_column]
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    return X_train, X_test, y_train, y_test

def save_preprocessed_data(X_train, X_test, y_train, y_test, file_path):
    joblib.dump((X_train, X_test, y_train, y_test), file_path)


if __name__ == "__main__":
    data = load_data()
    X_train, X_test, y_train, y_test = split_data(data)
    save_preprocessed_data(X_train, X_test, y_train, y_test, "preprocessed_data.pkl")Altyapı:

model_training.py:

Bu dosyada işlenmiş verileri yükleyip bir rastgele orman sınıflandırıcısı eğitecek ve modeli pickle dosyası olarak kaydedeceğiz.

from sklearn.ensemble import RandomForestClassifier
import joblib

def load_preprocessed_data(file_path):
    return joblib.load(file_path)

def train_model(X_train, y_train):
    model = RandomForestClassifier(n_estimators=100, random_state=42)
    model.fit(X_train, y_train)
    return model

def save_model(model, file_path):
    joblib.dump(model, file_path)


if __name__ == "__main__":
    X_train, X_test, y_train, y_test = load_preprocessed_data("preprocessed_data.pkl")

    model = train_model(X_train, y_train)
    save_model(model, "model.pkl")Altyapı:

model_evaluation.py:

Modeli değerlendirmek için hem modeli hem de işlenmiş veri setini yükleyecek, bir sınıflandırma raporu üretecek ve doğruluk skorunu yazdıracağız.

import joblib
from sklearn.metrics import accuracy_score, classification_report

def load_model(file_path):
    return joblib.load(file_path)

def load_preprocessed_data(file_path):
    return joblib.load(file_path)

def evaluate_model(model, X_test, y_test):
    predictions = model.predict(X_test)
    accuracy = accuracy_score(y_test, predictions)
    report = classification_report(y_test, predictions)
    return accuracy, report

if __name__ == "__main__":
    X_train, X_test, y_train, y_test = load_preprocessed_data("preprocessed_data.pkl")

    model = load_model("model.pkl")
    accuracy, report = evaluate_model(model, X_test, y_test)
    print(f"Model Accuracy: {accuracy}")
    print(f"Classification Report:\n{report}")Altyapı:

model_serving.py:

Model sunumu için kullanıcıların özellik girip tahmin alabileceği bir REST API oluşturmak üzere FastAPI kullanacağız. Normalde etiketler geneldir. Biraz ilgi çekici olması için şarap kategorilerini Verdante, Rubresco ve Floralis olarak değiştireceğiz.

Bu dosyayı çalıştırdığımızda FastAPI sunucusunu başlatırız; buna curl komutuyla ya da Python’da requests kütüphanesini kullanarak erişebiliriz.

from typing import List

import joblib
import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# Define the labels corresponding to the target classes
LABELS = [
    "Verdante",  # A vibrant and fresh wine, inspired by its balanced acidity and crisp flavors.
    "Rubresco",  # A rich and robust wine, named for its deep, ruby color and bold taste profile.
    "Floralis",  # A fragrant and elegant wine, known for its floral notes and smooth finish.
]

class Features(BaseModel):
    features: List[float]

def load_model(file_path):
    return joblib.load(file_path)

model = load_model("model.pkl")

@app.post("/predict")
def predict(features: Features):
    # Get the numerical prediction
    prediction_index = model.predict([features.features])[0]
    # Map the numerical prediction to the label
    prediction_label = LABELS[prediction_index]
    return {"prediction": prediction_label}

if __name__ == "__main__":
    uvicorn.run(app, host="127.0.0.1", port=9000)Altyapı:

requirements.txt:

Bu dosya, yukarıdaki Python dosyalarını çalıştırmak için gerekli tüm paketleri indirip kurmamıza yardımcı olur.

scikit-learn
pandas
fastapi
uvicornAltyapı:

Ana MLOps (CI) ardışık düzeni 

Şimdi sürekli entegrasyon Jenkins ardışık düzenlerini oluşturacağız. Basit bir ardışık düzen oluşturduğumuz gibi, “MLOps-pipe” adında bir düzen oluşturup veri işleme aşamasından model değerlendirmeye kadar her şeyi kapsayan betiği yazacağız.

MLOps ardışık düzen betiği şunlardan oluşur:

1. agent’ın “MLAgent” label’ı ile başlatılması.
2. Tüm Python dosyalarımızın bulunduğu çalışma alanı dizininin ayarlanması.
3. Makine öğrenmesi ardışık düzenindeki her adım için aşamalar oluşturulması:
1. Gerekli tüm Python paketlerinin kurulması (Initialize).
2. Yüklenen veri setinin işlenmesi (Load and Preprocess Data).
3. Modelin işlenmiş veri seti üzerinde eğitilmesi (Train Model).
4. Modelin değerlendirilmesi ve raporun üretilmesi (Evaluate Model).
5. curl komutuyla model sunucusunun test edilmesi (Test Serve Model).
4. Sunucu testi geçtikten sonra, sunucuyu dağıtmak için başka bir ardışık düzen tetiklenecek. Bu konu bir sonraki bölümde ele alınacaktır.
5. Post düğümünde, veriler işlenip pickle uzantılı bir eser (artifact) olarak kaydedilecektir.

Not: start /B komutu, arka planda yeni bir terminal penceresi başlatır ve model sunum betiğini çalıştırır. Ayrıca bu Jenkins ardışık düzen betiği yalnızca Windows’ta çalışır; Linux veya diğer işletim sistemleri için komutları değiştirmemiz gerekir.

pipeline {
    agent { 
        node { 
            label 'MLAgent' 
            customWorkspace 'C:\\Repository\\GitHub\\MLOps-Jenkins' 
        } 
    }

    stages {
        stage('Initialize') {
            steps {
                script {
                    // Install necessary Python packages
                    bat "pip install -r requirements.txt"
                }
            }
        }

        stage('Load and Preprocess Data') {
            steps {
                script {
                    // Run data loading script
                    bat "python data_loading.py"
                }
            }
        }

        stage('Train Model') {
            steps {
                script {
                    // Run model training script
                    bat "python model_training.py"
                }
            }
        }

        stage('Evaluate Model') {
            steps {
                script {
                    // Run model evaluation script
                    bat "python model_evaluation.py"
                }
            }
        }

        stage('Serve Model') {
            steps {
                script {
                    // Start FastAPI server in the background
                    bat 'start /B python model_serving.py'
                    // Wait for the server to start
                    sleep time: 10, unit: 'SECONDS'
                }
            }
        }

        stage('Test Serve Model') {
            steps {
                script {
                    // Test the server with sample values
                    bat '''
                        curl -X POST "http://127.0.0.1:9000/predict" ^
                        -H "Content-Type: application/json" ^
                        -d "{\\"features\\": [13.2, 2.77, 2.51, 18.5, 103.0, 1.15, 2.61, 0.26, 1.46, 3.0, 1.05, 3.33, 820.0]}"
                    '''
                }
            }
        }

        stage('Deploy Model') {
            steps {
                script {
                    // Trigger another Jenkins job for model serving
                    build job: 'ModelServingPipeline', wait: false
                }
            }
        }
    }

    post {
        always {
            archiveArtifacts artifacts: '**.pkl', fingerprint: true
            echo 'Pipeline execution complete.'
        }
    }
}Altyapı:

Model sunumu (CD) ardışık düzeni 

Şimdi sunucuyu yerelde dağıtıp çalıştırmak için bir sürekli dağıtım ardışık düzeni oluşturacağız.

Ardışık düzen betiği basit. Aracıyı tanımlayarak ve çalışma dizinini projemize çevirerek başlıyoruz. Sonrasında sunucuyu süresiz çalıştırıyoruz. 

Not: Jenkins’te bir sunucuyu süresiz çalıştırmak önerilmez; zira ardışık düzenlerin belirli bir başlangıç ve bitişi olmalıdır. Bu örnekte uygulamayı dağıttığımızı varsayacağız; ancak pratikte Docker’ı entegre edip uygulamayı bir Docker sunucusunda çalıştırmak daha iyidir.

Bir makine öğrenmesi mühendisi gibi düşünmeyi öğrenmekle ilgileniyorsanız, Üretim için Makine Öğrenmesi Modelleri Geliştirme: Bir MLOps Yaklaşımı kursunu düşünebilirsiniz; bu kurs, modellerinizi en yüksek potansiyellerine ulaşacak şekilde eğitmenize, belgelemenize, bakımını yapmanıza ve ölçeklendirmenize olanak tanır.

pipeline {
    agent { 
        node { 
            label 'MLAgent' 
            customWorkspace 'C:/Repository/GitHub/MLOps-Jenkins/' 
        } 
    }

    stages {
        stage('Start FastAPI Server') {
            steps {
                script {
                    // Start the FastAPI server
                    bat 'python model_serving.py'
                }
            }
        }
    }

}Altyapı:

CI/CD ardışık düzenlerini çalıştırma

CI/CD ardışık düzenini başlatmak için “MLOps-pipe” ardışık düzenine gidip “Şimdi Derle” düğmesine tıklayın.

Ardışık düzen başarıyla yürütüldüğünde, biri model için diğeri işlenmiş veri seti için olmak üzere iki eser (artifact) üretir.

Ardışık düzeni görselleştirmek ve tüm adımları görmek için Jenkins panosunda “Aşamalar” düğmesine tıklayın.

Her adımın ayrıntılı günlüklerini görmek için “Ardışık Düzen Konsolu” menüsünü kontrol edin.

Ayrıca “ModelServingPipeline”ı kontrol ederek sunucumuzun yerel URL’de http://127.0.0.1:9000 çalıştığını doğrulayabiliriz. 

FastAPI uygulamasını tarayıcıda deneme

FastAPI, yerel URL’ye /docs eklenerek erişilebilen Swagger UI ile gelir: http://127.0.0.1:9000/docs.

Swagger UI, FastAPI uygulamasını tarayıcıda test etmemize olanak tanır. Basittir ve model sunucumuzun düzgün çalıştığını görebiliriz. Örnek değerler için tahmin edilen şarap türü Rubresco olarak önerildi.

Denemeler bittiğinde model sunucusunu kapattığınızdan emin olun. Bunu Jenkins panosundaki “Durum” menüsüne gidip aşağıda gösterildiği gibi çarpı düğmesine tıklayarak yapabilirsiniz:

Bu eğitimdeki tüm kodlar, veri setleri, modeller ve meta dosyalar GitHub deposunda denemeniz için mevcuttur: kingabzpro/MLOps-with-Jenkins.

Sonuç

Jenkins, her türlü MLOps görevi için harika bir otomasyon sunucusudur. Daha fazla özellik, daha fazla kontrol ve gelişmiş gizlilik sunarak GitHub Actions’a mükemmel bir alternatif olarak öne çıkar. 

Jenkins’in en cazip yanlarından biri, ardışık düzenlerin basitçe oluşturulup yürütülebilmesi; bu da hem yeni başlayanlar hem de deneyimli kullanıcılar için erişilebilir kılar.

Benzer yetenekleri GitHub Actions kullanarak keşfetmek istiyorsanız, Makine Öğrenmesi için CI/CD’ye Yeni Başlayanlar Rehberi eğitimini kaçırmayın. MLOps bilgisini derinleştirmek isteyenler için Tam Otomatik MLOps kursu harika bir kaynaktır. MLOps mimarisi, CI/CD/CM/CT teknikleri ve zaman içinde sürekli değer üreten ML sistemlerini dağıtmak için otomasyon kalıpları hakkında kapsamlı içgörüler sunar.