So verschieben Sie ein Docker-Image in ein privates Repository

416

Ich habe ein Docker-Image mit dem Tag als me/my-imageund ich habe ein privates Repo auf dem Dockerhub mit dem Namen me-private.
Wenn ich meine me/my-imagedrücke, treffe ich immer das öffentliche Repo.

Wie lautet die genaue Syntax, um mein Bild speziell auf mein privates Repo zu übertragen?

docker docker-registry

— Eugene Goldberg
quelle

docs.docker.com/engine/getstarted/step_six

— Sudip Bhandari

1

Das Wort "privat" kommt auf der von Ihnen verlinkten Webseite nicht einmal vor.

— Martin Andersson

Schauen Sie sich diese Docker-Veröffentlichung in einem privaten Repository an

— Sylhare

616

Sie müssen Ihr Bild zuerst richtig kennzeichnen mit registryhost:

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

Dann Docker Push mit dem gleichen Tag.

docker push NAME[:TAG]

Beispiel:

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

— Abdullah Jibaly
quelle

1

Also, mit diesem Bild: 518a41981a6a, wie lautet die tatsächliche Tag-Syntax, damit es zum me-private Repo geht?

— Eugene Goldberg

10

docker tag 518a41981a6a me-private.com/myPrivateImage && docker push me-private.com/myPrivateImage

— Abdullah Jibaly

2

Ich habe auch in meiner obigen Antwort einige Syntaxprobleme behoben. Außerdem müssen Sie beim Push in eine Registrierung einen tatsächlichen Bildnamen und nicht die Bild-ID verwenden.

— Abdullah Jibaly

Aus irgendeinem Grund wird das Image weiterhin in die öffentliche Dockerhub-Registrierung anstatt in die private Registrierung verschoben. Nur zur Klarstellung - meine private Registrierung befindet sich auch im Dockerhub. Ich habe das Bild markiert und den Push ausgeführt, aber das Feedback zeigte an, dass alle Ebenen bereits gepusht wurden, was nicht der Fall wäre, wenn das Bild zum ersten Mal in die private Registrierung aufgenommen würde

— Eugene Goldberg

11

Oh, wenn Sie eine private Dockerhub-Registrierung verwenden, sollte dies ziemlich einfach sein. docker logindocker tag 518a41981a6a me-private/myPrivateImagedocker push me-private/myPrivateImage

— Stellen

213

Nur drei einfache Schritte:

docker login --username username
- fordert zur Eingabe des Kennworts auf, wenn Sie --passworddas empfohlene Kennwort weglassen , da es nicht in Ihrem Befehlsverlauf gespeichert wird
docker tag my-image username/my-repo
docker push username/my-repo

— Abhishek Dasgupta
quelle

42

Lassen Sie die --passwordFlagge weg, wenn Ihr Passwort nicht im Verlauf angezeigt werden soll. es wird Sie auffordern.

— AndrewD

5

funktioniert nicht, da kein privater Registrierungs-Hostname erwähnt wird.

— Boris Ivanov

@ BorisIvanov, was meinst du?

— Cowlinator

4

@cowlinator, Diese Antwort scheint Docker Hub anstelle eines privaten Repos zu verwenden, wie die Frage stellt.

— duct_tape_coder

6

Dies beantwortet nicht die Frage, wie in ein privates Repository verschoben werden soll.

— Mark K Cowan

48

Gehen Sie zuerst zu Ihrem Docker Hub-Konto und machen Sie das Repo. Hier ist ein Screenshot meines Docker Hub-Kontos:

Auf dem Bild können Sie sehen, dass mein Repo "Chuangg" ist.

Gehen Sie nun in das Repo und machen Sie es privat, indem Sie auf den Namen Ihres Bildes klicken. Also habe ich für mich auf "chuangg / gene_commited_image" geklickt und bin dann zu "Einstellungen" -> "Privat machen" gegangen. Dann folgte ich den Anweisungen auf dem Bildschirm

SO LADEN SIE IHR DOCKER-BILD AUF DOCKER HUB hoch

Methode 1 = Schieben Sie Ihr Bild durch die Befehlszeile (cli)

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

Ja, ich denke es muss die Container ID sein. Es kann wahrscheinlich nicht die Bild-ID sein.

Zum Beispiel = docker commit 99e078826312 chuangg/gene_commited_image

2) docker run -it chaung/gene_commited_image

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

Zum Beispiel = docker login --username=chuangg --email=gc.genechaung@gmail.com

Ja, Sie müssen sich zuerst anmelden. Abmelden mit "Docker-Abmelden"

4) docker push chuangg/gene_commited_image

Methode 2 = Verschieben Ihres Bildes mit pom.xml und der Befehlszeile.

Beachten Sie, dass ich ein Maven-Profil namens "Build-Docker" verwendet habe. Wenn Sie kein Profil verwenden möchten, entfernen Sie einfach die <profiles>, <profile>, and <id>build-docker</id>Elemente.

In der übergeordneten Datei 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 Befehl zum Bereitstellen des Docker-Images (aus dem Verzeichnis, in dem sich Ihre pom.xml befindet) = mvn clean deploy -Pbuild-docker docker:push

Beachten Sie, dass der Unterschied zwischen Methode 2 und 3 darin besteht, dass Methode 3 ein Extra <execution>für die Bereitstellung enthält.

Methode 3 = Verwenden von Maven zur automatischen Bereitstellung auf Docker Hub

Fügen Sie dieses Zeug Ihrer übergeordneten pom.xml hinzu:

    <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>

Wechseln Sie in das Verzeichnis C: \ Users \ Gene.docker \ und fügen Sie dieses Ihrer Datei config.json hinzu:

Geben Sie jetzt in Ihrem Docker-Schnellstart-Terminal = ein mvn clean install -Pbuild-docker

Für diejenigen unter Ihnen, die keine Maven-Profile verwenden, geben Sie einfach ein mvn clean install

Hier ist der Screenshot der Erfolgsmeldung:

Hier ist meine vollständige pom.xml und ein Screenshot meiner Verzeichnisstruktur:

<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>

Hier ist mein Eclipse-Verzeichnis:

Hier ist meine Docker-Datei:

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" ]

Häufiger Fehler Nr. 1:

Lösung für Fehler Nr. 1 = Synchronisieren Sie die <execution>Bereitstellungsphase nicht mit Maven, da Maven dann 2x versucht, das Image bereitzustellen, und einen Zeitstempel auf das JAR setzt. Deshalb habe ich verwendet <phase>install</phase>.

— Gen
quelle

46

Wenn Ihre Docker-Registrierung privat ist und selbst gehostet ist , sollten Sie Folgendes tun:

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

Beispiel:

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

— Nicolas Delaforge
quelle

15

Es gibt zwei Möglichkeiten:

Gehen Sie in den Hub, erstellen Sie zuerst das Repository und markieren Sie es als privat. Wenn Sie dann auf dieses Repo klicken, wird es privat sein. Dies ist der gängigste Ansatz.
Melden Sie sich bei Ihrem Docker-Hub-Konto an und wechseln Sie zu Ihren globalen Einstellungen . Es gibt eine Einstellung, mit der Sie festlegen können, wie Ihre Standardsichtbarkeit für die von Ihnen übertragenen Repositorys lautet. Standardmäßig ist es auf öffentlich eingestellt. Wenn Sie es jedoch in privat ändern, werden alle von Ihnen gepussten Repositorys standardmäßig als privat markiert. Es ist wichtig zu beachten, dass Sie über genügend private Repos in Ihrem Konto verfügen müssen. Andernfalls wird das Repo gesperrt, bis Sie Ihren Plan aktualisieren.

— Ken Cochrane
quelle

1

Zugegeben, die gestellte Frage ist nicht so einfach, wie man es sich wünschen könnte, aber ich habe keinen Zweifel daran, dass das Hauptproblem für den Fragesteller die Tatsache ist, dass Repositorys auf Docker Hub standardmäßig öffentlich sind. Jeder in diesem Thread ist jedoch hauptsächlich damit beschäftigt, Wikis für private Registrierungen abzupumpen und den docker pushBefehl zu berühren . Aber wenn ich die Frage richtig verstanden habe, ist keine dieser Antworten richtig und die oben von Ken Cochrane veröffentlichte ist die einzige, die akzeptiert werden sollte.

— Martin Andersson

Genau das, wonach ich suche. Wie bei @MartinAndersson erwähnt, wird Ihr Push-Image bei den obigen Antworten in der Befehlszeile weiterhin öffentlich angezeigt, wenn Sie auf DockerHub drücken.

— Shaung Cheng

9

Repository auf Dockerhub erstellen:

$docker tag IMAGE_ID UsernameOnDockerhub/repoNameOnDockerhub:latest

$docker push UsernameOnDockerhub/repoNameOnDockerhub:latest

Hinweis : hier "repoNameOnDockerhub": Repository mit dem Namen, den Sie erwähnen, muss auf Dockerhub vorhanden sein

"Neueste": ist nur ein Tag

— Anurag Manikkame
quelle

7

Ref: dock.docker.com

Dieses Thema enthält grundlegende Informationen zum Bereitstellen und Konfigurieren einer Registrierung

Führen Sie eine lokale Registrierung aus

Bevor Sie eine Registrierung bereitstellen können, müssen Sie Docker auf dem Host installieren.

Verwenden Sie einen Befehl wie den folgenden, um den Registrierungscontainer zu starten:

start_registry.sh

#!/bin/bash

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

Kopieren Sie ein Bild von Docker Hub in Ihre Registrierung

Ziehen Sie das ubuntu:16.04Bild vom Docker Hub.
```
$ docker pull ubuntu:16.04
```
Kennzeichnen Sie das Bild als localhost:5000/my-ubuntu. Dadurch wird ein zusätzliches Tag für das vorhandene Bild erstellt. Wenn der erste Teil des Tags ein Hostname und ein Port ist, interpretiert Docker dies beim Push als Speicherort einer Registrierung.
```
$ docker tag ubuntu:16.04 localhost:5000/my-ubuntu
```
Übertragen Sie das Image in die lokale Registrierung unter localhost:5000:
```
$ docker push localhost:5000/my-ubuntu
```
Entfernen Sie die lokal zwischengespeicherten Bilder. Dadurch wird das localhost:5000/my-ubuntuBild nicht aus Ihrer Registrierung entfernt.
```
$ docker image remove ubuntu:16.04
$ docker image remove localhost:5000/my-ubuntu
```
Ziehen Sie das localhost:5000/my-ubuntuBild aus Ihrer lokalen Registrierung.
```
$ docker pull localhost:5000/my-ubuntu
```

Stellen Sie eine einfache HTTP-Registrierung bereit

Laut docs.docker.com ist dies sehr unsicher und wird nicht empfohlen .

Bearbeiten Sie die daemon.jsonDatei, deren Standardspeicherort /etc/docker/daemon.jsonunter Linux oder C:\ProgramData\docker\config\daemon.jsonWindows Server liegt. Wenn Sie Docker for Macoder verwenden Docker for Windows, klicken Sie auf Docker icon -> Preferences -> Daemonund fügen Sie das hinzu insecure registry.

Wenn die daemon.jsonDatei nicht vorhanden ist, erstellen Sie sie. Vorausgesetzt, die Datei enthält keine anderen Einstellungen, sollte sie den folgenden Inhalt haben:
```
{
  "insecure-registries" : ["myregistrydomain.com:5000"]
}
```
Wenn unsichere Registrierungen aktiviert sind, führt Docker die folgenden Schritte aus:
- Versuchen Sie zunächst, HTTPS zu verwenden.
  - Wenn HTTPS verfügbar ist, das Zertifikat jedoch ungültig ist, ignorieren Sie den Fehler bezüglich des Zertifikats.
  - Wenn HTTPS nicht verfügbar ist, greifen Sie auf HTTP zurück.
Starten Sie Docker neu, damit die Änderungen wirksam werden.

— David Ding
quelle

6

Melden Sie sich zuerst in Ihrem privaten Repository an.

> docker login [OPTIONS] [SERVER]

[OPTIONS]: 
-u username 
-p password

z.B:

> docker login localhost:8080

Und dann markieren Sie Ihr Bild für Ihr privates Repository

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

z.B:

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

Schieben Sie Ihre Bilder schließlich in Ihr privates Repository

>docker push [OPTIONS] NAME[:TAG]

z.B:

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

Referenz

Docker-Befehlsreferenz

— Kran-Yuan
quelle

4

Einfache Arbeitslösung:

https://hub.docker.com/Klicken Sie hier , um ein privates Repository mit Namen zu erstellen. johnsmith/private-repositoryDies ist beispielsweise das Repository, das NAME/REPOSITORYSie beim Erstellen des Images für Ihr Image verwenden.

Zuerst, docker login
Zweitens verwende ich " docker build -t johnsmith/private-repository:01 ." (wobei 01 mein Versionsname ist), um ein Bild zu erstellen, und " docker images", um das erstellte Bild zu bestätigen, wie in diesem gelben Feld unten: (Entschuldigung, ich kann das Tabellenformat nicht einfügen, sondern nur die Textzeichenfolge )

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

Drittens benutze ich docker push johnsmith/private-repository:01(Ihr privates Repo wird hier sein Beispiel https://hub.docker.com/r/johnsmith/private-repository/ )

Erledigt!

— Dung
quelle