Jenkins untuk MLOps: Tutorial CI/CD Lengkap

Menyiapkan Jenkins di Windows 11

Kita dapat dengan mudah menginstal Jenkins di Linux dan macOS. Namun, instalasi di Windows memerlukan beberapa langkah. Langkah-langkah ini mencakup menginstal Java Development Kit, menyetel kebijakan keamanan lokal, menginstal Jenkins dengan pengguna domain, dan menjalankan server Jenkins.

Menginstal OpenJDK

Mari mulai dengan menginstal Java. Kita perlu mengunjungi situs Adoptium dan mengunduh rilis LTS terbaru untuk Windows 11.

Mengapa kita perlu menginstal OpenJDK? Jenkins adalah aplikasi berbasis Java yang memerlukan Java Runtime Environment (JRE) atau Java Development Kit (JDK) untuk berjalan.

Sumber gambar: Adoptium

Instal OpenJDK dengan nilai bawaan, kecuali kita perlu mencentang opsi “Set or override JAVA_HOME variable.”

Setelah instalasi selesai, kita dapat memeriksa apakah sudah terpasang dengan benar dengan mengetik java -version di jendela terminal:

Menyetel akun pengguna untuk “Log on as service”

Untuk menginstal Jenkins, Anda perlu memodifikasi “Local Security Policy” guna mengaktifkan akses login pengguna bagi installer. Caranya, tekan tombol Win + R pada keyboard Anda, ketik “secpol.msc” lalu tekan Enter. Kemudian navigasikan ke “Local Policies” > “User Rights Assignments” > “Log on as a service.”

Kita akan diarahkan ke jendela baru, di mana kita akan mengetikkan nama pengguna Windows dan mengklik tombol “Check Names.” Setelah itu, tekan tombol “OK” dan keluar dari jendela “Local Security Policy.”

Menginstal Jenkins

Kunjungi situs jenkins.io dan unduh paket Windows Installer untuk Jenkins.  

Sumber gambar: jenkins.io

Saat kita mencapai jendela yang bertuliskan "Run service as a local or domain user," ketik nama pengguna dan kata sandi Windows Anda, lalu tekan tombol “Test Credentials.” Jika disetujui, klik tombol “Next.”

Biarkan pengaturan lainnya tetap default dan selesaikan instalasi. Proses penyiapan mungkin memerlukan beberapa menit.

Menjalankan server Jenkins

Menjalankan server Jenkins cukup mudah. Kita hanya perlu menekan tombol Windows dan mencari "Services." Di jendela Services, cari Jenkins dan klik tombol play di bagian atas.

Secara default, Jenkins berjalan di https://localhost:8080/. Cukup tempelkan URL tersebut ke browser untuk mengakses dasbor. Untuk masuk ke dasbor Jenkins, Anda harus mengetik kata sandi administrator.

Untuk mendapatkan kata sandi administrator default, navigasikan ke direktori Jenkins lalu temukan dan buka berkas Jenkins.err.log.

Gulir ke bawah berkas error Jenkins untuk menemukan kata sandi yang dihasilkan. Salin dan tempelkan ke kotak input kata sandi administrator.

Setelah itu, server akan memerlukan beberapa menit untuk menginstal alat dan ekstensi yang diperlukan.

Setelah penyiapan server selesai, sistem akan meminta kita membuat pengguna baru. Masukkan semua informasi yang diperlukan dan klik tombol "Save and Continue".

Kita akan diarahkan ke dasbor, tempat kita akan membuat, melihat, dan menjalankan berbagai pipeline Jenkins. 

Membuat Agen di Jenkins

Agen, juga dikenal sebagai node, adalah mesin yang disetel untuk mengeksekusi job yang dikirim oleh server master Jenkins. Agen ini menyediakan lingkungan dan komputasi untuk menjalankan pipeline. Agen Windows 11 tersedia secara default, tetapi kita selalu dapat membuat agen sendiri dengan opsi yang disesuaikan.

Menyetel agen

Di dasbor utama, klik opsi “Manage Jenkins” lalu klik tombol “Set up agent” seperti di bawah ini. Atau, Anda dapat mengklik tombol “Nodes” untuk membuat dan mengelola agen.

Ketikkan nama agen dan pilih tipe “Permanent Agent.” 

Pastikan Anda menyediakan direktori untuk agen tempat semua berkas dan log akan disimpan. Tambahkan label dan biarkan pengaturan lainnya tetap default. Saat membuat pipeline, kita akan menggunakan label agen untuk menjalankan tugas.

Menjalankan agen secara lokal

Saat tombol “Save” ditekan, akan muncul prompt yang menginstruksikan kita untuk menyalin dan menempel perintah yang sesuai ke terminal berdasarkan sistem operasi yang kita gunakan.

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"Didukung oleh

Setelah menempel dan menjalankan perintah di terminal, kita akan melihat pesan sukses yang menunjukkan bahwa agen kita, dalam kasus saya, DC Agent 1, sedang berjalan di latar belakang.

Untuk memeriksa apakah agen berjalan dan siap mengeksekusi job, buka dasbor Jenkins, klik “Manage Jenkins,” lalu klik tombol “Nodes” untuk melihat status agen.

Membuat Pipeline Jenkins Sederhana 

Pipeline Jenkins adalah serangkaian langkah otomatis yang membantu dalam melatih, mengevaluasi, dan menerapkan model. Pipeline mendefinisikan proses ini menggunakan skrip pemrograman sederhana, sehingga memudahkan pengelolaan dan otomasi alur kerja proyek.

Di bagian ini, kita akan membuat contoh pipeline Jenkins dan menggunakan agen yang baru kita buat sebagai eksekutor pipeline.

Menyetel pipeline Jenkins 

Di dasbor, klik tombol “New Item,” ketik nama item, pilih opsi “Pipeline,” lalu klik “OK.”

Setelah itu, akan muncul prompt yang meminta kita mengonfigurasi pipeline. Gulir ke bawah ke bagian “Pipeline,” tempat kita perlu menulis skrip pipeline Jenkins.

Dalam skrip pipeline Jenkins, kita mulai dengan menyiapkan environment dan agen. Dalam kasus kita, kita menyetel agent dengan memberikan label agen yang telah kita definisikan sebelumnya.

Setelah itu, kita akan menulis bagian stages tempat semua langkah pipeline (Build, Test, Deploy) akan ditambahkan. Dalam contoh ini, kita hanya mencetak menggunakan perintah echo dan menjalankan perintah terminal menggunakan perintah bat.

• bat digunakan untuk Windows 11
• sh untuk Linux

Itu saja. Sesederhana itu. Berikut kode skripnya:

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'
            }
        }
    }
}Didukung oleh

Setelah menambahkan skrip, klik tombol “Apply” dan “Save.”

Menjalankan pipeline Jenkins

Klik tombol “Build Now” untuk menguji dan menjalankan pipeline. Untuk melihat statusnya, klik tombol “Status.” 

Setelah run selesai, kita dapat melihat log dengan mengklik run tertentu di menu "Status." 

Klik tautan "Last build (#2)" lalu klik tombol "Console Output." Ini akan membawa kita ke jendela output konsol, tempat kita dapat menemukan log dan hasil pipeline.

Kita bahkan dapat mengklik tombol “Pipeline Console” untuk melihat setiap langkah dalam pipeline secara detail. Ini mencakup output, waktu mulai dan selesai, perintah pipeline, dan log. 

Membuat Pipeline Jenkins untuk Proyek MLOPs

Setelah pengenalan awal Jenkins, sekarang saatnya kita serius dan mengerjakan proyek MLOps. 

Kita akan membuat dua pipeline: Pipeline pertama adalah CI, yang akan memuat dan memproses data, melatih model, mengevaluasi model, lalu menguji server model. Setelah itu, pipeline tersebut akan memulai pipeline CD, menyalakan server inferensi model.

Untuk memahami prosesnya secara detail, ikuti kursus CI/CD for Machine Learning, yang mengajarkan cara merampingkan proses pengembangan machine learning.

Berkas proyek

Seperti proyek pada umumnya, kita perlu membuat berkas proyek, termasuk berkas Python untuk pemuatan data, pelatihan model, evaluasi model, dan penyajian model. Kita juga memerlukan berkas requirements .txt untuk memasang paket Python yang diperlukan.

data_loading.py:

Dalam skrip ini, kita akan memuat dataset scikit-learn bernama Wine dan mengonversinya menjadi DataFrame pandas. Lalu, kita akan membagi dataset menjadi set pelatihan dan pengujian. Terakhir, kita akan menyimpan data yang telah diproses sebagai berkas pickle.

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")Didukung oleh

model_training.py:

Dalam berkas ini, kita akan memuat data yang telah diproses, melatih pengklasifikasi random forest, dan menyimpan model sebagai berkas pickle.

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")Didukung oleh

model_evaluation.py:

Untuk mengevaluasi model, kita akan memuat model dan dataset yang telah diproses, menghasilkan classification report, dan mencetak skor akurasi.

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}")Didukung oleh

model_serving.py:

Untuk penyajian model, kita akan menggunakan FastAPI untuk membuat REST API tempat pengguna dapat memasukkan fitur dan menghasilkan prediksi. Biasanya, label bersifat generik. Agar lebih menarik, kita akan mengubah kategori wine menjadi Verdante, Rubresco, dan Floralis.

Saat kita menjalankan berkas ini, kita meluncurkan server FastAPI, yang dapat diakses melalui perintah curl atau menggunakan pustaka requests di Python.

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)Didukung oleh

requirements.txt:

Berkas ini akan membantu kita mengunduh dan menginstal semua paket yang diperlukan untuk menjalankan berkas-berkas Python di atas.

scikit-learn
pandas
fastapi
uvicornDidukung oleh

Pipeline MLOps (CI) utama 

Sekarang kita akan membuat pipeline continuous integration Jenkins. Sama seperti saat membuat pipeline sederhana, kita akan membuat "MLOps-pipe" dan menulis skrip yang mencakup semuanya dari pemrosesan data hingga evaluasi model.

Skrip pipeline MLOps terdiri dari:

1. Menginisialisasi agent dengan label “MLAgent.”
2. Menyetel direktori workspace tempat semua berkas Python kita berada.
3. Membuat stage untuk setiap langkah dalam pipeline machine learning:
1. Memasang semua paket Python yang diperlukan (Initialize).
2. Memproses dataset yang dimuat (Load and Preprocess Data).
3. Melatih model pada dataset yang telah diproses (Train Model).
4. Mengevaluasi model dan menghasilkan laporan (Evaluate Model).
5. Menguji server model menggunakan perintah curl (Test Serve Model).
4. Setelah lolos pengujian server, pipeline lain akan dipicu untuk melakukan deployment server. Ini akan dibahas di bagian berikutnya.
5. Di post node, kita akan memproses data dan menyimpannya sebagai artifact dengan memberikan ekstensi berkas pickle.

Catatan: Perintah start /B meluncurkan jendela terminal baru di latar belakang dan menjalankan skrip penyajian model. Selain itu, skrip pipeline Jenkins ini hanya akan berfungsi di Windows, dan kita perlu mengubah perintah untuk Linux atau sistem operasi lainnya.

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.'
        }
    }
}Didukung oleh

Pipeline penyajian model (CD) 

Sekarang, kita akan membuat pipeline continuous deployment untuk melakukan deployment dan menjalankan server secara lokal.

Skrip pipeline ini sederhana. Kita mulai dengan mendefinisikan agen dan mengubah direktori kerja ke proyek kita. Setelah itu, kita menjalankan server tanpa batas waktu. 

Catatan: Menjalankan server tanpa batas di Jenkins tidak direkomendasikan, karena pipeline sebaiknya memiliki awal dan akhir yang jelas. Untuk contoh ini, kita akan mengasumsikan bahwa aplikasi telah dideploy, tetapi dalam praktiknya, lebih baik mengintegrasikan Docker dan menjalankan aplikasi di server Docker.

Jika Anda tertarik untuk belajar bagaimana berpikir seperti seorang machine learning engineer, pertimbangkan untuk mengikuti kursus Developing Machine Learning Models for Production with an MLOps Mindset, yang akan membantu Anda melatih, mendokumentasikan, memelihara, dan menskalakan model machine learning Anda secara maksimal.

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'
                }
            }
        }
    }

}Didukung oleh

Menjalankan pipeline CI/CD

Buka pipeline “MLOps-pipe” dan klik tombol “Build Now” untuk memulai pipeline CI/CD.

Setelah pipeline berhasil dieksekusi, pipeline menghasilkan dua artifact: satu untuk model dan satu untuk dataset yang telah diproses.

Klik tombol “Stages” pada dasbor Jenkins untuk memvisualisasikan pipeline dan melihat semua langkahnya.

Untuk melihat log terperinci dari setiap langkah, periksa menu "Pipeline Console."

Kita juga dapat memeriksa "ModelServingPipeline" untuk memverifikasi bahwa server kita berjalan pada URL lokal http://127.0.0.1:9000. 

Mencoba aplikasi FastAPI di browser

FastAPI dilengkapi Swagger UI, yang dapat diakses dengan menambahkan /docs ke URL lokal: http://127.0.0.1:9000/docs.

Swagger UI memungkinkan kita menguji aplikasi FastAPI di browser. Antarmukanya sederhana, dan kita dapat melihat bahwa server model kita berfungsi dengan baik. Nilai contoh yang diprediksi menunjukkan bahwa jenis wine adalah Rubresco.

Selalu pastikan untuk mematikan server model setelah Anda selesai bereksperimen. Anda dapat melakukannya dengan pergi ke menu “Status” di dasbor Jenkins lalu mengklik tombol silang, seperti di bawah ini:

Seluruh kode, dataset, model, dan metafile dalam tutorial ini tersedia di repositori GitHub untuk Anda coba: kingabzpro/MLOps-with-Jenkins.

Kesimpulan

Jenkins adalah server automasi yang hebat untuk berbagai tugas MLOps. Jenkins menonjol sebagai alternatif yang sangat baik untuk GitHub Actions dengan menawarkan lebih banyak fitur, kontrol yang lebih besar, dan privasi yang lebih baik. 

Salah satu aspek paling menarik dari Jenkins adalah kesederhanaannya dalam membuat dan mengeksekusi pipeline, sehingga dapat diakses baik bagi pemula maupun pengguna berpengalaman.

Jika Anda tertarik menjelajahi kemampuan serupa menggunakan GitHub Actions, jangan lewatkan tutorial A Beginner's Guide to CI/CD for Machine Learning. Bagi yang ingin memperdalam pemahaman tentang MLOps, kursus Fully Automated MLOps adalah sumber yang luar biasa. Kursus ini menawarkan wawasan komprehensif tentang arsitektur MLOps, teknik CI/CD/CM/CT, dan pola otomasi untuk menerapkan sistem ML yang dapat secara konsisten memberikan nilai dari waktu ke waktu.