Come avviare automaticamente due JAR su "contenitore run docker"

Question

Desidero che vengano eseguiti automaticamente due file JAR separati una volta che un contenitore docker viene chiamato tramite il comando run, quindi quando si digita lo docker run mycontainer vengono entrambi richiamati. Finora ho un file di dati simile al seguente:

# base image is java:8 (ubuntu) 
FROM java:8 

# add files to image 
ADD first.jar . 
ADD second.jar . 

# start on run 
CMD ["/usr/lib/jvm/java-8-openjdk-amd64/bin/java", "-jar", "first.jar"] 
CMD ["/usr/lib/jvm/java-8-openjdk-amd64/bin/java", "-jar", "second.jar"] 

Questo, tuttavia, avvia solo second.jar.

Ora, entrambi i jar sono server in un ciclo, quindi suppongo che una volta avviato, blocchi solo il terminale. Se eseguo il contenitore utilizzando run -it mycontainer bash e li chiamo manualmente, il primo eseguirà le sue uscite e non posso avviare l'altro.

C'è un modo per aprire diversi terminali e passare da uno all'altro per far funzionare ciascun JAR nel proprio contesto? Preferibilmente già nel file Docker.

So quasi nulla di ubuntu ma ho trovato il comando xterm che apre un nuovo terminale, tuttavia questo non funzionerà dopo aver chiamato un JAR. Quello che sto cercando sono le istruzioni per il file docker che ad esempio aprono un nuovo terminale, eseguono first.jar, alt-tab nel vecchio terminale ed eseguono second.jar lì, o almeno ottengono lo stesso risultato.

Grazie!

Answer 1

La seconda istruzione CMD sostituisce la prima, quindi è necessario utilizzare una singola istruzione per entrambi i comandi.

facile (non così buono) Approccio

Si potrebbe aggiungere uno script bash che esegue entrambi i comandi e blocchi sulla seconda:

# start.sh 
/usr/lib/jvm/java-8-openjdk-amd64/bin/java -jar first.jar & 
/usr/lib/jvm/java-8-openjdk-amd64/bin/java -jar second.jar 

Quindi modificare il tuo Dockerfile a questo:

Quando si utilizza docker stop, potrebbe non arrestarsi correttamente, vedere: https://blog.phusion.nl/2015/01/20/docker-and-the-pid-1-zombie-reaping-problem/

Meglio approccio

Per risolvere questo problema, è possibile utilizzare Phusion: https://hub.docker.com/r/phusion/baseimage/
Ha un init-sistema che è molto più facile da usare rispetto ad esempio supervisord.

Qui è un buon punto di partenza: https://github.com/phusion/baseimage-docker#getting_started

istruzioni per l'utilizzo Phusion

Purtroppo non è ufficiale openjdk-8-JDK disponibile per Ubuntu 14.04 LTS. Potresti provare con un ppa non ufficiale, che viene usato nella seguente spiegazione.

Nel tuo caso si avrebbe bisogno di bash script (che agiscono come "servizi"):

# start-first.sh (the file has to start with the following line!): 
#!/bin/bash 
usr/lib/jvm/java-8-openjdk-amd64/bin/java -jar /root/first.jar 

# start-second.sh 
#!/bin/bash 
usr/lib/jvm/java-8-openjdk-amd64/bin/java -jar /root/second.jar 

E il tuo Dockerfile sarebbe simile a questa:

# base image is phusion 
FROM phusion/baseimage:latest 

# Use init service of phusion 
CMD ["/sbin/my_init"] 

# Install unofficial openjdk-8 
RUN add-apt-repository ppa:openjdk-r/ppa && apt-get update && apt-get dist-upgrade -y && apt-get install -y openjdk-8-jdk 

ADD first.jar /root/first.jar 
ADD second.jar /root/second.jar 

# Add first service 
RUN mkdir /etc/service/first 
ADD start-first.sh /etc/service/first/run 
RUN chmod +x /etc/service/first/run 

# Add second service 
RUN mkdir /etc/service/second 
ADD start-second.sh /etc/service/second/run 
RUN chmod +x /etc/service/second/run 

# Clean up 
RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* 

Questo dovrebbe installare due servizi che verrà eseguito all'avvio e verrà spento correttamente quando si utilizza docker stop.

Answer 2

Se si desidera avviare due diversi processi all'interno un contenitore finestra mobile (comportamento non recommanded) si può usare qualcosa come supervisord

Answer 3

Un contenitore Docker ha solo un unico processo quando viene avviato.

è comunque possibile creare diversi processi in seguito .:

• Un modo semplice è quello di creare un secondo processo all'interno di uno script bash.
• È inoltre possibile utilizzare Supervisore: https://docs.docker.com/articles/using_supervisord/

Answer 4

Hai alcune opzioni. Molte delle risposte hanno menzionato l'utilizzo del supervisore per questo, che è una soluzione eccellente. Eccone alcuni altri:

Creare uno script breve che avvia appena entrambi i vasi. Aggiungilo al tuo CMD. Ad esempio, lo script, che chiameremo run_jars.sh potrebbe sembrare:

/usr/lib/jvm/java-8-openjdk-amd64/bin/java -jar first.jar; 
/usr/lib/jvm/java-8-openjdk-amd64/bin/java -jar second.jar; 

Allora la vostra CMD sarebbe CMD sh run_jars.sh

Un'altra alternativa è solo in esecuzione due uno containers-- separato per first.jar e l'altro per second.jar. È possibile eseguire ognuno attraverso docker run, ad esempio:

docker run my_repo/my_image:some_tag /usr/lib/jvm/java-8-openjdk-amd64/bin/java -jar second.jar