Archiving artifacts in Jenkins - Commands & Configuration

Introduction

When you run a build in Jenkins, you often create files like reports or compiled programs. Archiving artifacts means saving these files so you can look at them later or use them in other steps.

When you want to keep test reports after a build finishes to check results.

When you need to save compiled programs so they can be downloaded or used in deployment.

When you want to keep logs or output files from a build for troubleshooting.

When you want to share build outputs with your team without rerunning the build.

When you want to keep a history of important files from each build for auditing.

Config File - Jenkinsfile

Jenkinsfile

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        echo 'Building the project...'
        sh 'echo Hello World > output.txt'
      }
    }
    stage('Archive') {
      steps {
        archiveArtifacts artifacts: 'output.txt', fingerprint: true
      }
    }
  }
}

This Jenkinsfile defines a simple pipeline with two stages.

Build stage: Creates a file named output.txt with some content.

Archive stage: Uses archiveArtifacts to save output.txt as a build artifact. The fingerprint: true option tracks the file for changes.

Commands

This command updates or creates the Jenkins job configuration from a YAML file. It prepares Jenkins to run the pipeline that archives artifacts.

Terminal

jenkins-jobs --conf jenkins.ini update my-pipeline-job.yaml

Expected Output

Job 'my-pipeline-job' updated successfully

This command triggers the Jenkins job named 'my-pipeline-job' and waits for it to finish. It runs the pipeline that creates and archives the artifact.

Terminal

java -jar jenkins-cli.jar -s http://localhost:8080 build my-pipeline-job -s

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] stage

[Pipeline] { (Build)

[Pipeline] sh

+ echo Hello World > output.txt

[Pipeline] }

[Pipeline] stage

[Pipeline] { (Archive)

[Pipeline] archiveArtifacts

Archiving artifacts

[Pipeline] }

[Pipeline] End of Pipeline

Finished: SUCCESS

→

-s - Waits for the build to complete before returning output

This command downloads the archived artifact file from the last successful build to verify it was saved correctly.

Terminal

curl -s http://localhost:8080/job/my-pipeline-job/lastSuccessfulBuild/artifact/output.txt

Expected Output

Hello World

Key Concept

Archiving artifacts saves important build files so you can access them later without rerunning the build.

Common Mistakes

Not specifying the correct file path in the archiveArtifacts step

Jenkins will not find the files to archive and the artifact will be missing.

Use the exact relative path or pattern matching the files created during the build.

Forgetting to add the archiveArtifacts step in the pipeline

Build files will be created but not saved, so they disappear after the build finishes.

Always add an archiveArtifacts step after files are generated to save them.

Trying to archive files before they are created

Jenkins will archive nothing because the files do not exist yet.

Place the archiveArtifacts step after the build or test steps that create the files.

Summary

Use the archiveArtifacts step in Jenkins pipelines to save build files like reports or binaries.

Run the pipeline to create files and then archive them for later access.

Verify archived files by downloading them from the Jenkins build page or using curl.

Practice

1. What is the main purpose of using archiveArtifacts in a Jenkins pipeline?

easy

A. To delete old build files automatically

B. To save build output files for later use or sharing

C. To trigger another build job

D. To send email notifications after a build

Solution

1. Step 1: Understand the role of archiveArtifacts

   This command is used to save files generated by a build so they can be accessed later.

2. Step 2: Compare with other options

   Deleting files, triggering builds, or sending emails are different Jenkins features, not related to archiving artifacts.

3. Final Answer:

   To save build output files for later use or sharing -> Option B

4. Quick Check:

   Archiving = Saving build files [OK]

Hint: Archiving means saving build files for future use [OK]

Common Mistakes:

• Confusing archiving with deleting files
• Thinking it triggers other jobs
• Assuming it sends notifications

2. Which of the following is the correct syntax to archive all .jar files in a Jenkins pipeline script?

easy

A. archiveArtifacts '*.jar'

B. archiveArtifacts '*.jar;'

C. archiveArtifacts '*.jar' {}

D. archiveArtifacts '*.jar'()

Solution

1. Step 1: Recall the syntax of archiveArtifacts

   The correct syntax uses the command followed by the file pattern in quotes without extra characters.

2. Step 2: Identify incorrect syntax

   Options with semicolon, braces, or parentheses after the pattern are invalid in Jenkins pipeline syntax.

3. Final Answer:

   archiveArtifacts '*.jar' -> Option A

4. Quick Check:

   Correct syntax = archiveArtifacts 'pattern' [OK]

Hint: Use single quotes and no extra symbols after pattern [OK]

Common Mistakes:

• Adding semicolons inside the pattern string
• Using braces or parentheses incorrectly
• Missing quotes around the pattern

3. Given this Jenkins pipeline snippet:

stage('Build') {
  steps {
    sh 'echo Hello > output.txt'
    archiveArtifacts 'output.txt'
  }
}

What will Jenkins do after this stage completes?

medium

A. Send output.txt as an email attachment

B. Delete the file output.txt immediately

C. Fail the build because output.txt is not found

D. Save the file output.txt as a build artifact

Solution

1. Step 1: Understand the shell command

   The command creates a file named output.txt with the text 'Hello'.

2. Step 2: Analyze archiveArtifacts usage

   This command archives the specified file so it is saved with the build for later access.

3. Final Answer:

   Save the file output.txt as a build artifact -> Option D

4. Quick Check:

   archiveArtifacts saves files [OK]

Hint: archiveArtifacts saves files created in the build [OK]

Common Mistakes:

• Assuming the file is deleted after archiving
• Thinking the build fails if file exists
• Confusing archiving with emailing files

4. You wrote this Jenkins pipeline snippet:

archiveArtifacts '*.log'

But no files are archived after the build. What is the most likely reason?

medium

A. No .log files were created in the workspace

B. The syntax of archiveArtifacts is incorrect

C. Jenkins does not support archiving .log files

D. The build failed before reaching the archive step

Solution

1. Step 1: Check the file pattern and workspace

   If no .log files exist in the workspace, nothing will be archived.

2. Step 2: Verify syntax and Jenkins support

   The syntax is correct and Jenkins supports archiving any file type.

3. Step 3: Consider build status

   If the build failed before this step, archiving wouldn't run, but the question implies the step ran.

4. Final Answer:

   No .log files were created in the workspace -> Option A

5. Quick Check:

   Files must exist to be archived [OK]

Hint: Check if files exist before archiving [OK]

Common Mistakes:

• Assuming Jenkins can't archive certain file types
• Blaming syntax without checking files
• Ignoring build step execution order

5. You want to archive all .jar files in the build/libs folder and also keep the build logs named build.log. Which archiveArtifacts usage is correct?

hard

A. archiveArtifacts 'build/libs/*.jar', build.log

B. archiveArtifacts 'build/libs/*.jar build.log'

C. archiveArtifacts artifacts: 'build/libs/*.jar, build.log'

D. archiveArtifacts artifacts: 'build/libs/*.jar', 'build.log'

Solution

1. Step 1: Understand multiple file patterns in archiveArtifacts

   To archive multiple patterns, use the named parameter artifacts with a comma-separated string.

2. Step 2: Analyze each option

   archiveArtifacts 'build/libs/*.jar', build.log passes two positional arguments (invalid), archiveArtifacts 'build/libs/*.jar build.log' lacks comma separator, archiveArtifacts artifacts: 'build/libs/*.jar', 'build.log' has invalid syntax with two strings.

3. Final Answer:

   archiveArtifacts artifacts: 'build/libs/*.jar, build.log' -> Option C

4. Quick Check:

   Use artifacts: 'pattern1, pattern2' for multiple files [OK]

Hint: Use artifacts: 'pattern1, pattern2' to archive multiple files [OK]

Common Mistakes:

• Omitting the artifacts: parameter
• Separating patterns without commas
• Passing multiple strings instead of one