Direkt zum Inhalt

Jenkins für MLOps: Ein vollständiges CI/CD-Tutorial

Lerne, wie du Jenkins unter Windows installierst, Jenkins-Agenten und -Pipelines einrichtest und ausführst und MLOps-Projekte mit Jenkins-Pipelines vom Modelltraining bis zum Model-Serving aufbaust.
Aktualisierte 2. Okt. 2024  · 25 Min. Lesezeit

Jenkins Tutorial für MLOps Feature Image

In diesem Tutorial lernen wir, wie man Jenkins installiert und verwendet und wie man Agenten und Pipelines erstellt und ausführt. 

Konkret werden wir:

  1. Richte Jenkins so ein, dass es reibungslos auf einem Windows-Rechner läuft. Wir bieten auch Links zur Installation in anderen Betriebssystemen.
  2. Erstelle einen Agenten in Jenkins und führe ihn aus, um alle unsere Pipelines auszuführen.
  3. Baue eine einfache Pipeline und führe sie aus, um die Automatisierung verschiedener Projektschritte zu demonstrieren.
  4. Entwickle ein MLOps-Projekt mit einer Jenkins-Pipeline, um Daten aufzunehmen, zu verarbeiten, das Modell zu trainieren, zu evaluieren und das Modell zu bedienen.

Wenn du dein Wissen auffrischen möchtest, dann nimm an einem kurzen und unkomplizierten Kurs zu MLOps-Konzepten teil, in dem du lernst, wie du Machine-Learning-Modelle von Jupyter-Notizbüchern zu funktionierenden Modellen in der Produktion bringst, die einen echten Geschäftswert generieren.

Was ist Jenkins?

Jenkins ist ein Open-Source-Automatisierungsserver, der eine wichtige Rolle im Entwicklungsprozess für maschinelles Lernen spielt, indem er die kontinuierliche Integration (CI) und das kontinuierliche Deployment (CD) ermöglicht.

Jenkins ist in Java geschrieben und hilft dabei, die Datenverarbeitung, das Training, die Auswertung und den Einsatz von Machine Learning-Projekten zu automatisieren, was es zu einem unverzichtbaren Werkzeug für MLOps-Praktiken macht.

Jenkins Eigenschaften:

  • Einfache Installation: Jenkins kann einfach auf Windows, Linux, macOS, Docker und Kubernetes installiert werden. 
  • Einfache Einrichtung und Konfiguration: Jenkins lässt sich ganz einfach über die Weboberfläche einrichten und konfigurieren, die auch On-the-Fly-Fehlerprüfungen und eine integrierte Hilfe enthält.
  • Umfangreiches Plugin-Ökosystem: Mit Hunderten von Plugins lässt sich Jenkins mit praktisch jedem Drittanbieter-Tool in der CI/CD-Toolchain integrieren. In Bezug auf die Funktionen und Merkmale ist es ähnlich wie GitHub Actions.
  • Verteilte Arbeitsbelastung: Jenkins kann die Arbeit mithilfe von lokalen und Cloud-Agenten auf mehrere Rechner verteilen und hilft so, Tests, Schulungen und Einsätze auf mehreren Plattformen schneller durchzuführen.

Die Aufgabenautomatisierung mit Jenkins ist nur ein Teil des MLOps-Ökosystems. Du kannst dich über weitere Aufgaben informieren , indem du den Blog 25 Top MLOps Tools You Need to Know in 2024 liest. Es besteht aus Werkzeugen für die Verfolgung von Experimenten, die Verwaltung von Modell-Metadaten, die Orchestrierung von Arbeitsabläufen, die Versionierung von Daten und Pipelines, die Bereitstellung von Modellen sowie die Überwachung von Serving und Modellen in der Produktion.

MLOps-Fähigkeiten heute aufbauen

Fang ganz von vorne an und erwerbe karrierefördernde MLOps-Fähigkeiten.
Kostenloses Lernen beginnen

Einrichten von Jenkins unter Windows 11

Wir können Jenkins ganz einfach auf Linux und macOS installieren. Für die Installation unter Windows sind jedoch mehrere Schritte erforderlich. Diese Schritte umfassen die Installation des Java Development Kit, die Einrichtung der lokalen Sicherheitsrichtlinie, die Installation von Jenkins mit einem Domänenbenutzer und den Start des Jenkins-Servers.

Installation von OpenJDK

Beginnen wir mit der Installation von Java. Wir müssen auf die Adoptium-Website gehen und die neueste LTS-Version für Windows 11 herunterladen.

Warum müssen wir OpenJDK installieren? Jenkins ist eine Java-basierte Anwendung, für die eine Java-Laufzeitumgebung (JRE) oder ein Java Development Kit (JDK) erforderlich ist.

Herunterladen des OpenJDK für Windows

Bildquelle: Adoptium

Installiere das OpenJDK mit den Standardwerten, außer dass wir das Häkchen bei "Set or override JAVA_HOME variable" setzen müssen.

Installation des OpenJDK unter Windows

Nachdem die Installation abgeschlossen ist, können wir überprüfen, ob sie korrekt installiert wurde, indem wir java -version in das Terminalfenster eingeben:

OpenJDK auf einem Windows-Terminal testen

Einrichten eines Benutzerkontos für "Anmelden als Dienst"

Um Jenkins zu installieren, musst du die "Lokale Sicherheitsrichtlinie" ändern, um den Benutzer-Login-Zugriff für den Installer zu ermöglichen. Drücke dazu die Tasten Win + R auf deiner Tastatur, gib "secpol.msc" ein und drücke die Eingabetaste. Navigiere dann zu "Lokale Richtlinien" > "Zuweisung von Benutzerrechten" > "Als Dienst anmelden".

Einrichten der lokalen Sicherheitsrichtlinie für Jenkins

Wir werden zu einem neuen Fenster weitergeleitet, in dem wir unseren Windows-Benutzernamen eingeben und auf die Schaltfläche "Namen prüfen" klicken. Danach drückst du auf "OK" und verlässt das Fenster "Lokale Sicherheitsrichtlinie".

Suche nach dem Benutzer in Log on as a service

Jenkins installieren

Gehe auf die jenkins.io Website und lade das Windows Installer Paket für Jenkins herunter.  

Herunterladen von Jenkins für Windows

Bildquelle: jenkins.io

Wenn das Fenster "Dienst als lokaler oder Domänenbenutzer ausführen" erscheint, gibst du deinen Windows-Benutzernamen und dein Passwort ein und klickst dann auf die Schaltfläche "Anmeldeinformationen testen". Wenn sie genehmigt ist, klicke auf die Schaltfläche "Weiter".

Anmeldung bei Jenkins

Behalte alles andere als Standard und beende die Installation. Es kann ein paar Minuten dauern, bis es eingerichtet ist.

Fertigstellung der Jenkins-Installation

Starten des Jenkins-Servers

Der Start des Jenkins-Servers ist ganz einfach. Alles, was wir tun müssen, ist auf die Windows-Taste zu klicken und nach "Dienste" zu suchen. Suche im Dienste-Fenster nach Jenkins und klicke oben auf die Schaltfläche "Abspielen".

Starten des Jenkins-Servers

Standardmäßig läuft Jenkins unter https://localhost:8080/. Füge diese URL einfach in einen Browser ein, um auf das Dashboard zuzugreifen. Um das Jenkins Dashboard zu betreten, musst du das Administrator-Passwort eingeben.

Eingabe des Administrator-Passworts zum Entsperren von Jenkins

Um das Standard-Administratorkennwort zu erhalten, navigieren Sie zum Verzeichnis Jenkins, suchen und öffnen Sie die Datei Jenkins.err.log.

Jenkins Dateiverzeichnis

Scrolle in der Jenkins-Fehlerdatei nach unten, um das generierte Passwort zu finden. Kopiere es und füge es in das Eingabefeld für das Administrator-Passwort ein.

Jenkins-Fehlerprotokolldatei

Danach braucht der Server ein paar Minuten, um die notwendigen Tools und Erweiterungen zu installieren.

Erste Schritte mit dem Jenkins-Server

Sobald die Servereinrichtung abgeschlossen ist, werden wir aufgefordert, einen neuen Benutzer anzulegen. Gib alle erforderlichen Informationen ein und klicke auf die Schaltfläche "Speichern und weiter".

Den ersten Admin-Benutzer in Jenkins anlegen

Wir werden zum Dashboard weitergeleitet, wo wir verschiedene Jenkins-Pipelines erstellen, anzeigen und ausführen können. 

Willkommensfenster im Jenkins Dashboard

Einen Agenten in Jenkins erstellen

Agenten, auch Knoten genannt, sind Maschinen, die so eingerichtet sind, dass sie Aufträge ausführen, die vom Jenkins-Masterserver gesendet werden. Diese Agenten stellen die Umgebung und die Rechenleistung für den Betrieb von Pipelines bereit. Ein Windows 11-Agent ist standardmäßig verfügbar, aber wir können jederzeit einen eigenen Agenten mit angepassten Optionen erstellen.

Agenten einrichten

Klicke auf dem Haupt-Dashboard auf die Option "Jenkins verwalten" und dann auf die Schaltfläche "Agent einrichten" (siehe unten). Alternativ kannst du auch auf die Schaltfläche "Knoten" klicken, um Agenten zu erstellen und zu verwalten.

Jenkins-Agenten einrichten

Gib den Namen des Agenten ein und wähle den Typ "Permanenter Agent". 

Jenkins Dashboard-Knoten einrichten

Bitte stelle sicher, dass du ein Verzeichnis für den Agenten angibst, in dem alle Dateien und Protokolle gespeichert werden sollen. Füge ein Etikett hinzu und behalte die restlichen Einstellungen als Standard bei. Beim Erstellen der Pipeline verwenden wir das Agentenlabel, um die Aufgaben auszuführen.

Eingabe von Details zum Einrichten eines Jenkins-Agenten

Den Agenten lokal ausführen

Wenn du auf die Schaltfläche "Speichern" drückst, erscheint eine Eingabeaufforderung, die uns anweist, den entsprechenden Befehl zu kopieren und in das Terminal einzufügen, je nachdem, welches Betriebssystem wir verwenden.

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"

Nachdem wir den Befehl im Terminal eingefügt und ausgeführt haben, sehen wir eine Erfolgsmeldung, die anzeigt, dass unser Agent, in meinem Fall DC Agent 1, im Hintergrund läuft.

Starten des Jenkins Agenten Servers auf dem Terminal

Um zu überprüfen, ob der Agent läuft und bereit ist, einen Auftrag auszuführen, navigiere zum Jenkins-Dashboard, klicke auf "Jenkins verwalten" und dann auf die Schaltfläche "Knoten", um den Status des Agenten anzuzeigen.

Überprüfen, ob der Jenkins Agenten Server gestartet ist

Erstellen einer einfachen Jenkins-Pipeline 

Eine Jenkins-Pipeline ist eine Reihe von automatisierten Schritten, die beim Training, der Bewertung und dem Einsatz von Modellen helfen. Sie definiert diese Prozesse mithilfe eines einfachen Programmierskripts und erleichtert so die Verwaltung und Automatisierung von Projektabläufen.

In diesem Abschnitt erstellen wir eine beispielhafte Jenkins-Pipeline und verwenden unseren neu erstellten Agenten als Pipeline-Ausführer.

Einrichten einer Jenkins-Pipeline 

Klicke auf dem Dashboard auf die Schaltfläche "Neuer Artikel", gib den Namen des Artikels ein, wähle die Option "Pipeline" und klicke auf "OK".

Erstellen einer Jenkins-Pipeline

Danach werden wir aufgefordert, die Pipeline zu konfigurieren. Scrolle nach unten zum Abschnitt "Pipeline", wo wir das Jenkins-Pipeline-Skript schreiben müssen.

Jenkins Pipeline Skript

Im Jenkins-Pipeline-Skript richten wir zunächst die Umgebung und den Agenten ein. In unserem Fall setzen wir die agent, indem wir ihr das zuvor definierte Label des Agenten geben.

Danach werden wir einen Abschnitt stages schreiben, in dem die verschiedenen Schritte der Pipeline (Build, Test, Deploy) hinzugefügt werden. In unserem Fall drucken wir nur mit dem Befehl echo und führen die Terminalbefehle mit dem Befehl bat aus.

  • bat wird für Windows 11 verwendet
  • sh ist für Linux

Das war's. So einfach ist das. Hier ist der Skriptcode:

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

Nachdem du das Skript hinzugefügt hast, klicke auf die Schaltflächen "Anwenden" und "Speichern".

Ausführen der Jenkins-Pipeline

Klicke auf die Schaltfläche "Jetzt bauen", um die Pipeline zu testen und auszuführen. Um den Status zu sehen, klicke auf die Schaltfläche "Status". 

Aufbau der Jenkins-Pipeline

Nachdem der Lauf abgeschlossen ist, können wir die Protokolle einsehen, indem wir im Menü "Status" auf den jeweiligen Lauf klicken. 

Klicke auf den Link "Letzter Build (#2)" und dann auf die Schaltfläche "Konsolenausgabe". Dadurch gelangen wir zum Konsolenausgabefenster, in dem wir die Logs und Ergebnisse der Pipeline finden.

Jenkins Pipeline Ausgabekonsole

Wir können sogar auf die Schaltfläche "Pipeline-Konsole" klicken, um jeden Schritt in der Pipeline im Detail zu sehen. Dazu gehören die Ausgabe, die Zeit, die zum Starten und Beenden benötigt wurde, Pipeline-Befehle und Protokolle. 

Jenkins Pipeline Konsole

Nachdem die Jenkins-Installation abgeschlossen war, war das Erstellen und Ausführen von Pipelines einfach und schnell. Ich habe weniger als eine Stunde gebraucht, um das Skript zu verstehen und mein eigenes zu erstellen. Ich werde Jenkins anstelle von GitHub Actions verwenden, weil es mir mehr Flexibilität bietet.

Author's opinion

Erstellen einer Jenkins-Pipeline für ein MLOPs-Projekt

Nach der anfänglichen Einführung in Jenkins ist es an der Zeit, dass wir ernsthaft an dem MLOps-Projekt arbeiten. 

Wir werden zwei Pipelines erstellen: Die erste Pipeline ist die KI, die die Daten lädt und verarbeitet, das Modell trainiert, das Modell auswertet und dann den Modellserver testet. Danach wird die CD-Pipeline initiiert und der Modellinferenzserver gestartet.

Um den Prozess im Detail zu verstehen, besuche den Kurs CI/CD for Machine Learning, in dem du lernst, wie du die Entwicklungsprozesse für maschinelles Lernen optimieren kannst.

Projekt-Dateien

Wie bei jedem Projekt müssen wir die Projektdateien erstellen, einschließlich der Python-Dateien für das Laden der Daten, das Training des Modells, die Auswertung des Modells und die Bereitstellung des Modells. Wir brauchen auch eine requirements .txt Datei, um die notwendigen Python-Pakete zu installieren.

data_loading.py:

In diesem Skript laden wir einen Scikit-Learn-Datensatz namens Wein-Datensatz und wandeln ihn in einen Pandas DataFrame um. Dann teilen wir den Datensatz in eine Trainings- und eine Testmenge auf. Zum Schluss speichern wir die verarbeiteten Daten in einer Pickle-Datei.

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

model_training.py:

In dieser Datei laden wir die verarbeiteten Daten, trainieren einen Random Forest-Klassifikator und speichern das Modell als Pickle-Datei.

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

model_evaluation.py:

Um das Modell zu bewerten, laden wir sowohl das Modell als auch den vorverarbeiteten Datensatz, erstellen einen Klassifizierungsbericht und drucken die Trefferquote aus.

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

model_serving.py:

Für das Model Serving werden wir FastAPI verwenden, um eine REST-API zu erstellen, über die Nutzer Merkmale eingeben und Vorhersagen erstellen können. Normalerweise sind die Etiketten allgemein gehalten. Um die Sache interessanter zu machen, werden wir die Weinkategorien in Verdante, Rubresco und Floralis ändern.

Wenn wir diese Datei ausführen, starten wir den FastAPI-Server, auf den wir mit dem Befehl curl oder mit der Bibliothek requests in Python zugreifen können.

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)

requirements.txt:

Diese Datei hilft uns dabei, alle Pakete herunterzuladen und zu installieren, die wir benötigen, um die oben genannten Python-Dateien auszuführen.

scikit-learn
pandas
fastapi
uvicorn

Wichtigste MLOps (CI) Pipeline 

Wir werden nun Jenkins-Pipelines für die kontinuierliche Integration erstellen. So wie wir eine einfache Pipeline erstellt haben, werden wir eine "MLOps-Pipeline" erstellen und das Skript schreiben, das alles von der Datenverarbeitung bis zur Modellauswertung abdeckt.

Jenkins Pipeline Skript

Das Skript für die MLOps-Pipeline besteht aus:

  1. Initialisierung der agent mit der label "MLAgent."
  2. Einstellen des Workspace-Verzeichnisses, in dem sich alle unsere Python-Dateien befinden.
  3. Erstellen von Stufen für jeden Schritt in der Pipeline des maschinellen Lernens:
    1. Installiere alle notwendigen Python-Pakete (Initialize).
    2. Verarbeitung des geladenen Datensatzes (Load and Preprocess Data).
    3. Trainiere das Modell mit einem bearbeiteten Datensatz (Train Model).
    4. Das Modell auswerten und den Bericht erstellen (Evaluate Model).
    5. Teste den Modellserver mit dem Befehl curl (Test Serve Model ).
  4. Nach bestandener Prüfung des Servers wird eine weitere Pipeline ausgelöst, um den Server einzusetzen. Dies wird im nächsten Abschnitt behandelt.
  5. Im Post-Knoten verarbeiten wir die Daten und speichern sie als Artefakt, indem wir sie mit der Dateierweiterung pickle versehen.

Hinweis: Der Befehl start /B öffnet ein neues Terminalfenster im Hintergrund und führt das Skript aus, das das Modell bedient. Außerdem funktioniert dieses Jenkins-Pipeline-Skript nur unter Windows, und wir müssen die Befehle für Linux oder andere Betriebssysteme ändern.

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

Model Serving (CD) Pipeline 

Jetzt erstellen wir eine kontinuierliche Bereitstellungspipeline, um den Server lokal bereitzustellen und zu betreiben.

Das Pipeline-Skript ist einfach. Wir beginnen damit, den Agenten zu definieren und das Arbeitsverzeichnis in unser Projekt zu ändern. Danach lassen wir den Server auf unbestimmte Zeit laufen. 

Hinweis: Es ist nicht empfehlenswert, einen Server in Jenkins auf unbestimmte Zeit laufen zu lassen, da Pipelines einen definierten Anfang und ein definiertes Ende haben sollten. In diesem Beispiel gehen wir davon aus, dass wir die App bereitgestellt haben, aber in der Praxis ist es besser, Docker zu integrieren und die App auf einem Docker-Server laufen zu lassen.

Wenn du lernen möchtest, wie ein/e Ingenieur/in für maschinelles Lernen zu denken, solltest du den Kurs Developing Machine Learning Models for Production with an MLOps Mindset besuchen, der dich in die Lage versetzt, deine maschinellen Lernmodelle zu trainieren, zu dokumentieren, zu warten und zu skalieren, um ihr volles Potenzial auszuschöpfen.

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

}

Ausführen der CI/CD-Pipelines

Gehe zur Pipeline "MLOps-pipe" und klicke auf die Schaltfläche "Jetzt bauen", um die CI/CD-Pipeline zu starten.

Sobald die Pipeline erfolgreich ausgeführt wurde, erzeugt sie zwei Artefakte: eines für das Modell und eines für den verarbeiteten Datensatz.

Jenkins Pipeline Status

Klicke auf die Schaltfläche "Stages" im Jenkins-Dashboard, um die Pipeline zu visualisieren und alle Schritte zu sehen.

Stufen der Jenkins-Pipeline

Die detaillierten Protokolle der einzelnen Schritte kannst du im Menü "Pipeline-Konsole" einsehen.

Jenkins Pipeline Konsole

Wir können auch die "ModelServingPipeline" überprüfen, um sicherzustellen, dass unser Server unter der lokalen URL http://127.0.0.1:9000 läuft. 

Jenkins Pipeline Ausgabekonsole

Ausprobieren der FastAPI-Anwendung im Browser

Die FastAPI wird mit der Swagger UI ausgeliefert, die durch Hinzufügen von /docs zur lokalen URL aufgerufen werden kann: http://127.0.0.1:9000/docs.

Mit der Swagger UI können wir die FastAPI-Anwendung im Browser testen. Es ist ganz einfach, und wir können sehen, dass unser Modellserver gut funktioniert. Die vorhergesagten Probenwerte deuten darauf hin, dass der Weintyp Rubresco ist.

Swager UI für ML-Anwendung

Achte immer darauf, dass du den Modellserver nach dem Experimentieren herunterfährst. Du kannst das tun, indem du im Jenkins-Dashboard zum Menü "Status" gehst und dann auf die Schaltfläche "Kreuz" klickst, wie unten gezeigt:

Status des Jenkins-Pipelinelaufs

Der gesamte Code, die Datensätze, die Modelle und die Metadateien in diesem Tutorial sind im GitHub-Repository verfügbar, damit du siey: kingabzpro/MLOps-with-Jenkins.

Fazit

Jenkins ist ein großartiger Automatisierungsserver für alle Arten von MLOps-Aufgaben. Es zeichnet sich als hervorragende Alternative zu GitHub Actions aus, da es mehr Funktionen, mehr Kontrolle und mehr Datenschutz bietet. 

Einer der attraktivsten Aspekte von Jenkins ist seine Einfachheit bei der Erstellung und Ausführung von Pipelines, die es sowohl für Anfänger als auch für erfahrene Nutzer zugänglich macht.

Wenn du daran interessiert bist, ähnliche Möglichkeiten mit GitHub Actions zu erkunden, solltest du dir das Tutorial A Beginner's Guide to CI/CD for Machine Learning nicht entgehen lassen. Für diejenigen, die ihr Verständnis von MLOps vertiefen wollen, ist der Kurs "Fully Automated MLOps " eine fantastische Ressource. Es bietet umfassende Einblicke in die MLOps-Architektur, CI/CD/CM/CT-Techniken und Automatisierungsmuster für die Bereitstellung von ML-Systemen, die über einen längeren Zeitraum hinweg konsistent Werte liefern können.

Fähigkeiten im Bereich Machine Learning aufbauen

Bringe deine Fähigkeiten im maschinellen Lernen auf Produktionsniveau.

Abid Ali Awan's photo
Author
Abid Ali Awan
LinkedIn
Twitter

Als zertifizierter Data Scientist ist es meine Leidenschaft, modernste Technologien zu nutzen, um innovative Machine Learning-Anwendungen zu entwickeln. Mit meinem fundierten Hintergrund in den Bereichen Spracherkennung, Datenanalyse und Reporting, MLOps, KI und NLP habe ich meine Fähigkeiten bei der Entwicklung intelligenter Systeme verfeinert, die wirklich etwas bewirken können. Neben meinem technischen Fachwissen bin ich auch ein geschickter Kommunikator mit dem Talent, komplexe Konzepte in eine klare und prägnante Sprache zu fassen. Das hat dazu geführt, dass ich ein gefragter Blogger zum Thema Datenwissenschaft geworden bin und meine Erkenntnisse und Erfahrungen mit einer wachsenden Gemeinschaft von Datenexperten teile. Zurzeit konzentriere ich mich auf die Erstellung und Bearbeitung von Inhalten und arbeite mit großen Sprachmodellen, um aussagekräftige und ansprechende Inhalte zu entwickeln, die sowohl Unternehmen als auch Privatpersonen helfen, das Beste aus ihren Daten zu machen.

Themen

In diesen Kursen erfährst du mehr über MLOps!

Kurs

MLOps Concepts

2 hr
23.3K
Discover how MLOps can take machine learning models from local notebooks to functioning models in production that generate real business value.
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow
Verwandt

Der Blog

Lehrer/innen und Schüler/innen erhalten das Premium DataCamp kostenlos für ihre gesamte akademische Laufbahn

Keine Hacks, keine Tricks. Schüler/innen und Lehrer/innen, lest weiter, um zu erfahren, wie ihr die Datenerziehung, die euch zusteht, kostenlos bekommen könnt.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

4 Min.

Der Blog

Die 32 besten AWS-Interview-Fragen und Antworten für 2024

Ein kompletter Leitfaden zur Erkundung der grundlegenden, mittleren und fortgeschrittenen AWS-Interview-Fragen, zusammen mit Fragen, die auf realen Situationen basieren. Es deckt alle Bereiche ab und sorgt so für eine abgerundete Vorbereitungsstrategie.
Zoumana Keita 's photo

Zoumana Keita

30 Min.

Der Blog

Die 20 besten Snowflake-Interview-Fragen für alle Niveaus

Bist du gerade auf der Suche nach einem Job, der Snowflake nutzt? Bereite dich mit diesen 20 besten Snowflake-Interview-Fragen vor, damit du den Job bekommst!
Nisha Arya Ahmed's photo

Nisha Arya Ahmed

20 Min.

Der Blog

Top 30 Generative KI Interview Fragen und Antworten für 2024

Dieser Blog bietet eine umfassende Sammlung von Fragen und Antworten zu generativen KI-Interviews, die von grundlegenden Konzepten bis hin zu fortgeschrittenen Themen reichen.
Hesam Sheikh Hassani's photo

Hesam Sheikh Hassani

15 Min.

Der Blog

Q2 2023 DataCamp Donates Digest

DataCamp Donates hat im zweiten Quartal 2023 über 20.000 Stipendien an unsere gemeinnützigen Partner vergeben. Erfahre, wie fleißige benachteiligte Lernende diese Chancen in lebensverändernde berufliche Erfolge verwandelt haben.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

Der Blog

2022-2023 DataCamp Classrooms Jahresbericht

Zu Beginn des neuen Schuljahres ist DataCamp Classrooms motivierter denn je, das Lernen mit Daten zu demokratisieren. In den letzten 12 Monaten sind über 7.650 neue Klassenzimmer hinzugekommen.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

8 Min.

Mehr anzeigenMehr anzeigen