[DOCKER] J'ai essayé de moderniser une application Java EE avec OpenShift.
introduction
Rédaction d'un article sur la «Modernisation des applications Java EE avec OpenShift» à l'aide de «Red Hat OpenShift sur IBM Cloud», un service géré d'OpenShift d'IBM Cloud. https://www.atmarkit.co.jp/ait/articles/1911/15/news002.html
Le "Red Hat OpenShift sur IBM Cloud" utilisé dans cet article est un service payant, donc je pense qu'il est difficile pour beaucoup de gens d'essayer les étapes de l'article. Par conséquent, ** En utilisant MiniShift, qui peut être utilisé gratuitement, nous l'avons réécrit afin que vous puissiez facilement expérimenter la modernisation des applications Java EE avec OpenShift. ** **
** Cette fois, je voudrais essayer le cas où l'application et la base de données sont conteneurisées. Ceux qui liront l'article pourront en apprendre davantage sur l'intégration de plusieurs conteneurs (connexion application et base de données) en plus du contenu de l'article. ** Dans l'article, la base de données utilisait le service géré d'IBM Cloud "Compose for MySQL".
Nous avons fait une série de (1) à (5).
-
(This post) "J'ai essayé de moderniser une application Java EE avec OpenShift"- Application Java EE fonctionnant sur Open Liberty pour la logique métier Modernisation
-
"J'ai essayé de moderniser l'application Java EE par OpenShift (2)"-Modernisation de l'application Node.js de l'interface utilisateur (interface utilisateur) pour les patients
-
"J'ai essayé de moderniser l'application Java EE par OpenShift (3)"-Modération de l'ajout de la fonction d'application PHP pour le gestionnaire de dossiers de santé
-
"J'ai essayé de moderniser l'application Java EE avec OpenShift (4)"-DevOps et CI / CD en utilisant uniquement les fonctions OpenShift standard (Intégration continue / livraison continue)
-
"J'ai essayé de moderniser l'application Java EE avec OpenShift (5)"-DevOps et CI / CD (intégration / continuation continue) en utilisant Jenkins Livraison)
Modernisation des applications Java EE avec OpenShift
Dans IBM Code Patterns, "[Deploy microservices in a fictitious medical app using Java EE and Open Liberty](https: // developer) Il existe un modèle de code appelé ".ibm.com / jp / patterns / jee-app-modernization-with-openshift /)". À partir de maintenant, j'aimerais utiliser ce modèle de code pour réellement bouger mes mains et expérimenter la modernisation des applications Java EE. Il est facile d'imaginer que cette série d'étapes correspond à la procédure de migration d'un système sur site vers le cloud. À partir de maintenant, devenons un architecte de solutions et expérimentons le parcours de modernisation qui se répandra dans le cloud.
Exemple de cas d'utilisation de la santé
Exemple Health est une société médicale fictive. L'entreprise a une longue histoire et possède des centaines de milliers de dossiers de patients. À l'origine, Example Health utilisait une structure d'application monolithique pour ses applications. Leur structure d'application était une application Java à pile complète s'exécutant sur WebSphere connectée à une base de données Db2 sur le mainframe. L'architecture originale d'Example Health est:
Récemment, Example Health a décidé de moderniser l'application et de la diviser en microservices. Ils ont décidé de passer à une base de données SQL (MySQL) connectée à une application Java EE fonctionnant dans Open Liberty pour la logique métier et à une application Node.js pour l'interface utilisateur du patient. En outre, Example Health a décidé de conteneuriser toutes ces applications et bases de données SQL et de les exécuter sur «Red Hat OpenShift on IBM Cloud». La nouvelle architecture d'Example Health est la suivante:
Suite au passage à Red Hat OpenShift sur IBM Cloud, Example Health est désormais facilement extensible. Bientôt, de nouveaux microservices seront inclus, notamment des applications de gestion des dossiers de santé et d'analyse.
Préparation pour MiniShift
Veuillez préparer MiniShift en vous référant à un autre article de Qiita.
Remarque: veuillez installer Docker version 17.09 ou ultérieure sur l'hôte qui lance MiniShift. C'est une bonne idée d'installer la dernière version de Docker CE (Community Edition). Cela est dû au fait que le Dockerfile qui sera utilisé ultérieurement utilise la syntaxe pour changer le propriétaire du fichier avec l'indicateur ADD / COPY --chown qui est pris en charge à partir de Docker 17.09. La version de Docker qui s'exécute sur la machine virtuelle (VM) MiniShift est la 1.13, donc c'est gênant. En passant, si vous n'utilisez pas l'indicateur --chown dans le Dockerfile, vous pouvez éviter que cela ne soit gênant, mais cette fois nous le ferons sans changer la ressource du modèle de code.
MiniShift n'est pas utilisé dans la première moitié de la procédure. Arrêtez MiniShift jusqu'à ce que vous en ayez besoin.
# minishift stop
Si vous exécutez la commande "# eval $ (minishift docker-env)" après le lancement de MiniShift Lorsque vous effectuez un «push docker», enregistrez l'image avec le Docker en cours d'exécution sur la machine virtuelle (VM) MiniShift.
Cette fois, je veux enregistrer l'image dans le Docker de l'hôte qui démarre MiniShift de l'hôte de travail, donc si les valeurs sont entrées dans DOCKER_HOST, DOCKER_TLS_VERIFY, DOCKER_CERT_PATH en exécutant la commande "# env | grep DOCKER", utilisez la commande suivante pour créer l'environnement. Videz la variable.
export DOCKER_TLS_VERIFY=""
export DOCKER_HOST=""
export DOCKER_CERT_PATH=""
procédure
(Environnement que j'ai essayé) Configuration minimale CentOS 7.7
1. Maven (JDK est également installé en tant que dépendance de Maven)
# yum install maven
2. Confirmation du démarrage du démon Docker
Je construirai Docker plus tard, alors assurez-vous que le démon fonctionne sur Docker.
# systemctl status docker
Dans le Dockerfile, la syntaxe pour changer le propriétaire du fichier avec ADD / COPY --chown pris en charge à partir de Docker 17.09 est utilisée, donc Docker pris en charge par CentOS provoquera une erreur car la syntaxe est inconnue. Évitez de définir la version de Docker sur 17.09 ou une version supérieure, ou de traiter le fichier Docker avec la commande chown sur une ligne distincte (couche séparée) pour la partie --chown.
3. Clonez le projet GitHub. Clone crée un dossier example-health-jee-openshift.
# 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. Créez l'application Java EE.
# 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)
<<------------------------------------réduction------------------------------------>>
[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. Créez l'image Docker pour votre application Java EE.
# 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. Si la construction de Docker réussit, l'image de base openliberty / open-liberty et l'image ol-example-health créées cette fois seront générées.
# 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 de Red Hat UBI (Red Hat Universal Base Image) est utilisé pour l'image de base d'Open Liberty spécifiée dans la clause FROM du Dockerfile. Red Hat UBI est une image de conteneur fournie par le biais du contrôle qualité Red Hat et peut être redistribuée gratuitement. Les images de conteneur créées à partir de Red Hat UBI peuvent être prises en charge lors de l'exécution sur "Red Hat OpenShift on IBM Cloud". Dans un environnement qui n'utilise pas OpenShift, la prise en charge n'est pas disponible, mais il y a un avantage que vous pouvez utiliser l'image du conteneur RHEL gratuitement. Si vous exploitez un conteneur dans une entreprise, vous devrez peut-être juger s'il est sûr de donner un conteneur d'origine inconnue tel que CentOS ou Ubuntu de chaque département. Cependant, je n'avais pas d'autre choix que de l'utiliser pour diverses raisons, et parfois j'avais peur de l'utiliser. Avec Red Hat UBI, cette anxiété est éliminée car elle est fournie après le contrôle qualité de Red Hat. Si vous utilisez actuellement une image de conteneur CentOS ou Ubuntu, pourquoi ne pas essayer Red Hat UBI?
Red Hat UBI(Red Hat Universal Base Image) https://access.redhat.com/containers/#/search/ubi
7. Enregistrez l'image Docker de l'application Java EE "ol-example-health" dans Docker Hub.
- Créez un compte Docker Hub à l'avance.
- Remplacez daihiraoka par le nom de votre compte Docker Hub et exécutez.
Marquez l'image ol-example-health au format "Nom du compte Docker Hub / Nom de l'image: nom de la balise".
# docker tag ol-example-health:1 daihiraoka/ol-example-health:1
Si vous affichez la liste des images Docker, vous pouvez voir que l'image daihiraoka / ol-example-health a été créée.
# 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
Connectez-vous à Docker Hub et enregistrez l'image daihiraoka / ol-example-health dans le référentiel Docker Hub.
# docker login -u daihiraoka
Login Succeeded
# docker push daihiraoka/ol-example-health:1
Lorsque l'enregistrement de l'image est terminé, daihiraoka / ol-example-health sera affiché dans le référentiel Docker Hub.
Note:
Cette fois, j'ai utilisé Docker Hub dans la procédure Code Patterns, mais IBM Cloud dispose d'un service Container Registry. À des fins commerciales, IBM Cloud Container Registry est généralement utilisé pour gérer les images de conteneurs.
· Présentation d’IBM Cloud Container Registry
https://cloud.ibm.com/docs/services/Registry?topic=registry-registry_overview&locale=ja
8. Lancez 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
- Application des variables d'environnement MiniShift
# eval $(minishift oc-env) <-PATH définition de la commande oc
# eval $(minishift docker-env) <-Paramètres de connexion à Docker s'exécutant sur MiniShift VM
# source <(oc completion bash) <-Achèvement du shell des commandes et des ressources
Lorsque j'essaye d'exécuter minishift oc-env, la commande est sortie car elle passe par le PATH de la commande oc.
# 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
Lorsque minishift docker-env est exécuté, les informations de connexion au Docker s'exécutant sur la VM MiniShift exécutée sur le KVM sont affichées comme indiqué ci-dessous. En définissant cette variable d'environnement, l'image du conteneur sera gérée dans le registre Docker de la machine virtuelle MiniShift au lieu du registre Docker local.
# 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. Connectez-vous à la CLI OpenShift avec votre nom d'utilisateur en tant que développeur.
(MiniShift accepte n'importe quel mot de passe, utilisez donc n'importe quelle chaîne.)
# 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. Créez un projet pour Example Health.
Cela créera un nouveau projet et définira le pod (conteneur) comme projet de travail à déployer.
# 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. Imprimez une liste d'ImageStream (is) pour votre projet OpenShift afin de trouver le catalogue MySQL.
# 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 de l'image du conteneur utilisée par mysql cette fois. Les nodejs et dotnet affichés dans la liste sont les mêmes que le catalogue de la console Web dans l'image ci-dessous. OpenShift fournit un mécanisme pour déployer facilement des applications même avec CLI.
12. Créez un conteneur pour votre base de données MySQL à l'aide du S2I (Source to Image) d'OpenShift.
# 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
Définissez la variable d'environnement avec "-e".
| paramètre | Aperçu |
|---|---|
| -e MYSQL_USER | Nom d'utilisateur MySQL |
| -e MYSQL_PASSWORD | Mot de passe MySQL |
| -e MYSQL_DATABASE | Nom de la base de données |
| --name | Nom du conteneur |
| openshift/mysql:5.7 | openshift/mysql:5.7 est le nom ImageStream de l'image du conteneur de base(mysql pour le projet openshift:5.7) |
| ~https://github.com(réduction) | ~(tilde)Spécifiez le référentiel de code source sur le côté droit entre |
Cette fois, j'omets le stockage persistant qui stocke les données dans la base de données. Si vous n'avez pas défini de stockage persistant pour le pod (conteneur), toutes les données enregistrées seront supprimées lorsque le pod (conteneur) est arrêté. Dans ce cas, lorsqu'un nouveau pod (conteneur) est démarré, il est vide et vous devez redémarrer après l'importation du schéma SQL.
Résultat d'exécution
--> 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.
Après un certain temps, le pod mysql [mysql-1-hktv2] démarre.
# 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. Créez un schéma de base de données dans le conteneur MySQL
Connectez-vous au conteneur avec la commande oc rsh pour créer le schéma de base de données dans MySQL.
# oc rsh mysql-1-hktv2
Si vous vous connectez avec rsh, vous pouvez voir dans github que la structure du répertoire est à l'intérieur du conteneur.
sh-4.2$ ls
LICENSE README.md example-health-api generate readme_images screenshots
Importer le schéma SQL des données d'enregistrement de santé du patient Nom du fichier: 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.
Génère une liste de tables dans la base de données de santé. Si l'importation du schéma SQL est terminée avec succès, la table de sortie s'affiche.
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 |
+------------------+
Maintenant que la base de données a été créée, quittez le conteneur avec la commande "exit".
sh-4.2$ exit
exit
14. Application Java EE pour la logique métier et les paramètres de communication conteneur à conteneur MySQL
Revenez à votre hôte de travail et tapez "pwd" et vous devriez être dans le dossier "example-health-jee-openshift / example-health-api".
# 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
Pour connecter MySQL à une application Java EE pour la logique métier, recherchez d'abord le nom du service MySQL.
# oc get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
mysql ClusterIP 172.30.88.187 <none> 3306/TCP 9m
La communication entre les pods se fait par nom de service. Souvenez-vous du nom du service tel qu'il sera utilisé à l'étape suivante.
Utilisez le script example-health-api / create-secrets.sh pour définir les informations de connexion MySQL.
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://Nom du service:numéro de port/Nom de la base de données?sessionVariables=sql_mode=''"
--from-literal=db_host="jdbc:mysql://mysql:3306/health?sessionVariables=sql_mode=''"
Remarque: Depuis octobre 2019, create-secrets.sh a un "/" entre "DB name /? SessionVariables" et "DB name" et "?". Lors de la connexion avec JDBC, une erreur de connexion se produit car "/" est également inclus dans la chaîne de caractères du nom de la base de données. Par conséquent, supprimez le "/".
Dans OpenShift, les informations d'authentification telles que les mots de passe sont stockées dans un objet appelé secrets, qui dispose d'un mécanisme pour conserver les informations confidentielles. Et les informations de connexion de MySQ sont utilisées comme une variable d'environnement dans le pod (conteneur). Pour l'utiliser comme variable d'environnement, liez la variable d'environnement et les secrets dans l'objet Deployment qui définit le déploiement du pod (conteneur) dans kubernetes-openshift.yaml à l'étape suivante.
- Extrait de kubernetes-openshift.yaml qui définit env (variable d'environnement)
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
Et les paramètres Open Liberty DataSource utilisent les variables d'environnement définies ci-dessus pour définir les paramètres de connexion à la base de données.
- Extrait de example-health-api / liberty / server.xml définissant DataSource
<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}"/>
Remarque: Il existe une variable d'environnement non définie: ENV_MYSQL_DB_NAME ci-dessus, car le nom de la base de données est défini dans la variable d'environnement: ENV_MYSQL_URL. Ici, le code des modèles de code d'origine est affiché tel quel.
Exécutez le script pour créer des secrets dans OpenShift. Après sa création, si vous sortez la liste des secrets avec la commande "oc get secrets", vous pouvez voir qu'elle est créée avec le nom "db-secrets".
# ./create-secrets.sh
secret/db-secrets created
# oc get secrets
NAME TYPE DATA AGE
db-secrets Opaque 3 2d
15. Déployer l'application Java EE
Modifiez le fichier: example-health-api / kubernetes-openshift.yaml et remplacez la clé d'image dans la section conteneurs par l'image Docker de votre application Java EE envoyée vers Docker Hub.
- Remplacez daihiraoka par le nom de votre compte Docker Hub. --Remplacez la balise ol-example-health du dernier au 1.
(Changer avant)
containers:
- name: example-health-api
image: ykoyfman/ol-example-health:latest
(Après changement)
containers:
- name: example-health-api
image: daihiraoka/ol-example-health:1
Déployez l'application Java EE sur votre cluster.
# oc create -f kubernetes-openshift.yaml
service/example-health-api created
deployment.apps/example-health-api created
Dans example-health-api / kubernetes-openshift.yaml, la définition du déploiement du pod Open Liberty (conteneur) est décrite. Accédez à EndPoint (IP) du pod Open Liberty (conteneur). Le service à faire est décrit. En exécutant ce yaml, le pod (conteneur) d'Open Liberty sera démarré dans OpenShift et vous pourrez vous connecter au pod (conteneur) d'Open Liberty en utilisant Service.
Après un certain temps, le pod Open Liberty (conteneur) démarre. Lorsque vous exécutez la commande "oc get pod" pour afficher une liste de pods (conteneurs), le STATUT des pods (containers) de "example-health-api- <caractères alphanumériques arbitraires>" devient "Running".
# 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. Créez une Route, un objet OpenShift pour la publication d'applications Java EE sur Internet.
# oc expose svc example-health-api
route.route.openshift.io/example-health-api exposed
Assurez-vous que votre application Java EE fonctionne. Tout d'abord, obtenez le nom d'hôte attribué à Route.
# 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
Dans ce cas, le premier example-health-api NAME est le nom de la Route et le FQDN HOST / PORT suivant est le nom d'hôte généré. Lors de l'accès à Route, l'adresse IP du point de terminaison du pod Open Liberty (conteneur) est accessible via example-health-api de SERVICES.
17. Vérifiez le fonctionnement de l'application Java EE sur le navigateur
Dans la fenêtre du navigateur, accédez à <FQDN créé par Route> / openapi / ui /. Affiche les points de terminaison et les spécifications Open API pris en charge par les applications Java EE. Exemple) http://example-health-api-health.192.168.42.138.nip.io/openapi/ui/
Business Logic est maintenant lancé sur Red Hat OpenShift sur IBM Cloud. Pour le moment, la base de données a un schéma SQL créé mais aucune donnée. Dans la procédure suivante, l'UTILISATEUR enregistre les données de test du dossier de santé du patient à l'aide de l'API REST dans l'itinéraire ①.
18. Préparation du programme de génération de données de test du dossier médical du patient
--Créer les données de test du dossier de santé du patient Exécutez generate.sh pour enregistrer les données de test dans MySQL avec l'API REST. Dans generate.sh, vous pouvez générer des données synthétiques réalistes (mais pas réelles) sur les patients et les dossiers de santé associés dans divers formats [synthea](https://github.com/synthetichealth/synthea] Un programme appelé) est utilisé.
--Nom de script: example-health-jee-openshift / generate / generate.sh
--Installez le csvtojson Node.js nécessaire pour exécuter generate.sh.
# 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
-Passez le PATH pour que csvtojson puisse être utilisé.
# PATH=$PATH:/root/example-health-jee-openshift/generate/node_modules/csvtojson/bin
19. Modifier la valeur du délai d'expiration par défaut de l'itinéraire
Modifiez la valeur de délai d'expiration par défaut pour le nom de la route: example-health-api créé à l'étape précédente en 60 minutes. Lorsque l'UTILISATEUR exécute generate.sh, il appelle le pod Open Liberty (conteneur) avec l'API REST via le routeur de l'équilibreur de charge d'application OpenShift (ALB). Étant donné que le délai d'expiration par défaut du routeur OpenShift est de 30 secondes, la valeur par défaut est trop courte pour un appel d'API REST de longue durée, tel que la saisie de données de test, il est donc nécessaire de définir une valeur de délai d'expiration longue.
# oc annotate route example-health-api --overwrite haproxy.router.openshift.io/timeout=60m
route.route.openshift.io/example-api annotated
Le résultat du changement peut être confirmé avec la commande "oc describe 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. Exécution du programme de données de test du dossier médical du patient
Faisons le. Les options de generate.sh sont -p pour la population et -u pour le nom d'hôte exposé dans route. Cette fois, nous enregistrerons les données de 150 personnes.
# ./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
Il n'a fallu que quelques minutes entre l'affichage de BUILD SUCCESSFUL et la fin de l'enregistrement. Si vous souhaitez vérifier l'état en cours de route, vérifiez le journal du Pod (conteneur) d'Open Liberty en exécutant la commande "oc logs -f example-health-api- <caractères alphanumériques arbitraires>".
21. Confirmation des données enregistrées du dossier de santé du patient
Utilisez l'API "/ resources / v1 / getInfo / patients" pour obtenir une liste de patients et vérifier si les données du dossier de santé du patient sont enregistrées. Si vous spécifiez le nom d'hôte / ressources / v1 / getInfo / patients dans l'URL avec curl et que vous l'exécutez, vous pouvez obtenir les données de 150 patients, ce qui est le même que le nombre enregistré à l'avance.
# 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-
<<<réduction>>>
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. Résumé
Example Health a maintenant réussi à séparer la partie logique métier de la structure d'application Java EE monolithique et à l'exécuter en tant qu'application Java EE pour la logique métier s'exécutant sur Open Liberty s'exécutant sur OpenShift dans MiniShift. Vous pouvez également utiliser le générateur de données de test de gestion de la santé des patients (generater.sh) pour remplir une base de données MySQL avec des données de test de gestion de la santé des patients à l'aide de l'API REST, puis accéder à ces données à partir d'une application Java EE. Est fait.
Il semble que le voyage de modernisation a été complété par les étapes jusqu'à présent, mais tel quel, il n'est pas suffisant en tant que service car il ne peut être géré que par l'API REST. À partir de l'étape suivante, j'aimerais déployer une autre application de l'interface utilisateur Node.js du patient séparée de l'application monolithique Java EE vers OpenShift et la combiner avec l'application Java EE pour la logique métier que j'ai créée cette fois.
La suite continue avec le post de "J'ai essayé de moderniser l'application Java EE par OpenShift (2)".
Recommended Posts