[DOCKER] Ich habe versucht, eine Java EE-Anwendung mit OpenShift zu modernisieren.
Einführung
Beitrag zu "Modernisierung von Java EE-Anwendungen mit OpenShift" mit "Red Hat OpenShift in IBM Cloud", einem verwalteten Dienst von OpenShift in IBM Cloud. https://www.atmarkit.co.jp/ait/articles/1911/15/news002.html
Der in diesem Artikel verwendete "Red Hat OpenShift in der IBM Cloud" ist ein kostenpflichtiger Dienst. Ich denke, es ist für viele Menschen schwierig, die Schritte in diesem Artikel auszuprobieren. Aus diesem Grund haben wir ** mit MiniShift, das kostenlos verwendet werden kann, neu geschrieben, damit Sie die Modernisierung von Java EE-Anwendungen mit OpenShift problemlos erleben können. ** **.
** Dieses Mal möchte ich den Fall ausprobieren, in dem sowohl die Anwendung als auch die Datenbank containerisiert sind. Diejenigen, die den Artikel lesen, können sich zusätzlich zum Inhalt des Artikels über die Integration mehrerer Container (Anwendungs- und Datenbankverbindung) informieren. ** In diesem Artikel verwendete die Datenbank den von IBM Cloud verwalteten Dienst "Compose for MySQL".
Wir haben eine Reihe von (1) bis (5) gemacht.
-
(Dieser Beitrag) "Ich habe versucht, eine Java EE-Anwendung mit OpenShift zu modernisieren"-Java EE-Anwendung, die unter Open Liberty für Geschäftslogik ausgeführt wird Modernisierung
-
"Ich habe versucht, die Java EE-Anwendung von OpenShift (2) zu modernisieren"-Modernisierung der Node.js-Anwendung der Benutzeroberfläche (Benutzeroberfläche) für Patienten
-
"Ich habe versucht, die Java EE-Anwendung von OpenShift (3) zu modernisieren"-Moderation zum Hinzufügen einer PHP-Anwendungsfunktion für den Health Record Manager
-
"Ich habe versucht, die Java EE-Anwendung mit OpenShift (4) zu modernisieren"-DevOps und CI / CD nur mit Standard-OpenShift-Funktionen (Kontinuierliche Integration / kontinuierliche Lieferung)
-
"Ich habe versucht, die Java EE-Anwendung mit OpenShift (5) zu modernisieren"-DevOps und CI / CD (kontinuierliche Integration / Fortsetzung) mit Jenkins Lieferung)
Modernisierung von Java EE-Anwendungen mit OpenShift
In IBM Code Patterns "[Bereitstellen von Microservices in einer fiktiven medizinischen App mit Java EE und Open Liberty](https: // Entwickler) Es gibt ein Codemuster namens ".ibm.com / jp / patternes / jee-app-modernization-with-openshift /)". Von nun an möchte ich dieses Codemuster verwenden, um meine Hände tatsächlich zu bewegen und die Modernisierung von Java EE-Anwendungen zu erleben. Es ist leicht vorstellbar, dass diese Reihe von Schritten dem Verfahren für die Migration von einem lokalen System in die Cloud entspricht. Lassen Sie uns von nun an Lösungsarchitekt werden und die Modernisierungsreise erleben, die sich in der Cloud ausbreiten wird.
Beispiel für einen Health-Anwendungsfall
Beispiel Gesundheit ist ein fiktives medizinisches Unternehmen. Das Unternehmen hat eine lange Geschichte und verfügt über Hunderttausende von Patientenakten. Ursprünglich verwendete Example Health eine monolithische Anwendungsstruktur für seine Anwendungen. Ihre Anwendungsstruktur war eine Full-Stack-Java-Anwendung, die auf WebSphere ausgeführt wurde und mit einer Db2-Datenbank auf dem Mainframe verbunden war. Die ursprüngliche Architektur von Example Health lautet:
Vor kurzem hat Example Health beschlossen, die Anwendung zu modernisieren und in Microservices aufzuteilen. Sie entschieden sich für eine SQL-Datenbank (MySQL), die mit einer Java EE-Anwendung verbunden ist, die in Open Liberty für Geschäftslogik ausgeführt wird, und einer Node.js-Anwendung für die Benutzeroberfläche des Patienten. Darüber hinaus hat Example Health beschlossen, alle diese Anwendungen und SQL-Datenbanken zu containerisieren und auf "Red Hat OpenShift in IBM Cloud" auszuführen. Die neue Architektur von Example Health lautet wie folgt:
Durch die Umstellung auf Red Hat OpenShift in der IBM Cloud ist Example Health jetzt problemlos erweiterbar. In Kürze werden neue Microservices enthalten sein, darunter Anwendungen zur Verwaltung von Gesundheitsakten und zur Analyse.
Vorbereitung für MiniShift
Bitte bereiten Sie MiniShift vor, indem Sie auf einen anderen Beitrag von Qiita verweisen.
Hinweis: Bitte installieren Sie Docker Version 17.09 oder höher auf dem Host, auf dem MiniShift gestartet wird. Es ist eine gute Idee, die neueste Version von Docker CE (Community Edition) zu installieren. Dies liegt daran, dass die Docker-Datei, die später verwendet wird, die Syntax verwendet, um den Eigentümer der Datei mit dem ADD / COPY-Flag zu ändern, das von Docker 17.09 unterstützt wird. Die Version von Docker, die auf der virtuellen MiniShift-Maschine (VM) ausgeführt wird, ist 1.13 und daher problematisch. Übrigens, wenn Sie das Flag --chown in der Docker-Datei nicht verwenden, können Sie vermeiden, dass es unangenehm wird. Diesmal tun wir dies jedoch, ohne die Ressource des Codemusters zu ändern.
-
OpenShift (MiniShift) unter CentOS 7 unter ESXi installieren
-
Offizielle Website-https: //docs.okd.io/latest/minishift/getting-started/installing.html
MiniShift wird in der ersten Hälfte des Verfahrens nicht verwendet. Stoppen Sie MiniShift, bis Sie es brauchen.
# minishift stop
Wenn Sie nach dem Start von MiniShift den Befehl "# eval $ (minishift docker-env)" ausführen Wenn Sie einen "Docker-Push" ausführen, registrieren Sie das Image beim Docker, der auf der virtuellen MiniShift-Maschine (VM) ausgeführt wird.
Dieses Mal möchte ich das Image im Docker des Hosts registrieren, der MiniShift des Arbeitshosts startet. Wenn die Werte also in DOCKER_HOST, DOCKER_TLS_VERIFY, DOCKER_CERT_PATH eingegeben werden, indem Sie den Befehl "# env | grep DOCKER" ausführen, verwenden Sie den folgenden Befehl, um die Umgebung zu erstellen. Leeren Sie die Variable.
export DOCKER_TLS_VERIFY=""
export DOCKER_HOST=""
export DOCKER_CERT_PATH=""
Verfahren
(Umgebung, die ich ausprobiert habe) CentOS 7.7 Minimale Konfiguration
1. Maven (JDK wird auch als Abhängigkeit von Maven installiert)
# yum install maven
2. Bestätigung des Starts des Docker-Daemons
Ich werde Docker später erstellen, stellen Sie also sicher, dass der Dämon auf Docker ausgeführt wird.
# systemctl status docker
In der Docker-Datei wird die Syntax zum Ändern des Eigentümers der Datei mit ADD / COPY - Chown verwendet, die von Docker 17.09 unterstützt wird. Daher verursacht Docker, das von CentOS unterstützt wird, einen Fehler, da die Syntax unbekannt ist. Vermeiden Sie es, die Docker-Version 17.09 oder höher zu erstellen oder die Docker-Datei mit dem Befehl chown in einer separaten Zeile (separate Ebene) für den Teil --chown zu verarbeiten.
3. Klonen Sie das GitHub-Projekt. Klon erstellt einen Beispiel-Health-Jee-OpenShift-Ordner.
# git clone https://github.com/daihiraoka/example-health-jee-openshift.git
Cloning into 'example-health-jee-openshift'...
remote: Enumerating objects: 263, done.
remote: Counting objects: 100% (263/263), done.
remote: Compressing objects: 100% (175/175), done.
remote: Total 263 (delta 108), reused 204 (delta 53), pack-reused 0
Receiving objects: 100% (263/263), 17.82 MiB | 5.57 MiB/s, done.
Resolving deltas: 100% (108/108), done.
# cd example-health-jee-openshift
# ls
example-health-api generate LICENSE readme_images README.md screenshots
4. Erstellen Sie die Java EE-Anwendung.
# cd example-health-api/
# mvn package
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building health-api 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-resources-plugin/2.5/maven-resources-plugin-2.5.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-resources-plugin/2.5/maven-resources-plugin-2.5.pom (7 KB at 7.4 KB/sec)
<<------------------------------------Kürzung------------------------------------>>
[INFO] Building war: /root/example-health-jee-openshift/example-health-api/target/health-api.war
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 34.656s
[INFO] Finished at: Thu Oct 17 13:58:55 JST 2019
[INFO] Final Memory: 14M/143M
[INFO] ------------------------------------------------------------------------
5. Erstellen Sie das Docker-Image für Ihre Java EE-Anwendung.
# docker build -t ol-example-health:1 .
Sending build context to Docker daemon 13.48MB
Step 1/10 : FROM openliberty/open-liberty:javaee8-ubi-min
javaee8-ubi-min: Pulling from openliberty/open-liberty
bdb299bbb0dd: Pull complete
22b1a8fa1ec0: Pull complete
bccea9526f92: Pull complete
ca821998be76: Pull complete
7d738fac7181: Pull complete
2356e9fc5285: Pull complete
048ba391e9fe: Pull complete
347eb7134a38: Pull complete
94456b65cdbb: Pull complete
Digest: sha256:1f08f83c3076aaec7a7d3639864ca06998a779cecad6ad1452d501008c56f63b
Status: Downloaded newer image for openliberty/open-liberty:javaee8-ubi-min
---> fc55e2d66c27
Step 2/10 : ENV INSTALL_DIR /opt/ol/wlp/
---> Running in 45aaeaaa0c92
Removing intermediate container 45aaeaaa0c92
---> 27fe222d05be
Step 3/10 : ENV CONFIG_DIR /opt/ol/wlp/usr/servers/defaultServer/
---> Running in 395e839afb7f
Removing intermediate container 395e839afb7f
---> 8632cfb62026
Step 4/10 : ADD --chown=default:root https://repo1.maven.org/maven2/mysql/mysql-connector-java/8.0.16/mysql-connector-java-8.0.16.jar ${INSTALL_DIR}lib/mysql-connector-java-8.0.16.jar
Downloading [==================================================>] 2.293MB/2.293MB
---> 61898c26bdb1
Step 5/10 : RUN chmod 644 ${INSTALL_DIR}lib/mysql-connector-java-8.0.16.jar
---> Running in 8011b3b50bac
Removing intermediate container 8011b3b50bac
---> 5909218a689a
Step 6/10 : COPY liberty-mysql/mysql-driver.xml ${CONFIG_DIR}configDropins/defaults/
---> f42f5684e5b0
Step 7/10 : COPY liberty/server.xml $CONFIG_DIR
---> 67938badab11
Step 8/10 : COPY liberty/jvm.options $CONFIG_DIR
---> 60c3c494f5ef
Step 9/10 : COPY target/health-api.war /opt/ol/wlp/usr/servers/defaultServer/apps
---> 1bcb2f837df9
Step 10/10 : EXPOSE 9080
---> Running in eba84e894ddc
Removing intermediate container eba84e894ddc
---> aa91da14cf12
Successfully built aa91da14cf12
Successfully tagged ol-example-health:1
6. Wenn der Docker-Build erfolgreich ist, werden das diesmal erstellte Basis-Image openliberty / open-liberty und das ol-example-health-Image ausgegeben.
# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
ol-example-health 1 aa91da14cf12 48 seconds ago 348MB
openliberty/open-liberty javaee8-ubi-min fc55e2d66c27 16 hours ago 343MB
Note: RHEL7 von Red Hat UBI (Red Hat Universal Base Image) wird für das in der FROM-Klausel der Docker-Datei angegebene Basis-Image von Open Liberty verwendet. Red Hat UBI ist ein Container-Image, das durch die Red Hat-Qualitätskontrolle bereitgestellt wird und kostenlos kostenlos weitergegeben werden kann. Auf Red Hat UBI erstellte Container-Images können unterstützt werden, wenn sie unter "Red Hat OpenShift in IBM Cloud" ausgeführt werden. In einer Umgebung, in der OpenShift nicht verwendet wird, ist keine Unterstützung verfügbar. Es besteht jedoch der Vorteil, dass Sie das RHEL-Container-Image kostenlos verwenden können. Wenn Sie einen Container in einem Unternehmen betreiben, müssen Sie möglicherweise beurteilen, ob es sicher ist, einen Container unbekannter Herkunft wie CentOS oder Ubuntu aus jeder Abteilung zu geben. Ich hatte jedoch keine andere Wahl, als es aus verschiedenen Gründen zu verwenden, und manchmal machte ich mir Sorgen, es zu verwenden. Mit Red Hat UBI wird diese Angst beseitigt, da sie nach der Qualitätskontrolle von Red Hat bereitgestellt wird. Wenn Sie derzeit ein CentOS- oder Ubuntu-Container-Image verwenden, probieren Sie Red Hat UBI aus.
Red Hat UBI(Red Hat Universal Base Image) https://access.redhat.com/containers/#/search/ubi
7. Registrieren Sie das Docker-Image "ol-example-health" der Java EE-Anwendung in Docker Hub.
--Erstellen Sie im Voraus ein Docker Hub-Konto.
- Ersetzen Sie daihiraoka durch Ihren Docker Hub-Kontonamen und führen Sie es aus.
Kennzeichnen Sie das ol-example-health-Image im Format "Docker Hub-Kontoname / Bildname: Tag-Name".
# docker tag ol-example-health:1 daihiraoka/ol-example-health:1
Wenn Sie die Liste der Docker-Bilder ausgeben, können Sie sehen, dass das Bild daihiraoka / ol-example-health erstellt wurde.
# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
daihiraoka/ol-example-health 1 901666e26ca5 27 minutes ago 450MB
ol-example-health 1 901666e26ca5 27 minutes ago 450MB
openliberty/open-liberty javaee8-ubi-min bb992680821b 17 hours ago 445MB
Melden Sie sich bei Docker Hub an und registrieren Sie das Image daihiraoka / ol-example-health im Docker Hub-Repository.
# docker login -u daihiraoka
Login Succeeded
# docker push daihiraoka/ol-example-health:1
Wenn die Bildregistrierung abgeschlossen ist, wird daihiraoka / ol-example-health im Docker Hub-Repository angezeigt.
Note:
Dieses Mal habe ich Docker Hub in der Prozedur "Codemuster" verwendet, aber IBM Cloud verfügt über einen Containerregistrierungsdienst. Für die kommerzielle Verwendung wird IBM Cloud Container Registry normalerweise zum Verwalten von Container-Images verwendet.
· Übersicht über die IBM Cloud Container Registry
https://cloud.ibm.com/docs/services/Registry?topic=registry-registry_overview&locale=ja
8. Starten Sie MiniShift
# minishift start
-- Starting profile 'minishift'
-- Check if deprecated options are used ... OK
-- Checking if https://github.com is reachable ... OK
-- Checking if requested OpenShift version 'v3.11.0' is valid ... OK
-- Checking if requested OpenShift version 'v3.11.0' is supported ... OK
-- Checking if requested hypervisor 'kvm' is supported on this platform ... OK
Server Information ...
OpenShift server started.
<img width="400" alt="dockerhub-01.png " src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/209170/d24a8d74-9aca-898e-1066-86395168ba48.png ">
The server is accessible via web console at:
https://192.168.42.138:8443/console
- Anwenden von MiniShift-Umgebungsvariablen
# eval $(minishift oc-env) <-PATH Definition des Befehls oc
# eval $(minishift docker-env) <-Verbindungseinstellungen zu Docker unter MiniShift VM
# source <(oc completion bash) <-Shell-Vervollständigung von Befehlen und Ressourcen
Wenn ich versuche, minishift oc-env auszuführen, wird der Befehl ausgegeben, da er den Pfad des oc-Befehls durchläuft.
# minishift oc-env
export PATH="/root/.minishift/cache/oc/v3.11.0/linux:$PATH"
# Run this command to configure your shell:
# eval $(minishift oc-env)
# ls -1 /root/.minishift/cache/oc/v3.11.0/linux
oc
Wenn minishift docker-env ausgeführt wird, werden die Verbindungsinformationen zum Docker, der auf der MiniShift-VM ausgeführt wird, die auf der KVM ausgeführt wird, wie unten gezeigt ausgegeben. Durch Definieren dieser Umgebungsvariablen wird das Container-Image in der Docker-Registrierung der MiniShift-VM anstelle der lokalen Docker-Registrierung behandelt.
# minishift docker-env
export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://192.168.42.138:2376"
export DOCKER_CERT_PATH="/root/.minishift/certs"
9. Melden Sie sich mit Ihrem Benutzernamen als Entwickler bei der OpenShift CLI an.
(In MiniShift kann jedes Kennwort verwendet werden. Verwenden Sie daher eine beliebige Zeichenfolge.)
# oc login -u developer
Logged into "https://192.168.42.138:8443" as "developer" using existing credentials.
You have one project on this server: "myproject"
Using project "myproject".
10. Erstellen Sie ein Projekt für Example Health.
Dadurch wird ein neues Projekt erstellt und der Pod (Container) als Arbeitsprojekt festgelegt, das bereitgestellt werden soll.
# oc new-project health
Now using project "health" on server "https://192.168.42.138:8443".
You can add applications to this project with the 'new-app' command. For example, try:
oc new-app centos/ruby-25-centos7~https://github.com/sclorg/ruby-ex.git
to build a new example application in Ruby.
11. Drucken Sie eine Liste von ImageStream (is) für Ihr OpenShift-Projekt, um den MySQL-Katalog zu finden.
# oc get is -n openshift
NAME DOCKER REPO TAGS UPDATED
dotnet 172.30.1.1:5000/openshift/dotnet 2.0,latest 16 hours ago
httpd 172.30.1.1:5000/openshift/httpd 2.4,latest 16 hours ago
jenkins 172.30.1.1:5000/openshift/jenkins 2,latest,1 16 hours ago
mariadb 172.30.1.1:5000/openshift/mariadb 10.1,10.2,latest 16 hours ago
mongodb 172.30.1.1:5000/openshift/mongodb 2.6,3.2,3.4 + 3 more... 16 hours ago
mysql 172.30.1.1:5000/openshift/mysql latest,5.5,5.6 + 1 more... 16 hours ago
nginx 172.30.1.1:5000/openshift/nginx 1.10,1.12,1.8 + 1 more... 16 hours ago
nodejs 172.30.1.1:5000/openshift/nodejs 4,6,8 + 4 more... 16 hours ago
perl 172.30.1.1:5000/openshift/perl 5.20,5.24,5.26 + 2 more... 16 hours ago
php 172.30.1.1:5000/openshift/php 7.1,latest,5.5 + 2 more... 16 hours ago
postgresql 172.30.1.1:5000/openshift/postgresql 9.4,9.5,9.6 + 3 more... 16 hours ago
python 172.30.1.1:5000/openshift/python 3.5,3.6,latest + 3 more... 16 hours ago
redis 172.30.1.1:5000/openshift/redis 3.2,latest 16 hours ago
ruby 172.30.1.1:5000/openshift/ruby 2.2,2.3,2.4 + 3 more... 16 hours ago
wildfly 172.30.1.1:5000/openshift/wildfly 11.0,12.0,13.0 + 5 more... 16 hours ago
ImageStream des diesmal von MySQL verwendeten Container-Images. Die in der Liste angezeigten Knoten und Dotnet entsprechen dem Webkonsolen-Katalog in der Abbildung unten. OpenShift bietet einen Mechanismus zum einfachen Bereitstellen von Anwendungen auch mit CLI.
12. Erstellen Sie mit OpenShifts S2I (Source to Image) einen Container für Ihre MySQL-Datenbank.
# oc new-app \
-e MYSQL_USER=admin \
-e MYSQL_PASSWORD=password \
-e MYSQL_DATABASE=health \
--name=mysql \
openshift/mysql:5.7~https://github.com/daihiraoka/example-health-jee-openshift.git
Definieren Sie die Umgebungsvariable mit "-e".
| Parameter | Überblick |
|---|---|
| -e MYSQL_USER | MySQL-Benutzername |
| -e MYSQL_PASSWORD | MySQL-Passwort |
| -e MYSQL_DATABASE | Name der Datenbank |
| --name | Containername |
| openshift/mysql:5.7 | openshift/mysql:5.7 ist der ImageStream-Name des Basiscontainer-Images(MySQL für OpenShift-Projekt:5.7) |
| ~https://github.com(Kürzung) | ~(Tilde)Geben Sie das Quellcode-Repository auf der rechten Seite zwischen an |
Dieses Mal lasse ich den persistenten Speicher weg, in dem die Daten in der Datenbank gespeichert sind. Wenn Sie keinen dauerhaften Speicher für den Pod (Container) festgelegt haben, werden alle registrierten Daten gelöscht, wenn der Pod (Container) gestoppt wird. In diesem Fall ist ein neuer Pod (Container) beim Starten leer und Sie müssen den Import des SQL-Schemas neu starten.
Ausführungsergebnis
--> Found image f83a293 (6 days old) in image stream "openshift/mysql" under tag "5.7" for "openshift/mysql:5.7"
MySQL 5.7
---------
MySQL is a multi-user, multi-threaded SQL database server. The container image provides a containerized packaging of the MySQL mysqld daemon and client application. The mysqld server daemon accepts connections from clients and provides access to content from MySQL databases on behalf of the clients.
Tags: database, mysql, mysql57, rh-mysql57
* A source build using source code from https://github.com/daihiraoka/example-health-jee-openshift.git will be created
* The resulting image will be pushed to image stream tag "mysql:latest"
* Use 'start-build' to trigger a new build
* This image will be deployed in deployment config "mysql"
* Port 3306/tcp will be load balanced by service "mysql"
* Other containers can access this service through the hostname "mysql"
--> Creating resources ...
imagestream.image.openshift.io "mysql" created
buildconfig.build.openshift.io "mysql" created
deploymentconfig.apps.openshift.io "mysql" created
service "mysql" created
--> Success
Build scheduled, use 'oc logs -f bc/mysql' to track its progress.
Application is not exposed. You can expose services to the outside world by executing one or more of the commands below:
'oc expose svc/mysql'
Run 'oc status' to view your app.
Nach einer Weile startet der MySQL-Pod [MySQL-1-hktv2].
# oc get pod
NAME READY STATUS RESTARTS AGE
mysql-1-build 0/1 Completed 0 3m
mysql-1-hktv2 1/1 Running 0 2m
13. Erstellen Sie ein Datenbankschema im MySQL-Container
Melden Sie sich mit dem Befehl oc rsh beim Container an, um das Datenbankschema in MySQL zu erstellen.
# oc rsh mysql-1-hktv2
Wenn Sie sich mit rsh anmelden, können Sie in github sehen, dass sich die Verzeichnisstruktur im Container befindet.
sh-4.2$ ls
LICENSE README.md example-health-api generate readme_images screenshots
Importieren Sie das SQL-Schema der Patientenakten. Dateiname: example-health-api / samples / health_schema.sql
sh-4.2$ mysql -u admin -ppassword health < ./example-health-api/samples/health_schema.sql
mysql: [Warning] Using a password on the command line interface can be insecure.
Gibt eine Liste von Tabellen in der Integritätsdatenbank aus. Wenn der Import des SQL-Schemas erfolgreich abgeschlossen wurde, wird die Ausgabetabelle angezeigt.
sh-4.2$ mysql -u admin -ppassword health -e "show tables;"
mysql: [Warning] Using a password on the command line interface can be insecure.
+------------------+
| Tables_in_health |
+------------------+
| Allergies |
| Appointments |
| MESSAGE |
| Observations |
| Organizations |
| Patients |
| Prescriptions |
| Providers |
| SEQUENCE |
+------------------+
Nachdem die Datenbank erstellt wurde, beenden Sie den Container mit dem Befehl "exit".
sh-4.2$ exit
exit
14. Java EE-Anwendung für Geschäftslogik und MySQL-Kommunikationseinstellungen von Container zu Container
Gehen Sie zurück zu Ihrem Arbeits-Host und geben Sie "pwd" ein. Sie sollten sich im Ordner "example-health-jee-openshift / example-health-api" befinden.
# pwd
/root/example-health-jee-openshift/example-health-api
# ls
create-secrets.sh Dockerfile kubernetes-openshift.yaml liberty liberty-mysql pom.xml samples src target
Um MySQL mit einer Java EE-Anwendung für Geschäftslogik zu verbinden, suchen Sie zuerst den MySQL-Dienstnamen.
# oc get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
mysql ClusterIP 172.30.88.187 <none> 3306/TCP 9m
Die Kommunikation zwischen Pods erfolgt über den Dienstnamen. Merken Sie sich den Dienstnamen, wie er im nächsten Schritt verwendet wird.
Verwenden Sie das Skript example-health-api / create-secrets.sh, um die MySQL-Verbindungsinformationen festzulegen.
cat create-secrets.sh
#!/bin/bash
oc create secret generic db-secrets \
--from-literal=db_username=admin \
--from-literal=db_password=password \
# --from-literal=db_host="jdbc:mysql://Dienstname:Port-Nummer/Name der Datenbank?sessionVariables=sql_mode=''"
--from-literal=db_host="jdbc:mysql://mysql:3306/health?sessionVariables=sql_mode=''"
Hinweis: Ab Oktober 2019 hat create-secrets.sh ein "/" zwischen "DB-Name /? SessionVariables" und "DB-Name" und "?". Bei der Verbindung mit JDBC tritt ein Verbindungsfehler auf, da "/" auch in der Zeichenfolge des DB-Namens enthalten ist. Löschen Sie daher das "/".
In OpenShift werden Authentifizierungsinformationen wie Kennwörter in einem Objekt namens Secrets gespeichert, das über einen Mechanismus zum Speichern vertraulicher Informationen verfügt. Die Verbindungsinformationen von MySQ werden als Umgebungsvariable im Pod (Container) verwendet. Um es als Umgebungsvariable zu verwenden, verknüpfen Sie die Umgebungsvariable und die Geheimnisse im Deployment-Objekt, das im nächsten Schritt die Bereitstellung des Pods (Containers) in kubernetes-openshift.yaml definiert.
- Auszug aus kubernetes-openshift.yaml, der env (Umgebungsvariable) definiert
env:
- name: ENV_MYSQL_UR
valueFrom:
secretKeyRef:
name: db-secrets
key: db_host
- name: ENV_MYSQL_USER
valueFrom:
secretKeyRef:
name: db-secrets
key: db_username
- name: ENV_MYSQL_PWD
valueFrom:
secretKeyRef:
name: db-secrets
key: db_password
Die Open Liberty DataSource-Einstellungen verwenden die oben definierten Umgebungsvariablen, um die Datenbankverbindungsparameter festzulegen.
- Auszug aus example-health-api / liberty / server.xml, der DataSource definiert
<dataSource id="DefaultDataSource" jndiName="jdbc/health-api" jdbcDriverRef="mysql-driver"
type="javax.sql.ConnectionPoolDataSource" transactional="true">
<properties url="${ENV_MYSQL_URL}"
databaseName="${ENV_MYSQL_DB_NAME}"
user="${ENV_MYSQL_USER}"
password="${ENV_MYSQL_PWD}"/>
Hinweis: Es gibt eine undefinierte Umgebungsvariable: ENV_MYSQL_DB_NAME oben, da der Datenbankname in der Umgebungsvariablen ENV_MYSQL_URL definiert ist. Hier wird der ursprüngliche Code-Muster-Code so angezeigt, wie er ist.
Führen Sie das Skript aus, um Geheimnisse in OpenShift zu erstellen. Wenn Sie die Liste der Geheimnisse nach der Erstellung mit dem Befehl "oc get secret" ausgeben, können Sie sehen, dass sie mit dem Namen "db-secret" erstellt wurde.
# ./create-secrets.sh
secret/db-secrets created
# oc get secrets
NAME TYPE DATA AGE
db-secrets Opaque 3 2d
15. Stellen Sie die Java EE-Anwendung bereit
Bearbeiten Sie die Datei: example-health-api / kubernetes-openshift.yaml und ändern Sie den Image-Schlüssel im Container-Abschnitt in das Docker-Image für Ihre Java EE-Anwendung, die an Docker Hub gesendet wird.
- Ersetzen Sie daihiraoka durch Ihren Docker Hub-Kontonamen. --Ersetzen Sie das Tag für ol-example-health von spätestens auf 1.
(Vorher ändern)
containers:
- name: example-health-api
image: ykoyfman/ol-example-health:latest
(Nach der veränderung)
containers:
- name: example-health-api
image: daihiraoka/ol-example-health:1
Stellen Sie die Java EE-Anwendung in Ihrem Cluster bereit.
# oc create -f kubernetes-openshift.yaml
service/example-health-api created
deployment.apps/example-health-api created
In example-health-api / kubernetes-openshift.yaml wird die Definition für die Bereitstellung des Open Liberty-Pods (Containers) beschrieben. Greifen Sie auf den EndPoint (IP) des Open Liberty-Pods (Containers) zu. Der zu erledigende Service wird beschrieben. Wenn Sie dieses Yaml ausführen, wird der Pod (Container) von Open Liberty in OpenShift gestartet, und Sie können mithilfe des Dienstes eine Verbindung zum Pod (Container) von Open Liberty herstellen.
Nach einer Weile startet der Open Liberty Pod (Container). Wenn der Befehl "oc get pod" ausgeführt wird, um die Liste der Pods (Container) auszugeben, wird der STATUS der Pods (Container) von "example-health-api-
# oc get pod
NAME READY STATUS RESTARTS AGE
example-health-api-7fcb786fb6-l5kx9 1/1 Running 0 1m
mysql-1-build 0/1 Completed 0 22m
mysql-1-hktv2 1/1 Running 0 21m
16. Erstellen Sie Route, ein OpenShift-Objekt zum Veröffentlichen von Java EE-Anwendungen im Internet.
# oc expose svc example-health-api
route.route.openshift.io/example-health-api exposed
Stellen Sie sicher, dass Ihre Java EE-Anwendung funktioniert. Holen Sie sich zunächst den Hostnamen, der der Route zugewiesen wurde.
# oc get route
NAME HOST/PORT PATH SERVICES PORT TERMINATION WILDCARD
example-health-api example-health-api-health.192.168.42.138.nip.io example-health-api http None
In diesem Fall ist der erste NAME example-health-api der Routenname und der nächste HOST / PORT FQDN der generierte Hostname. Wenn auf Route zugegriffen wird, wird über die Beispiel-Health-API von SERVICES auf die IP-Adresse des Endpunkts des Open Liberty-Pods (Containers) zugegriffen.
17. Überprüfen Sie den Betrieb der Java EE-Anwendung im Browser
Gehen Sie im Browserfenster zu
Business Logic wird jetzt auf Red Hat OpenShift in der IBM Cloud gestartet. Im Moment hat die Datenbank ein SQL-Schema erstellt, aber keine Daten. Im folgenden Verfahren registriert der BENUTZER die Testdaten der Patientenakte mithilfe der REST-API in der Route ①.
18. Vorbereitung des Programms zur Generierung von Daten zur Patientenakte
- Erstellen von Testdaten für Patientengesundheitsdaten Führen Sie generate.sh aus, um die Testdaten in MySQL mit der REST-API zu registrieren. In generate.sh können Sie synthetische realistische (aber nicht reale) Patientendaten und zugehörige Gesundheitsakten in verschiedenen Formaten ausgeben [synthea](https://github.com/synthetichealth/synthea] Ein Programm namens) wird verwendet.
--Script-Name: example-health-jee-openshift / generate / generate.sh
--Installieren Sie die Node.js csvtojson, die zum Ausführen von generate.sh erforderlich ist.
# ls
example-health-api generate LICENSE readme_images README.md screenshots
# cd generate/
# ls
generate.sh package.json README.md
# pwd
/root/example-health-jee-openshift/generate
# yum install npm
Installing:
npm x86_64 1:3.10.10-1.6.17.1.1.el7 epel 2.5 M
Installing for dependencies:
libuv x86_64 1:1.30.1-1.el7 epel 138 k
nodejs x86_64 1:6.17.1-1.el7 epel 4.7 M
# npm install csvtojson
[email protected] /root/example-health-jee-openshift/generate
└─┬ [email protected]
├── [email protected]
├── [email protected]
└─┬ [email protected]
└── [email protected]
# pwd
/root/example-health-jee-openshift/generate
-Übergeben Sie den PFAD, damit csvtojson verwendet werden kann.
# PATH=$PATH:/root/example-health-jee-openshift/generate/node_modules/csvtojson/bin
19. Ändern Sie den Standard-Timeout-Wert für die Route
Ändern Sie den Standardwert für das Zeitlimit für den im vorherigen Schritt erstellten Routennamen: example-health-api auf 60 Minuten. Wenn der USER generate.sh ausführt, ruft er den Open Liberty-Pod (Container) mit der REST-API über den Router des OpenShift Application Load Balancer (ALB) auf. Da das Standardzeitlimit des OpenShift-Routers 30 Sekunden beträgt, ist der Standardwert für einen lang laufenden REST-API-Aufruf wie die Eingabe von Testdaten zu kurz. Daher muss ein langer Zeitlimitwert festgelegt werden.
# oc annotate route example-health-api --overwrite haproxy.router.openshift.io/timeout=60m
route.route.openshift.io/example-api annotated
Das Ergebnis der Änderung kann mit dem Befehl "oc description route
# oc describe route example-health-api
Name: example-health-api
Namespace: health
Created: 13 minutes ago
Labels: app=example-health-api
Annotations: haproxy.router.openshift.io/timeout=60m
openshift.io/host.generated=true
Requested Host: example-health-api-health.192.168.42.138.nip.io
exposed on router router 13 minutes ago
Path: <none>
TLS Termination: <none>
Insecure Policy: <none>
Endpoint Port: http
Service: example-health-api
Weight: 100 (100%)
Endpoints: 172.17.0.10:9080
20. Ausführen des Testdatenprogramms für Patientenakten
Machen wir das. Die Optionen in generate.sh sind -p für die Grundgesamtheit und -u für den in der Route angegebenen Hostnamen. Dieses Mal werden wir die Daten von 150 Personen registrieren.
# ./generate.sh -p 150 -u http://example-health-api-health.192.168.42.138.nip.io
Cloning into 'synthea'...
remote: Enumerating objects: 38, done.
remote: Counting objects: 100% (38/38), done.
remote: Compressing objects: 100% (28/28), done.
remote: Total 31698 (delta 7), reused 21 (delta 2), pack-reused 31660
Receiving objects: 100% (31698/31698), 605.79 MiB | 9.81 MiB/s, done.
Resolving deltas: 100% (18183/18183), done.
Checking out files: 100% (663/663), done.
BUILD SUCCESSFUL in 30s
4 actionable tasks: 2 executed, 2 up-to-date
Es dauerte nur wenige Minuten von der Anzeige von BUILD SUCCESSFUL bis zum Abschluss der Registrierung. Wenn Sie den Status unterwegs überprüfen möchten, überprüfen Sie das Protokoll des Pod (Containers) von Open Liberty, indem Sie den Befehl "oc logs -f example-health-api-
21. Bestätigung der registrierten Patientenakten
Verwenden Sie die API "/ resources / v1 / getInfo / patient", um eine Liste der Patienten abzurufen und zu überprüfen, ob die Gesundheitsdaten des Patienten registriert sind. Wenn Sie den Hostnamen / resources / v1 / getInfo / patient in der URL mit curl angeben und ausführen, können Sie die Daten von 150 Patienten abrufen, was der im Voraus registrierten Nummer entspricht.
# curl -X GET "http://example-health-api-health.192.168.42.138.nip.io/resources/v1/getInfo/patients" -H "accept: */*"
{"ResultSet Output":[{"CA_DOB":"1962-10-
<<<Kürzung>>>
09","CA_FIRST_NAME":"Sergio","CA_GENDER":"M","CA_LAST_NAME":"Castellanos"},{"CA_DOB":"1988-06-06","CA_FIRST_NAME":"Lorraine","CA_GENDER":"F","CA_LAST_NAME":"Ledner"},{"CA_DOB":"2018-01-29","CA_FIRST_NAME":"Shemika","CA_GENDER":"F","CA_LAST_NAME":"Terry"},{"CA_DOB":"1954-03-26","CA_FIRST_NAME":"Clyde","CA_GENDER":"M","CA_LAST_NAME":"Ferry"},{"CA_DOB":"1946-03-25","CA_FIRST_NAME":"Bobby","CA_GENDER":"M","CA_LAST_NAME":"Krajcik"}],"StatusCode":200,"StatusDescription":"Execution Successful"}
22. Zusammenfassung
Beispiel Health hat den Geschäftslogikteil jetzt erfolgreich von der monolithischen Java EE-Anwendungsstruktur getrennt und als Java EE-Anwendung für Geschäftslogik ausgeführt, die unter Open Liberty unter OpenShift in MiniShift ausgeführt wird. Sie können auch den Testdatengenerator für das Patientengesundheitsmanagement (generater.sh) verwenden, um eine MySQL-Datenbank mit Testdaten für das Patientengesundheitsmanagement mithilfe der REST-API zu füllen und dann über eine Java EE-Anwendung auf diese Daten zuzugreifen. Ist fertig.
Es scheint, dass die Modernisierungsreise durch die Schritte bis zu diesem Punkt abgeschlossen wurde, aber so wie es ist, ist es als Service nicht ausreichend, da es nur von der REST-API verarbeitet werden kann. Ab dem nächsten Schritt möchte ich eine andere Anwendung der Patienten-Benutzeroberfläche Node.js bereitstellen, die von der monolithischen Java EE-Anwendung auf OpenShift aufgeteilt ist, und sie mit der Java EE-Anwendung für Geschäftslogik kombinieren, die ich dieses Mal erstellt habe.
Die Fortsetzung geht weiter zum Beitrag "Ich habe versucht, die Java EE-Anwendung von OpenShift (2) zu modernisieren".
Recommended Posts