Pushing images to registry in Jenkins - Commands & Configuration

Introduction

When you build a container image, you need to save it somewhere so others can use it. Pushing images to a registry lets you store and share your container images easily.

When you want to share your app's container image with your team.

When you need to deploy your app on a cloud service that pulls images from a registry.

When you want to keep a backup of your container images in a central place.

When you want to automate image storage as part of your Jenkins pipeline.

When you want to update your app by pushing a new image version to the registry.

Config File - Jenkinsfile

Jenkinsfile

pipeline {
  agent any
  environment {
    REGISTRY = 'docker.io'
    IMAGE_NAME = 'my-app'
    IMAGE_TAG = 'v1.0'
    REGISTRY_CREDENTIALS = 'dockerhub-credentials'
  }
  stages {
    stage('Build Image') {
      steps {
        script {
          sh 'docker build -t $REGISTRY/$IMAGE_NAME:$IMAGE_TAG .'
        }
      }
    }
    stage('Login to Registry') {
      steps {
        script {
          withCredentials([usernamePassword(credentialsId: env.REGISTRY_CREDENTIALS, usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
            sh 'echo $PASSWORD | docker login $REGISTRY -u $USERNAME --password-stdin'
          }
        }
      }
    }
    stage('Push Image') {
      steps {
        script {
          sh 'docker push $REGISTRY/$IMAGE_NAME:$IMAGE_TAG'
        }
      }
    }
  }
}

This Jenkinsfile defines a pipeline with three stages:

• Build Image: Builds the Docker image with a tag.
• Login to Registry: Logs into the Docker registry securely using stored credentials.
• Push Image: Pushes the built image to the registry.

Environment variables store registry info and credentials ID for easy updates.

Commands

This command builds a Docker image from the current folder and tags it with the registry address, image name, and version tag.

Terminal

docker build -t docker.io/my-app:v1.0 .

Expected Output

Sending build context to Docker daemon  8.192kB

Step 1/5 : FROM alpine:3.14

 ---> a24bb4013296

Step 2/5 : COPY . /app

 ---> Using cache

 ---> 5d5c3f3a1a2b

Step 3/5 : RUN apk add --no-cache curl

 ---> Running in 7a8f9c3b4d5e

Removing intermediate container 7a8f9c3b4d5e

 ---> 9c1f2d3e4b5a

Step 4/5 : CMD ["/app/start.sh"]

 ---> Running in 3b2a1c4d5e6f

Removing intermediate container 3b2a1c4d5e6f

 ---> 7e8f9a0b1c2d

Step 5/5 : LABEL version="v1.0"

 ---> Running in 4d5e6f7a8b9c

Removing intermediate container 4d5e6f7a8b9c

 ---> 1a2b3c4d5e6f

Successfully built 1a2b3c4d5e6f

Successfully tagged docker.io/my-app:v1.0

→

-t - Tags the image with name and version

Logs into Docker Hub registry securely by passing the password through standard input to avoid exposing it in the command line.

Terminal

echo mypassword | docker login docker.io -u myusername --password-stdin

Expected Output

Login Succeeded

→

--password-stdin - Reads password from standard input for security

Pushes the tagged image to the Docker Hub registry so others can pull and use it.

Terminal

docker push docker.io/my-app:v1.0

Expected Output

The push refers to repository [docker.io/my-app]

123456789abc: Pushed 

latest: digest: sha256:abcdef1234567890 size: 1234

Key Concept

If you remember nothing else from this pattern, remember: you must build, log in, then push your image to share it in a registry.

Common Mistakes

Trying to push an image without logging into the registry first

Docker will reject the push because it does not know who you are or if you have permission.

Always run 'docker login' with your credentials before pushing images.

Forgetting to tag the image with the registry address before pushing

Docker tries to push to the default local repository, which does not exist remotely.

Use the '-t' flag with the full registry path when building or tagging the image.

Exposing your password directly in the command line

Passwords can be seen by other users on the system or saved in shell history.

Use '--password-stdin' and pass the password securely via echo or environment variables.

Summary

Build your Docker image with a tag that includes the registry address.

Log in securely to the Docker registry using stored credentials.

Push the tagged image to the registry so it can be shared and deployed.

Practice

1. What is the main purpose of pushing a Docker image to a registry in Jenkins?

easy

A. To run the Docker image on the Jenkins server

B. To delete the local Docker image after building

C. To create a new Dockerfile automatically

D. To save the built image so it can be shared and deployed elsewhere

Solution

1. Step 1: Understand Docker image pushing

   Pushing an image uploads it to a registry so others can access it.

2. Step 2: Connect to Jenkins usage

   Jenkins automates this to share images for deployment or other jobs.

3. Final Answer:

   To save the built image so it can be shared and deployed elsewhere -> Option D

4. Quick Check:

   Pushing = Save and share image [OK]

Hint: Pushing means uploading image for sharing [OK]

Common Mistakes:

• Confusing push with running the image
• Thinking push deletes local images
• Assuming push creates Dockerfiles

2. Which Jenkins pipeline step correctly pushes a Docker image named myapp:latest to Docker Hub after login?

easy

A. sh 'docker push myapp:latest'

B. sh 'docker pull myapp:latest'

C. sh 'docker build myapp:latest'

D. sh 'docker run myapp:latest'

Solution

1. Step 1: Identify the push command

   To upload an image, the command is docker push followed by the image name and tag.

2. Step 2: Check other commands

   docker pull downloads, docker build creates, and docker run executes images.

3. Final Answer:

   sh 'docker push myapp:latest' -> Option A

4. Quick Check:

   Push uploads image [OK]

Hint: Push uses 'docker push' command [OK]

Common Mistakes:

• Using pull instead of push
• Confusing build with push
• Trying to run instead of push

3. Given this Jenkins pipeline snippet, what will be the output if the Docker login fails?

stage('Push Image') {
  steps {
    sh 'docker login -u user -p wrongpassword'
    sh 'docker push myapp:latest'
  }
}

medium

A. The image will be pushed anonymously

B. The push will succeed anyway

C. The push will fail because login failed

D. The pipeline will skip the push step

Solution

1. Step 1: Understand docker login failure effect

   If login fails, Docker does not authenticate, so push cannot succeed to a private registry.

2. Step 2: Check pipeline behavior

   Since login command fails, the push command will also fail due to lack of permissions.

3. Final Answer:

   The push will fail because login failed -> Option C

4. Quick Check:

   Failed login blocks push [OK]

Hint: Push needs successful login first [OK]

Common Mistakes:

• Assuming push works without login
• Thinking pipeline skips failed steps automatically
• Believing anonymous push is allowed

4. You have this Jenkins pipeline snippet but the image is not pushed. What is the error?

stage('Push') {
  steps {
    sh 'docker login -u user -p $PASSWORD'
    sh 'docker push myapp'
  }
}

medium

A. The login command syntax is incorrect

B. The image tag is missing in the push command

C. The password variable should be in double quotes

D. Docker push does not require login

Solution

1. Step 1: Check the push command syntax

   The push command must specify the image name with a tag, e.g., myapp:latest. Without a tag, it defaults to 'latest' but explicit is better.

2. Step 2: Verify other parts

   Login syntax is correct, password variable usage is valid in shell, and login is required before push.

3. Final Answer:

   The image tag is missing in the push command -> Option B

4. Quick Check:

   Push needs image:tag [OK]

Hint: Always specify image tag when pushing [OK]

Common Mistakes:

• Omitting image tag causes push issues
• Misusing environment variables in shell
• Skipping login before push

5. In a Jenkins pipeline, you want to push a Docker image to a private registry that requires login. Which sequence correctly automates this process?

hard

A. Login with credentials, tag image with registry URL, then push tagged image

B. Push image first, then login to registry, then tag image

C. Tag image without login, then push, then login after push

D. Login, push image without tagging, then tag image

Solution

1. Step 1: Understand Docker push workflow

   You must login first to authenticate, then tag the image with the registry URL to specify destination, then push the tagged image.

2. Step 2: Analyze options

   Options B, C, and D have wrong order causing push failures or wrong image pushed.

3. Final Answer:

   Login with credentials, tag image with registry URL, then push tagged image -> Option A

4. Quick Check:

   Login -> tag -> push [OK]

Hint: Login first, tag image, then push [OK]

Common Mistakes:

• Pushing before login
• Pushing untagged images to private registry
• Tagging after pushing