CODEWITHSUNDEEP
jenkins
Konstantin Milyutin
Konstantin Milyutin

Reputation: 12366

Export/import jobs in Jenkins

Is it possible to exchange jobs between 2 different Jenkins'? I'm searching for a way to export/import jobs.

Upvotes: 332

Views: 402487

Answers (19)

Artipixel
Artipixel

Reputation: 1244

A solution for Kubernetes

I found this topic helpful, and I created a solution for Kubernetes that will be useful to anyone who needs it in the future.

Using kubectl cp - Making a tar file, extracting it on your local and upload the files to the other jenkins

Export:

POD_NAME=humanzjenkins-0
POD_NAMESPACE=jenkins
POD_DIRECTORY=var/jenkins_home/jobs
LOCAL_DIRECTORY=./
TAR_FILE=/tmp/jenkins_backup.tar.gz

# Create a tarball of 'config.xml' files excluding the 'Old builds' directory
kubectl exec -n $POD_NAMESPACE $POD_NAME -- sh -c "find $POD_DIRECTORY -type f -name 'config.xml' ! -path '*/Old builds/*' | tar -czf $TAR_FILE -T -"

# Copy the tarball to the local machine
kubectl cp $POD_NAMESPACE/$POD_NAME:$TAR_FILE $LOCAL_DIRECTORY/jenkins_backup.tar.gz

# Clean up the tarball inside the pod
kubectl exec -n $POD_NAMESPACE $POD_NAME -- rm -f $TAR_FILE

# extract the tar file
tar -xf jenkins_backup.tar -C ./

# remove the tar file
rm -f jenkins_backup.tar

Import:

kubectl cp  ./ jenkins/humanzjenkins-0:var/jenkins_home/jobs

Upvotes: 0

Jitendra Chandani
Jitendra Chandani

Reputation: 385

Simple PHP script worked for me.

Export:

<?php
// add all job codes in the array
$jobs = array("job1", "job2", "job3");
foreach ($jobs as $value)
{
    fwrite(STDOUT, $value. " \n") or die("Unable to open file!");
    $path = "http://server1:8080/jenkins/job/".$value."/config.xml";
    $myfile = fopen($value.".xml", "w");
    fwrite($myfile, file_get_contents($path));
    fclose($myfile);
}

Import:

<?php
// add all job codes in the array
$jobs = array("job1", "job2", "job3");
foreach ($arr as $value)
{
    fwrite(STDOUT, $value. " \n") or die("Unable to open file!");
    $cmd = "java -jar jenkins-cli.jar -s http://server2:8080/jenkins/ create-job ".$value." < ".$value.".xml";
    echo exec($cmd);
}

Upvotes: 1

karthick
karthick

Reputation: 121

Jenkins export jobs to a directory

#! /bin/bash
SAVEIFS=$IFS
IFS=$(echo -en "\n\b")
declare -i j=0
for i in $(java -jar jenkins-cli.jar -s http://server:8080/jenkins list-jobs  --username **** --password ***);
do
  let "j++";
  echo $j;
  if [ $j -gt 283 ] // If you have more jobs do it in chunks as it will terminate in the middle of the process. So Resume your job from where it ends.
  then
    java -jar jenkins-cli.jar -s http://lxvbmcbma:8080/jenkins get-job --username **** --password **** ${i} > ${i}.xml;
    echo "done";
  fi
done

Import jobs

for f in *.xml;
do
  echo "Processing ${f%.*} file.."; //truncate the .xml extention and load the xml file for job creation
  java -jar jenkins-cli.jar -s http://server:8080/jenkins create-job ${f%.*}  < $f
done

Upvotes: 6

Katu
Katu

Reputation: 1564

Thanks to Larry Cai's answer I managed to create a script to backup all my Jenkins jobs. I created a job that runs this every week. In case someone finds it useful, here it is:

#!/bin/bash
#IFS for jobs with spaces.
SAVEIFS=$IFS
IFS=$(echo -en "\n\b")
for i in $(java -jar /run/jenkins/war/WEB-INF/jenkins-cli.jar -s http://server:8080/ list-jobs); 
do 
  java -jar /run/jenkins/war/WEB-INF/jenkins-cli.jar -s http://server:8080/ get-job ${i} > ${i}.xml;
done
IFS=$SAVEIFS
mkdir deploy
tar cvfj "jenkins-jobs.tar.bz2" ./*.xml

Upvotes: 7

MaratC
MaratC

Reputation: 6869

A one-liner without authentication:

$ curl -s http://OLD_JENKINS/job/JOBNAME/config.xml | curl -X POST 'http://NEW_JENKINS/createItem?name=JOBNAME' --header "Content-Type: application/xml" -d @-

A one-liner with authentication:

$ curl -s http:///<USER>:<API_TOKEN>@OLD_JENKINS/job/JOBNAME/config.xml | curl -X POST 'http:///<USER>:<API_TOKEN>@NEW_JENKINS/createItem?name=JOBNAME' --header "Content-Type: application/xml" -d @-

With Crumb, if CSRF is active (see details here), get crumb with:

$ CRUMB_OLD=$(curl -s 'http://<USER>:<API_TOKEN>@OLD_JENKINS/crumbIssuer/api/xml?xpath=concat(//crumbRequestField,":",//crumb)')
$ CRUMB_NEW=$(curl -s 'http://<USER>:<API_TOKEN>@NEW_JENKINS/crumbIssuer/api/xml?xpath=concat(//crumbRequestField,":",//crumb)')

Apply crumb with -H CRUMB:

$ curl -s -H $CRUMB_OLD http:///<USER>:<API_TOKEN>@OLD_JENKINS/job/JOBNAME/config.xml | curl -X POST -H $CRUMB_NEW 'http:///<USER>:<API_TOKEN>@NEW_JENKINS/createItem?name=JOBNAME' --header "Content-Type: application/xml" -d @-

Upvotes: 184

Damien C
Damien C

Reputation: 1137

Here is a bash script for dumping / migrating all jobs from input Jenkins, with a filtering on job name with first param.
i.e. type io-jenkins.sh MyAppName

You'll need to install before httpie1 and jq tools to make it work.

#!/bin/bash

if [[ $# != 1 ]] ; then 
    echo "Please type filter as first arg"
    exit 127
fi
input="https://<username>:<api-token>@<input-jenkins-baseurl>/"
output="https://<username>:<api-token>@<output-jenkins-baseurl>/"

jobsTree=$(http $input/api/json?tree=jobs[name]|jq -r ".jobs[].name" |grep $1)

IFS=$'\n'
for job in $jobsTree ; do 
    echo "Get '$job' config.xml"
    https "$input/job/$job/config.xml" > /tmp/jenkins-job.xml
    https POST "$output/createItem?name=$job" Content-Type:"application/xml" < /tmp/jenkins-job.xml
done

rm /tmp/jenkins-job.xml

1 HTTPie is an awesome and super-synthetic REST command line client. They also provide UI client (quite like Postman).

# Quick setup
brew install httpie jq # MACOS
apt-get install httpie jq # Linux / Debian

Upvotes: 0

xxxvodnikxxx
xxxvodnikxxx

Reputation: 1277

The most easy way, with direct access to the machine is to copy the job folder from first jenkins to another one (you can exclude workspaces - workspace folder), because the whole job configuration is stored in the xml file on the disk (config.xml in the job path folder)

Then in the new jenkins just reload configuration in the global settings (admin access is required) should be enough, if not, then you will need to restart Jenkins tool.

Another way can be to use plugins mentioned above this post.

edit:

  • in case you can probably also exclude modules folders and in case of pipelines as well shared libraries folders like workspace@libs

Upvotes: 2

JRichardsz
JRichardsz

Reputation: 16515

2021 and the export & import process are a pain!!

If you have shell access to both jenkins instances: the old and new, follow these steps to perform a success jobs migration:

In your old jenkins

  • locate the jenkins home in your old jenkins. Usually /var/lib/jenkins. If you are using bitnami : /opt/bitnami/jenkins
  • inside jenkins home, enter to jobs folder
  • you should see folders with the name of your jobs. Inside of these folder, you just need the config.xml
  • backup all the required jobs. Just the folder and its config.xml. There are a lot of other files that is not required.

In your new jenkins:

  • locate the jenkins home
  • copy your jobs (previous backup) to the jobs folder
  • ensure that these new folder have the user "jenkins" as owner. If not use this: chown jenkins:jenkins /var/lib/jenkins -R
  • restart jenkins
  • use your jobs :D

According to the count of up-votes or comments, I could think the possibility of create a new plugin :)

Upvotes: 2

Saikat
Saikat

Reputation: 16760

If you have exported the config.xml then use the same to import:

curl -k -X POST 'https:///<user>:<token>@<jenkins_url>/createItem?name=<job_name>' --header "Content-Type: application/xml" -d @config.xml

I am connecting via HTTPS and disabled certificate validation using -k.

  • This is how to generate user api token on Jenkins.
  • Jenkins REST API details can be seen if you click the link with same name at bottom right corner of your Jenkins instance.

Upvotes: 4

Khez
Khez

Reputation: 10350

Jenkins has a rather good wiki, albeit hard to read when you're new to CI software...

They offer a simple solution for moving jobs between servers

The trick probably was the need to reload config from the Jenkins Configuration Page.

Update 2020.03.10

The JenkinsCI landscape has changed a lot... I've been using Job DSL for a while now. We have a SEED Job that generates the rest of the jobs.

This helps us both recreate or move for the Jenkins server whenever needed :) You could also version those files for even more maintainability!

Upvotes: 176

Gayan Weerakutti
Gayan Weerakutti

Reputation: 13715

In a web browser visit:

http://[jenkinshost]/job/[jobname]/config.xml

Just save the file to your disk.

Upvotes: 51

Guardian
Guardian

Reputation: 393

It is very easy just download plugin name

Job Import Plugin

Enter the URL of your Remote Jenkins server and it will import the jobs automatically

Upvotes: 3

GaneSH Malkar
GaneSH Malkar

Reputation: 116

Job Import plugin is the easy way here to import jobs from another Jenkins instance. Just need to provide the URL of the source Jenkins instance. The Remote Jenkins URL can take any of the following types of URLs:

  • http://$JENKINS - get all jobs on remote instance

  • http://$JENKINS/job/$JOBNAME - get a single job

  • http://$JENKINS/view/$VIEWNAME - get all jobs in a particular view

Upvotes: 8

Justin Morgan
Justin Morgan

Reputation: 30760

For those of us in the Windows world who may or may not have Bash available, here's my PowerShell port of Katu and Larry Cai's approach. Hope it helps someone.

##### Config vars #####
$serverUri = 'http://localhost:8080/' # URI of your Jenkins server
$jenkinsCli = 'C:\Program Files (x86)\Jenkins\war\WEB-INF\jenkins-cli.jar' # Path to jenkins-cli.jar on your machine
$destFolder = 'C:\Jenkins Backup\' # Output folder (will be created if it doesn't exist)
$destFile = 'jenkins-jobs.zip' # Output filename (will be overwritten if it exists)
########################

$work = Join-Path ([System.IO.Path]::GetTempPath()) ([System.IO.Path]::GetRandomFileName())
New-Item -ItemType Directory -Force -Path $work | Out-Null # Suppress output noise
echo "Created a temp working folder: $work"

$jobs = (java -jar $jenkinsCli -s $serverUri list-jobs)
echo "Found $($jobs.Length) existing jobs: [$jobs]"

foreach ($j in $jobs)
{
    $outfile = Join-Path $work "$j.xml"
    java -jar $jenkinsCli -s $serverUri get-job $j | Out-File $outfile
}
echo "Saved $($jobs.Length) jobs to temp XML files"

New-Item -ItemType Directory -Force -Path $destFolder | Out-Null # Suppress output noise
echo "Found (or created) $destFolder folder"

$destPath = Join-Path $destFolder $destFile
Get-ChildItem $work -Filter *.xml | 
    Write-Zip -Level 9 -OutputPath $destPath -FlattenPaths |
    Out-Null # Suppress output noise
echo "Copied $($jobs.Length) jobs to $destPath"

Remove-Item $work -Recurse -Force
echo "Removed temp working folder"

Upvotes: 4

user1050755
user1050755

Reputation: 11691

Go to your Jenkins server's front page, click on REST API at the bottom of the page:

Create Job

To create a new job, post config.xml to this URL with query parameter name=JOBNAME. You need to send a Content-Type: application/xml header. You'll get 200 status code if the creation is successful, or 4xx/5xx code if it fails. config.xml is the format Jenkins uses to store the project in the file system, so you can see examples of them in the Jenkins home directory, or by retrieving the XML configuration of existing jobs from /job/JOBNAME/config.xml.

Upvotes: 15

pcrews
pcrews

Reputation: 170

This does not work for existing jobs, however there is Jenkins job builder.

This allows one to keep job definitions in yaml files and in a git repo which is very portable.

Upvotes: 1

jimmont
jimmont

Reputation: 2544

In my Jenkins instance (version 1.548) the configuration file is at:

/var/lib/jenkins/jobs/-the-project-name-/config.xml

Owned by jenkins user and jenkins group with 644 permissions. Copying the file to and from here should work. I haven't tried changing it directly but have backed-up the config from this spot in case the project needs to be setup again.

Upvotes: 17

Larry Cai
Larry Cai

Reputation: 59963

Probably use jenkins command line is another option, see https://wiki.jenkins-ci.org/display/JENKINS/Jenkins+CLI

  • create-job: Creates a new job by reading stdin as a configuration XML file.
  • get-job: Dumps the job definition XML to stdout

So you can do 

java -jar jenkins-cli.jar -s http://server get-job myjob > myjob.xml
java -jar jenkins-cli.jar -s http://server create-job newmyjob < myjob.xml

It works fine for me and I am used to store in inside my version control system

Upvotes: 202

jwernerny
jwernerny

Reputation: 7048

There's a plugin called Job Import Plugin that may be what you are looking for. I have used it. It does have issues with importing projects from a server that doesn't allow anonymous access.

For Completeness: If you have command line access to both, you can do the procedure already mentioned by Khez for Moving, Copying and Renaming Jenkins Jobs.

Upvotes: 25

Related Questions