Come inviare un'immagine docker a un repository privato


418

Ho un'immagine docker contrassegnata come me/my-image e ho un repository privato nella dockerhub denominato me-private.
Quando spingo il miome/my-image , finisco sempre per colpire il repository pubblico.

Qual è la sintassi esatta per trasferire specificamente la mia immagine al mio repository privato?



1
La parola "privato" non compare nemmeno sulla pagina Web collegata.
Martin Andersson,

Risposte:


617

Devi prima etichettare correttamente l'immagine con registryhost:

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

Quindi push docker usando lo stesso tag.

docker push NAME[:TAG]

Esempio:

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

1
quindi, con questa immagine: 518a41981a6a, qual è la sintassi effettiva del tag per farlo andare al repository me-private, per favore?
Eugene Goldberg,

10
docker tag 518a41981a6a me-private.com/myPrivateImage && docker push me-private.com/myPrivateImage
Abdullah Jibaly,

2
Ho risolto anche alcuni problemi di sintassi nella mia risposta sopra. Inoltre, quando si passa a un registro, è necessario utilizzare un nome immagine effettivo e non l'ID immagine.
Abdullah Jibaly,

per qualche motivo l'immagine va ancora nel registro dockerhub pubblico anziché in quello privato. Solo per chiarimenti: il mio registro privato è anche nella dockerhub. Ho taggato l'immagine e ho fatto il push, ma il feedback indicava che tutti i layer erano già stati spinti, il che non sarebbe il caso se l'immagine stesse andando al registro privato per la prima volta
Eugene Goldberg,

11
Oh, se stai usando un registro dockerhub privato dovrebbe essere abbastanza semplice. Assicurati di fare un docker loginprimo, quindi docker tag 518a41981a6a me-private/myPrivateImagedocker push me-private/myPrivateImage
tagga la

214

Solo tre semplici passaggi:

  1. docker login --username username

    • richiede la password se si omette ciò --passwordche è raccomandato in quanto non lo memorizza nella cronologia dei comandi
  2. docker tag my-image username/my-repo

  3. docker push username/my-repo


42
lasciare la --passwordbandiera se non si desidera che la password venga visualizzata nella cronologia. ti chiederà.
AndrewD,

5
non funziona come nessun nome host di privateregistry menzionato.
Boris Ivanov,

@BorisIvanov, che vuoi dire?
cowlinator il

4
@cowlinator, Questa risposta sembra utilizzare Docker Hub piuttosto che un repository privato quando viene posta la domanda.
duct_tape_coder

6
Questo non risponde alla domanda, su come spingere in un repository privato .
Mark K Cowan,

48

Per prima cosa vai al tuo account Docker Hub ed effettua il repository. Ecco uno screenshot del mio account Docker Hub: inserisci qui la descrizione dell'immagine

Dalla foto, puoi vedere il mio repository è "chuangg"

Ora vai nel repository e rendilo privato facendo clic sul nome della tua immagine. Quindi, per me, ho cliccato su "chuangg / gene_commited_image", poi sono andato su Impostazioni -> Rendi privato. Quindi ho seguito le istruzioni sullo schermo inserisci qui la descrizione dell'immagine

COME CARICARE L'IMMAGINE DEL DOCKER SU DOCKER HUB

Metodo # 1 = Invio dell'immagine attraverso la riga di comando (cli)

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

Sì, penso che debba essere l'ID contenitore. Probabilmente non può essere l'ID immagine.

Ad esempio = docker commit 99e078826312 chuangg/gene_commited_image

2) docker run -it chaung/gene_commited_image

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

Ad esempio = docker login --username=chuangg --email=gc.genechaung@gmail.com

Sì, devi prima effettuare il login. Disconnettersi utilizzando "Logout Logout"

4) docker push chuangg/gene_commited_image

Metodo # 2 = Invio dell'immagine tramite pom.xml e riga di comando.

Nota, ho usato un profilo Maven chiamato "build-docker". Se non vuoi usare un profilo, rimuovi semplicemente gli <profiles>, <profile>, and <id>build-docker</id>elementi.

All'interno del pom.xml padre:

<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 per distribuire l'immagine Docker (dalla directory in cui si trova il tuo pom.xml) = mvn clean deploy -Pbuild-docker docker:push

Nota, la differenza tra il Metodo 2 e 3 è che il Metodo 3 ha un extra <execution>per la distribuzione.

Metodo # 3 = Utilizzo di Maven per la distribuzione automatica nell'hub Docker

Aggiungi questa roba al tuo genitore 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>

Vai alla directory C: \ Users \ Gene.docker \ e aggiungi questo al tuo file config.json: inserisci qui la descrizione dell'immagine

Ora nel Terminale di avvio rapido Docker digitare = mvn clean install -Pbuild-docker

Per quelli di voi che non usano i profili Maven, basta digitare mvn clean install

Ecco lo screenshot del messaggio di successo: inserisci qui la descrizione dell'immagine

Ecco il mio pom.xml completo e uno screenshot della mia struttura di directory:

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

Ecco la mia directory di Eclipse: inserisci qui la descrizione dell'immagine

Ecco il mio 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" ] 

Errore comune n. 1: inserisci qui la descrizione dell'immagine

Soluzione per errore n. 1 = Non sincronizzare la <execution>fase di distribuzione con maven poiché quindi tenta di distribuire l'immagine 2x e posiziona un timestamp sul vaso. Ecco perché l'ho usato <phase>install</phase>.


46

Se il registro della finestra mobile è privato e ospitato autonomamente , procedere come segue:

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

Esempio :

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

15

Esistono due opzioni:

  1. Andare nell'hub e creare prima il repository e contrassegnarlo come privato. Quindi quando invii a quel repository, sarà privato. Questo è l'approccio più comune.

  2. accedi al tuo account hub docker e vai alle tue impostazioni globali . C'è un'impostazione che ti consente di impostare quale sia la tua visibilità predefinita per i repository che invii. Per impostazione predefinita, è impostato su pubblico, ma se lo si modifica in privato, tutti i repository che si spingono verranno contrassegnati come privati ​​per impostazione predefinita. È importante notare che sarà necessario disporre di sufficienti repository privati ​​disponibili sul proprio account, altrimenti il ​​repository verrà bloccato fino a quando non si aggiorna il piano.


1
Certo, la domanda pubblicata non è così semplice come si potrebbe desiderare, ma non ho dubbi che la questione chiave per l'interrogante è il fatto che i repository su Docker Hub sono pubblici per impostazione predefinita. Eppure, tutti su questo thread sono per lo più occupati a pompare wiki per registri privati , oltre a toccare il docker pushcomando. Ma se ho capito bene la domanda, nessuna di queste risposte è corretta e quella postata sopra da Ken Cochrane è l'unica che dovrebbe essere accettata.
Martin Andersson,

Esattamente quello che sto cercando. Come accennato da @MartinAndersson, le risposte sopra nella riga di comando consentiranno comunque di rendere pubblica l'immagine in push, se stai spingendo su DockerHub.
Shaung Cheng,

9

Crea repository su dockerhub:

$docker tag IMAGE_ID UsernameOnDockerhub/repoNameOnDockerhub:latest

$docker push UsernameOnDockerhub/repoNameOnDockerhub:latest

Nota : qui "repoNameOnDockerhub": il repository con il nome che stai citando deve essere presente su dockerhub

"latest": è solo un tag


7

Rif: dock.docker.com

Questo argomento fornisce informazioni di base sulla distribuzione e la configurazione di un registro

Esegui un registro locale

Prima di poter distribuire un registro, è necessario installare Docker sull'host.

Utilizzare un comando come il seguente per avviare il contenitore del registro:

start_registry.sh

#!/bin/bash

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

Copia un'immagine da Docker Hub nel tuo registro

  1. Estrarre l' ubuntu:16.04immagine dall'hub Docker.

    $ docker pull ubuntu:16.04
    
  2. Contrassegna l'immagine come localhost:5000/my-ubuntu. Questo crea un tag aggiuntivo per l'immagine esistente. Quando la prima parte del tag è un nome host e una porta, Docker lo interpreta come la posizione di un registro, quando viene inviato.

    $ docker tag ubuntu:16.04 localhost:5000/my-ubuntu
    
  3. Invia l'immagine al registro locale in esecuzione su localhost:5000:

    $ docker push localhost:5000/my-ubuntu
    
  4. Rimuovi le immagini memorizzate nella cache locale. Ciò non rimuove l' localhost:5000/my-ubuntuimmagine dal registro.

    $ docker image remove ubuntu:16.04
    $ docker image remove localhost:5000/my-ubuntu
    
  5. Estrarre l' localhost:5000/my-ubuntuimmagine dal registro locale.

    $ docker pull localhost:5000/my-ubuntu
    
Distribuire un semplice registro HTTP

Secondo docs.docker.com , questo è molto insicuro e non è raccomandato .

  1. Modifica il daemon.jsonfile, il cui percorso predefinito è /etc/docker/daemon.jsonsu Linux o C:\ProgramData\docker\config\daemon.jsonsu Windows Server. Se si utilizza Docker for Maco Docker for Windows, fare clic su Docker icon -> Preferences -> Daemon, aggiungere in insecure registry.

    Se il daemon.jsonfile non esiste, crearlo. Supponendo che non ci siano altre impostazioni nel file, dovrebbe avere i seguenti contenuti:

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

    Con i registri non sicuri abilitati, Docker esegue i seguenti passaggi:

    • Innanzitutto, prova a utilizzare HTTPS.
      • Se HTTPS è disponibile ma il certificato non è valido, ignorare l'errore relativo al certificato.
      • Se HTTPS non è disponibile, tornare a HTTP.
  2. Riavvia Docker per rendere effettive le modifiche.


6

Per prima cosa accedi al tuo repository privato.

> docker login [OPTIONS] [SERVER]

[OPTIONS]: 
-u username 
-p password

per esempio:

> docker login localhost:8080

E quindi tagga la tua immagine per il tuo repository privato

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

per esempio:

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

Spingi infine le tue immagini gestite nel tuo repository privato

>docker push [OPTIONS] NAME[:TAG]

per esempio:

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

Riferimento


4

Soluzione di lavoro semplice:

Vai qui https://hub.docker.com/per creare un repository PRIVATO con il nome, ad esempio johnsmith/private-repositoryquesto è quello NAME/REPOSITORYche utilizzerai per la tua immagine durante la creazione dell'immagine.

  • Primo, docker login

  • In secondo luogo, utilizzo " docker build -t johnsmith/private-repository:01 ." (dove 01 è il nome della mia versione) per creare l'immagine e utilizzo " docker images" per confermare l'immagine creata come in questa casella gialla di seguito: (mi dispiace, non posso incollare il formato della tabella ma solo la stringa di testo )

johnsmith / private-repository (REPOSITORY) 01 (TAG) c5f4a2861d6e (ID IMMAGINE) 2 giorni fa (CREATO) 305MB (DIMENSIONE)

Fatto!

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.