Kontinuierliche Integration mit Docker-Containern, GitLab Runner und CI/CD Automation for Simulink Check

Einführung

Die Bedeutung von Softwarezuverlässigkeit und -integrität nimmt mit zunehmender Komplexität und Vernetzung der Systeme stetig zu. Trotz der Einhaltung etablierter bewährter Ingenieurpraktiken bleibt die Entwicklung von Systemen mit hoher Integrität ein technisch anspruchsvolles und finanziell intensives Unterfangen. Angesichts des erheblichen Aufwands, der mit Überprüfungen, Analysen, Tests und Regressionstests verbunden ist, suchen Ingenieure ständig nach Möglichkeiten, Verschwendung zu reduzieren und gleichzeitig die Gesamtqualität der Software zu verbessern. Einer der neuesten Trends ist der Vormarsch von Continuous Integration und Continuous Deployment (CI/CD)-Lösungen.

CI/CD-Praktiken haben die Softwareentwicklung revolutioniert und ermöglichen die schnelle und konsistente Bereitstellung qualitativ hochwertiger Software. Doch die rasante Weiterentwicklung dieser Technologie sowie die Vielzahl der verfügbaren Tools können die Erstellung einer robusten CI/CD-Lösung extrem schwierig machen. Dieser Artikel stellt einen umfassenden Ansatz zur Implementierung von CI/CD-Pipelines mit GitLab^® Runner, Docker^® und CI/CD Automation for Simulink Check™ vor.

Bedeutung von CI/CD für die Entwicklung und Zertifizierung sicherheitskritischer Software

CI/CD sind unverzichtbare Praktiken in der modernen Softwareentwicklung, insbesondere für sicherheitskritische Systeme, wie sie beispielsweise im Gesundheitswesen, in der Automobilindustrie und in der Luft- und Raumfahrt eingesetzt werden. Der Einsatz einer effizienten CI/CD-Lösung kann dazu beitragen, Qualität und Zuverlässigkeit zu verbessern, eine schnellere Erkennung und Behebung von Problemen zu ermöglichen und die fortlaufende Einhaltung regulatorischer Standards sicherzustellen. Da bereits eine einzige Änderung der Anforderungen eine Kaskade von Nachbesserungsarbeiten auslösen kann, ist ein solider CI/CD-Prozess unerlässlich für die kosteneffektive Verwaltung jedes sicherheitskritischen Softwareentwicklungsprogramms.

Dieser Artikel beschreibt die folgenden Schritte zur Konfiguration von Werkzeugen außerhalb der nativen Modellierungsumgebung für die Integration mit der MATLAB^®- und Simulink^®-Toolsuite:

• Simulink Check Process Advisor
• GitLab und GitLab Runners
  • Konfiguration von GitLab CI/CD-Pipelines
• Docker
  • Erstellen des Docker-Images
  • Build-Argumente
  • Image erstellen und Container starten
  • GitLab Runner ausführen, um auf Jobs zu warten
  • Testen und Fehlerbehebung des Docker-Image

Simulink Check Process Advisor

Die Process Advisor App, die als Teil der CI/CD Automation for Simulink Check verfügbar ist, ist ein leistungsstarkes Werkzeug zur Entwicklung einer Model-Based Design-Pipeline innerhalb der MATLAB-Umgebung, die dann über die bereitgestellte Vorlagendatei .yml in einer externen Umgebung verwendet werden kann. Für Modellentwickler, die eine Prozesspipeline innerhalb der MATLAB-Umgebung konfigurieren möchten, sei auf die folgende Dokumentation verwiesen:

1. Einrichten eines Prozessmodells: Passen Sie Ihr Prozessmodell an
2. Automatisierung der Modellverifizierung und -validierung: Automatisieren und führen Sie Aufgaben mit Process Advisor aus.
3. Bewährte Praktiken für die Verwendung von Process Advisor: Bewährte Praktiken für die Erstellung von Prozessmodellen

GitLab und GitLab Runners

An diesem Punkt sind Sie bereit, Ihr Prozessmodell in eine CI/CD-Pipeline in GitLab zu integrieren. Um sicherzustellen, dass Aktualisierungen Ihres Simulink-Prozessmodells automatisch in der GitLab-Pipeline widergespiegelt werden, wird ein spezieller Ansatz verwendet: Anstatt Ihr Prozessmodell in einer statischen .yml-Datei nachzubilden, verwenden wir stattdessen eine .yml-Datei, die eine weitere .yml-Datei generiert, welche die aktuellen Tasks im Prozessmodell enthält. Siehe die Beispiel-Pipeline-Konfigurationsdatei (.gitlab-ci.yml) in Anhang A. Beachten Sie, dass es zwei Phasen gibt:

Phasen: 
 - SimulinkPipelineGeneration 
 - SimulinkPipelineExecution

Die erste Stufe erzeugt die Pipeline für die zweite Stufe.

Jetzt ist es wichtig zu überlegen, wie die im Prozessablauf verwendeten Modellierungs- und Verifizierungswerkzeuge lizenziert werden sollen. Eine Möglichkeit besteht darin, Batch-Token zu verwenden. Um ein Batch-Token zu verwenden, müssen Sie eines vom Batch Licensing Pilot anfordern und im Variablenbereich Ihrer .yml-Datei einfügen.

Variablen: 
 MLM_LICENSE_TOKEN: "<MATLAB_BATCH_TOKEN>"

Nicht alle Produkte unterstützen Batch-Token. In solchen Fällen müssen Sie möglicherweise eine herkömmliche Lizenzdatei (.lic) verwenden. Weitere Informationen zu Batch-Tokens finden Sie hier: MATLAB Batch Licensing Tokens. Beachten Sie, dass es sich bewährt hat, das Festcodieren von Tokens (und anderen Anmeldeinformationen) in Ihrer .yml- oder Dockerfile-Datei zu vermeiden. Für einen sichereren Ansatz sollten Sie erwägen, Ihr Docker-Image mithilfe von Umgebungsvariablen zu erstellen.

Konfiguration von GitLab CI/CD-Pipelines

Die Konfiguration Ihres GitLab-Projekts zur Verwaltung von Jobs ist unkompliziert. Zuerst müssen Sie sicherstellen, dass GitLab weiß, wo Ihre .yml-Datei zu finden ist. Unter Settings > CI/CD > General pipelines > CI/CD configuration file geben Sie den Pfad zur .yml-Datei Ihres Projekts an, idealerweise mit dem Namen „.gitlab-ic.yml“ (Abbildung 1).

Als Nächstes müssen Sie einen neuen Runner in GitLab erstellen. Dadurch wird ein gitlab-runner-token zur Verfügung gestellt, das Sie später verwenden werden, um Ihren Docker-Container bei Ihrer GitLab-Runner-Instanz zu registrieren (Abbildung 2).

Unter Settings > CI/CD > Runners > New project runner geben Sie ein Tag an und klicken Sie Create Runner (Abbildung 3).

Sobald der Runner erstellt ist, kopieren und speichern Sie das Runner-Authentifizierungstoken (Abbildung 4).

Docker

Erstellen des Docker-Images

Dies ist wohl der schwierigste Teil des Prozesses, da Sie sicherstellen müssen, dass Ihr Docker-Image nicht nur alle Tool-Abhängigkeiten installiert hat, sondern auch über eine Lizenz zur Verwendung dieser Tools verfügt. Wichtig ist auch zu beachten, dass Ihr Docker-Image eine von mehreren Betriebssystemdistributionen sein kann. In diesem Beispiel wird Ubuntu 22.04 verwendet.

Beginnen Sie mit der Installation aller Tools, die zum Ausführen Ihres Simulink-Prozessmodells und der GitLab-Runner benötigt werden. Fügen Sie in Ihrer Dockerfile ein Basis MATLAB Image hinzu:

VON mathworks/matlab-deps:${MATLAB_DOCKER_RELEASE}

Anschließend installieren Sie einige der erforderlichen Basisabhängigkeiten. Beachten Sie, dass die Build-Variablen später besprochen werden. Siehe die Beispiel-Dockerdatei in Anhang B für die vollständige Installationsbeschreibung. Die Dockerdatei beginnt mit der Installation der Abhängigkeiten für MPM, welches dann zur Installation der benötigten MATLAB und Simulink Produkte verwendet wird (mit Ausnahme von Simulink Code Inspector™). Installieren Sie als Nächstes die Abhängigkeiten für matlab-proxy. Sobald diese installiert sind, verwenden Sie MPM, um die benötigten Tools zu installieren und Ihre Lizenzierungsmethode zu konfigurieren. Beachten Sie, dass Sie außerdem gitlab-runner auf Ihrem Docker-Image installieren müssen und registrieren Sie es mit dem gitlab-runner-token, das Sie zuvor gespeichert. Der folgende Codeausschnitt zeigt, wie die Installation und Registrierung mit den gewünschten Konfigurationsoptionen erfolgt:

RUN curl -L 
 "https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh" | sudo bash && \ 
 sudo apt-get install --no-install-recommends --yes \ 
 gitlab-runner && \ 
 sudo apt-get clean && sudo apt-get autoremove && \ 
 gitlab-runner start && \ 
 sudo gitlab-runner register --non-interactive \ 
 --url "<gitlab-url>" \ 
 --token "${GITLAB_TOKEN}" \ 
 --docker-image ${IMAGE_NAME} \ 
 --executor "shell"

Wie aus der Dockerdatei hervorgeht, kann MPM alle erforderlichen MATLAB- und Simulink-Tools installieren, mit Ausnahme des Simulink Code Inspector. Für Simulink Code Inspector müssen Sie eine .iso-Datei von der MathWorks Website herunterladen und aus dieser Datei installieren Sie es. Weitere Informationen finden Sie in der mpm install-Dokumentation.

Nachdem Ihre Produkte installiert sind, müssen Sie nun Ihre Lizenzierungsmethode konfigurieren. Derzeit stehen drei Lizenzierungsmethoden zur Verfügung:

• Verwendung eines Batch-Token: Installieren Sie matlab-batch, um die Verwendung von MATLAB Batch-Lizenztoken zu ermöglichen. Beachten Sie, dass Polyspace Code Prover Server™ und Polyspace Bug Finder Server™ keine Batch-Token-Lizenzierung unterstützen und dass die Verwendung von Polyspace Code Prover™ und Polyspace Bug Finder™ für Desktop-Anwendungen in CI/CD-Umgebungen gegen die Softwarelizenzvereinbarung verstößt. Zur Installation von matlab-batch fügen Sie Folgendes zu Ihrer Dockerfile hinzu:

  • RUN wget -q https://ssd.mathworks.com/supportfiles/ci/matlab-batch/v1/glnxa64/matlab-batch \ 
        && sudo mv matlab-batch /usr/local/bin \ 
        && sudo chmod +x /usr/local/bin/matlab-batch
    

• Verwendung eines Lizenzserver: Geben Sie Host und Port des Rechners an, der die Netzwerklizenzen bereitstellt, wenn Sie die Lizenzinformationen als Umgebungsvariable einbinden möchten. Dies ist die bevorzugte Lizenzierungsoption. Es ist möglich, einen Build mit Folgendem zu erstellen:

  • --build-arg LICENSE_SERVER=27000@MyServerName
    

  Alternativ können Sie den Lizenzserver auch direkt in Ihrer Dockerdatei angeben:

  • ENV MLM_LICENSE_FILE=27000@flexlm-server-name
    

• Verwendung einer Lizenzdatei (.lic): Vom direkten Einfügen einer Lizenzdatei in einen Container wird dringend abgeraten. Alternativ können Sie jedoch ein Laufwerk in Ihren Container einbinden, das die erforderlichen Lizenzdateien enthält. Wenn Sie ein gemountetes Laufwerk für Ihre Lizenzdatei verwenden, fügen Sie eine der folgenden Zeilen in die Beispiel-Dockerdatei ein:

  • COPY ${PATH_TO_LICENSE} /opt/matlab/licenses/
    

  • ADD ${PATH_TO_LICENSE} /opt/matlab/licenses/
    

Noch eine letzte Sache zu den installierten Abhängigkeiten: Für einige Berichte wird ein Bildschirm benötigt, um Screenshots von Modellen aufzunehmen. Xvfb stellt eine virtuelle Anzeige für Aufgaben wie die folgenden bereit: padv.builtin.task.GenerateSDDReport, padv.builtin.task.GenerateSimulinkWebView und padv.builtin.task.GenerateModelComparison. Dies sollte als Teil der MPM-Abhängigkeiten installiert werden. Stellen Sie sicher, dass MPM von dem Benutzer installiert wird, der die Pipeline ausführen wird.

Build-Argumente

In diesem Beispiel ist die Dockerdatei so konfiguriert, dass sie mehrere Build-Argumente akzeptiert. Build-Argumente können wertvoll sein, um eine einzige Dockerfile zu pflegen, mit der mehrere Images erstellt werden können, oder um Benutzern die Möglichkeit zu geben, Build-Informationen zu übergeben, die sich im Laufe der Zeit ändern können oder die nicht direkt in die Dockerdatei einprogrammiert werden sollen.

Diese Dockerdatei enthält die folgenden Build-Argumente (--build-arg):

# docker build      --build-arg MATLAB_DOCKER_RELEASE=<matlab-docker-release> 
#      --build-arg MATLAB_VERSION=<matlab-release> 
# --build-arg GITLAB_TOKEN=<gitlab-token> 
# --build-arg MATLAB_BATCH_TOKEN=<matlab-token> 
# --build-arg IMAGE_NAME=<image-image> 
# --build-arg PATH_TO_LICENSE=<path-to-license>

Am Anfang Ihrer Dockerdatei können Sie für jedes Argument einen Standardwert festlegen, falls dem Build-Befehl kein Wert übergeben wird:

ARG MATLAB_DOCKER_RELEASE=r2023b-ubuntu22.04 
ARG MATLAB_VERSION=r2023b 
ARG MATLAB_BATCH_TOKEN="<USER>|TOKEN_ML|<TOKEN>" 
ARG GITLAB_TOKEN=<TOKEN> 
ARG IMAGE_NAME=matlab_image 
ARG PATH_TO_LICENSE=<PATH_TO_LICENSE>

Nach der FROM-Anweisung in Ihrer Dockerfile, müssen Sie die zu verwendenden Variablen deklarieren:

FROM mathworks/matlab-deps:${MATLAB_DOCKER_RELEASE}
 
ARG MATLAB_VERSION
ARG MATLAB_BATCH_TOKEN
ARG GITLAB_TOKEN
ARG IMAGE_NAME
ARG PATH_TO_LICENSE

Beachten Sie im obigen Ausschnitt, dass der Wert für MATLAB_DOCKER_RELEASE über die folgende Syntax abgerufen wird: ${<var>}.

Image erstellen und Container starten

Nachdem Ihre Dockerfile nun fertig ist, können Sie Ihren ersten Container über das Docker-Terminal erstellen:

• Wechseln Sie im Docker-Terminal mit dem Befehl `cd` in das Verzeichnis der Dockerfile und überprüfen Sie Folgendes:

> cd <path-to-dockerfile> 
> ls

• Docker-Image erstellen:

> docker build -t <image-name> -f <dockerfile-name>

Wenn Ihre Docker-Datei Build-Argumente verwendet, könnte Ihr Build-Befehl etwa so aussehen:

> docker build --build-arg PATH_TO_LICENSE=<path-to-license> --build-arg GITLAB_TOKEN=<gitlab-runner-token> --build-arg MATLAB_BATCH_TOKEN="<USER>|TOKEN_ML|<TOKEN>" -t <image-name> -f <dockerfile-name>

Sobald der Container erstellt ist, können Sie ihn über die Docker-Benutzeroberfläche oder über das Terminal ausführen:

> docker run --name <container_name> -v <optional_volume> <image_name>:latest

Ihre Dockerfile hat Ihr Image bereits als Ihren gitlab-runner registriert. Um dies zu bestätigen, sehen Sie sich die Datei /etc/gitlab-runner/config.toml innerhalb von Docker an und überprüfen Sie, ob der richtige Runner registriert ist (Abbildung 5).

Falls die Runner-Registrierung fehlerhaft ist oder geändert oder neu gestartet werden muss, verwenden Sie im Terminal des Docker-Images folgenden Befehl, um den Runner abzumelden und anschließend den korrekten Runner wiederherzustellen:

> sudo gitlab-runner unregister --token "<gitlab_token>" 
> sudo gitlab-runner register --non-interactive --url "<gitlab-url>" --token "<gitlab-runner-token>" --executor "shell"

GitLab Runner ausführen, um auf Jobs zu warten

Nachdem der Container nun läuft und als Ihr GitLab-Runner registriert ist, können Sie gitlab-runner starten und damit beginnen, Jobs zu finden (Abbildung 6). Starten Sie den Runner im Terminal des Containers mit folgendem Befehl:

>sudo gitlab-runner run

Es gibt viele Möglichkeiten, Ihre Pipeline zu starten, darunter geplante Builds, manuelle oder bedarfsgesteuerte Builds und Builds basierend auf neuen Commits in Ihrem GitLab-Repository (Abbildung 7).

• Geplante Builds: In GitLab verwenden Sie Build > Pipeline schedule um festzulegen, wann Pipelines ausgeführt werden sollen.
• Bei Commit-Builds: Standardmäßig führt GitLab die Pipeline jedes Mal aus, wenn Änderungen in das Repository übertragen werden. Um zu steuern, wie Builds ausgelöst werden, müssen Sie die .yml-Datei ändern oder bestimmte Tags zu den Commit-Nachrichten hinzufügen. Weitere Informationen unter Control how jobs run.
• Manuelle Builds: In GitLab verwenden Sie Settings > CI/CD > Run pipeline, um manuelle Builds auszulösen. Settings > CI/CD > Pipeline trigger tokens enthält Informationen zur Verwendung von curl, um Builds über ein Terminal auslösen.

Sobald die Pipeline ihre Ausführung abgeschlossen hat, können die Ergebnisse des letzten Jobs in Ihrer Pipeline angezeigt und heruntergeladen werden – Collect_Artifacts (Abbildung 8).

Testen und Beheben von Problemen mit dem Docker-Image

Beim Einrichten und Konfigurieren Ihres Docker-Images ist es wichtig, die Funktionen zwischendurch testen zu können. Hier sind ein paar hilfreiche Schritte, die Sie im Terminal des Docker-Containers durchführen können, um sicherzustellen, dass alles wie erwartet funktioniert:

1. Überprüfen Sie die MATLAB-Installation über das Terminal des Containers:

$ matlab-batch "disp('Hello, World.')"

2. Zur Generierung bestimmter Berichte (SDD) benötigt MATLAB eine Anzeige. Hierfür können Sie Xvfb verwenden. Um Xvfb zu testen:

$ sudo xvfb-run -e /dev/stdout -a matlab-batch "disp('Hello, World.')"

3. Die MATLAB Pipeline manuell ausführen:
   1. Klonen Sie das Repository (möglicherweise werden Sie zur Eingabe von Anmeldeinformationen aufgefordert – für die Zwei-Faktor-Authentifizierung sind Zugriffstoken erforderlich, die Sie in GitLab finden, indem Sie in der linken Seitenleiste Ihren Avatar auswählen: Wählen Sie Edit profile > Access Tokens > Add new token)

      $ sudo git clone <gitlab-repo-url> <local-repo>
      $ sudo git clone https://<user>:<access_token>@<gitlab-repo-url> <local-repo>
      

   2. Wechseln Sie in das Verzeichnis eines MATLAB-Projekts:

      $ cd <local-repo>/<project-path>
      

   3. Führen Sie die erste Phase der Pipeline aus:

      $ sudo -E matlab-batch -logfile "MATLAB_LOG_FILE" -nodesktop "cp = openProject(pwd); padv.pipeline.generatePipeline( padv.pipeline.GitLabOptions(PipelineArchitecture = padv.pipeline.Architecture.SerialStagesGroupPerTask, Tags = 'docker-matlab', GeneratedYMLFileName = 'simulink_pipeline.yml', GeneratedPipelineDirectory = fullfile('derived','pipeline'), MatlabLaunchCmd = 'xvfb -a matlab-batch', AddBatchStartupOption = false, EnableArtifactCollection = 'always'));"
      

   4. Überprüfen Sie die Generierung der simulink_pipeline.yml-Datei:

      $ cd derived 
      $ ls
      

Fazit

Die Integration von CI/CD ist von entscheidender Bedeutung für die Aufrechterhaltung hoher Standards in Bezug auf Qualität, Zuverlässigkeit und Compliance. CI/CD-Praktiken optimieren den Entwicklungsprozess und ermöglichen eine schnelle und konsistente Bereitstellung von Aktualisierungen, während gleichzeitig sichergestellt wird, dass alle Änderungen strenge Zertifizierungsanforderungen erfüllen. Dieser Ansatz steigert nicht nur die Produktivität, sondern verringert auch erheblich das Risiko von Fehlern und Nichteinhaltung von Vorschriften, die in zertifizierten Umgebungen von entscheidender Bedeutung sind.

Durch die Anwendung der in diesem Artikel besprochenen Tools und Praktiken sollten Organisationen in der Lage sein, eine robuste Umgebung mit Docker und GitLab Runner einzurichten, um eine effiziente und kostensparende CI/CD-Pipeline zu erstellen. Diese Pipeline soll einen effizienten, zuverlässigen und regelkonformen Entwicklungszyklus ermöglichen und letztendlich dazu beitragen, qualitativ hochwertige, zertifizierbare Systeme mit größerer Sicherheit und Effizienz zu liefern.