Cómo empujar una imagen acoplable a un repositorio privado

Tengo una imagen de Docker etiquetada como me/my-image, y tengo un repositorio privado en el Dockerhub llamado me-private.
Cuando presiono mi me/my-image, siempre termino golpeando el repositorio público.

¿Cuál es la sintaxis exacta para enviar específicamente mi imagen a mi repositorio privado?

Primero debe etiquetar su imagen correctamente con su registryhost:

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

Luego, presione Docker usando esa misma etiqueta.

docker push NAME[:TAG]

Ejemplo:

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

Solo tres pasos simples:

1. docker login --username username

   • solicita la contraseña si omite lo --passwordque se recomienda, ya que no lo almacena en su historial de comandos

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

3. docker push username/my-repo

Primero vaya a su cuenta de Docker Hub y haga el repositorio. Aquí hay una captura de pantalla de mi cuenta de Docker Hub:

De la foto, puedes ver que mi repositorio es "chuangg"

Ahora ingrese al repositorio y haga que sea privado haciendo clic en el nombre de su imagen. Entonces, para mí, hice clic en "chuangg / gene_commited_image", luego fui a Configuración -> Hacer privado. Luego seguí las instrucciones en pantalla

CÓMO CARGAR SU IMAGEN DOCKER EN EL HUB DOCKER

Método # 1 = Empujar su imagen a través de la línea de comando (cli)

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

Sí, creo que tiene que ser la identificación del contenedor. Probablemente no puede ser la ID de la imagen.

Por ejemplo = docker commit 99e078826312 chuangg/gene_commited_image

2) docker run -it chaung/gene_commited_image

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

Por ejemplo = docker login --username=chuangg [email protected]

Sí, primero debes iniciar sesión. Cerrar sesión usando "Docker Logout"

4) docker push chuangg/gene_commited_image

Método # 2 = Empujar su imagen usando pom.xml y la línea de comando.

Tenga en cuenta que utilicé un perfil de Maven llamado "build-docker". Si no desea utilizar un perfil, simplemente elimine los <profiles>, <profile>, and <id>build-docker</id>elementos.

Dentro del padre 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 para desplegar la imagen de Docker (desde el directorio donde se encuentra su pom.xml) = mvn clean deploy -Pbuild-docker docker:push

Tenga en cuenta que la diferencia entre el Método 2 y 3 es que el Método 3 tiene un extra <execution>para la implementación.

Método # 3 = Usar Maven para implementar automáticamente en Docker Hub

Agregue estas cosas a su padre 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>

Vaya al directorio C: \ Users \ Gene.docker \ y agregue esto a su archivo config.json:

Ahora en su Docker Quickstart Terminal escriba = mvn clean install -Pbuild-docker

Para aquellos de ustedes que no usan Perfiles Maven, simplemente escriba mvn clean install

Aquí está la captura de pantalla del mensaje de éxito:

Aquí está mi pom.xml completo y una captura de pantalla de la estructura de mi directorio:

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

Aquí está mi directorio de Eclipse:

Aquí está mi 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" ] 

Error Común # 1:

Solución para el error n. ° 1 = No sincronice la <execution>fase de despliegue con maven porque entonces maven intenta desplegar la imagen 2x y coloca una marca de tiempo en el jar. Por eso lo usé <phase>install</phase>.

Si el registro de Docker es privado y está autohospedado , debe hacer lo siguiente:

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

Ejemplo:

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

Hay dos opciones:

1. Vaya al centro, cree primero el repositorio y márquelo como privado. Luego, cuando empuje a ese repositorio, será privado. Este es el enfoque más común.

2. inicie sesión en su cuenta de Docker Hub y vaya a su configuración global . Hay una configuración que le permite establecer cuál es su visa predeterminada para los repositorios que empuja. De forma predeterminada, se establece en público, pero si lo cambia a privado, todos los repositorios que inserte se marcarán como privados de forma predeterminada. Es importante tener en cuenta que necesitará tener suficientes repositorios privados disponibles en su cuenta, de lo contrario, el repositorio se bloqueará hasta que actualice su plan.

Crear repositorio en dockerhub:

$docker tag IMAGE_ID UsernameOnDockerhub/repoNameOnDockerhub:latest

$docker push UsernameOnDockerhub/repoNameOnDockerhub:latest

Nota : aquí "repoNameOnDockerhub": el repositorio con el nombre que está mencionando debe estar presente en dockerhub

"último": es solo etiqueta

Ref: dock.docker.com

Este tema proporciona información básica sobre la implementación y configuración de un registro

Ejecute un registro local

Antes de poder implementar un registro, debe instalar Docker en el host.

Use un comando como el siguiente para iniciar el contenedor 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

Copie una imagen de Docker Hub a su registro

1. Extraiga la ubuntu:16.04imagen de Docker Hub.

   $ docker pull ubuntu:16.04
   

2. Etiqueta la imagen como localhost:5000/my-ubuntu. Esto crea una etiqueta adicional para la imagen existente. Cuando la primera parte de la etiqueta es un nombre de host y un puerto, Docker interpreta esto como la ubicación de un registro, al presionar.

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

3. Empuje la imagen al registro local que se ejecuta en localhost:5000:

   $ docker push localhost:5000/my-ubuntu
   

4. Eliminar las imágenes almacenadas en caché localmente. Esto no elimina la localhost:5000/my-ubuntuimagen de su registro.

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

5. Extraiga la localhost:5000/my-ubuntuimagen de su registro local.

   $ docker pull localhost:5000/my-ubuntu
   

Según docs.docker.com , esto es muy inseguro y no se recomienda .

1. Edite el daemon.jsonarchivo, cuya ubicación predeterminada es /etc/docker/daemon.jsonLinux o C:\ProgramData\docker\config\daemon.jsonWindows Server. Si usa Docker for Maco Docker for Windows, haga clic Docker icon -> Preferences -> Daemon, agregue el insecure registry.

   Si el daemon.jsonarchivo no existe, créelo. Suponiendo que no hay otras configuraciones en el archivo, debe tener los siguientes contenidos:

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

   Con los registros inseguros habilitados, Docker sigue los siguientes pasos:

   • Primero, intente usar HTTPS.
     • Si HTTPS está disponible pero el certificado no es válido, ignore el error sobre el certificado.
     • Si HTTPS no está disponible, recurra a HTTP.

2. Reinicie Docker para que los cambios surtan efecto.

Primero inicie sesión en su repositorio privado.

> docker login [OPTIONS] [SERVER]

[OPTIONS]: 
-u username 
-p password

p.ej:

> docker login localhost:8080

Y luego etiqueta tu imagen para tu repositorio privado

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

p.ej:

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

Finalmente empuje sus imágenes marcadas a su repositorio privado

>docker push [OPTIONS] NAME[:TAG]

p.ej:

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

Referencia

• referencia de comando de Docker

Solución de trabajo simple:

Vaya aquí https://hub.docker.com/para crear un repositorio PRIVADO con nombre, por ejemplo, johnsmith/private-repositoryeste es el NAME/REPOSITORYque usará para su imagen cuando construya la imagen.

• Primero, docker login

• En segundo lugar, uso " docker build -t johnsmith/private-repository:01 ." (donde 01 es el nombre de mi versión) para crear la imagen, y uso " docker images" para confirmar la imagen creada, como en este cuadro amarillo a continuación: (lo siento, no puedo pegar el formato de tabla pero solo la cadena de texto )

johnsmith / private-repository (REPOSITORY) 01 (TAG) c5f4a2861d6e (ID DE IMAGEN) hace 2 días (CREADO) 305MB (TAMAÑO)

• Tercero, yo uso docker push johnsmith/private-repository:01 (su repositorio privado estará aquí, ejemplo https://hub.docker.com/r/johnsmith/private-repository/ )

¡Hecho!