it-swarm.com.de

So verschieben Sie ein Docker-Image in ein privates Repository

Ich habe ein Docker-Image mit dem Namen me/my-image und ich habe ein privates Repo auf dem Dockerhub namens me-private. Wenn ich mein Ich/mein Bild schiebe, lande ich immer im öffentlichen Repo.

Was ist die genaue Syntax, um speziell mein Bild auf mein privates Repo zu übertragen? 

289
Eugene Goldberg

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

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

Dann Docker Push mit demselben Tag.

docker Push NAME[:TAG]

Beispiel:

docker tag 518a41981a6a myRegistry.com/myImage
docker Push myRegistry.com/myImage
439
Abdullah Jibaly

Nur drei einfache Schritte:

  1. docker login --username username --password password

  2. docker tag my-image username/my-repo

  3. docker Push username/my-repo

162

Gehen Sie zuerst zu Ihrem Docker Hub-Konto und führen Sie das Repo aus. Hier ist ein Screenshot meines Docker Hub-Kontos:  enter image description here

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

Gehen Sie jetzt 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 Bildschirmanweisungen  enter image description here

SO LADEN SIE IHR DOCKER-BILD AUF DEN DOCKER-HUB EIN

Methode # 1 = Schieben Sie Ihr Bild über 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 protected]

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

4) docker Push chuangg/gene_commited_image

Method # 2 = Pushing Ihres Bildes mit pom.xml und Befehlszeile. 

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

In der übergeordneten 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-Image (aus dem Verzeichnis, in dem sich Ihre pom.xml befindet) = mvn clean deploy -Pbuild-docker docker:Push

Beachten Sie, der Unterschied zwischen Methode 2 und 3 besteht darin, dass Methode 3 einen zusätzlichen <execution> für die Bereitstellung hat.

Method # 3 = Verwenden von Maven zur automatischen Bereitstellung bei 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 dies der Datei config.json hinzu:  enter image description here

Jetzt in Ihrem Docker Quickstart Terminal eingeben = mvn clean install -Pbuild-docker 

Wenn Sie kein Maven-Profil verwenden, geben Sie einfach mvn clean install ein.

Hier ist der Screenshot der Erfolgsmeldung:  enter image description here

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:  enter image description here

Hier ist meine 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" ] 

Häufiger Fehler # 1:  enter image description here

Lösung für Fehler Nr. 1 = Synchronisieren Sie den <execution> nicht mit der Maven-Implementierungsphase, da Maven dann versucht, das Image 2x bereitzustellen und einen Zeitstempel auf die jar-Datei zu setzen. Deshalb habe ich <phase>install</phase> verwendet. 

41
Gene

Wenn Ihre Docker-Registrierung privat ist und selbst gehostet, 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
27

Es gibt zwei Möglichkeiten:

  1. Gehen Sie in den Hub, erstellen Sie zuerst das Repository und markieren Sie es als privat. Wenn Sie dann zu diesem Repo wechseln, wird es privat sein. Dies ist der am weitesten verbreitete Ansatz.

  2. melden Sie sich bei Ihrem Docker Hub-Konto an und gehen Sie zu Ihren globalen Einstellungen . Es gibt eine Einstellung, mit der Sie die Standardsichtbarkeit für die von Ihnen verwendeten Repositorys festlegen können. Standardmäßig ist es auf public gesetzt. Wenn Sie es jedoch in private ändern, werden alle von Ihnen verwendeten Repositories standardmäßig als privat markiert. Beachten Sie, dass für Ihr Konto ausreichend private Repos zur Verfügung stehen müssen. Andernfalls wird das Repo gesperrt, bis Sie Ihren Plan aktualisieren.

13
Ken Cochrane

Melden Sie sich zuerst bei Ihrem privaten Repository an.

> docker login [OPTIONS] [SERVER]

[OPTIONS]: 
-u username 
-p password

z.B:

> docker login localhost:8080

Und dann kennzeichnen Sie Ihr Image 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 schließlich Ihre getaggten Bilder in Ihr privates Repository

>docker Push [OPTIONS] NAME[:TAG]

z.B:

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

Referenz

3
crane-yuan

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

  1. Ziehen Sie das ubuntu:16.04-Bild vom Docker Hub ab.

    $ docker pull ubuntu:16.04
    
  2. 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 Standort einer Registry.

    $ docker tag ubuntu:16.04 localhost:5000/my-ubuntu
    
  3. Schieben Sie das Image in die lokale Registrierung, die unter localhost:5000 ausgeführt wird:

    $ docker Push localhost:5000/my-ubuntu
    
  4. Entfernen Sie die lokal zwischengespeicherten Bilder. Das localhost:5000/my-ubuntu-Image wird dadurch nicht aus Ihrer Registrierung entfernt.

    $ docker image remove ubuntu:16.04
    $ docker image remove localhost:5000/my-ubuntu
    
  5. Ziehen Sie das localhost:5000/my-ubuntu-Bild aus Ihrer lokalen Registrierung ab.

    $ docker pull localhost:5000/my-ubuntu
    

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

  1. Bearbeiten Sie die daemon.json-Datei, deren Standardspeicherort /etc/docker/daemon.json unter Linux oder C:\ProgramData\docker\config\daemon.json unter Windows Server ist. Wenn Sie Docker for Mac oder Docker for Windows verwenden, klicken Sie auf Docker icon -> Preferences -> Daemon und fügen Sie den insecure registry hinzu.

    Wenn die daemon.json-Datei nicht vorhanden ist, erstellen Sie sie. Angenommen, es gibt keine weiteren Einstellungen in der Datei, sollte sie folgenden Inhalt haben:

    {
      "insecure-registries" : ["myregistrydomain.com:5000"]
    }
    

    Wenn unsichere Registrierungen aktiviert sind, durchläuft Docker die folgenden Schritte:

    • Versuchen Sie es zuerst mit HTTPS .
      • 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.
  2. Starten Sie Docker neu, damit die Änderungen wirksam werden.

3
David Ding

Einfache Arbeitslösung:

Gehen Sie hier https://hub.docker.com/, um ein PRIVATE-Repository mit Namen zu erstellen. Beispiel: johnsmith/private-repository Dies ist der NAME/REPOSITORY, den Sie für Ihr Image verwenden, wenn Sie das Image erstellen.

  • Zuerst docker login

  • Zweitens verwende ich "docker build -t johnsmith/private-repository:01 ." (wobei 01 mein Versionsname ist), um ein Bild zu erstellen, und ich verwende "docker images", um das erstellte Bild wie in diesem gelben Feld unten zu bestätigen: nur Zeichenfolge)

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

Erledigt!

3
Dung

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, hat auf dockerhub präsent sein 

"latest": ist nur ein Tag 

0