So verschieben Sie ein Docker-Image in ein privates Repository

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?

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

Nur drei einfache Schritte:

1. docker login --username username

   • fordert zur Eingabe des Kennworts auf, wenn Sie --passworddas empfohlene Kennwort weglassen , da es nicht in Ihrem Befehlsverlauf gespeichert wird

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

3. docker push username/my-repo

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

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

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

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 auf dieses Repo klicken, wird es privat sein. Dies ist der gängigste Ansatz.

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

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

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.04Bild vom Docker Hub.

   $ 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 Speicherort einer Registrierung.

   $ docker tag ubuntu:16.04 localhost:5000/my-ubuntu
   

3. Übertragen Sie das Image in die lokale Registrierung unter localhost:5000:

   $ docker push localhost:5000/my-ubuntu
   

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

5. Ziehen Sie das localhost:5000/my-ubuntuBild aus Ihrer lokalen Registrierung.

   $ docker pull localhost:5000/my-ubuntu
   

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

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

2. Starten Sie Docker neu, damit die Änderungen wirksam werden.

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

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!