So erstellen Sie mit Dockerfile ein Spiegelbild der Java-Laufzeitumgebung

So erstellen Sie mit Dockerfile ein Spiegelbild der Java-Laufzeitumgebung

Die aktuelle Umgebung ist:

  • Centos 7.5
  • docker-ce 18.06.1-ce

1. Verwenden Sie zunächst das Basisimage von centos7.5.1804, um einige für den Betrieb erforderliche Umgebungen zu installieren

Erstellen Sie ein entsprechendes Dateiverzeichnis im Verzeichnis /app

[root@node2 /app/]# mkdir dockerfile/{web/{nginx,tomcat,jdk,apache},system/{centos,ubuntu,redhat}} -pv
[root@node2 /app]# cd dockerfile/system/centos/
[root@node2 /app/dockerfile/system/centos]# mkdir centos-7.5-base
[root@node2 /app/dockerfile/system/centos]# cd centos-7.5-base

Erstellen einer Docker-Datei

[root@node2 /app/dockerfile/system/centos/centos-7.5-base]#vim Dockerfile 
#Nginx-Basisimage
VON centos:7.5.1804

LABEL-Betreuer „mr.luo <[email protected]>“

RUN yum install -y vim wget pcre pcre-devel zlib zlib-devel openssl openssl-devel iproute net-tools iotop

Erstellen Sie ein Docker-Build-Skript und führen Sie es direkt aus

[root@node2 /app/dockerfile/system/centos/centos-7.5-base]#vim build-command.sh 
#!/bin/bash
Docker-Build -t 172.20.7.50/baseimages/centos-base:7.5.1804.

Führen Sie das Skript aus, um ein neues Image zu erstellen

[root@node2 /app/dockerfile/system/centos/centos-7.5-base]#bash build-command.sh 
Senden des Build-Kontexts an den Docker-Daemon 3.072kB
Schritt 1/3: VON centos:7.5.1804
---> 76d6bc25b8a5
Schritt 2/3: LABEL-Betreuer „[email protected]“
---> Cache verwenden
---> 05ccd970d71d
Schritt 3/3: Führen Sie den Befehl yum install -y vim wget pcre pcre-devel zlib zlib-devel openssl openssl-devel iproute net-tools iotop aus.
---> Cache verwenden
---> 73d683a54877
Erfolgreich erstellt 73d683a54877
Erfolgreich markiert: 172.20.7.50/baseimages/centos-base:7.5.1804

2. Verwenden Sie das vorbereitete Basisumgebungsimage, um ein JDK-Image zu erstellen

Beenden Sie centos-7.5-base und erstellen Sie ein jdk1.8-Verzeichnis im aktuellen Verzeichnis.

[root@node2 /app/dockerfile/system/centos/centos-7.5-base]# cd ..
[root@node2 /app/dockerfile/system/centos]# mkdir jdk1.8
[root@node2 /app/dockerfile/system/centos]# cd jdk1.8/

Dockerfile erstellen

[root@node2 /app/dockerfile/system/centos/jdk1.8]#vim Dockerfile 
VON 172.20.7.50/baseimages/centos-base:7.5.1804
LABEL-Betreuer „mr.luo <[email protected]>“

HINZUFÜGEN jdk-8u162-linux-x64.tar.gz /usr/local/src/
RUN ln -s /usr/local/src/jdk1.8.0_162/ /usr/local/jdk

Profil /etc/profile hinzufügen

ENV JAVA_HOME /usr/local/jdk
ENV JRE_HOME $JAVA_HOME/jre
ENV-KLASSENSPATH $JAVA_HOME/lib/:$JRE_HOME/lib/
ENV PATH $PATH:$JAVA_HOME/bin

RUN rm -rf /etc/localtime && ln -snf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo "Asia/Shanghai" > /etc/timezone

Laden Sie das JDK-Paket in das aktuelle Verzeichnis hoch:

Kopieren Sie die Datei /etc/profile in das aktuelle Verzeichnis

[root@node2 /app/dockerfile/system/centos/jdk1.8]#cp-Profil /etc/Profil

Fügen Sie die JDK-Umgebungsvariable am Ende des Profils hinzu

[root@node2 /app/dockerfile/system/centos/jdk1.8]#vim-Profil 
exportiere JAVA_HOME=/usr/local/jdk
exportiere TOMCAT_HOME=/apps/tomcat
export PATH=$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$TOMCAT_HOME/bin:$PATH
export CLASSPATH=.$CLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib:$JAVA_HOME/lib/tools.jar

Erstellen Sie ein Shell-Skript für den Docker-Build

[root@node2 /app/dockerfile/system/centos/jdk1.8]#vim build-command.sh 
#!/bin/bash
#
Docker-Build -t 172.20.7.50/baseimages/centos7.5-jdk:8.162.

Beginnen Sie mit der Bildererstellung

[root@node2 /app/dockerfile/system/centos/jdk1.8]#bash build-command.sh 
  Senden des Build-Kontexts an den Docker-Daemon 189,8 MB
  Schritt 1/10: VON 172.20.7.50/baseimages/centos-base:7.5.1804
   ---> 73d683a54877
  Schritt 2/10: LABEL-Betreuer „mr.luo <[email protected]>“
   ---> Wird ausgeführt in 65604dd1f392
  Zwischenbehälter entfernen 65604dd1f392
   ---> c4720603ce38
  Schritt 3/10: ADD jdk-8u162-linux-x64.tar.gz /usr/local/src/
   ---> bc98adffe1b4
  Schritt 4/10: RUN ln -s /usr/local/src/jdk1.8.0_162/ /usr/local/jdk
   ---> Wird ausgeführt in df5a6f67f9fd
  Zwischenbehälter entfernen df5a6f67f9fd
   ---> 0ae1af0416c6
  Schritt 5/10: Profil /etc/profile hinzufügen
   ---> eee23a69c0c8
  Schritt 6/10: ENV JAVA_HOME /usr/local/jdk
   ---> Wird ausgeführt in edbef8563e83
  Zwischenbehälter entfernen edbef8563e83
   ---> 5f783f642054
  Schritt 7/10: ENV JRE_HOME $JAVA_HOME/jre
   ---> Läuft in fa0e5f08e732
  Zwischenbehälter entfernen fa0e5f08e732
   ---> 28a4d31463d4
  Schritt 8/10: ENV CLASSPATH $JAVA_HOME/lib/:$JRE_HOME/lib/
   ---> Wird ausgeführt in 3c4ebb04ac62
  Zwischenbehälter entfernen 3c4ebb04ac62
   ---> 245f2dd82d52
  Schritt 9/10: ENV PATH $PATH:$JAVA_HOME/bin
   ---> Wird ausgeführt in 4f5e6093f0a9
  Zwischenbehälter entfernen 4f5e6093f0a9
   ---> 5be0e6261eea
  Schritt 10/10: RUN rm -rf /etc/localtime && ln -snf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo "Asia/Shanghai" > /etc/timezone
   ---> Wird ausgeführt in 52d8cb8463a8
  Zwischenbehälter ausbauen 52d8cb8463a8
   ---> 9fb867ae8c39
  Erfolgreich erstellt 9fb867ae8c39
  Erfolgreich markiert 172.20.7.50/baseimages/centos7.5-jdk:8.162

Zeigen Sie die Dateien im aktuellen Verzeichnis an

[root@node2 /app/dockerfile/system/centos/jdk1.8]#ls
build-command.sh Dockerfile jdk-8u162-linux-x64.tar.gz Profil

Überprüfen Sie, ob das vorbereitete Bild normal verwendet werden kann

[root@node2 /app/dockerfile/system/centos/jdk1.8]#docker run -it --rm 172.20.7.50/baseimages/centos7.5-jdk:8.162 bash
[root@919844b164dc /]# java -version 
Java-Version „1.8.0_162“
Java(TM) SE-Laufzeitumgebung (Build 1.8.0_162-b12)
Java HotSpot(TM) 64-Bit Server VM (Build 25.162-b12, gemischter Modus)
[root@919844b164dc /]# Datum
Do, 22. November 2018, 21:17:49 CST
[root@919844b164dc /]# beenden
Ausfahrt

3. Erstellen Sie ein Tomcat-Image

Geben Sie das zuvor erstellte /app/dockerfile/web/tomcat ein und erstellen Sie ein Tomcat-Basisverzeichnis

[root@node2 ~]# cd /app/dockerfile/web/tomcat 
[root@node2 /app/dockerfile/web/tomcat]#mkdir tomcat-base

Dockerfile erstellen

[root@node2 /app/dockerfile/web/tomcat/tomcat-base]#vim Dockerfile 
VON 172.20.7.50/baseimages/centos7.5-jdk:8.162

LABEL-Betreuer „mr.luo <[email protected]>“

Führen Sie den Befehl mkdir /apps aus.
ADD apache-tomcat-8.5.33.tar.gz /apps
RUN ln -s /apps/apache-tomcat-8.5.33 /apps/tomcat

Erstellen Sie ein Docker-Build-Skript

[root@node2 /app/dockerfile/web/tomcat/tomcat-base]#vim build-command.sh 
#!/bin/bash

docker build -t 172.20.7.50/baseimages/centos-tomcat:8.5.33 .

Führen Sie den folgenden Befehl aus, um die Image-Datei zu erstellen:

[root@node2 /app/dockerfile/web/tomcat/tomcat-base]#bash build-command.sh 
  Senden des Build-Kontexts an den Docker-Daemon 9,625 MB
  Schritt 1/5: VON 172.20.7.50/baseimages/centos7.5-jdk:8.162
   ---> 9fb867ae8c39
  Schritt 2/5: LABEL-Betreuer „mr.luo <[email protected]>“
   ---> Wird ausgeführt in 9ce6fc4d2850
  Zwischenbehälter entfernen 9ce6fc4d2850
   ---> b68755061b28
  Schritt 3/5: Führen Sie mkdir /apps aus.
   ---> Läuft in b483c6b127f2
  Zwischenbehälter entfernen b483c6b127f2
   ---> 605c1a048a5f
  Schritt 4/5: ADD apache-tomcat-8.5.33.tar.gz /apps
   ---> 3c44f96ed41c
  Schritt 5/5: RUN ln -s /apps/apache-tomcat-8.5.33 /apps/tomcat
   ---> Wird ausgeführt in 4c1aa39a6c92
  Zwischenbehälter entfernen 4c1aa39a6c92
   ---> 9b3bc4f58cc9
  Erfolgreich gebaut 9b3bc4f58cc9
  Erfolgreich markiert 172.20.7.50/baseimages/centos-tomcat:8.5.33

Verwenden Sie das erstellte Image, um einen Container zu starten und zu prüfen, ob er erfolgreich erstellt wurde. Fügen Sie -p hinzu, um den Port beim Starten freizugeben und ihn auf einer physischen Maschine zu testen

[root@node2 /app/dockerfile/web/tomcat/tomcat-base]#docker run -it -p 8802:8080 172.20.7.50/baseimages/centos-tomcat:8.5.33 bash  
[root@917b2c2262a3 /]# cd /apps/
[root@917b2c2262a3 Apps]# ll
gesamt 0
drwxr-xr-x 9 root root 220 22. Nov. 22:08 apache-tomcat-8.5.33
lrwxrwxrwx 1 root root 26. Nov. 22 22:08 Tomcat -> /apps/apache-tomcat-8.5.33
[root@917b2c2262a3 apps]# ./tomcat/bin/catalina.sh start
Verwenden von CATALINA_BASE: /apps/tomcat
Verwenden von CATALINA_HOME: /apps/tomcat
Verwenden von CATALINA_TMPDIR: /apps/tomcat/temp
Verwenden von JRE_HOME: /usr/local/jdk/jre
CLASSPATH verwenden: /apps/tomcat/bin/bootstrap.jar:/apps/tomcat/bin/tomcat-juli.jar
Tomcat wurde gestartet.

Testen mit einem Browser auf der Clientseite

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.

Das könnte Sie auch interessieren:
  • Detaillierte Erklärung der CMD- und ENTRYPOINT-Befehle im Dockerfile
  • So schreiben Sie das beste Dockerfile
  • Detaillierte Erklärung der COPY- und ADD-Befehle in Dockerfile
  • Eine detaillierte Einführung in die Dockerfile-Image-Erstellungsdatei und verwandte Befehle in Docker
  • Detaillierte Erläuterung der Verwendung von Dockerfile zum Erstellen eines MySQL-Images und zum Implementieren der Dateninitialisierung und Berechtigungseinstellung
  • Detaillierte Erläuterung der spezifischen Verwendung der ENV-Anweisung in Dockerfile
  • Beispiele für die Verwendung von Dockerfile
  • Dockerfile zum Erstellen des offiziellen Tomcat-Images und detaillierte Erklärung zur Image-Verwendung
  • Zusammenfassung gängiger Befehle in Dockerfile
  • So stellen Sie ein SpringBoot-Projekt mit Dockerfile bereit
  • So erstellen Sie Ihr eigenes Image mit Dockerfile
  • Einführung in die Dockerfile-Anweisungen ADD und COPY
  • Detaillierte Erklärung zu Multi-Stage (Multi-Stage Build) in Dockerfile
  • Docker-Grundlagen: Detaillierte Erklärung der Dockerfile-Befehle
  • So stellen Sie den Node.js-Dienst mithilfe von Dockerfile bereit
  • Dockerfile-Anweisungen erklärt
  • Eine kurze Einführung in die Dockerfile-Anweisung VOLUME
  • Dockerfile – einfache Einführung

<<:  Fünf Möglichkeiten zum Durchlaufen von JavaScript-Arrays

>>:  Der Unterschied zwischen MySQL execute, executeUpdate und executeQuery

Artikel empfehlen

Lösung für den Fehler beim Importieren von MySQL Big Data in Navicat

Die von Navicat exportierten Daten können nicht i...

Docker stellt über einen Port eine Verbindung zu einem Container her

Docker-Container-Verbindung 1. Netzwerk-Port-Mapp...

Einrichten eines Proxyservers mit nginx

Nginx kann seine Reverse-Proxy-Funktion zum Imple...

So implementieren Sie Lastenausgleich in MySQL

Vorwort MySQL ist ein schnelles, leistungsstarkes...

Beispielcode zum Erstellen eines minimierten Header-Effekts nur mit CSS

Zusammengeklappte Kopfzeilen sind eine großartige...

Analyse des Prozesses zum Veröffentlichen und Bereitstellen von Spring Boot-Anwendungen über Docker

Inhaltsverzeichnis Manuelle Bereitstellung 1. Ers...

Wie oft werden mehrere setStates in React aufgerufen?

Inhaltsverzeichnis 1. Zwei setState, wie oft soll...

Detailliertes Tutorial zur Verwendung des Plugins tomcat8-maven-plugin in Maven

Ich habe viele Artikel online durchsucht, aber ke...

Detaillierte Erläuterung der Anwendungsbeispiele für Vue-Router 4

Inhaltsverzeichnis 1. Installieren und erstellen ...

Detaillierte Erklärung der Lösung für verweigerte Berechtigungen in Linux

Zugriff verweigert: Der Grund hierfür ist: Es lie...

MySQL 8.0.22 Zip-komprimierte Paketversion (kostenlose Installation) Download, Installations- und Konfigurationsschritte detailliert

Inhaltsverzeichnis Der erste Schritt besteht dari...

Einführung und Verwendungsübersicht der React-Native-Screenshot-Komponente react-native-view-shot

Inhaltsverzeichnis 1. Phänomen 2. Lösung 3. Zusam...

Sitemesh-Tutorial – Grundsätze und Anwendungen der Seitendekorationstechnologie

1. Grundlegende Konzepte 1. Sitemesh ist eine Sei...

Einige Verbesserungen in MySQL 8.0.24 Release Note

Inhaltsverzeichnis 1. Verbindungsmanagement 2. Ve...

Verwenden Sie crontab, um das Skript zur regelmäßigen Ausführung des JAR-Programms in centOS6 auszuführen

1. Schreiben Sie ein einfaches Java-Programm öffe...