Archiving artifacts in Jenkins - Deep Dive

Overview - Archiving artifacts

What is it?

Archiving artifacts in Jenkins means saving files produced by a build so they can be accessed later. These files can be anything like compiled programs, logs, or reports. Archiving helps keep important build outputs safe and easy to find after the build finishes. It is like putting your finished work in a labeled folder for future use.

Why it matters

Without archiving artifacts, important build outputs could be lost or hard to find, making it difficult to debug or share results. Archiving ensures that teams can review, download, or use these files anytime after the build. This saves time and prevents repeated work, improving collaboration and reliability in software delivery.

Where it fits

Before learning archiving artifacts, you should understand basic Jenkins jobs and builds. After mastering archiving, you can explore advanced topics like artifact promotion, pipeline artifact handling, and artifact storage solutions.

Mental Model

Core Idea

Archiving artifacts is like saving your finished work in a safe place so you can access it anytime after the build is done.

Think of it like...

Imagine you bake cookies and put them in a labeled jar to keep them fresh and easy to find later. Archiving artifacts is like putting your build files in a jar labeled with the build number.

┌─────────────┐
│ Build Runs  │
└─────┬───────┘
      │
      ▼
┌─────────────┐
│ Build Output│
│ (files)     │
└─────┬───────┘
      │ Archive
      ▼
┌─────────────┐
│ Artifact    │
│ Storage     │
└─────────────┘

Build-Up - 7 Steps

1

Foundation

What are build artifacts

Concept: Introduce what build artifacts are and why they matter.

Build artifacts are files created during a build process, like compiled programs, logs, or test reports. They represent the output of your work and are important to keep for later use or review.

Result

You understand that artifacts are the important files your build produces.

Knowing what artifacts are helps you see why saving them is necessary for tracking and sharing build results.

2

Foundation

Basic Jenkins job and build flow

Concept: Explain how Jenkins runs jobs and produces build outputs.

Jenkins runs jobs that execute steps like compiling code or running tests. Each job run is called a build. The build produces files in the workspace folder during execution.

Result

You see where artifacts come from in Jenkins builds.

Understanding the build flow clarifies where and when artifacts are created and why they need to be saved.

3

Intermediate

How to archive artifacts in Jenkins UI

🤔Before reading on: do you think archiving artifacts requires extra plugins or is built-in? Commit to your answer.

Concept: Show how to use Jenkins built-in feature to archive artifacts after a build.

In Jenkins job configuration, you can add a post-build action called 'Archive the artifacts'. You specify file patterns like '**/*.jar' to save matching files from the workspace. After the build, Jenkins copies these files to a safe storage linked to the build.

Result

Artifacts matching the pattern are saved and accessible from the build page.

Knowing the simple UI step to archive artifacts empowers you to preserve important build outputs without extra tools.

4

Intermediate

Using artifact patterns and wildcards

🤔Before reading on: do you think you must list every file exactly or can you use patterns? Commit to your answer.

Concept: Explain how to specify which files to archive using patterns and wildcards.

Jenkins supports wildcards like '*' and '**' to select files. For example, '**/*.zip' archives all zip files in any folder. This lets you save many files without listing each one. You can also exclude files with '!' prefix.

Result

You can flexibly select files to archive using patterns.

Understanding patterns prevents missing important files or archiving too many unnecessary ones.

5

Intermediate

Accessing and downloading archived artifacts

Concept: Show how to find and download artifacts after a build completes.

After a build finishes, Jenkins shows an 'Artifacts' section on the build page. You can click files to download or view them. This makes sharing and reviewing build outputs easy for the team.

Result

You can retrieve archived files anytime from Jenkins UI.

Knowing how to access artifacts makes archiving practical and useful for collaboration.

6

Advanced

Archiving artifacts in Jenkins pipelines

🤔Before reading on: do you think pipeline syntax for archiving differs from freestyle jobs? Commit to your answer.

Concept: Teach how to archive artifacts using Jenkins pipeline scripts.

In a Jenkins pipeline, use the 'archiveArtifacts' step with a file pattern. Example: archiveArtifacts artifacts: '**/target/*.jar', fingerprint: true. This archives files and optionally fingerprints them for tracking.

Result

Artifacts are saved during pipeline runs and linked to the build.

Knowing pipeline syntax integrates artifact archiving into code-defined workflows for automation.

7

Expert

Fingerprinting and artifact tracking

🤔Before reading on: do you think archiving artifacts automatically tracks their usage across builds? Commit to your answer.

Concept: Explain fingerprinting to track artifact usage and detect duplicates.

Fingerprinting creates a unique ID for each archived file based on content. Jenkins tracks which builds produced or used the same artifact. This helps identify shared dependencies and avoid duplication.

Result

You can trace artifact origins and usage across builds.

Understanding fingerprinting improves artifact management and debugging in complex projects.

Under the Hood

When you archive artifacts, Jenkins copies matching files from the build workspace to a dedicated storage area on the Jenkins master. It stores metadata linking these files to the specific build number. For fingerprinting, Jenkins computes a hash of the file content to uniquely identify it and records this in its database. This allows Jenkins to track artifact usage across builds and jobs.

Why designed this way?

Jenkins separates workspace files from archived artifacts to prevent loss when workspaces are cleaned or reused. Storing artifacts centrally ensures long-term availability. Fingerprinting was added to solve the problem of tracking shared files and dependencies in large projects, improving traceability and build reliability.

┌─────────────┐       ┌───────────────┐
│ Build       │       │ Jenkins Master│
│ Workspace   │──────▶│ Artifact Store│
│ (files)     │       │ (archived)    │
└─────────────┘       └───────┬───────┘
                                │
                                ▼
                      ┌───────────────────┐
                      │ Fingerprint DB    │
                      │ (file hashes)     │
                      └───────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does archiving artifacts automatically back up your entire workspace? Commit yes or no.

Common Belief: Archiving artifacts saves the entire workspace automatically.

Reality: Archiving only saves files matching the specified patterns, not the whole workspace.

Why it matters: Assuming the whole workspace is saved can cause loss of important files if patterns are incomplete.

Quick: Do you think archived artifacts are stored on the build agent machine? Commit yes or no.

Common Belief: Artifacts remain on the build agent after archiving.

Reality: Artifacts are copied to the Jenkins master or configured storage, not left on the agent.

Why it matters: Expecting artifacts on agents can cause confusion when agents are cleaned or reused.

Quick: Does fingerprinting automatically archive files? Commit yes or no.

Common Belief: Fingerprinting archives files by itself.

Reality: Fingerprinting only tracks files that are already archived; it does not archive files.

Why it matters: Confusing fingerprinting with archiving can lead to missing artifact storage.

Quick: Can you archive files outside the workspace by default? Commit yes or no.

Common Belief: You can archive any file on the system from Jenkins easily.

Reality: Jenkins archives only files inside the workspace by default for security and consistency.

Why it matters: Trying to archive outside files without setup can cause build failures or security risks.

Expert Zone

1

Artifact archiving impacts build storage size; managing retention policies is crucial to avoid disk space issues.

2

Fingerprinting helps detect when different builds produce identical files, enabling smarter caching and dependency management.

3

In distributed Jenkins setups, artifact storage location and transfer speed affect build performance and reliability.

When NOT to use

Archiving artifacts is not suitable for very large files or datasets; in such cases, use dedicated artifact repositories like Nexus or Artifactory. Also, avoid archiving temporary or intermediate files that are not needed after the build.

Production Patterns

In production, teams use artifact archiving combined with artifact repositories for versioning and sharing. Pipelines automate archiving with fingerprinting to track dependencies. Retention policies clean old artifacts to save space. Some use external storage like cloud buckets linked to Jenkins.

Connections

Continuous Integration

Archiving artifacts is a key part of CI pipelines to preserve build outputs for testing and deployment.

Understanding artifact archiving clarifies how CI systems maintain reliable build outputs for downstream steps.

Version Control Systems

Artifacts complement source code in version control by saving compiled or generated files separately.

Knowing artifact archiving helps distinguish between source code management and build output management.

Library Management in Software Development

Artifact fingerprinting relates to how libraries are tracked and reused across projects.

Seeing fingerprinting as a form of library version tracking connects build artifacts to dependency management.

Common Pitfalls

#1 Not specifying correct file patterns causes no artifacts to be archived.

Wrong approach:

Archive the artifacts with pattern: '*.jar' when jar files are in subfolders.

Correct approach:

Archive the artifacts with pattern: '**/*.jar' to include jars in all folders.

Root cause:

Misunderstanding how wildcards work in Jenkins file patterns.

#2 Archiving too many files bloats storage and slows Jenkins.

Wrong approach:

Archive the artifacts with pattern: '**/*' to save everything.

Correct approach:

Archive only necessary files with specific patterns like '**/target/*.jar'.

Root cause:

Not filtering artifacts leads to unnecessary storage use.

#3 Expecting artifacts to persist after workspace cleanup without archiving.

Wrong approach:

Rely on workspace files after build finishes without archiving step.

Correct approach:

Add 'Archive the artifacts' post-build action to save files permanently.

Root cause:

Confusing workspace lifetime with artifact storage.

Key Takeaways

Archiving artifacts saves important build files so they can be accessed anytime after the build.

You must specify correct file patterns to archive the right files; wildcards help select many files easily.

Artifacts are stored separately from the workspace to ensure they are safe even if the workspace is cleaned.

Fingerprinting tracks artifact usage across builds but does not archive files by itself.

In pipelines, archiving artifacts is done with a special step, enabling automation and better build management.