Struttura dell'applicazione java

Demo
└── src
|    ├── main
|    │   ├── java
|    │   │   └── org
|    │   │       └── demo
|    │   │           └── App.java
|    │   └── resources
|    │       └── application.properties
|    └── test
|         └── java
|               └── org
|                   └── demo
|                         └── App.java  
├──── Dockerfile
├──── pom.xml

Contenuto del Dockerfile

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

Comandi per creare ed eseguire image

• Vai alla directory del progetto.Diciamo D:/Demo

$ cd D/demo
$ mvn clean install
$ docker build demo .
$ docker run -p 8080:8080 -t demo

Verificare che il contenitore sia in esecuzione o meno

$ docker ps

L'output sarà

CONTAINER ID        IMAGE               COMMAND                CREATED             STATUS              PORTS                    NAMES
55c11a464f5a        demo1               "java -jar demo.jar"   21 seconds ago      Up About a minute   0.0.0.0:8080->8080/tcp   cranky_mayer

Il modo più semplice è lasciare che lo strumento di compilazione controlli il processo. Altrimenti, dovresti mantenere il file di compilazione del tuo strumento di compilazione (come pom.xml per Maven o build.gradle per Gradle) e Dockerfile.

Un modo semplice per creare un contenitore Docker per la tua app Java è usare Jib, che è disponibile come Maven e Gradle plugin.

Ad esempio, se stai usando Maven e vuoi costruire il tuo contenitore per la tua corsa Docker daemon, puoi semplicemente eseguire questo comando:

mvn compile com.google.cloud.tools:jib-maven-plugin:0.9.2:dockerBuild

Puoi anche creare direttamente in un registro Docker con Jib senza bisogno di installare docker, esegui un demone Docker (che richiede i privilegi di root) o scrivi un Dockerfile. È anche più veloce e crea immagini riproducibili.

Vedi di più su Jib al suo repository Github: https://github.com/GoogleContainerTools/jib

Abbiamo usato il plugin Spotify Docker Maven per un po'. Il plugin consente di associare un Docker costruirlo a una fase del ciclo di vita di Maven.

Un esempio: Esegui la compilazione Docker dopo il confezionamento (fase: pacchetto) dell'applicazione configurando il plugin per aggiungere l'applicazione creata come risorsa al contesto di compilazione Docker. Nella fase di distribuzione, esegui l'obiettivo Docker push per inviare l'immagine Docker a un registro. Questo può essere eseguito accanto al normale plug-in deploy, che pubblica il artefatto in un repository come Nexus.

In seguito, abbiamo diviso la build in due processi separati sul server CI. Poiché Docker è solo un modo per eseguire la tua applicazione (a volte abbiamo bisogno dell'applicazione rilasciata su diversi ambienti non solo Docker), la build Maven non dovrebbe fare affidamento su Docker.

Quindi il primo lavoro rilascia l'applicazione in Nexus (tramite Maven deploy). Il secondo lavoro (che può essere una dipendenza a valle del primo lavoro) scarica l'ultima versione artefatto, esegue la compilazione Docker e spinge l'immagine al registro di sistema. Per scaricare l'ultima versione usiamo il Versions Maven Plugin (versions:use-latest-releases) così come il Maven Dependency Plugin (dependency:get e dependency:copy).

Il secondo lavoro può anche essere avviato per una versione specifica dell'applicazione per (ri)creare l'immagine Docker per una versione precedente. Inoltre è possibile utilizzare una pipeline di compilazione (su Jenkins), che esegue sia i lavori che i passaggi la versione di rilascio o l'artefatto di rilascio nella build Docker.

Un paio di cose:

• Se elimini i file nella stessa istruzione in cui li aggiungi, non consumeranno spazio nell'immagine. Se guardi alcuni dei Dockerfiles per le immagini ufficiali vedrai che scaricano il sorgente, lo costruiscono ed eliminano tutto nello stesso passaggio (ad esempio https://github.com/docker-library/python/blob/0fa3202789648132971160f686f5a37595108f44/3.5/slim/Dockerfile). Questo significa che devi fare un po ' di ginnastica fastidiosa, ma è perfettamente fattibile.

• Non vedo il problema con due Dockerfiles separati. La cosa bella di questo è che potresti usare il JRE piuttosto che il JDK per ospitare il tuo barattolo.

Esistono usi alternativi per l'esecuzione di pacchetti jar o war

• aggiungi jar nell'immagine.
• imposta heapsize per java
• esegui il comando jar tramite entrypoint

File dockerfile di esempio

FROM base
ADD sample.jar renamed.jar
ENV HEAP_SIZE 256m
ENTRYPOINT exec java -Xms$HEAP_SIZE -Xmx$HEAP_SIZE -jar renamed.jar

Inoltre esempio di distribuzione del pacchetto su tomcat

FROM tomcat7
ADD sample.war ${CATALINA_HOME}/webapps/ROOT.war
CMD ${CATALINA_HOME}/bin/catalina.sh run

Creazione di file dockerfile come immagine

cp tomcat.dockerfile /workingdir/Dockerfile
docker build -t name /workingdir/Dockerfile .

Elenco immagini

docker images

Usa l'immagine per creare un contenitore

docker run --name cont_name --extra-vars var1=val1 var2=val2 imagename

Qui Descrivo come lo faccio nel mio ambiente di sviluppo.

• Crea il war / jar localmente con Maven
• Copiarlo in una cartella Docker locale
• Esegui Intellij Docker plugin {[2] } che crea un'immagine docker che contiene war / jar, esegue il server delle applicazioni e lo distribuisce sul server Docker remoto

Spero che aiuti.

Containerizza la tua applicazione java usando lo strumento Jib senza scrivere dockerfile

Jib è uno strumento Java open source gestito da Google per la creazione di immagini Docker di applicazioni Java. Semplifica la containerizzazione poiché con esso, non abbiamo bisogno di scrivere un dockerfile. E in realtà, non abbiamo nemmeno bisogno di avere installato docker per creare e pubblicare le immagini docker noi stessi.

Google pubblica Jib sia come Maven che come Gradle plugin. https://github.com/GoogleContainerTools/jib

Containerizza la tua applicazione java usando Maven project

Https://github.com/GoogleContainerTools/jib/tree/master/jib-maven-plugin#quickstart

Containerizza la tua applicazione java usando Gradle project

Https://github.com/GoogleContainerTools/jib/tree/master/jib-gradle-plugin#quickstart