Wie downloade ich Maven-Projekt? und wie viele Möglichkeiten, es zu erreichen?

Ich bin neu in Docker, und nicht wissen, wie man ein java-Projekt mit maven obwohl ich habe gelesen, dass viele Dokumente und versucht, viele Methoden.

Sollte Baue ich das Bild mit Dockerfile?
, Was die Befehle wie, wenn es zum ausführen des maven-Projekt in dem host mit Dockerfile?

InformationsquelleAutor der Frage Yashon Lin | 2015-01-04

22

Versuchen, mit den neuen offiziellen Bilder, es gibt eine für Maven

https://registry.hub.docker.com/_/maven/

Das Bild kann verwendet werden, zum ausführen von Maven bei der Erstellung zum erstellen einer kompilierten Anwendung oder, wie in den folgenden Beispielen, einen Maven-build-in einem container.

Beispiel 1 - Maven-Ausführung in einem container

Dem folgenden Befehl wird Ihre Maven-build-in einem container:
```
docker run -it --rm \
       -v "$(pwd)":/opt/maven \
       -w /opt/maven \
       maven:3.2-jdk-7 \
       mvn clean install
```
Hinweise:
- Das schöne an diesem Ansatz ist, dass alle software installiert ist und läuft in den Behälter. Nur brauchen das Andockfenster auf dem host-Rechner.
- Sehen Dockerfile für diese version
Beispiel 2 - Verwendung Nexus cache-Dateien

Führen Sie den Nexus-container
```
docker run -d -p 8081:8081 --name nexus sonatype/nexus
```
Erstellen "settings.xml" Datei:
```
<settings>
  <mirrors>
    <mirror>
      <id>nexus</id>
      <mirrorOf>*</mirrorOf>
      <url>http://nexus:8081/content/groups/public/</url>
    </mirror>
  </mirrors>
</settings>
```
Nun führen Sie Maven mit Verlinkung zu den nexus-container, so dass Abhängigkeiten zwischengespeichert werden
```
docker run -it --rm \
       -v "$(pwd)":/opt/maven \
       -w /opt/maven \
       --link nexus:nexus \
       maven:3.2-jdk-7 \
       mvn -s settings.xml clean install
```
Hinweise:
- Ein Vorteil der Nexus läuft im hintergrund, ist, dass andere 3rd-party-repositories verwaltet werden können über die admin-URL ein transparent an die Maven builds laufen im lokalen Container.
Update (2018-04-06)

"--Link" - option im Andockfenster wurde als veraltet markiert. Nutzen Docker ' s native DNS Sie können führen Sie das obige Beispiel wie folgt
```
#
# Create a common container network
#
docker network create build

#
# Run the containers on this network
#
docker run -d --network build -p 8081:8081 --name nexus sonatype/nexus
docker run -it --rm --network build \
       -v "$(pwd)":/opt/maven \
       -w /opt/maven \
       maven:3.2-jdk-7 \
       mvn -s settings.xml clean install
```
InformationsquelleAutor der Antwort Mark O'Connor

Möglicherweise gibt es viele Möglichkeiten.. Aber ich umgesetzt, indem Sie die folgenden zwei Möglichkeiten

Gegebene Beispiel ist der maven-Projekt.

1. Mit Dockerfile in maven-Projekt

Verwenden Sie die folgende Datei-Struktur:

Demo
└── src
|    ├── main
|    │   ├── java
|    │       └── org
|    │           └── demo
|    │               └── Application.java
|    │   
|    └── test
|
├──── Dockerfile
├──── pom.xml

Und aktualisieren Sie die Dockerfile:

FROM java:8
EXPOSE 8080
ADD /target/demo.jar demo.jar
ENTRYPOINT ["java","-jar","demo.jar"]

Navigieren Sie zu dem Projekt-Ordner und geben Sie folgenden Befehl ein, Sie werden ab
Datei image erstellen und ausführen, Bild:

$ mvn clean
$ mvn install
$ docker build -f Dockerfile -t springdemo .
$ docker run -p 8080:8080 -t springdemo

Sie das video auf Spring Boot mit Docker

2. Mithilfe von Maven-plugins

Beurteilung gegeben maven-plugin in pom.xml

<plugin>
    <groupId>com.spotify</groupId>
    <artifactId>docker-maven-plugin</artifactId>
    <version>0.4.5</version>
        <configuration>
            <imageName>springdocker</imageName>
            <baseImage>java</baseImage>
            <entryPoint>["java", "-jar", "/${project.build.finalName}.jar"]</entryPoint>
            <resources>
                <resource>
                    <targetPath>/</targetPath>
                    <directory>${project.build.directory}</directory>
                    <include>${project.build.finalName}.jar</include>
                </resource>
            </resources>
        </configuration>
    </plugin>

Navigieren Sie zu dem Projekt-Ordner und geben Sie folgenden Befehl können Sie zum erstellen von Bild-und ausführen, Bild:

$ mvn clean package docker:build
$ docker images
$ docker run -p 8080:8080 -t <image name>

Im ersten Beispiel erstellen wir Dockerfile und Bereitstellung von Basis-image und hinzufügen von jar ein so nach tun, dass wir Andockfenster Befehl zum erstellen eines Bildes mit bestimmten Namen und führen Sie dann das Bild..

In der Erwägung, dass im zweiten Beispiel verwenden wir maven-plugin, in dem wir die Bereitstellung von baseImage und imageName so brauchen wir nicht zu erstellen Dockerfile hier.. nach packaging maven-Projekt bekommen wir das docker-image, und wir brauchen nur zu laufen, dass Bild..

InformationsquelleAutor der Antwort Riddhi Gohil

8

Als Faustregel gilt, sollten Sie bauen ein Fett JAR mit Maven (ein GLAS enthält Ihren code und alle Abhängigkeiten).

Dann schreiben Sie bitte eine Dockerfile, die Ihren Anforderungen entspricht (wenn Sie können bauen eine fat-JAR müssten Sie nur ein Basis-Betriebssystem, wie CentOS, und die JVM).

Dies ist, was ich für ein Scala-app (Java-basiert).
```
FROM centos:centos7

# Prerequisites.

RUN yum -y update
RUN yum -y install wget tar

# Oracle Java 7

WORKDIR /opt

RUN wget --no-cookies --no-check-certificate --header "Cookie: gpw_e24=http%3A%2F%2Fwww.oracle.com%2F; oraclelicense=accept-securebackup-cookie" http://download.oracle.com/otn-pub/java/jdk/7u71-b14/server-jre-7u71-linux-x64.tar.gz
RUN tar xzf server-jre-7u71-linux-x64.tar.gz
RUN rm -rf server-jre-7u71-linux-x64.tar.gz
RUN alternatives --install /usr/bin/java java /opt/jdk1.7.0_71/bin/java 1

# App

USER daemon

# This copies to local fat jar inside the image
ADD /local/path/to/packaged/app/appname.jar /app/appname.jar

# What to run when the container starts
ENTRYPOINT [ "java", "-jar", "/app/appname.jar" ]

# Ports used by the app
EXPOSE 5000
```
Dies schafft eine CentOS-basierte Bild mit Java7.
Wenn gestartet, wird es führen Sie Ihre app jar.

Der beste Weg, um bereitstellen, ist es über die Docker-Registrierung, es ist wie ein Github für Docker-images.

Können Sie bauen ein Bild wie dieses:
```
# current dir must contain the Dockerfile
docker build -t username/projectname:tagname .
```
Können Sie dann schieben Sie ein Bild in dieser Art:
```
docker push username/projectname # this pushes all tags
```
Einmal das Bild auf der Docker-Registry, können Sie ziehen Sie es von überall in der Welt und führen Sie es.

Sehen Andockfenster Bedienungsanleitung für weitere Informationen.

Etwas im Auge zu behalten:

Könnten Sie auch ziehen Sie Ihre repository in ein Bild und bauen Sie das Glas als Teil der container-Ausführung, aber es ist nicht ein guter Ansatz, wie der code könnte sich ändern, und Sie könnten am Ende mit einer anderen version der app ohne Vorherige Ankündigung.

Aufbau einer fat-jar behebt dieses Problem.

InformationsquelleAutor der Antwort Matteo Pacini

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Beispiel 1 - Maven-Ausführung in einem container

Beispiel 2 - Verwendung Nexus cache-Dateien

Update (2018-04-06)