Install Jenkins and the default suggested plugins by using the Jenkins installation documentation. If you already have Jenkins installed, make sure you have the default suggested plugins installed, including Git and Workspace Cleanup. The default suggested plugins are marked as suggested in the Jenkins platform plugins list. The pipeline generator was developed with Jenkins 2.462.2.

Install these Jenkins plugins:

For information on how to install plugins, see the Jenkins documentation Managing Plugins.

 Plugin Versions

Install the required products and tools on your build agent by using one of these approaches:

Configure at least two executors on your Jenkins instance. Executors control the number of concurrent tasks or builds Jenkins can run. The pipeline generator requires at least two executors: one executor to generate the pipeline and load the children stages and another executor to execute those stages. If you decide to run model tasks in parallel using the pipeline architecture IndependentModelPipelines, you need additional executors to handle each of the generated parallel pipelines. For information on how to define Jenkins executors, see the Jenkins documentation on Managing Nodes.

Create a Pipeline project in Jenkins using the default settings. For this example, you can follow the Jenkins documentation to create a basic Pipeline through the classic UI. In a later section, you return to these configuration settings to configure your Pipeline project to use the template Jenkinsfile from your source control management (SCM) system.

Set up a remote GitLab repository by creating a new blank project. See the GitLab documentation for Create a project.

For this example, create a copy of the Process Advisor example project for Jenkins.

processAdvisorJenkinsExampleStart

Connect your project, remote repository, and CI platform by adding the remote URL to your local repository. For more information, see Share Git Repository to Remote. Typically, a remote URL in GitLab has the format, https://gitlab.com/gitlab-org/gitlab.git.

Specify the Jenkins node agent by replacing <Jenkins agent label> with the label for your Jenkins agent. For example:

// Copyright 2025 The MathWorks, Inc.
node('my-jenkins-agent-label'){

Specify the MATLAB support package root path by specifying the environment variable MW_SUPPORT_PACKAGE_ROOT as the path to the MATLAB support package root on the Jenkins agent. You can get the path by running matlabshared.supportpkg.getSupportPackageRoot in MATLAB on the agent. For example:

env.MW_SUPPORT_PACKAGE_ROOT = 'C:\\ProgramData\\MATLAB\\SupportPackages\\R2025a\\bin';

If your project is in a subfolder of the repository root, uncomment and set the environment variable MW_RELATIVE_PROJECT_PATH. The path must end with /.

For example, if the full path to your project is /home/user/repo-root/src/myproject, you specify the relative project path as:

env.MW_RELATIVE_PROJECT_PATH = "src/myproject/";

Optionally, you can customize project directories by defining these environment variables.

<RemoteBuildCacheName>/
└── branchName/
    └── folderForEachRunId/
        └── folderForEachTaskIteration/
            ├── Project/
                ├── PA_Results/
                ├── derived/
            │       └── artifacts.dmr
        ├── ir_dag.json
        ├── simulink_pipeline
└── __lastSuccessfulRunId__

Optionally, if you plan to integrate with one of the supported external artifact management systems, you must configure your Jenkins credentials for your chosen artifact management system by uncommenting the withCredentials code block that contains the environment variable for that artifact management system and setting the Jenkins credential secret. See the Jenkins documentation for Using credentials.

Optionally, you can set up integration with an artifact management system by uncommenting and defining one of these secrets in your Jenkins credentials. Do not specify secrets or tokens directly in the Jenkinsfile_pipeline_gen file. See the Jenkins documentation for Using credentials.

withCredentials([string( credentialsId: 'ARTIFACTORY_API_TOKEN_SECRET',variable: 'artifactory_api_token')]) {
    env.ARTIFACTORY_API_TOKEN = artifactory_api_token;
}

withCredentials([string( credentialsId: 'S3_AWS_SECRET_ACCESS_KEY_SECRET',variable: 's3_access_key')]) {
    env.S3_AWS_SECRET_ACCESS_KEY = s3_access_key;
}

withCredentials([string( credentialsId: 'AZ_CONNECTION_STRING_SECRET',variable: 'az_connection_string')]) {
    env.AZ_CONNECTION_STRING = az_connection_string;
}

Optionally, if you want to run the root job in a container, use a docker.image wrapper as shown in this code example:

def pipelineGenerationPath = "${env.MW_RELATIVE_PROJECT_PATH}${env.MW_PIPELINE_GEN_DIRECTORY}";
stage('Pipeline Generation'){
    cleanWs();def scmVars=checkout scm;
    docker.image('<Full Image Name>').inside("<Optional Containers Arguments>") {
        // Loading pipeline utilities script
        ...
    }
}

Specify which Jenkins agents can run the pipeline by replacing <Jenkins agent label> with the label for your Jenkins agent. For example:

op.AgentLabel = "my-jenkins-agent-label";

Choose where the pipeline stores your artifacts by setting the ArtifactServiceMode property. Each artifact storage approach has its own specific configuration requirements as shown in ArtifactServiceMode. Depending on which artifact storage approach you choose, you need to specify additional properties and Jenkins credentials.

op.ArtifactServiceMode = "network";
op.NetworkStoragePath = "/artifactManagement/cacheStorage";

op.ArtifactServiceMode = "jfrog";
op.ArtifactoryUrl = "http://localhost:8082/artifactory";
op.ArtifactoryRepoName = "example-repo-local";

op.ArtifactServiceMode = "s3";
op.S3BucketName = "my-artifacts-bucket";
op.S3AwsAccessKeyID = "AKIAIOSFODNN7EXAMPLE";

op.ArtifactServiceMode = "azure_blob";
op.AzContainerName = "mycontainer";

Optionally, if you want to runs tasks inside a containerized environment, such as a Docker container, uncomment and specify the properties RunnerType and ImageTag. For example:

op.RunnerType = "container";
op.ImageTag = 'my-docker-image-name';

% Docker image settings
op.MatlabLaunchCmd = "xvfb-run -a matlab -batch"; 
op.MatlabStartupOptions = "";
op.AddBatchStartupOption = false;

Optionally, you can customize other pipeline generator options by specifying the other properties of the padv.pipeline.JenkinsOptions object in the generate_jenkins_pipeline file.

For example, the template generate_jenkins_pipeline file specifies the pipeline architecture "SerialStagesGroupPerTask" which creates one stage for each task in the process. But you can change the number of stages and grouping of tasks in the generated pipeline by changing the PipelineArchitecture property value.

By default, the generate_jenkins_pipeline function generates a pipeline for the "CIPipeline" process. To target a different process, specify a different process name in the call to the padv.pipeline.generatePipeline function in the generate_jenkins_pipeline file. For example:

padv.pipeline.generatePipeline(op,"myFastFailProcess");

For the purpose of this example, commit and push your copy of the processAdvisorJenkinsExampleStart project to source control.

In Jenkins, in the Pipeline section of the project configuration window, select Pipeline script from SCM from the Definition list.

Select your source control system from the SCM list.

Paste your repository URL into the Repository URL box.

Complete the required setup as shown in Collect Detailed Execution Data with OpenTelemetry Integration.

Install and configure the Jenkins OpenTelemetry plugin.

In your padv.pipeline.JenkinsOptions object, set the EnableOpenTelemetry property to true. The pipeline generator automatically enables OpenTelemetry for the runprocess function and start spans for other stages in the generated pipeline such as report generation and artifact collection.

Optionally, if you want to use custom resource attributes, such as a Git™ commit ID, you can specify those by using an OTEL_RESOURCE_ATTRIBUTES environment variable in your Jenkinsfile.