This project is a complete starter project you can use to deploy a FHIR server using HAPI FHIR JPA.
Note that this project is specifically intended for end users of the HAPI FHIR JPA server module (in other words, it helps you implement HAPI FHIR, it is not the source of the library itself). If you are looking for the main HAPI FHIR project, see here: https://github.com/hapifhir/hapi-fhir
Need Help? Please see: https://github.com/hapifhir/hapi-fhir/wiki/Getting-Help
In order to use this sample, you should have:
- This project checked out. You may wish to create a GitHub Fork of the project and check that out instead so that you can customize the project and save the results to GitHub.
- Oracle Java (JDK) installed: Minimum JDK8 or newer.
- Apache Maven build tool (newest version)
- Docker, as the entire project can be built using multistage docker (with both JDK and maven wrapped in docker) or used directly from Docker Hub
Running via Docker Hub
Each tagged/released version of hapi-fhir-jpaserver
is built as a Docker image and published to Docker hub. To run the published Docker image from DockerHub:
docker pull hapiproject/hapi:latest
docker run -p 8080:8080 hapiproject/hapi:latest
This will run the docker image with the default configuration, mapping port 8080 from the container to port 8080 in the host. Once running, you can access https://localhost:8080/
in the browser to access the HAPI FHIR server's UI or use https://localhost:8080/fhir/
as the base URL for your REST requests.
If you change the mapped port, you need to change the configuration used by HAPI to have the correct hapi.fhir.tester
property/value.
You can customize HAPI directly from the run
command using environment variables. For example:
docker run -p 8080:8080 -e hapi.fhir.default_encoding=xml hapiproject/hapi:latest
HAPI looks in the environment variables for properties in the application.yaml file for defaults.
You can customize HAPI by telling HAPI to look for the configuration file in a different location, eg.:
docker run -p 8090:8080 -v $(pwd)/yourLocalFolder:/configs -e "--spring.config.location=file:https:///configs/another.application.yaml" hapiproject/hapi:latest
Here, the configuration file (another.application.yaml) is placed locally in the folder yourLocalFolder.
docker run -p 8090:8080 -e "--spring.config.location=classpath:/another.application.yaml" hapiproject/hapi:latest
Here, the configuration file (another.application.yaml) is part of the compiled set of resources.
version: '3.7'
services:
web:
image: "hapiproject/hapi:latest"
ports:
- "8090:8080"
configs:
- source: hapi
target: /data/hapi/application.yaml
volumes:
- hapi-data:/data/hapi
environment:
SPRING_CONFIG_LOCATION: 'file:https:///data/hapi/application.yaml'
configs:
hapi:
external: true
volumes:
hapi-data:
external: true
The easiest way to run this server entirely depends on your environment requirements. At least, the following 4 ways are supported:
mvn jetty:run
If you need to run this server on a different port (using Maven), you can change the port in the run command as follows:
mvn -Djetty.port=8888 jetty:run
Server will then be accessible at https://localhost:8888/ and eg. https://localhost:8888/fhir/metadata. Remember to adjust you overlay configuration in the application.yaml to eg.
tester:
-
id: home
name: Local Tester
server_address: 'https://localhost:8888/fhir'
refuse_to_fetch_third_party_urls: false
fhir_version: R4
mvn clean spring-boot:run -Pboot
Server will then be accessible at https://localhost:8080/ and eg. https://localhost:8080/fhir/metadata. Remember to adjust you overlay configuration in the application.yaml to eg.
tester:
-
id: home
name: Local Tester
server_address: 'https://localhost:8080/fhir'
refuse_to_fetch_third_party_urls: false
fhir_version: R4
mvn clean package spring-boot:repackage -Pboot && java -jar target/ROOT.war
Server will then be accessible at https://localhost:8080/ and eg. https://localhost:8080/fhir/metadata. Remember to adjust you overlay configuration in the application.yaml to eg.
tester:
-
id: home
name: Local Tester
server_address: 'https://localhost:8080/fhir'
refuse_to_fetch_third_party_urls: false
fhir_version: R4
mvn clean package com.google.cloud.tools:jib-maven-plugin:dockerBuild -Dimage=distroless-hapi && docker run -p 8080:8080 distroless-hapi
Server will then be accessible at https://localhost:8080/ and eg. https://localhost:8080/fhir/metadata. Remember to adjust you overlay configuration in the application.yaml to eg.
tester:
-
id: home
name: Local Tester
server_address: 'https://localhost:8080/fhir'
refuse_to_fetch_third_party_urls: false
fhir_version: R4
./build-docker-image.sh && docker run -p 8080:8080 hapi-fhir/hapi-fhir-jpaserver-starter:latest
Server will then be accessible at https://localhost:8080/ and eg. https://localhost:8080/fhir/metadata. Remember to adjust you overlay configuration in the application.yaml to eg.
tester:
-
id: home
name: Local Tester
server_address: 'https://localhost:8080/fhir'
refuse_to_fetch_third_party_urls: false
fhir_version: R4
Much of this HAPI starter project can be configured using the yaml file in src/main/resources/application.yaml. By default, this starter project is configured to use H2 as the database.
To configure the starter app to use MySQL, instead of the default H2, update the application.yaml file to have the following:
spring:
datasource:
url: 'jdbc:mysql:https://localhost:3306/hapi_dstu3'
username: admin
password: admin
driverClassName: com.mysql.jdbc.Driver
On some systems, it might be necessary to override hibernate's default naming strategy. The naming strategy must be set using spring.jpa.hibernate.physical_naming_strategy.
spring:
jpa:
hibernate.physical_naming_strategy: NAME_OF_PREFERRED_STRATEGY
On linux systems or when using docker mysql containers, it will be necessary to review the case-sensitive setup for
mysql schema identifiers. See https://dev.mysql.com/doc/refman/8.0/en/identifier-case-sensitivity.html. We suggest you
set lower_case_table_names=1
during mysql startup.
To configure the starter app to use PostgreSQL, instead of the default H2, update the application.yaml file to have the following:
spring:
datasource:
url: 'jdbc:postgresql:https://localhost:5432/hapi_dstu3'
username: admin
password: admin
driverClassName: org.postgresql.Driver
Because the integration tests within the project rely on the default H2 database configuration, it is important to either explicity skip the integration tests during the build process, i.e., mvn install -DskipTests
, or delete the tests altogether. Failure to skip or delete the tests once you've configured PostgreSQL for the datasource.driver, datasource.url, and hibernate.dialect as outlined above will result in build errors and compilation failure.
The UI that comes with this server is an exact clone of the server available at https://hapi.fhir.org. You may skin this UI if you'd like. For example, you might change the introductory text or replace the logo with your own.
The UI is customized using Thymeleaf template files. You might want to learn more about Thymeleaf, but you don't necessarily need to: they are quite easy to figure out.
Several template files that can be customized are found in the following directory: https://github.com/hapifhir/hapi-fhir-jpaserver-starter/tree/master/src/main/webapp/WEB-INF/templates
Using the Maven-Embedded Jetty method above is convenient, but it is not a good solution if you want to leave the server running in the background.
Most people who are using HAPI FHIR JPA as a server that is accessible to other people (whether internally on your network or publically hosted) will do so using an Application Server, such as Apache Tomcat or Jetty. Note that any Servlet 3.0+ compatible Web Container will work (e.g Wildfly, Websphere, etc.).
Tomcat is very popular, so it is a good choice simply because you will be able to find many tutorials online. Jetty is a great alternative due to its fast startup time and good overall performance.
To deploy to a container, you should first build the project:
mvn clean install
This will create a file called ROOT.war
in your target
directory. This should be installed in your Web Container according to the instructions for your particular container. For example, if you are using Tomcat, you will want to copy this file to the webapps/
directory.
Again, browse to the following link to use the server (note that the port 8080 may not be correct depending on how your server is configured).
You will then be able access the JPA server e.g. using https://localhost:8080/fhir/metadata.
If you would like it to be hosted at eg. hapi-fhir-jpaserver, eg. https://localhost:8080/hapi-fhir-jpaserver/ or https://localhost:8080/hapi-fhir-jpaserver/fhir/metadata - then rename the WAR file to hapi-fhir-jpaserver.war
and adjust the overlay configuration accordingly e.g.
tester:
-
id: home
name: Local Tester
server_address: 'https://localhost:8080/hapi-fhir-jpaserver/fhir'
refuse_to_fetch_third_party_urls: false
fhir_version: R4
Docker compose is a simple option to build and deploy container. To deploy with docker compose, you should build the project
with mvn clean install
and then bring up the containers with docker-compose up -d --build
. The server can be
reached at https://localhost:8080/.
In order to use another port, change the ports
parameter
inside docker-compose.yml
to 8888:8080
, where 8888 is a port of your choice.
The docker compose set also includes my MySQL database, if you choose to use MySQL instead of H2, change the following properties in application.yaml:
spring:
datasource:
url: 'jdbc:mysql:https://hapi-fhir-mysql:3306/hapi'
username: admin
password: admin
driverClassName: com.mysql.jdbc.Driver
Make sure you run with the maven profile called boot
and NOT also jetty
. Then you are ready to press debug the project directly without any extra Application Servers.
Install Tomcat.
Make sure you have Tomcat set up in IntelliJ.
- File->Settings->Build, Execution, Deployment->Application Servers
- Click +
- Select "Tomcat Server"
- Enter the path to your tomcat deployment for both Tomcat Home (IntelliJ will fill in base directory for you)
Add a Run Configuration for running hapi-fhir-jpaserver-example under Tomcat
- Run->Edit Configurations
- Click the green +
- Select Tomcat Server, Local
- Change the name to whatever you wish
- Uncheck the "After launch" checkbox
- On the "Deployment" tab, click the green +
- Select "Artifact"
- Select "hapi-fhir-jpaserver-example:war"
- In "Application context" type /hapi
Run the configuration.
- You should now have an "Application Servers" in the list of windows at the bottom.
- Click it.
- Select your server, and click the green triangle (or the bug if you want to debug)
- Wait for the console output to stop
Point your browser (or fiddler, or what have you) to https://localhost:8080/hapi/baseDstu3/Patient
It is important to use MySQL5Dialect when using MySQL version 5+.
The server may be configured with subscription support by enabling properties in the application.yaml file:
-
hapi.fhir.subscription.resthook_enabled
- Enables REST Hook subscriptions, where the server will make an outgoing connection to a remote REST server -
hapi.fhir.subscription.email.*
- Enables email subscriptions. Note that you must also provide the connection details for a usable SMTP server. -
hapi.fhir.subscription.websocket_enabled
- Enables websocket subscriptions. With this enabled, your server will accept incoming websocket connections on the following URL (this example uses the default context path and port, you may need to tweak depending on your deployment environment): ws:https://localhost:8080/websocket
Set hapi.fhir.cql_enabled=true
in the application.yaml file to enable Clinical Quality Language on this server.
Set hapi.fhir.mdm_enabled=true
in the application.yaml file to enable MDM on this server. The MDM matching rules are configured in mdm-rules.json. The rules in this example file should be replaced with actual matching rules appropriate to your data. Note that MDM relies on subscriptions, so for MDM to work, subscriptions must be enabled.
By default, the server will use embedded lucene indexes for terminology and fulltext indexing purposes. You can switch this to using lucene by editing the properties in application.yaml
For example:
elasticsearch.enabled=true
elasticsearch.rest_url=localhost:9200
elasticsearch.username=SomeUsername
elasticsearch.password=SomePassword
elasticsearch.protocol=http
elasticsearch.required_index_status=YELLOW
elasticsearch.schema_management_strategy=CREATE
Set hapi.fhir.lastn_enabled=true
in the application.yaml file to enable the $lastn operation on this server. Note that the $lastn operation relies on Elasticsearch, so for $lastn to work, indexing must be enabled using Elasticsearch.
It is possible to change the cached search results time. The option reuse_cached_search_results_millis
in the [application.yaml] is 6000 miliseconds by default.
Set reuse_cached_search_results_millis: -1
in the [application.yaml] file to ignore the cache time every search.
The default Dockerfile contains a release-distroless
stage to build a variant of the image
using the gcr.io/distroless/java-debian10:11
base image:
docker build --target=release-distroless -t hapi-fhir:distroless .
Note that distroless images are also automatically build and pushed to the container registry,
see the -distroless
suffix in the image tags.
To add a custom operation, refer to the documentation in the core hapi-fhir libraries here.
Within hapi-fhir-jpaserver-starter
, create a generic class (that does not extend or implement any classes or interfaces), add the @Operation
as a method within the generic class, and then register the class as a provider using RestfulServer.registerProvider()
.