Jak wypchnąć obraz dokera do prywatnego repozytorium

Mam obraz dokera oznaczony jako me/my-imagei mam prywatne repozytorium o nazwie dokerhub me-private.
Kiedy naciskam me/my-image, zawsze trafiam do publicznego repozytorium.

Jaka jest dokładna składnia, aby konkretnie przesłać mój obraz do mojego prywatnego repozytorium?

Najpierw musisz poprawnie oznaczyć obraz swoim registryhost:

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

Następnie dokuj wypychaj, używając tego samego znacznika.

docker push NAME[:TAG]

Przykład:

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

Tylko trzy proste kroki:

1. docker login --username username

   • wyświetla monit o podanie hasła, jeśli zostanie ono pominięte, --passwordponieważ nie jest ono przechowywane w historii poleceń

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

3. docker push username/my-repo

Najpierw przejdź do swojego konta Docker Hub i zrób repozytorium. Oto zrzut ekranu mojego konta Docker Hub:

Ze zdjęcia widać, że moje repo to „chuangg”

Teraz przejdź do repozytorium i ustaw je jako prywatne, klikając nazwę obrazu. Więc dla mnie kliknąłem „chuangg / gene_commited_image”, a potem poszedłem do Ustawienia -> Ustaw jako prywatny. Następnie wykonałem instrukcje na ekranie

JAK ZAŁOŻYĆ OBRAZ DOCKERA NA PIASTĘ DOCKER

Metoda nr 1 = Przepychanie obrazu przez linię poleceń (cli)

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

Tak, myślę, że musi to być identyfikator kontenera. Prawdopodobnie nie może to być identyfikator obrazu.

Na przykład = docker commit 99e078826312 chuangg/gene_commited_image

2) docker run -it chaung/gene_commited_image

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

Na przykład = docker login --username=chuangg --email=gc.genechaung@gmail.com

Tak, musisz się najpierw zalogować. Wyloguj się za pomocą „wylogowania dokera”

4) docker push chuangg/gene_commited_image

Metoda nr 2 = Przesuwanie obrazu za pomocą pom.xml i wiersza poleceń.

Uwaga: użyłem profilu Maven o nazwie „build-docker”. Jeśli nie chcesz używać profilu, po prostu usuń <profiles>, <profile>, and <id>build-docker</id>elementy.

Wewnątrz nadrzędnego 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, aby wdrożyć obraz Docker (z katalogu, w którym znajduje się plik pom.xml) = mvn clean deploy -Pbuild-docker docker:push

Uwaga: różnica między metodą nr 2 i nr 3 polega na tym, że metoda nr 3 ma dodatkową zaletę <execution>dla wdrożenia.

Metoda nr 3 = Użycie Maven do automatycznego wdrożenia w Docker Hub

Dodaj to do swojego pom.xml twojego rodzica:

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

Przejdź do katalogu C: \ Users \ Gene.docker \ i dodaj to do pliku config.json:

Teraz w Docker Quickstart Terminal wpisz = mvn clean install -Pbuild-docker

Jeśli nie używasz profili Maven, po prostu wpisz mvn clean install

Oto zrzut ekranu komunikatu o sukcesie:

Oto mój pełny pom.xml i zrzut ekranu mojej struktury katalogów:

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

Oto mój katalog Eclipse:

Oto mój plik Docker:

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

Typowy błąd nr 1:

Rozwiązanie dla błędu nr 1 = Nie synchronizuj <execution>fazy wdrażania z maven, ponieważ następnie maven próbuje wdrożyć obraz 2x i umieszcza znacznik czasu na słoiku. Właśnie dlatego użyłem <phase>install</phase>.

Jeśli rejestr dokera jest prywatny i hostowany samodzielnie , wykonaj następujące czynności:

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

Przykład:

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

Istnieją dwie opcje:

1. Przejdź do koncentratora, najpierw utwórz repozytorium i oznacz je jako prywatne. Gdy przejdziesz do tego repozytorium, będzie ono prywatne. To jest najczęstsze podejście.

2. zaloguj się do konta w centrum dokowanym i przejdź do ustawień globalnych . Istnieje ustawienie, które pozwala ustawić domyślną widoczność repozytoriów, które wypychasz. Domyślnie jest ustawiony na publiczny, ale jeśli zmienisz go na prywatny, wszystkie repozytoria, które wypychasz, będą domyślnie oznaczone jako prywatne. Ważne jest, aby pamiętać, że będziesz musiał mieć wystarczająco dużo prywatnych repozytoriów na swoim koncie, w przeciwnym razie repo zostanie zablokowane, dopóki nie uaktualnisz swojego planu.

Utwórz repozytorium w dockerhub:

$docker tag IMAGE_ID UsernameOnDockerhub/repoNameOnDockerhub:latest

$docker push UsernameOnDockerhub/repoNameOnDockerhub:latest

Uwaga : tutaj „repoNameOnDockerhub”: repozytorium o nazwie, o której wspominasz, musi być obecne w dockerhub

„najnowsze”: to tylko tag

Patrz: dock.docker.com

Ten temat zawiera podstawowe informacje na temat wdrażania i konfigurowania rejestru

Uruchom rejestr lokalny

Przed wdrożeniem rejestru musisz zainstalować Docker na hoście.

Aby uruchomić kontener rejestru, użyj polecenia podobnego do następującego:

start_registry.sh

#!/bin/bash

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

Skopiuj obraz z Docker Hub do rejestru

1. Wyciągnij ubuntu:16.04obraz z Docker Hub.

   $ docker pull ubuntu:16.04
   

2. Oznacz obraz jako localhost:5000/my-ubuntu. To tworzy dodatkowy znacznik dla istniejącego obrazu. Gdy pierwszą częścią tagu jest nazwa hosta i port, Docker interpretuje to jako lokalizację rejestru podczas wypychania.

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

3. Wepchnij obraz do rejestru lokalnego działającego w localhost:5000:

   $ docker push localhost:5000/my-ubuntu
   

4. Usuń lokalnie buforowane obrazy. To nie usuwa localhost:5000/my-ubuntuobrazu z rejestru.

   $ docker image remove ubuntu:16.04
   $ docker image remove localhost:5000/my-ubuntu
   

5. Wyciągnij localhost:5000/my-ubuntuobraz z lokalnego rejestru.

   $ docker pull localhost:5000/my-ubuntu
   

Według docs.docker.com jest to bardzo niepewne i nie jest zalecane .

1. Edytuj daemon.jsonplik, którego domyślną lokalizacją jest /etc/docker/daemon.jsonLinux lub C:\ProgramData\docker\config\daemon.jsonWindows Server. Jeśli używasz Docker for Maclub Docker for Windowskliknij Docker icon -> Preferences -> Daemon, dodaj w insecure registry.

   Jeśli daemon.jsonplik nie istnieje, utwórz go. Zakładając, że w pliku nie ma innych ustawień, powinien on mieć następującą zawartość:

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

   Po włączeniu niezabezpieczonych rejestrów Docker wykonuje następujące kroki:

   • Najpierw spróbuj użyć HTTPS.
     • Jeśli protokół HTTPS jest dostępny, ale certyfikat jest nieprawidłowy, zignoruj ​​błąd dotyczący certyfikatu.
     • Jeśli HTTPS nie jest dostępny, wróć do HTTP.

2. Zrestartuj Docker, aby zmiany odniosły skutek.

Najpierw zaloguj się do swojego prywatnego repozytorium.

> docker login [OPTIONS] [SERVER]

[OPTIONS]: 
-u username 
-p password

na przykład:

> docker login localhost:8080

A następnie oznacz swoje zdjęcie do prywatnego repozytorium

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

na przykład:

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

Wreszcie wypchnij swoje taged obrazy do prywatnego repozytorium

>docker push [OPTIONS] NAME[:TAG]

na przykład:

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

Odniesienie

• odniesienie do polecenia dokera

Proste rozwiązanie robocze:

Przejdź tutaj https://hub.docker.com/, aby utworzyć prywatną repozytorium z nazwą na przykład johnsmith/private-repositoryjest to NAME/REPOSITORYbędziesz używać dla obrazu podczas budowania wizerunku.

• Pierwszy, docker login

• Po drugie, używam „ docker build -t johnsmith/private-repository:01 .” (gdzie 01 to moja wersja) do tworzenia obrazu i używam „ docker images” do potwierdzenia obrazu utworzonego, na przykład w tym żółtym polu poniżej: (przepraszam, nie mogę wkleić formatu tabeli, ale tylko ciąg tekstowy )

johnsmith / private-repository (REPOSITORY) 01 (TAG) c5f4a2861d6e (ID OBRAZU) 2 dni temu (UTWORZONY) 305 MB (ROZMIAR)

• Po trzecie, używam docker push johnsmith/private-repository:01(Twoje prywatne repo będzie tutaj przykład https://hub.docker.com/r/johnsmith/private-repository/ )

Gotowy!