Może być wiele sposobów.. Ale zaimplementowałem postępując na dwa sposoby

Podany przykład dotyczy projektu maven.

1. Używanie pliku Dockerfile w projekcie maven

Użyj następującej struktury plików:

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

I zaktualizuj plik Dockerfile jako:

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

Przejdź do folderu projektu i wpisz następujące polecenie będziesz ab le stworzyć obraz i uruchomić ten obraz:

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

Pobierz film na Spring Boot with Docker

2. Korzystanie z wtyczek Maven

Dodaj dany plugin Mavena w 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>

Przejdź do folderu projektu i wpisz następujące polecenie będziesz mógł utworzyć obraz i uruchomić ten obraz:

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

W pierwszym przykładzie tworzymy plik Dockerfile i dostarczamy obraz bazowy oraz dodajemy jar an so, po wykonaniu tej czynności uruchomimy polecenie docker, aby zbudować obraz o określonej nazwie, a następnie uruchomić ten obraz..

Natomiast w drugim przykładzie jesteśmy używając wtyczki maven, w której dostarczamy baseImage i imageName, więc nie musimy tutaj tworzyć pliku Dockerfile.. po spakowaniu projektu maven otrzymamy obraz dokera i musimy go tylko uruchomić..

Z reguły powinieneś zbudować fat JAR używając Mavena (JAR, który zawiera zarówno Twój kod, jak i wszystkie zależności).

Następnie możesz napisać Dockerfile, który odpowiada Twoim wymaganiom(jeśli możesz zbudować fat JAR, potrzebujesz tylko bazowego systemu operacyjnego, takiego jak CentOS i JVM).

To jest to, czego używam do aplikacji Scala (która jest oparta na Javie).

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

Tworzy to obraz oparty na CentOS z Java7. Po uruchomieniu uruchomi Twój jar aplikacji.

The najlepszym sposobem wdrożenia jest poprzez rejestr Dockera, to jak Github dla obrazów Dockera.

Możesz zbudować taki obraz:

# current dir must contain the Dockerfile
docker build -t username/projectname:tagname .

Możesz następnie wypchnąć obraz w ten sposób:

docker push username/projectname # this pushes all tags

Gdy obraz znajdzie się w rejestrze dokera, możesz go pobrać z dowolnego miejsca na świecie i uruchomić.

O czym warto pamiętać :

Można również wyciągnąć repozytorium wewnątrz obrazu i zbudować jar jako część wykonania kontenera, ale nie jest to dobre podejście, ponieważ kod może się zmienić i możesz skończyć używając innej wersji aplikacji bez powiadomienia.

Budowanie słoika tłuszczu usuwa ten problem.