Docker image as artifact in Jenkins - Commands & Configuration

Introduction

When you build software, you want to save the exact version of your app so you can use it later. Docker images let you package your app and its environment together. Storing these images as artifacts means you keep a safe copy to use in testing or production.

When you want to save a tested version of your app to deploy later without rebuilding.

When you need to share your app image between different teams or environments.

When you want to keep track of app versions for rollback if something goes wrong.

When you want to automate your build and deployment process using Jenkins pipelines.

When you want to reduce build time by reusing existing Docker images.

Config File - Jenkinsfile

Jenkinsfile

pipeline {
  agent any
  stages {
    stage('Build Docker Image') {
      steps {
        script {
          dockerImage = docker.build('my-app:1.0')
        }
      }
    }
    stage('Save Docker Image as Artifact') {
      steps {
        sh 'docker save my-app:1.0 -o my-app-1.0.tar'
        archiveArtifacts artifacts: 'my-app-1.0.tar', fingerprint: true
      }
    }
  }
}

This Jenkinsfile defines a pipeline with two stages:

• Build Docker Image: Builds a Docker image named my-app:1.0.
• Save Docker Image as Artifact: Saves the image to a tar file and archives it as a Jenkins artifact for later use.

Commands

Builds a Docker image named 'my-app' with tag '1.0' from the current directory's Dockerfile.

Terminal

docker build -t my-app:1.0 .

Expected Output

Sending build context to Docker daemon  2.048kB

Step 1/3 : FROM alpine:3.14

 ---> a24bb4013296

Step 2/3 : COPY app.sh /app.sh

 ---> Using cache

 ---> 5d41402abc4b

Step 3/3 : CMD ["/app.sh"]

 ---> Running in 7b8f9c3e1a2b

Removing intermediate container 7b8f9c3e1a2b

Successfully built 5d41402abc4b

Successfully tagged my-app:1.0

→

-t - Assigns a name and tag to the image

Saves the Docker image 'my-app:1.0' into a tar file named 'my-app-1.0.tar' to store or share.

Terminal

docker save my-app:1.0 -o my-app-1.0.tar

Expected Output

No output (command runs silently)

→

-o - Specifies the output file for the saved image

Lists the saved Docker image file with human-readable size to confirm it was created.

Terminal

ls -lh my-app-1.0.tar

Expected Output

-rw-r--r-- 1 user user 12M Jun  1 12:00 my-app-1.0.tar

→

-lh - Lists files with human-readable sizes

Key Concept

If you remember nothing else from this pattern, remember: saving your Docker image as an artifact lets you reuse and share the exact app version safely.

Common Mistakes

Not tagging the Docker image before saving it.

Without a tag, it's hard to identify or reuse the image version later.

Always use the '-t' flag with 'docker build' to name and tag your image clearly.

Forgetting to save the image to a file before archiving.

Jenkins cannot archive the image directly; it needs a file artifact.

Use 'docker save' to export the image to a tar file before archiving.

Not archiving the saved image file in Jenkins.

Without archiving, the image file won't be stored or accessible after the build.

Use 'archiveArtifacts' step in Jenkins to save the tar file as a build artifact.

Summary

Build a Docker image with a clear name and tag using 'docker build -t'.

Save the built image to a tar file using 'docker save' for storage or sharing.

Archive the saved tar file as a Jenkins artifact to keep it safe and accessible.

Practice

1. What is the main reason to save a Docker image as an artifact in Jenkins?

easy

A. To run the image on a different operating system

B. To delete the image after the build

C. To convert the image into a container

D. To reuse the image later without rebuilding it

Solution

1. Step 1: Understand Docker image reuse

   Saving a Docker image as an artifact allows you to reuse it later without rebuilding, saving time and resources.

2. Step 2: Identify Jenkins artifact purpose

   Jenkins artifacts store files from builds for later use or sharing, perfect for Docker images.

3. Final Answer:

   To reuse the image later without rebuilding it -> Option D

4. Quick Check:

   Docker image reuse = To reuse the image later without rebuilding it [OK]

Hint: Artifacts store files to reuse later, like saving your work [OK]

Common Mistakes:

• Thinking artifacts delete images
• Confusing image with container
• Assuming artifacts change OS compatibility

2. Which Jenkins pipeline step correctly archives a saved Docker image file named myimage.tar?

easy

A. archiveArtifacts artifacts: 'myimage.tar'

B. archiveArtifacts file: 'myimage.tar'

C. archiveArtifact artifacts: 'myimage.tar'

D. archiveArtifacts files: 'myimage.tar'

Solution

1. Step 1: Recall Jenkins archiveArtifacts syntax

   The correct syntax uses the parameter name 'artifacts' to specify files to archive.

2. Step 2: Match correct parameter and spelling

   archiveArtifacts artifacts: 'myimage.tar' uses 'archiveArtifacts artifacts: 'myimage.tar'', which is correct syntax.

3. Final Answer:

   archiveArtifacts artifacts: 'myimage.tar' -> Option A

4. Quick Check:

   Correct parameter is 'artifacts' = archiveArtifacts artifacts: 'myimage.tar' [OK]

Hint: Use 'artifacts' parameter exactly in archiveArtifacts step [OK]

Common Mistakes:

• Using 'file' instead of 'artifacts'
• Misspelling 'archiveArtifacts'
• Using singular 'archiveArtifact'

3. Given this Jenkins pipeline snippet:

stage('Save Image') {
  steps {
    sh 'docker save myapp:latest -o myapp.tar'
    archiveArtifacts artifacts: 'myapp.tar'
  }
}

What will Jenkins do after this stage completes?

medium

A. Delete the Docker image myapp:latest

B. Save the Docker image as a file and archive it as a build artifact

C. Run the Docker container from the saved image

D. Build a new Docker image named myapp:latest

Solution

1. Step 1: Analyze docker save command

   The command 'docker save myapp:latest -o myapp.tar' saves the Docker image to a file named myapp.tar.

2. Step 2: Understand archiveArtifacts usage

   The 'archiveArtifacts' step archives the saved file as a Jenkins build artifact for later use.

3. Final Answer:

   Save the Docker image as a file and archive it as a build artifact -> Option B

4. Quick Check:

   docker save + archiveArtifacts = Save the Docker image as a file and archive it as a build artifact [OK]

Hint: docker save creates file; archiveArtifacts stores it [OK]

Common Mistakes:

• Confusing save with build
• Thinking it runs containers
• Assuming image is deleted

4. You wrote this Jenkins pipeline snippet:

sh 'docker save myapp:latest -o myapp.tar'
archiveArtifacts file: 'myapp.tar'

Why does Jenkins fail to archive the Docker image file?

medium

A. Because 'docker save' does not create a file

B. Because the image name is incorrect

C. Because the parameter name should be 'artifacts', not 'file'

D. Because archiveArtifacts cannot archive .tar files

Solution

1. Step 1: Check archiveArtifacts parameter

   The correct parameter to specify files is 'artifacts', not 'file'. Using 'file' causes failure.

2. Step 2: Confirm docker save output

   'docker save' correctly creates the file 'myapp.tar', so the problem is not with the file creation.

3. Final Answer:

   Because the parameter name should be 'artifacts', not 'file' -> Option C

4. Quick Check:

   Parameter must be 'artifacts' = Because the parameter name should be 'artifacts', not 'file' [OK]

Hint: Use 'artifacts' parameter exactly in archiveArtifacts step [OK]

Common Mistakes:

• Using 'file' instead of 'artifacts'
• Assuming docker save fails silently
• Thinking archiveArtifacts rejects .tar files

5. You want to reuse a Docker image saved as appimage.tar from a previous Jenkins build artifact in a new pipeline. Which sequence correctly loads and runs the image?

hard

A. sh 'docker load -i appimage.tar'
sh 'docker run appimage:latest'

B. sh 'docker run -i appimage.tar'
sh 'docker load appimage:latest'

C. sh 'docker save -i appimage.tar'
sh 'docker run appimage:latest'

D. sh 'docker load appimage.tar'
sh 'docker run appimage:latest'

Solution

1. Step 1: Understand docker load syntax

   To load an image from a file, use 'docker load -i filename'. This imports the image into Docker.

2. Step 2: Run the loaded image

   After loading, run the image by its tag, e.g., 'docker run appimage:latest'.

3. Final Answer:

   sh 'docker load -i appimage.tar' sh 'docker run appimage:latest' -> Option A

4. Quick Check:

   Load with '-i', then run by tag = sh 'docker load -i appimage.tar' sh 'docker run appimage:latest' [OK]

Hint: Load with 'docker load -i', then run image by tag [OK]

Common Mistakes:

• Using 'docker run' with file instead of image tag
• Confusing 'docker save' with 'docker load'
• Omitting '-i' option in docker load