Jenkins cho MLOps: Hướng dẫn CI/CD toàn diện

Thiết lập Jenkins trên Windows 11

Chúng ta có thể dễ dàng cài đặt Jenkins trên Linux và macOS. Tuy nhiên, cài đặt trên Windows cần vài bước. Các bước này gồm cài Java Development Kit, thiết lập chính sách bảo mật cục bộ, cài Jenkins với người dùng domain, và khởi động máy chủ Jenkins.

Cài đặt OpenJDK

Bắt đầu bằng cách cài đặt Java. Chúng ta cần truy cập trang Adoptium và tải bản LTS mới nhất cho Windows 11.

Tại sao cần cài OpenJDK? Jenkins là ứng dụng dựa trên Java, cần Java Runtime Environment (JRE) hoặc Java Development Kit (JDK) để chạy.

Nguồn ảnh: Adoptium

Cài OpenJDK với các giá trị mặc định, ngoại trừ cần tích chọn “Set or override JAVA_HOME variable.”

Sau khi cài xong, chúng ta có thể kiểm tra bằng cách gõ java -version trong cửa sổ terminal:

Thiết lập tài khoản người dùng cho “Log on as service”

Để cài Jenkins, bạn cần chỉnh “Local Security Policy” để bật quyền đăng nhập cho trình cài đặt. Nhấn tổ hợp phím Win + R, gõ “secpol.msc” và nhấn Enter. Sau đó điều hướng tới “Local Policies” > “User Rights Assignments” > “Log on as a service.”

Một cửa sổ mới sẽ mở ra, tại đó chúng ta nhập tên người dùng Windows của mình và bấm nút “Check Names”. Sau đó bấm “OK” và thoát cửa sổ “Local Security Policy”.

Cài đặt Jenkins

Truy cập trang jenkins.io và tải gói Windows Installer cho Jenkins.  

Nguồn ảnh: jenkins.io

Khi đến cửa sổ "Run service as a local or domain user", nhập tên người dùng và mật khẩu Windows của bạn, rồi bấm “Test Credentials”. Nếu thành công, bấm “Next”.

Giữ các lựa chọn còn lại ở mặc định và hoàn tất cài đặt. Quá trình thiết lập có thể mất vài phút.

Khởi động máy chủ Jenkins

Khởi động máy chủ Jenkins rất đơn giản. Chỉ cần nhấn phím Windows và tìm "Services." Trong cửa sổ Services, tìm Jenkins và bấm nút play ở phía trên.

Mặc định Jenkins chạy tại https://localhost:8080/. Chỉ cần dán URL đó vào trình duyệt để truy cập bảng điều khiển. Để vào dashboard Jenkins, bạn phải nhập mật khẩu quản trị viên.

Để lấy mật khẩu quản trị mặc định, điều hướng tới thư mục Jenkins và tìm mở tệp Jenkins.err.log.

Cuộn xuống trong tệp lỗi của Jenkins để tìm mật khẩu được tạo. Sao chép và dán vào ô nhập mật khẩu quản trị.

Sau đó, máy chủ sẽ mất vài phút để cài các công cụ và tiện ích mở rộng cần thiết.

Khi thiết lập máy chủ xong, hệ thống sẽ nhắc tạo người dùng mới. Nhập đầy đủ thông tin cần thiết và bấm nút "Save and Continue".

Chúng ta sẽ được chuyển tới dashboard, nơi tạo, xem và chạy các pipeline Jenkins khác nhau. 

Tạo một Agent trong Jenkins

Agent, còn gọi là node, là các máy được thiết lập để thực thi các job do máy chủ Jenkins master phân phối. Các agent cung cấp môi trường và tài nguyên tính toán để chạy pipeline. Một agent Windows 11 có sẵn theo mặc định, nhưng chúng ta luôn có thể tạo agent riêng với tùy chọn tùy chỉnh.

Thiết lập agent

Trên dashboard chính, bấm “Manage Jenkins” rồi bấm nút “Set up agent” như hình dưới. Hoặc bạn có thể bấm nút “Nodes” để tạo và quản lý agent.

Nhập tên agent và chọn loại “Permanent Agent”. 

Hãy đảm bảo bạn cung cấp thư mục cho agent, nơi tất cả tệp và log sẽ được lưu. Thêm một label và giữ các cài đặt còn lại mặc định. Khi tạo pipeline, chúng ta sẽ dùng label của agent để chạy tác vụ.

Chạy agent cục bộ

Khi bấm nút “Save”, một hướng dẫn sẽ xuất hiện, yêu cầu chúng ta sao chép và dán lệnh phù hợp vào terminal theo hệ điều hành của mình.

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"Được hỗ trợ bởi

Sau khi dán và chạy lệnh trong terminal, chúng ta sẽ thấy thông báo thành công cho biết agent của chúng ta, trong trường hợp này là DC Agent 1, đang chạy nền.

Để kiểm tra agent có đang chạy và sẵn sàng thực thi job không, hãy vào dashboard Jenkins, bấm “Manage Jenkins,” rồi bấm nút “Nodes” để xem trạng thái agent.

Tạo một Jenkins Pipeline đơn giản 

Jenkins pipeline là chuỗi bước tự động hỗ trợ huấn luyện, đánh giá và triển khai mô hình. Nó định nghĩa các quy trình này bằng script lập trình đơn giản, giúp quản lý và tự động hóa workflow dự án dễ hơn.

Trong phần này, chúng ta sẽ tạo một pipeline mẫu và dùng agent vừa tạo làm bộ thực thi pipeline.

Thiết lập một Jenkins pipeline 

Trên dashboard, bấm nút “New Item”, nhập tên mục, chọn “Pipeline” và bấm “OK”.

Sau đó, hệ thống sẽ yêu cầu cấu hình pipeline. Cuộn xuống phần “Pipeline”, nơi chúng ta cần viết script pipeline Jenkins.

Trong script pipeline Jenkins, chúng ta bắt đầu bằng thiết lập môi trường và agent. Ở đây, chúng ta thiết lập agent bằng cách cung cấp label của agent đã định nghĩa trước đó.

Sau đó, chúng ta sẽ viết phần stages nơi thêm các bước khác nhau của pipeline (Build, Test, Deploy). Trong ví dụ này, chúng ta chỉ in bằng lệnh echo và chạy lệnh terminal bằng bat.

• bat dùng cho Windows 11
• sh dùng cho Linux

Vậy là xong. Rất đơn giản. Đây là đoạn mã script:

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'
            }
        }
    }
}Được hỗ trợ bởi

Sau khi thêm script, bấm “Apply” và “Save”.

Chạy Jenkins pipeline

Bấm nút “Build Now” để kiểm tra và chạy pipeline. Để xem trạng thái, bấm nút “Status”. 

Sau khi chạy xong, chúng ta có thể xem log bằng cách bấm vào lượt chạy cụ thể trong menu "Status". 

Bấm vào liên kết "Last build (#2)" rồi bấm nút "Console Output". Bạn sẽ tới cửa sổ console output, nơi có log và kết quả của pipeline.

Chúng ta cũng có thể bấm nút “Pipeline Console” để xem chi tiết từng bước trong pipeline, gồm đầu ra, thời gian bắt đầu và kết thúc, lệnh pipeline và log. 

Tạo Jenkins Pipeline cho một dự án MLOPs

Sau phần giới thiệu ban đầu về Jenkins, đã đến lúc chúng ta nghiêm túc và bắt tay vào dự án MLOps. 

Chúng ta sẽ tạo hai pipeline: Pipeline đầu tiên là CI, sẽ tải và xử lý dữ liệu, huấn luyện mô hình, đánh giá mô hình, sau đó kiểm thử máy chủ phục vụ mô hình. Sau đó, nó sẽ kích hoạt pipeline CD, khởi chạy máy chủ suy luận mô hình.

Để hiểu chi tiết quy trình, hãy học khóa CI/CD for Machine Learning, khóa học dạy bạn cách tối ưu hóa quy trình phát triển học máy.

Tệp dự án

Như bất kỳ dự án nào, chúng ta cần tạo các tệp dự án, bao gồm các tệp Python cho tải dữ liệu, huấn luyện mô hình, đánh giá mô hình và phục vụ mô hình. Chúng ta cũng cần tệp requirements .txt để cài đặt các gói Python cần thiết.

data_loading.py:

Trong script này, chúng ta sẽ tải bộ dữ liệu Wine của scikit-learn và chuyển thành pandas DataFrame. Sau đó, chúng ta sẽ chia dữ liệu thành tập huấn luyện và kiểm thử. Cuối cùng, lưu dữ liệu đã xử lý dưới dạng tệp 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")Được hỗ trợ bởi

model_training.py:

Trong tệp này, chúng ta sẽ tải dữ liệu đã xử lý, huấn luyện bộ phân loại rừng ngẫu nhiên và lưu mô hình dưới dạng tệp 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")Được hỗ trợ bởi

model_evaluation.py:

Để đánh giá mô hình, chúng ta sẽ tải cả mô hình và dữ liệu đã tiền xử lý, tạo báo cáo phân loại và in điểm chính xác.

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}")Được hỗ trợ bởi

model_serving.py:

Đối với phục vụ mô hình, chúng ta sẽ dùng FastAPI để tạo REST API, nơi người dùng có thể nhập đặc trưng và tạo dự đoán. Thông thường, nhãn khá chung chung. Để thú vị hơn, chúng ta sẽ đổi các loại rượu thành Verdante, Rubresco và Floralis.

Khi chạy tệp này, chúng ta khởi động máy chủ FastAPI, có thể truy cập qua lệnh curl hoặc bằng thư viện requests trong 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)Được hỗ trợ bởi

requirements.txt:

Tệp này sẽ giúp chúng ta tải và cài tất cả gói cần thiết để chạy các tệp Python ở trên.

scikit-learn
pandas
fastapi
uvicornĐược hỗ trợ bởi

Pipeline MLOps (CI) chính 

Giờ chúng ta sẽ tạo các pipeline tích hợp liên tục trên Jenkins. Giống như khi tạo pipeline đơn giản, chúng ta sẽ tạo "MLOps-pipe" và viết script bao trọn mọi thứ từ xử lý dữ liệu đến đánh giá mô hình.

Script pipeline MLOps gồm:

1. Khởi tạo agent với label “MLAgent.”
2. Thiết lập thư mục workspace nơi chứa tất cả tệp Python của chúng ta.
3. Tạo các stage cho từng bước trong pipeline học máy:
1. Cài đặt tất cả gói Python cần thiết (Initialize).
2. Xử lý bộ dữ liệu đã tải (Load and Preprocess Data).
3. Huấn luyện mô hình trên dữ liệu đã xử lý (Train Model).
4. Đánh giá mô hình và tạo báo cáo (Evaluate Model).
5. Kiểm thử máy chủ mô hình bằng lệnh curl (Test Serve Model).
4. Sau khi vượt qua kiểm thử máy chủ, một pipeline khác sẽ được kích hoạt để triển khai máy chủ. Phần này sẽ được trình bày ở mục tiếp theo.
5. Trong post node, chúng ta sẽ xử lý dữ liệu và lưu dưới dạng artifact bằng cách cung cấp phần mở rộng tệp pickle.

Lưu ý: Lệnh start /B mở một cửa sổ terminal mới chạy nền và chạy script phục vụ mô hình. Ngoài ra, script pipeline Jenkins này chỉ hoạt động trên Windows; chúng ta cần đổi lệnh cho Linux hoặc hệ điều hành khác.

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.'
        }
    }
}Được hỗ trợ bởi

Pipeline phục vụ mô hình (CD) 

Bây giờ, chúng ta sẽ tạo pipeline triển khai liên tục để triển khai và chạy máy chủ cục bộ.

Script pipeline khá đơn giản. Chúng ta bắt đầu bằng định nghĩa agent và đổi thư mục làm việc sang dự án. Sau đó, chạy máy chủ vô thời hạn. 

Lưu ý: Chạy một máy chủ vô thời hạn trong Jenkins không được khuyến nghị, vì pipeline nên có điểm bắt đầu và kết thúc xác định. Trong ví dụ này, ta giả định đã triển khai ứng dụng, nhưng trong thực tế tốt hơn là tích hợp Docker và chạy ứng dụng trên máy chủ Docker.

Nếu bạn muốn học cách tư duy như kỹ sư học máy, hãy cân nhắc khóa Developing Machine Learning Models for Production with an MLOps Mindset, khóa học sẽ giúp bạn huấn luyện, ghi chép, duy trì và mở rộng mô hình học máy tới mức tối đa.

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

}Được hỗ trợ bởi

Chạy các pipeline CI/CD

Vào pipeline “MLOps-pipe” và bấm “Build Now” để khởi động pipeline CI/CD.

Sau khi pipeline chạy thành công, nó tạo ra hai artifact: một cho mô hình và một cho bộ dữ liệu đã xử lý.

Bấm nút “Stages” trên dashboard Jenkins để trực quan hóa pipeline và xem tất cả các bước.

Để xem log chi tiết của từng bước, hãy kiểm tra menu "Pipeline Console".

Chúng ta cũng có thể kiểm tra "ModelServingPipeline" để xác nhận máy chủ đang chạy tại URL cục bộ http://127.0.0.1:9000. 

Thử ứng dụng FastAPI trên trình duyệt

FastAPI đi kèm Swagger UI, có thể truy cập bằng cách thêm /docs vào URL cục bộ: http://127.0.0.1:9000/docs.

Swagger UI cho phép chúng ta thử ứng dụng FastAPI ngay trên trình duyệt. Nó đơn giản, và chúng ta có thể thấy máy chủ mô hình hoạt động ổn. Các giá trị mẫu dự đoán cho thấy loại rượu là Rubresco.

Luôn đảm bảo tắt máy chủ mô hình sau khi bạn thử nghiệm xong. Bạn có thể làm điều đó bằng cách vào menu “Status” trong dashboard Jenkins rồi bấm nút dấu chéo như hình dưới:

Toàn bộ mã, bộ dữ liệu, mô hình và siêu tệp trong hướng dẫn này đều có trên kho GitHub để bạn thử: kingabzpro/MLOps-with-Jenkins.

Kết luận

Jenkins là một máy chủ tự động hóa tuyệt vời cho mọi tác vụ MLOps. Nó nổi bật như một lựa chọn thay thế xuất sắc cho GitHub Actions nhờ cung cấp nhiều tính năng hơn, kiểm soát tốt hơn và tăng cường quyền riêng tư. 

Một trong những điểm hấp dẫn nhất của Jenkins là sự đơn giản trong việc tạo và thực thi pipeline, khiến cả người mới lẫn người dùng dày dạn đều có thể tiếp cận.

Nếu bạn quan tâm khám phá năng lực tương tự bằng GitHub Actions, đừng bỏ lỡ hướng dẫn A Beginner's Guide to CI/CD for Machine Learning. Với những ai muốn đào sâu MLOps, khóa Fully Automated MLOps là nguồn tài nguyên tuyệt vời, cung cấp cái nhìn toàn diện về kiến trúc MLOps, kỹ thuật CI/CD/CM/CT và các mẫu tự động hóa để triển khai hệ thống ML mang lại giá trị bền vững theo thời gian.