How to push a docker image to a private repository

Question

I have a docker image tagged as me/my-image, and I have a private repo on the dockerhub named me-private.
When I push my me/my-image, I end up always hitting the public repo.

What is the exact syntax to specifically push my image to my private repo?

The word "private" does not even occur on the web page you linked. — Martin Andersson, Oct 28 '17 at 21:09
Check this one out [Docker publish to a private repository](https://sylhare.github.io/2019/08/05/Docker-private-registry.html) — Sylhare, Dec 19 '19 at 16:48
simple quickstart: https://docs.docker.com/docker-hub/ Shows how to `docker build` and `docker push` to a `dockerhub` private repo. — rustyMagnet, Apr 13 '21 at 08:28

score 939 · Accepted Answer · edited Jul 14 '17 at 16:36

939

You need to tag your image correctly first with your registryhost:

docker tag [OPTIONS] IMAGE[:TAG] [REGISTRYHOST/][USERNAME/]NAME[:TAG]

Then docker push using that same tag.

docker push NAME[:TAG]

Example:

docker tag 518a41981a6a myRegistry.com/myImage
docker push myRegistry.com/myImage

edited Jul 14 '17 at 16:36

MiniGod

3,683
1
26
27

answered Feb 05 '15 at 16:49

Abdullah Jibaly

53,220
42
124
197

3

so, with this image: 518a41981a6a, what is the actual tag syntax to make it go to the me-private repo, please? – Eugene Goldberg Feb 05 '15 at 16:54
25

`docker tag 518a41981a6a me-private.com/myPrivateImage && docker push me-private.com/myPrivateImage` – Abdullah Jibaly Feb 05 '15 at 17:04
2

I fixed some syntax issues in my answer above as well. Also, fyi when you push to a registry you have to use an actual image name and not the image id. – Abdullah Jibaly Feb 05 '15 at 17:05
for some reason the image still goes to the public dockerhub registry instead of the private one. Just for the clarification - my private registry is also on the dockerhub. I tagged the image, and did the push, but the feedback was indicating that all layers have already been pushed, which would not be the case if the image was going to the private registry for the first time – Eugene Goldberg Feb 05 '15 at 17:14
15

Oh, if you're using a private dockerhub registry it should be pretty simple. Make sure you do a `docker login` first, then tag your image: `docker tag 518a41981a6a me-private/myPrivateImage` and push: `docker push me-private/myPrivateImage` – Abdullah Jibaly Feb 05 '15 at 17:20
The namespace is unique so if you push a private tag there's no way it can go to a different public tag. – Abdullah Jibaly Feb 05 '15 at 17:21
2

If i updated the image and used the same tag, would it overwrite it? – Steve Ng Feb 25 '16 at 17:30
As noted below, you need to create the repository on docker hub first. – taranaki Jan 27 '17 at 16:57

score 333 · Answer 2 · edited Nov 20 '19 at 15:03

333

Just three simple steps:

docker login --username username
- prompts for password if you omit --password which is recommended as it doesn't store it in your command history
docker tag my-image username/my-repo
docker push username/my-repo

edited Nov 20 '19 at 15:03

SomeGuyOnAComputer

5,414
6
40
72

answered May 22 '17 at 09:16

Abhishek Dasgupta

3,643
1
11
9

67

leave off the `--password` flag if you don't want your password to show up in history. it will prompt you. – AndrewD Dec 12 '17 at 19:30
11

not working as no privateregistry hostname mentioned. – Boris Ivanov Nov 08 '18 at 16:53
@BorisIvanov , what do you mean? – cowlinator Jan 23 '19 at 21:19
11

@cowlinator, This answer seems to be using Docker Hub rather than a private repo as the question asks. – duct_tape_coder Feb 14 '19 at 16:38
I'm asking what "no privateregistry hostname mentioned" refers to – cowlinator Feb 14 '19 at 23:20
14

This doesn't answer the question, of how to push to a *private* repository. – Mark K Cowan Apr 29 '19 at 12:14
Funnily if I omit the --password flag and let it prompt for password, the credentials are "incorrect", if I type it with the flag they are "correct" and it works... – Silidrone Sep 30 '20 at 13:56

score 119 · Answer 3 · answered Jul 25 '17 at 20:32

If you docker registry is private and self hosted you should do the following :

docker login <REGISTRY_HOST>:<REGISTRY_PORT>
docker tag <IMAGE_ID> <REGISTRY_HOST>:<REGISTRY_PORT>/<APPNAME>:<APPVERSION>
docker push <REGISTRY_HOST>:<REGISTRY_PORT>/<APPNAME>:<APPVERSION>

Example :

docker login repo.company.com:3456
docker tag 19fcc4aa71ba repo.company.com:3456/myapp:0.1
docker push repo.company.com:3456/myapp:0.1

score 54 · Answer 4 · edited Jul 18 '17 at 15:07

First go to your Docker Hub account and make the repo. Here is a screenshot of my Docker Hub account:

From the pic, you can see my repo is “chuangg”

Now go into the repo and make it private by clicking on your image’s name. So for me, I clicked on “chuangg/gene_commited_image”, then I went to Settings -> Make Private. Then I followed the on screen instructions

HOW TO UPLOAD YOUR DOCKER IMAGE ONTO DOCKER HUB

Method #1= Pushing your image through the command line (cli)

1) docker commit <container ID> <repo name>/<Name you want to give the image>

Yes, I think it has to be the container ID. It probably cannot be the image ID.

For example= docker commit 99e078826312 chuangg/gene_commited_image

2) docker run -it chaung/gene_commited_image

3) docker login --username=<user username> --password=<user password>

For example= docker login --username=chuangg --email=gc.genechaung@gmail.com

Yes, you have to login first. Logout using “docker logout”

4) docker push chuangg/gene_commited_image

Method #2= Pushing your image using pom.xml and command line.

Note, I used a Maven Profile called “build-docker”. If you don’t want to use a profile, just remove the <profiles>, <profile>, and <id>build-docker</id> elements.

Inside the parent pom.xml:

<profiles>
        <profile>
            <id>build-docker</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>io.fabric8</groupId>
                        <artifactId>docker-maven-plugin</artifactId>
                        <version>0.18.1</version>
                        <configuration>
                            <images>
                                <image>
                                    <name>chuangg/gene_project</name>
                                    <alias>${docker.container.name}</alias>
                                    <!-- Configure build settings -->
                                    <build>
                                        <dockerFileDir>${project.basedir}\src\docker\vending_machine_emulator</dockerFileDir>
                                        <assembly>
                                            <inline>
                                                <fileSets>
                                                    <fileSet>
                                                        <directory>${project.basedir}\target</directory>
                                                        <outputDirectory>.</outputDirectory>
                                                        <includes>
                                                            <include>*.jar</include>
                                                        </includes>
                                                    </fileSet>
                                                </fileSets>
                                            </inline>
                                        </assembly>
                                    </build>
                                </image>
                            </images>
                        </configuration>
                        <executions>
                            <execution>
                                <id>docker:build</id>
                                <phase>package</phase>
                                <goals>
                                    <goal>build</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>

Docker Terminal Command to deploy the Docker Image (from the directory where your pom.xml is located)= mvn clean deploy -Pbuild-docker docker:push

Note, the difference between Method #2 and #3 is that Method #3 has an extra <execution> for the deployment.

Method #3= Using Maven to automatically deploy to Docker Hub

Add this stuff to your parent pom.xml:

    <distributionManagement>
        <repository>
            <id>gene</id>
            <name>chuangg</name>
            <uniqueVersion>false</uniqueVersion>
            <layout>legacy</layout>
            <url>https://index.docker.io/v1/</url>
        </repository>
    </distributionManagement>


    <profiles>
        <profile>
            <id>build-docker</id>
            <build>
                <plugins>

                    <plugin>
                        <groupId>io.fabric8</groupId>
                        <artifactId>docker-maven-plugin</artifactId>
                        <version>0.18.1</version>
                        <configuration>
                            <images>
                                <image>
                                    <name>chuangg/gene_project1</name>
                                    <alias>${docker.container.name}</alias>
                                    <!-- Configure build settings -->
                                    <build>
                                        <dockerFileDir>${project.basedir}\src\docker\vending_machine_emulator</dockerFileDir>
                                        <assembly>
                                            <inline>
                                                <fileSets>
                                                    <fileSet>
                                                        <directory>${project.basedir}\target</directory>
                                                        <outputDirectory>.</outputDirectory>
                                                        <includes>
                                                            <include>*.jar</include>
                                                        </includes>
                                                    </fileSet>
                                                </fileSets>
                                            </inline>
                                        </assembly>
                                    </build>
                                </image>
                            </images>
                        </configuration>
                        <executions>
                            <execution>
                                <id>docker:build</id>
                                <phase>package</phase>
                                <goals>
                                    <goal>build</goal>
                                </goals>
                            </execution>
                            <execution>
                                <id>docker:push</id>
                                <phase>install</phase>
                                <goals>
                                    <goal>push</goal>
                                </goals>
                            </execution>

                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>
</project>

Go to C:\Users\Gene.docker\ directory and add this to your config.json file:

Now in your Docker Quickstart Terminal type= mvn clean install -Pbuild-docker

For those of you not using Maven Profiles, just type mvn clean install

Here is the screenshot of the success message:

Here is my full pom.xml and a screenshot of my directory structure:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.gene.app</groupId>
<artifactId>VendingMachineDockerMavenPlugin</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

<name>Maven Quick Start Archetype</name>
<url>www.gene.com</url>

<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.gene.sample.Customer_View</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>

                    <source>1.7</source>
                    <target>1.7</target>

                </configuration>
            </plugin>
        </plugins>
    </pluginManagement>
</build>


<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.8.2</version>
        <scope>test</scope>
    </dependency>

</dependencies>

<distributionManagement>
    <repository>
        <id>gene</id>
        <name>chuangg</name>
        <uniqueVersion>false</uniqueVersion>
        <layout>legacy</layout>
        <url>https://index.docker.io/v1/</url>
    </repository>
</distributionManagement>


<profiles>
    <profile>
        <id>build-docker</id>
        <properties>
            <java.docker.version>1.8.0</java.docker.version>
        </properties>
        <build>
            <plugins>

                <plugin>
                    <groupId>io.fabric8</groupId>
                    <artifactId>docker-maven-plugin</artifactId>
                    <version>0.18.1</version>
                    <configuration>
                        <images>
                            <image>
                                <name>chuangg/gene_project1</name>
                                <alias>${docker.container.name}</alias>
                                <!-- Configure build settings -->
                                <build>
                                    <dockerFileDir>${project.basedir}\src\docker\vending_machine_emulator</dockerFileDir>
                                    <assembly>
                                        <inline>
                                            <fileSets>
                                                <fileSet>
                                                    <directory>${project.basedir}\target</directory>
                                                    <outputDirectory>.</outputDirectory>
                                                    <includes>
                                                        <include>*.jar</include>
                                                    </includes>
                                                </fileSet>
                                            </fileSets>
                                        </inline>
                                    </assembly>
                                </build>
                            </image>
                        </images>
                    </configuration>
                    <executions>
                        <execution>
                            <id>docker:build</id>
                            <phase>package</phase>
                            <goals>
                                <goal>build</goal>
                            </goals>
                        </execution>
                        <execution>
                            <id>docker:push</id>
                            <phase>install</phase>
                            <goals>
                                <goal>push</goal>
                            </goals>
                        </execution>

                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

Here is my Eclipse Directory:

Here is my Dockerfile:

FROM java:8

MAINTAINER Gene Chuang
RUN echo Running Dockerfile in src/docker/vending_machine_emulator/Dockerfile directory

ADD maven/VendingMachineDockerMavenPlugin-1.0-SNAPSHOT.jar /bullshitDirectory/gene-app-1.0-SNAPSHOT.jar 

CMD ["java", "-classpath", "/bullshitDirectory/gene-app-1.0-SNAPSHOT.jar", "com/gene/sample/Customer_View" ]

Common Error #1:

Solution for Error #1= Do not sync the <execution> with maven deploy phase because then maven tries to deploy the image 2x and puts a timestamp on the jar. That’s why I used <phase>install</phase>.

score 25 · Answer 5 · answered May 29 '15 at 15:06

25

There are two options:

Go into the hub, and create the repository first, and mark it as private. Then when you push to that repo, it will be private. This is the most common approach.
log into your docker hub account, and go to your global settings. There is a setting that allows you to set what your default visability is for the repositories that you push. By default it is set to public, but if you change it to private, all of your repositories that you push will be marked as private by default. It is important to note that you will need to have enough private repos available on your account, or else the repo will be locked until you upgrade your plan.

answered May 29 '15 at 15:06

Ken Cochrane

75,357
9
52
60

3

Granted, the question posted is not as straightforward as one could wish for, but I have no doubt the key issue for the questioner is the fact that _repositories_ on Docker Hub are public by default. Yet, everybody on this thread is mostly occupied pumping out wikis for private _registries_ as well as touching on the `docker push` command. But if I have understood the question right, none of these answers are correct and the one posted above by Ken Cochrane is the only one that should be accepted. – Martin Andersson Oct 28 '17 at 21:25
1

Exactly what I am looking for. As @MartinAndersson mentioned, answers above in command line will still let your pushed image be in public, if you're pushing on DockerHub. – Shawn Jul 14 '19 at 17:45
1

I agree @MartinAndersson, this should be the correct answer to the OP question. – codea Apr 17 '21 at 14:32

score 18 · Answer 6 · answered May 21 '18 at 02:12

Ref: dock.docker.com

This topic provides basic information about deploying and configuring a registry

Run a local registry

Before you can deploy a registry, you need to install Docker on the host.

Use a command like the following to start the registry container:

start_registry.sh

#!/bin/bash

docker run -d \
  -p 5000:5000 \
  --restart=always \
  --name registry \
  -v /data/registry:/var/lib/registry \
  registry:2

Copy an image from Docker Hub to your registry

Pull the ubuntu:16.04 image from Docker Hub.
```
$ docker pull ubuntu:16.04
```
Tag the image as localhost:5000/my-ubuntu. This creates an additional tag for the existing image. When the first part of the tag is a hostname and port, Docker interprets this as the location of a registry, when pushing.
```
$ docker tag ubuntu:16.04 localhost:5000/my-ubuntu
```
Push the image to the local registry running at localhost:5000:
```
$ docker push localhost:5000/my-ubuntu
```
Remove the locally-cached images. This does not remove the localhost:5000/my-ubuntu image from your registry.
```
$ docker image remove ubuntu:16.04
$ docker image remove localhost:5000/my-ubuntu
```
Pull the localhost:5000/my-ubuntu image from your local registry.
```
$ docker pull localhost:5000/my-ubuntu
```

Deploy a plain HTTP registry

According to docs.docker.com, this is very insecure and is not recommended.

Edit the daemon.json file, whose default location is /etc/docker/daemon.json on Linux or C:\ProgramData\docker\config\daemon.json on Windows Server. If you use Docker for Mac or Docker for Windows, click Docker icon -> Preferences -> Daemon, add in the insecure registry.

If the daemon.json file does not exist, create it. Assuming there are no other settings in the file, it should have the following contents:
```
{
  "insecure-registries" : ["myregistrydomain.com:5000"]
}
```
With insecure registries enabled, Docker goes through the following steps:
- First, try using HTTPS.
  - If HTTPS is available but the certificate is invalid, ignore the error about the certificate.
  - If HTTPS is not available, fall back to HTTP.
Restart Docker for the changes to take effect.

Anurag Manikkame · Answer 7 · 2018-12-07T12:26:14.743

14

Create repository on dockerhub :

$docker tag IMAGE_ID UsernameOnDockerhub/repoNameOnDockerhub:latest

$docker push UsernameOnDockerhub/repoNameOnDockerhub:latest

Note : here "repoNameOnDockerhub" : repository with the name you are mentioning has to be present on dockerhub

"latest" : is just tag

edited Dec 07 '18 at 12:26

answered Dec 07 '18 at 10:07

Anurag Manikkame

857
7
8

repoNameOnDockerhub is an illegal image name as the rules say it must consist of groups of lowercase characters and digits separated by a separator which can be a dash/hyphen, an underscore or a double underscore. One place in the docs says a dot/period can be a separator and another doesn't mention it. I suspect the username must be lowercase as well but I can only find informal rules on dockerhub saying they require username to have lower case, digits, dash and underscore and be 2-255 in length. – Lee Meador Mar 05 '21 at 21:09

score 12 · Answer 8 · answered Sep 01 '17 at 03:39

First login your private repository.

> docker login [OPTIONS] [SERVER]

[OPTIONS]: 
-u username 
-p password

eg:

> docker login localhost:8080

And then tag your image for your private repository

> docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]

eg:

> docker tag myApp:v1 localhost:8080/myname/myApp:v1

Finally push your taged images to your private repository

>docker push [OPTIONS] NAME[:TAG]

eg:

> docker push localhost:8080/myname/myApp:v1

Reference

docker command reference

score 9 · Answer 9 · edited Nov 09 '21 at 23:51

Following are the steps to push Docker Image to Private Repository of DockerHub

1- First check Docker Images using command

docker images

2- Check Docker Tag command Help

docker tag --help

3- Now Tag a name to your created Image

docker tag localImgName:tagName DockerHubUser\Private-repoName:tagName (tag name is optional. Default name is latest)

4- Before pushing Image to DockerHub Private Repo, first login to DockerHub using command

docker login [provide dockerHub username and Password to login]

5- Now push Docker Image to your private Repo using command

docker push [options] ImgName[:tag] e.g docker push DockerHubUser\Private-repoName:tagName

6- Now navigate to the DockerHub Private Repo and you will see Docker image is pushed on your private Repository with name written as TagName in previous steps

Dung · Answer 10 · 2017-09-18T15:07:31.850

Simple working solution:

Go here https://hub.docker.com/ to create a PRIVATE repository with name for example johnsmith/private-repository this is the NAME/REPOSITORY you will use for your image when building the image.

First, docker login
Second, I use "docker build -t johnsmith/private-repository:01 ." (where 01 is my version name) to create image, and I use "docker images" to confirm the image created such as in this yellow box below: (sorry I can not paste the table format but the text string only)

johnsmith/private-repository(REPOSITORY) 01(TAG) c5f4a2861d6e(IMAGE ID) 2 days ago(CREATED) 305MB(SIZE)

Third, I use docker push johnsmith/private-repository:01 (Your private repo will be here example https://hub.docker.com/r/johnsmith/private-repository/)

Done!

score 2 · Answer 11 · answered Feb 13 '22 at 09:15

If somebody looking for a quick way to push all images to a private repository, you can use my bash script - it will push all the Docker images to the new private registry:

#!/bin/bash

repo="<change_to_your_new_repo>"
remote_repo="<the_new_repo_name>"

for img in $(docker images --format "{{.Repository}}:{{.Tag}}")
do
        image=$(echo $img | cut -d ":" -f 1)
        image_tag=$(echo $img | cut -d ":" -f 2)

        docker image tag $image:$image_tag $repo/$remote_repo/$image:$image_tag
        docker image push $repo/$remote_repo/$image:$image_tag

        docker rmi $repo/$remote_repo/$image:$image_tag
done

score 2 · Answer 12 · answered Jun 24 '22 at 16:53

When pushing to a Docker Hub account, whether public or private, the process is the same.

The OP said:

I have a docker image tagged as me/my-image, and I have a private repo on the dockerhub named me-private.
When I push my me/my-image, I end up always hitting the public repo.

The immediate problem is that the private repo (me-private) appears to have a different name than the image (my-image). The repo and the image must have the same name (minus any tag).

TLDR;
An image named my-image or my-image:tag must have a repo name of my-image.

Since the OP's repo was named me-private, Docker Hub wouldn't see those as the same and would create the new repo named my-image.

(That new repo would be public by default, unless you change settings to make all your repositories private.)

As of June 2022, the process for setting up a Docker Hub repo is:

Given the following values:

username = yourusername
image name = theimage
tag = thetag

1) tag (or commit) the local image, adding a prefix with your username:

docker tag theimage:thetag yourusername/theimage:thetag

Notes:

if you're in an organization, you need to double prefix the image - like so:

docker tag theimage:thetag yourusername/yourorganizationname/theimage:thetag

if your tag is latest, :thetag part can be left out; Docker assumes :latest if you don't enter a :thetag part

2) push the prefixed image to Docker Hub:

 docker push yourusername/theimage:thetag

OR

 docker push yourusername/yourorganizationname/theimage:thetag

For a private repo, one of these extra steps is necessary:

Either

before step 1 above, create a private repository in your Docker Hub account

Remember that the repository name must be the same as theimage that you're planning to push. Do not include a thetag portion on the repository name. Eg, if your image is ubuntu:14.04, you would name your repository ubuntu. (All tagged images - eg, ubuntu:latest, ubuntu:14.04, etc - will go into the ubuntu repo.)

Or

if you didn't create the repository in advance (which is not required!): go to your account in Docker Hub; click on the newly pushed repo, then its Settings tab - and make your repo private.

score 0 · Answer 13 · answered Jul 21 '21 at 06:33

There is also a "default privacy" setting in dockerhub. Visit https://hub.docker.com/settings/default-privacy or click account settings->default privacy.

Set the toggle to "private".

This is not a complete solution but at least private by default is better than public by default. You can go back and make the ones public you want.

mononoke83 · Answer 14 · 2022-02-23T16:17:30.467

0

After pull an image in local, you can do the next:

docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]

Then docker push using that same tag.

docker push NAME[:TAG]

Example:

docker tag gvenzl/oracle-xe:21-slim quay.io/repository/yourDirectory/oracle_xe:oracle-xe

docker push quay.io/repository/yourDirectory/oracle_xe:oracle-xe

edited Feb 23 '22 at 16:17

answered Feb 23 '22 at 16:04

mononoke83

342
2
16