Implementierung eines Tomcat-Images, das mit Dockerfile basierend auf Alpine erstellt wurde

[root@docker43 ~]# docker pull alpine
Standard-Tag verwenden: latest
Es wird versucht, das Repository docker.io/library/alpine abzurufen ...
aktuell: Abrufen von docker.io/library/alpine
4fe2ade4980c: Ziehen abgeschlossen
Digest: sha256:621c2f39f8133acb8e64023a94dbdf0d5ca81896102b9e57c0dc184cadaf5528
Status: Neueres Image für docker.io/alpine:latest heruntergeladen
[root@docker43 ~]# Docker-Bilder
REPOSITORY TAG BILD ID ERSTELLT GRÖSSE
docker.io/alpine-latest 196d12cf6ab1 vor 3 Wochen 4,41 MB

[root@docker43 ~]# cd /opt/
[root@docker43 opt]# mkdir -p alpine_jre && cd alpine_jre && touch Dockerfile
[root@docker43 alpine_jre]# ll
Gesamtverbrauch 0
-rw-r--r-- 1 root root 0 6. Okt. 17:39 Dockerfile

# Basisbild VON alpine
 
# Autoreninformationen MAINTAINER JRE Docker Maintainers "[email protected]"
 
# Ändern Sie die Quelle RUN echo "http://mirrors.aliyun.com/alpine/latest-stable/main/" > /etc/apk/repositories && \
  echo "http://mirrors.aliyun.com/alpine/latest-stable/community/" >> /etc/apk/repositories
 
# Installieren Sie die erforderliche Software RUN apk update && \
  apk add --no-cache ca-certificates && \
  apk add --no-cache curl bash tree tzdata && \
  cp -rf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
 
# Definieren Sie die Umgebungsvariable ENV PATH /usr/local/bin:${PATH}
 
# JRE installieren
Führen Sie den Befehl apk add --nocache openjdk8-jre-base && \ aus.
  rm -rf /var/cache/apk/*
 
LAUFEN { \
    echo '#!/bin/sh'; \
    echo 'set -e'; \
    echo; \
    echo 'Verzeichnisname "$(Verzeichnisname "$(readlink -f "$(which javac || which java)")")"'; \
   } > /usr/local/bin/docker-java-home \
  && chmod +x /usr/local/bin/docker-java-home
 
ENV JAVA_HOME /usr/lib/jvm/default-jvm
ENV-PFAD ${PATH}:${JAVA_HOME}/bin:${JAVA_HOME}/jre/bin
ENV JAVA_VERSION 8u71
ENV JAVA_ALPINE_VERSION 8.171.11-r0
RUN set -x \
  \
  && apk add --no-cache \
  \
  openjdk8-jre="$JAVA_ALPINE_VERSION" 

[root@docker43 alpine_jre]# docker build -t alpine_jre .

[root@docker43 alpine_jre]# Docker-Bilder
REPOSITORY TAG BILD ID ERSTELLT GRÖSSE
alpine_jre latest 614bc57ab66e vor 33 Sekunden 91,1 MB
docker.io/alpine-latest 196d12cf6ab1 vor 3 Wochen 4,41 MB

[root@docker43 ~]# cd /opt/
[root@docker43 opt]# mkdir -p jre_tomcat && cd jre_tomcat && touch Dockerfile
[root@docker43 jre_tomcat]# ll
Gesamtverbrauch 0
-rw-r--r-- 1 root root 0 6. Okt. 17:46 Dockerfile

#Basisbild VON alpine_jre
 
# Autoreninformationen MAINTAINER Tomcat Docker Maintainers "[email protected]"
 
# Tomcat-Variablen definieren (falls es weitere gibt, können Sie sie hier hinzufügen)
ENV CATALINA_HOME /usr/local/tomcat
ENV-PFAD $CATALINA_HOME/bin:$PATH
RUN mkdir -p "$CATALINA_HOME"
ARBEITSVERZEICHNIS $CATALINA_HOME
 
# lass "Tomcat Native" irgendwo isoliert leben
ENV TOMCAT_NATIVE_LIBDIR $CATALINA_HOME/native-jni-lib
ENV LD_LIBRARY_PATH ${LD_LIBRARY_PATH:+$LD_LIBRARY_PATH:}$TOMCAT_NATIVE_LIBDIR
 
Führen Sie den Befehl apk add --no-cache gnupg aus.
 
# siehe http://archive.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/KEYS
# siehe auch „update.sh“ (https://github.com/docker-library/tomcat/blob/master/update.sh)
ENV GPG_KEYS 05AB33110949707C93A279E3D3EFE6B686867BA6 07E48665A34DCAFAE522E5E6266191C37C037D42 47309207D818FFD8DCD3F83F1931D684307A10A5 541FBE7D8F78B25E055DDEE13C370389288584E7 61B832AC2F1C5A90F0F9B00A1C506407564C17A3 713DA88BE50911535FE716F5208B0AB1D63011C7 79F7026C690BAA50B92CD8B66A3AD3F4F22C4FED 9BA44C2621385CB966EBA586F72C284D731FABEE A27677289986DB50844682F8ACB77FC2E86E29AC A9C5DF4D22E99998D9875A5110C01C5A2F6059E7 DCFD35E0BF8CA7344752DE8B6FB21E8933C60243 F3A04C595DB5B6A5F1ECA43E3B7BBB100D811BBE F7DA48BB64BCB84ECBA7EE6935CD23C10D498E23
RUN set -ex; \
    für Schlüssel in $GPG_KEYS; mache \
        gpg --keyserver ha.pool.sks-keyservers.net --recv-keys "$key"; \
    Erledigt
 
# Definieren Sie die Tomcat-Version ENV TOMCAT_MAJOR 8
ENV TOMCAT_VERSION 8.0.53
 
# Herunterladen # https://issues.apache.org/jira/browse/INFRA-8753?focusedCommentId=14735394#comment-14735394
ENV TOMCAT_TGZ_URL https://www.apache.org/dyn/closer.cgi?action=download&filename=tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz
# nicht alle Spiegel enthalten tatsächlich die .asc-Dateien :'(
ENV TOMCAT_ASC_URL http://archive.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz.asc
 
# Installieren Sie RUN set -x \
    \
    && apk add --no-cache --virtual .fetch-deps \
        CA-Zertifikate \
        Teer \
        openssl \
    && wget -O tomcat.tar.gz "$TOMCAT_TGZ_URL" \
    && wget -O tomcat.tar.gz.asc "$TOMCAT_ASC_URL" \
    && gpg --batch --verify tomcat.tar.gz.asc tomcat.tar.gz \
    && tar -xvf tomcat.tar.gz --strip-components=1 \
    && rm bin/*.bat \
    && rm tomcat.tar.gz* \
    \
    && nativeBuildDir="$(mktemp -d)" \
    && tar -xvf bin/tomcat-native.tar.gz -C "$nativeBuildDir" --strip-components=1 \
    && apk add --no-cache --virtual .native-build-deps \
        April-Entwickler \
        dpkg-dev dpkg \
        gcc \
        libc-dev \
        machen \
        "openjdk${JAVA_VERSION%%[-~bu]*}"="$JAVA_ALPINE_VERSION" \
        openssl-dev \
    && ( \
        exportiere CATALINA_HOME="$PWD" \
        && cd "$nativeBuildDir/native" \
        && gnuArch="$(dpkg-architecture --query DEB_BUILD_GNU_TYPE)" \
        && ./konfigurieren \
            --build="$gnuArch" \
            --libdir="$TOMCAT_NATIVE_LIBDIR" \
            --Präfix="$CATALINA_HOME" \
            --with-apr="$(welche apr-1-Konfiguration)" \
            --mit-java-home="$(docker-java-home)" \
            --mit-ssl=ja \
        && make -j$(getconf _NPROCESSORS_ONLN) \
        && make install \
    ) \
    && runDeps="$( \
        scanelf --needed --nobanner --recursive "$TOMCAT_NATIVE_LIBDIR" \
            | awk '{ gsub(/,/, "\nso:", $2); print "so:" $2 }' \
            | sortieren -u \
            | xargs -r apk info --installiert \
            | sortieren -u \
    )" \
    && apk add --virtual .tomcat-native-rundeps $runDeps \
    && apk del .fetch-deps .native-build-deps \
    && rm -rf "$nativeBuildDir" \
    && rm bin/tomcat-native.tar.gz
 
# Überprüfen Sie, ob Tomcat Native ordnungsgemäß funktioniert
RUN set -e \
    && nativeLines="$(catalina.sh configtest 2>&1)" \
    && nativeLines="$(echo "$nativeLines" | grep 'Apache Tomcat Native')" \
    && nativeLines="$(echo "$nativeLines" | sort -u)" \
    && if ! echo "$nativeLines" | grep 'INFO: Auf APR basierende Apache Tomcat Native-Bibliothek geladen' >&2; then \
        echo >&2 "$nativeLines"; \
        Ausgang 1; \
    fi
 
# Port 8080 entwickeln EXPOSE 8080
# Befehl CMD ["catalina.sh", "run"] ausführen

[root@docker43 jre_tomcat]# docker build -t tomcat:1.0 .

[root@docker43 jre_tomcat]# Docker-Bilder
REPOSITORY TAG BILD ID ERSTELLT GRÖSSE
Tomcat 1.0 64c9cec4375d vor 7 Sekunden 124 MB
alpine_jre latest 614bc57ab66e vor 8 Minuten 91,1 MB
docker.io/alpine-latest 196d12cf6ab1 vor 3 Wochen 4,41 MB

[root@docker43 ~]# cd /opt/
[root@docker43 opt]# mkdir tomcat_web && cd tomcat_web && touch Dockerfile && touch start.sh
[root@docker43 tomcat_web]# ll
Gesamtverbrauch 0
-rw-r--r-- 1 root root 0 6. Okt. 17:53 Dockerfile
-rw-r--r-- 1 root root 0 6. Okt. 17:53 start.sh

#!/bin/sh
# Lizenziert an die Apache Software Foundation (ASF) unter einer oder mehreren
# Mitwirkenden-Lizenzvereinbarungen. Siehe die mitgelieferte NOTICE-Datei
# dieses Werk für weitere Informationen bezüglich des Urheberrechts.
# Die ASF lizenziert diese Datei an Sie unter der Apache-Lizenz, Version 2.0
# (die „Lizenz“); Sie dürfen diese Datei nur in Übereinstimmung mit
# die Lizenz. Sie können eine Kopie der Lizenz erhalten unter
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Sofern nicht gesetzlich vorgeschrieben oder schriftlich vereinbart,
# Die Verteilung unter dieser Lizenz erfolgt auf einer "AS IS"-Basis,
# OHNE GARANTIEN ODER BEDINGUNGEN JEGLICHER ART, weder ausdrücklich noch stillschweigend.
# Siehe die Lizenz für die spezifische Sprache, die Berechtigungen regelt und
# Einschränkungen gemäß der Lizenz.
 
# -----------------------------------------------------------------------------
# Steuerungsskript für den CATALINA-Server
#
# Voraussetzungen für Umgebungsvariablen
#
# Setzen Sie die Variablen nicht in diesem Skript. Setzen Sie sie stattdessen in ein Skript ein
# setenv.sh in CATALINA_BASE/bin, um Ihre Anpassungen getrennt zu halten.
#
# CATALINA_HOME verweist möglicherweise auf Ihr Catalina-Build-Verzeichnis.
#
# CATALINA_BASE (Optional) Basisverzeichnis zum Auflösen dynamischer Teile
# einer Catalina-Installation. Wenn nicht vorhanden, wird Folgendes angezeigt:
# dasselbe Verzeichnis, auf das CATALINA_HOME verweist.
#
# CATALINA_OUT (Optional) Vollständiger Pfad zu einer Datei, in der stdout und stderr
# wird umgeleitet.
# Standard ist $CATALINA_BASE/logs/catalina.out
#
# CATALINA_OPTS (Optional) Java-Laufzeitoptionen, die beim "Start" verwendet werden,
# Der Befehl „run“ oder „debug“ wird ausgeführt.
# Alle Optionen hier einbinden und nicht in JAVA_OPTS, das soll
# darf nur von Tomcat selbst verwendet werden, nicht vom Stop-Prozess,
# der Versionsbefehl usw.
# Beispiele sind Heap-Größe, GC-Protokollierung, JMX-Ports usw.
#
# CATALINA_TMPDIR (Optional) Verzeichnispfad des temporären Verzeichnisses
# die JVM verwenden soll (java.io.tmpdir). Standardmäßig
# $CATALINA_BASE/temp.
#
# JAVA_HOME Muss auf Ihre Java Development Kit-Installation verweisen.
# Erforderlich, um mit dem Argument „Debug“ ausgeführt zu werden.
#
# JRE_HOME muss auf Ihre Java Runtime-Installation verweisen.
# Wird standardmäßig auf JAVA_HOME gesetzt, wenn es leer ist. Wenn JRE_HOME und JAVA_HOME
# sind beide gesetzt, JRE_HOME wird verwendet.
#
# JAVA_OPTS (Optional) Java-Laufzeitoptionen, die bei jedem Befehl verwendet werden
# wird ausgeführt.
# Hier und nicht in CATALINA_OPTS alle Optionen einbinden, die
# sollte von Tomcat und auch vom Stoppprozess verwendet werden,
# der Versionsbefehl usw.
# Die meisten Optionen sollten in CATALINA_OPTS gehen.
#
# JAVA_ENDORSED_DIRS (Optional) Liste von durch Doppelpunkt getrennten Verzeichnissen
# enthält einige Jars, um den Austausch von APIs zu ermöglichen
# außerhalb des JCP erstellt (d. h. DOM und SAX von W3C).
# Es kann auch verwendet werden, um die XML-Parser-Implementierung zu aktualisieren.
# Standardmäßig $CATALINA_HOME/endorsed.
#
# JPDA_TRANSPORT (Optional) JPDA-Transport, der beim „jpda start“ verwendet wird
# Befehl wird ausgeführt. Der Standardwert ist „dt_socket“.
#
# JPDA_ADDRESS (Optional) Java-Laufzeitoptionen, die beim „jpda start“ verwendet werden
# Befehl wird ausgeführt. Der Standardwert ist localhost:8000.
#
# JPDA_SUSPEND (Optional) Java-Laufzeitoptionen, die beim „jpda start“ verwendet werden
# Befehl wird ausgeführt. Gibt an, ob die JVM angehalten werden soll
# Ausführung sofort nach dem Start. Standard ist „n“.
#
# JPDA_OPTS (Optional) Java-Laufzeitoptionen, die beim „jpda start“ verwendet werden
# Befehl wird ausgeführt. Falls verwendet, JPDA_TRANSPORT, JPDA_ADDRESS,
# und JPDA_SUSPEND werden ignoriert. Somit werden alle erforderlichen jpda
# Optionen MÜSSEN angegeben werden. Der Standardwert ist:
#
# -agentlib:jdwp=transport=$JPDA_TRANSPORT,
# Adresse=$JPDA_ADDRESS,Server=y,suspend=$JPDA_SUSPEND
#
# JSSE_OPTS (Optional) Java-Laufzeitoptionen zur Steuerung des TLS
# Implementierung, wenn JSSE verwendet wird. Standard ist:
# "-Djdk.tls.ephemeralDHKeySize=2048"
#
# CATALINA_PID (Optional) Pfad der Datei, die die PID enthalten soll
# des Catalina-Startup-Java-Prozesses, wenn Start (Fork) ist
# gebraucht
#
# LOGGING_CONFIG (Optional) Überschreibt die Protokollierungskonfigurationsdatei von Tomcat
# Beispiel (alles in einer Zeile)
# LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties"
#
# LOGGING_MANAGER (Optional) Überschreibt den Protokollierungsmanager von Tomcat
# Beispiel (alles in einer Zeile)
# LOGGING_MANAGER="-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager"
#
# USE_NOHUP (Optional) Wenn auf die Zeichenfolge true gesetzt, wird der Startbefehl
# Verwenden Sie „nohup“, damit der Tomcat-Prozess alle Aufhänger ignoriert
# Signale. Der Standardwert ist "false", außer bei HP-UX, wo
# der Standardwert ist „true“
# -----------------------------------------------------------------------------
 
# Betriebssystemspezifische Unterstützung. $var _muss_ entweder auf „true“ oder „false“ gesetzt werden.
cygwin=falsch
darwin=falsch
os400=false
hpux=false
Fall "`uname`" in
CYGWIN*) cygwin=true;;
Darwin*) darwin=true;;
OS400*) os400=true;;
HP-UX*) hpux=true;;
esac
 
# Links auflösen – $0 könnte ein Softlink sein
PRG="$0"
 
während [ -h "$PRG" ]; mache
 ls=`ls -ld "$PRG"`
 link=`Ausdruck "$ls" : '.*-> \(.*\)$'`
 wenn Ausdruck "$link" : '/.*' > /dev/null; dann
  PRG="$link"
 anders
  PRG=`Verzeichnisname "$PRG"`/"$link"
 fi
Erledigt
 
# Standardumgebungsvariablen abrufen
PRGDIR=`Verzeichnisname "$PRG"`
 
# CATALINA_HOME nur festlegen, wenn es noch nicht festgelegt ist
[ -z "$CATALINA_HOME" ] && CATALINA_HOME=`cd "$PRGDIR/.." >/dev/null; pwd`
 
# CATALINA_BASE aus CATALINA_HOME kopieren, falls nicht bereits festgelegt
[ -z "$CATALINA_BASE" ] && CATALINA_BASE="$CATALINA_HOME"
 
# Stellen Sie sicher, dass beim Start keine benutzerdefinierten CLASSPATH-Variablen verwendet werden.
#, aber erlauben Sie ihre Angabe in setenv.sh, in seltenen Fällen, wenn es nötig ist.
CLASSPATH=
 
wenn [ -r "$CATALINA_BASE/bin/setenv.sh" ]; dann
 . "$CATALINA_BASE/bin/setenv.sh"
elif [ -r "$CATALINA_HOME/bin/setenv.sh" ]; dann
 . "$CATALINA_HOME/bin/setenv.sh"
fi
 
# Stellen Sie bei Cygwin sicher, dass die Pfade im UNIX-Format vorliegen, bevor irgendetwas bearbeitet wird
wenn $cygwin; dann
 [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
 [ -n "$JRE_HOME" ] && JRE_HOME=`cygpath --unix "$JRE_HOME"`
 [ -n "$CATALINA_HOME" ] && CATALINA_HOME=`cygpath --unix "$CATALINA_HOME"`
 [ -n "$CATALINA_BASE" ] && CATALINA_BASE=`cygpath --unix "$CATALINA_BASE"`
 [ -n "$CLASSPATH" ] && CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
fi
 
# Stellen Sie sicher, dass weder CATALINA_HOME noch CATALINA_BASE einen Doppelpunkt enthalten
# da dies als Trennzeichen im Klassenpfad verwendet wird und Java kein
# Mechanismus zum Escapen, wenn das gleiche Zeichen im Pfad erscheint.
Fall $CATALINA_HOME in
 *:*) echo "CATALINA_HOME wird verwendet: $CATALINA_HOME";
    echo "Kann nicht gestartet werden, da CATALINA_HOME einen Doppelpunkt (:) enthält";
    Ausgang 1;
esac
Fall $CATALINA_BASE in
 *:*) echo "CATALINA_BASE wird verwendet: $CATALINA_BASE";
    echo "Kann nicht gestartet werden, da CATALINA_BASE einen Doppelpunkt (:) enthält";
    Ausgang 1;
esac
 
# Für OS400
wenn $os400; dann
 # Setzen Sie die Jobpriorität für interaktive Aufgaben auf Standard (interaktiv - 6) mit
 # die interaktive Priorität - 6, die Hilfsthreads, die auf Anfragen antworten
 # werden mit der gleichen Priorität wie interaktive Jobs ausgeführt.
 BEFEHL='chgjob job('$JOBNAME') runpty(6)'
 System $BEFEHL
 
 # Multithreading aktivieren
 exportiere QIBM_MULTI_THREADED=Y
fi
 
# Standard-Java-Umgebungsvariablen abrufen
wenn $os400; dann
 # -r funktioniert auf os400 nur, wenn die Dateien:
 # 1. Eigentum des Benutzers
 # 2. im Besitz der PRIMARY-Gruppe des Benutzers
 # dies funktioniert nicht, wenn der Benutzer zu sekundären Gruppen gehört
 . "$CATALINA_HOME"/bin/setclasspath.sh
anders
 wenn [ -r "$CATALINA_HOME"/bin/setclasspath.sh ]; dann
  . "$CATALINA_HOME"/bin/setclasspath.sh
 anders
  echo "$CATALINA_HOME/bin/setclasspath.sh kann nicht gefunden werden"
  echo "Diese Datei wird zum Ausführen dieses Programms benötigt"
  Ausfahrt 1
 fi
fi
 
# Zusätzliche JAR-Dateien zu CLASSPATH hinzufügen
wenn [ ! -z "$CLASSPATH" ] ; dann
 CLASSPATH="$CLASSPATH":
fi
CLASSPATH="$CLASSPATH""$CATALINA_HOME"/bin/bootstrap.jar
 
wenn [ -z "$CATALINA_OUT" ] ; dann
 CATALINA_OUT="$CATALINA_BASE"/logs/catalina.out
fi
 
wenn [ -z "$CATALINA_TMPDIR" ] ; dann
 # Definieren Sie das für Catalina zu verwendende java.io.tmpdir
 CATALINA_TMPDIR="$CATALINA_BASE"/temp
fi
 
# tomcat-juli.jar zum Klassenpfad hinzufügen
# tomcat-juli.jar kann pro Instanz überschrieben werden
wenn [ -r "$CATALINA_BASE/bin/tomcat-juli.jar" ] ; dann
 CLASSPATH=$CLASSPATH:$CATALINA_BASE/bin/tomcat-juli.jar
anders
 CLASSPATH=$CLASSPATH:$CATALINA_HOME/bin/tomcat-juli.jar
fi
 
# Bugzilla 37848: Wenn kein TTY verfügbar ist, keine Ausgabe an die Konsole
habe_tty=0
wenn [ "`tty`" != "kein tty" ]; dann
  habe_tty=1
fi
 
# Für Cygwin, stellen Sie die Pfade auf das Windows-Format um, bevor Sie Java ausführen
wenn $cygwin; dann
 JAVA_HOME=`cygpath --absolute --windows "$JAVA_HOME"`
 JRE_HOME=`cygpath --absolute --windows "$JRE_HOME"`
 CATALINA_HOME=`cygpath --absolute --windows "$CATALINA_HOME"`
 CATALINA_BASE=`cygpath --absolute --windows "$CATALINA_BASE"`
 CATALINA_TMPDIR=`cygpath --absolute --windows "$CATALINA_TMPDIR"`
 CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
 JAVA_ENDORSED_DIRS=`cygpath --Pfad --windows "$JAVA_ENDORSED_DIRS"`
fi
 
wenn [ -z "$JSSE_OPTS" ] ; dann
 JSSE_OPTS="-Djdk.tls.ephemeralDHKeySize=2048"
fi
JAVA_OPTS="$JAVA_OPTS $JSSE_OPTS"
 
# Registrieren Sie benutzerdefinierte URL-Handler
# Tun Sie dies hier, damit benutzerdefinierte URL-Handles (insbesondere „war:...“) in der Sicherheitsrichtlinie verwendet werden können
JAVA_OPTS = "$JAVA_OPTS -Djava.protocol.handler.pkgs=org.apache.catalina.webresources"
 
# Legen Sie die Juli-LogManager-Konfigurationsdatei fest, wenn sie vorhanden ist und kein Override ausgegeben wurde.
wenn [ -z "$LOGGING_CONFIG" ]; dann
 wenn [ -r "$CATALINA_BASE"/conf/logging.properties ]; dann
  LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties"
 anders
  #Bugzilla 45585
  LOGGING_CONFIG="-Dnop"
 fi
fi
 
wenn [ -z "$LOGGING_MANAGER" ]; dann
 LOGGING_MANAGER="-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager"
fi
 
# Entfernen Sie das Kommentarzeichen aus der folgenden Zeile, um die Umask verfügbar zu machen, wenn Sie den
#org.apache.catalina.security.SecurityListener
#JAVA_OPTS="$JAVA_OPTS -Dorg.apache.catalina.security.SecurityListener.UMASK=`umask`"
 
wenn [ -z "$USE_NOHUP" ]; dann
  wenn $hpux; dann
    USE_NOHUP="true"
  anders
    USE_NOHUP="falsch"
  fi
fi
nicht gesetzt _NOHUP
wenn [ "$USE_NOHUP" = "true" ]; dann
  _NOHUP=keine Meldung
fi
 
# ----- Den angeforderten Befehl ausführen -----------------------------------------
 
# Bugzilla 37848: Gib dies nur aus, wenn wir ein TTY haben
wenn [ $have_tty -eq 1 ]; dann
 echo "CATALINA_BASE wird verwendet: $CATALINA_BASE"
 echo "CATALINA_HOME wird verwendet: $CATALINA_HOME"
 echo "CATALINA_TMPDIR wird verwendet: $CATALINA_TMPDIR"
 wenn [ "$1" = "debug" ] ; dann
  echo "JAVA_HOME verwenden: $JAVA_HOME"
 anders
  echo "JRE_HOME wird verwendet: $JRE_HOME"
 fi
 echo "CLASSPATH verwenden: $CLASSPATH"
 wenn [ ! -z "$CATALINA_PID" ]; dann
  echo "CATALINA_PID wird verwendet: $CATALINA_PID"
 fi
fi
 
wenn [ "$1" = "jpda" ] ; dann
 wenn [ -z "$JPDA_TRANSPORT" ]; dann
  JPDA_TRANSPORT="dt_socket"
 fi
 wenn [ -z "$JPDA_ADDRESS" ]; dann
  JPDA_ADDRESS="localhost:8000"
 fi
 wenn [ -z "$JPDA_SUSPEND" ]; dann
  JPDA_SUSPEND="n"
 fi
 wenn [ -z "$JPDA_OPTS" ]; dann
  JPDA_OPTS="-agentlib:jdwp=transport=$JPDA_TRANSPORT,Adresse=$JPDA_ADDRESS,Server=y,suspend=$JPDA_SUSPEND"
 fi
 CATALINA_OPTS="$JPDA_OPTS $CATALINA_OPTS"
 Schicht
fi
 
wenn [ "$1" = "debug" ] ; dann
 wenn $os400; dann
  echo "Debug-Befehl unter OS400 nicht verfügbar"
  Ausfahrt 1
 anders
  Schicht
  wenn [ "$1" = "-security" ] ; dann
   wenn [ $have_tty -eq 1 ]; dann
    echo "Sicherheitsmanager verwenden"
   fi
   Schicht
   exec "$_RUNJDB" "$LOGGING_CONFIG" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS \
    -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \
    -sourcepath "$CATALINA_HOME"/../../java \
    -Djava.security.manager \
    -Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy \
    -Dcatalina.base="$CATALINA_BASE" \
    -Dcatalina.home="$CATALINA_HOME" \
    -Djava.io.tmpdir="$CATALINA_TMPDIR" \
    org.apache.catalina.startup.Bootstrap "$@" starten
  anders
   exec "$_RUNJDB" "$LOGGING_CONFIG" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS \
    -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \
    -sourcepath "$CATALINA_HOME"/../../java \
    -Dcatalina.base="$CATALINA_BASE" \
    -Dcatalina.home="$CATALINA_HOME" \
    -Djava.io.tmpdir="$CATALINA_TMPDIR" \
    org.apache.catalina.startup.Bootstrap "$@" starten
  fi
 fi
 
elif [ "$1" = "ausführen" ]; dann
 
 Schicht
 wenn [ "$1" = "-security" ] ; dann
  wenn [ $have_tty -eq 1 ]; dann
   echo "Sicherheitsmanager verwenden"
  fi
  Schicht
  eval exec "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS \
   -Djava.endorsed.dirs="\"$JAVA_ENDORSED_DIRS\"" -classpath "\"$CLASSPATH\"" \
   -Djava.security.manager \
   -Djava.security.policy=="\"$CATALINA_BASE/conf/catalina.policy\"" \
   -Dcatalina.base="\"$CATALINA_BASE\"" \
   -Dcatalina.home="\"$CATALINA_HOME\"" \
   -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
   org.apache.catalina.startup.Bootstrap "$@" starten
 anders
  eval exec "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS \
   -Djava.endorsed.dirs="\"$JAVA_ENDORSED_DIRS\"" -classpath "\"$CLASSPATH\"" \
   -Dcatalina.base="\"$CATALINA_BASE\"" \
   -Dcatalina.home="\"$CATALINA_HOME\"" \
   -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
   org.apache.catalina.startup.Bootstrap "$@" start \
   >> "$CATALINA_OUT" 2>&1 
 fi
fi

#Basisimage VON Tomcat:1.0
 
# Projektverzeichnis und Logverzeichnis erstellen, welches auf dem Host gemountet werden muss -v RUN set -x \
  &&mkdir -p /Webs/logs \
  \
  &&rm -rf /usr/local/tomcat/logs \
  \
  &&ln -sf /Webs/logs /usr/local/tomcat/logs
 
# Kopieren Sie die Startdatei in den Container COPY start.sh /usr/local/tomcat/bin/
 
# Geben Sie dem Container-Startskript Berechtigungen RUN chmod +x /usr/local/tomcat/bin/start.sh
 
# Port 8080 öffnen EXPOSE 8080
 
# Tomcat ausführen
CMD ["start.sh","ausführen"] 

[root@docker43 tomcat_web]# docker build -t tomcat_web:v1 .

[root@docker43 tomcat_web]# Docker-Bilder
REPOSITORY TAG BILD ID ERSTELLT GRÖSSE
tomcat_web v1 b3651c50a7b5 vor 26 Sekunden 124 MB
Tomcat 1.0 64c9cec4375d vor 6 Minuten 124 MB
alpine_jre latest 614bc57ab66e vor 14 Minuten 91,1 MB
docker.io/alpine-latest 196d12cf6ab1 vor 3 Wochen 4,41 MB

[root@docker43 ~]# cd /home/
[root@docker43 home]# mkdir test.tomcat.com && cd test.tomcat.com
[root@docker43 test.tomcat.com]# touch server.xml # Konfigurationsdatei [root@docker43 test.tomcat.com]# mkdir logs # Protokollverzeichnis [root@docker43 test.tomcat.com]# mkdir wwwroot # Hauptverzeichnis des Projekts (Bei Änderungen denken Sie daran, diese auch in server.xml zu ändern)
[root@docker43 test.tomcat.com]# ll
Gesamtverbrauch 0
drwxr-xr-x 2 root root 6 Okt 6 18:03 Protokolle
-rw-r--r-- 1 root root 0 6. Okt. 18:02 server.xml
drwxr-xr-x 2 root root 6 Oktober 6 18:03 wwwroot

  <?xml version='1.0' encoding='utf-8'?>
  <Server-Port="8005" shutdown="HERUNTERFAHREN">
  <Listener-Klassenname="org.apache.catalina.startup.VersionLoggerListener" />
  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
  <Listener-Klassenname="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
  <Listener-Klassenname="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener-Klassenname="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />
 
  <GlobalNamingResources>
 
   <Ressourcenname="Benutzerdatenbank" auth="Container"
        Typ="org.apache.catalina.UserDatabase"
        Beschreibung="Aktualisierbare und speicherbare Benutzerdatenbank"
        Fabrik="org.apache.catalina.users.MemoryUserDatabaseFactory"
        Pfadname="conf/tomcat-users.xml" />
  </GlobalNamingResources>
 
  <Dienstname="Catalina">
   <Connector-Port="8080" Protokoll="org.apache.coyote.http11.Http11AprProtocol"
        VerbindungsTimeout="20000"
        maxThreads="1000" 
        minSpareThreads="100" 
        redirectPort="8443" URIEncoding="UTF-8"/>
   <Connector port="8009" maxThreads="1000" minSpareThreads="100" protocol="AJP/1.3" redirectPort="8443" />
   <Engine-Name="Catalina" Standardhost="localhost">
    <Realm-Klassenname="org.apache.catalina.realm.LockOutRealm">
    <Realm-Klassenname="org.apache.catalina.realm.UserDatabaseRealm" Ressourcenname="Benutzerdatenbank"/>
    </Reich>
 
    <Hostname="localhost" appBase="/Webs/wwwroot" unpackWARs="true" autoDeploy="true">
     <Kontextpfad="" docBase="/Webs/wwwroot" reloadable="true" />
     <Valve-Klassenname="org.apache.catalina.valves.AccessLogValve" 
     Verzeichnis="Protokolle" 
     Präfix="localhost__access_log" 
     Suffix=".txt" 
     Muster="%{X-Real-IP}i %l %u %t "%r" %s %b" />
 
    </Host>
 
   </Engine>
  </Dienst>
 </Server>

[root@docker43 test.tomcat.com]# cd wwwroot/
[root@docker43 wwwroot]# cat index.html 

[root@docker43 test.tomcat.com]# docker ps
CONTAINER ID BILD BEFEHL ERSTELLT STATUS PORTS NAMEN
ab62045e0688 tomcat_web:v1 "start.sh run -con..." vor 2 Sekunden 1 Sekunde aktiv 0.0.0.0:5081->8080/tcp test.tomcat.com

[root@docker43 test.tomcat.com]# curl 127.0.0.1:5081
Erfolg [root@docker43 test.tomcat.com]#