This is work in progress - provisioning doesn't work for some reason
Fineract-CN contains of more than a dozen of micro services. One doesn't need to run all of them at once - this is actually quite resource consuming.
These instructions list the bare minimum - getting a single micro service - Identity provisioned and running.
Once you complete these steps you will get basic understanding how fineract-cn works and how its micro services are provisioned.
You need
- Java8, Docker, docker-compose, Postman
- it is possible to go without Docker and Docker compose (you need to install Postgres and Cassandra yourself) but we don't cover it here.
Prepare your environment
Find hosts file (/etc/hosts in Unix/Mac) and add:
127.0.0.1 cassandra
127.0.0.1 activemq
127.0.0.1 eureka
127.0.0.1 postgres
127.0.0.1 provisioner-ms
127.0.0.1 identity-ms
Check out the code
mkdir fincn_bare_minimum
cd fincn_bare_minimum
git clone https://github.com/apache/fineract-cn-identity
git clone https://github.com/apache/fineract-cn-provisioner
git clone https://github.com/apache/fineract-cn-docker-compose/
Generate RSA keys
java -cp fineract-cn-docker-compose/external_tools/lang-0.1.0-BUILD-SNAPSHOT.jar org.apache.fineract.cn.lang.security.RsaKeyPairFactory SPRING > application-common.properties
Prepare common configuration
Open newly generated application-common.properties and add to the end of file:
#Keep the values you created
system.publicKey.exponent=65537
system.publicKey.modulus=1654279...
system.publicKey.timestamp=2019-12-10T07_53_27
system.privateKey.modulus=165427..
system.privateKey.exponent=11642831705210..
#add following values
activemq.brokerUrl=tcp://activemq:61616
cassandra.cl.delete=ONE
cassandra.cl.read=ONE
cassandra.cl.write=ONE
cassandra.cluster.pwd=password
cassandra.cluster.user=cassandra
cassandra.clusterName="datacenter1"
cassandra.contactPoints=cassandra:9042
cassandra.keyspace=seshat
eureka.client.fetchRegistry=true
eureka.client.initialInstanceInfoReplicationIntervalSeconds=10
eureka.client.instanceInfoReplicationIntervalSeconds=1
eureka.client.serviceUrl.defaultZone=http://eureka:8761/eureka
eureka.client.serviceUrl.registerWithEureka=true
eureka.instance.hostname=eureka
eureka.instance.leaseRenewalIntervalInSeconds=10
eureka.registration.enabled=true
feign.hystrix.enabled=false
portfolio.bookLateFeesAndInterestAsUser=service-runner
postgresql.host=postgres
rhythm.beatCheckRate=60000
rhythm.user=imhotep
ribbon.eureka.enabled=true
ribbon.listOfServers=eureka:8761
server.max-http-header-size=24576
spring.cloud.config.enabled=false
spring.cloud.discovery.enabled=true
system.initialclientid=service-runner
Start external tools
cd fineract-cn-docker-compose/external_tools
docker-compose up -d
cd ../..
Now wait for external tools (Postgre, Cassandra, ActiveMQ and Eureka to start).
Verify external tools have started
- Connect to Postgres database (you can use IntelliJ IDEA for that)
- jdbc:postgresql://postgres:5432/postgres (user postgres, password: postgres)
- Connect to Apache Cassandra (you can use IntelliJ IDEA for that)
- jdbc:cassandra://localhost:9042 (user cassandra)
- Eureka is available here: http://eureka:8761/
- ActiveMQ is available here: http://activemq:8161/
Run Provisioner
Open fineract-cn-provisioner with IntelliJ IDEA and wait the project to be imported
Open ProvisionerApplication class and right click on class name and choose "Create ProvisionerApplication Run/Debug configuration"
In the dialog open Environment and under Program Arguments add: --spring.config.location=../application-common.properties
Click OK and then right click again and select Run
If it doesn't run (you get error: "Cause: org.gradle.api.internal.ClosureBackedAction") then open Gradle properties:
and switch to run with IntelliJ
And then Run again.
After ~10sec you should get in terminal:
10:10:01.081 [main] INFO o.a.f.c.p.ProvisionerApplication - Started ProvisionerApplication in 11.642 seconds (JVM running for 13.988)
Verify Provisioner Micro Service started correctly
- A new schema "seshat" is created to postgres database
- A new keyspace "seshat" is created to cassandra database and following tables are there:
- applications
- clients
- config
- tenant_applications
- tenants
- users
Run Identity Micro Service
Now we repeat the same steps with fineract-cn-identity.
Open fineract-cn-identity with IntelliJ IDEA and wait the project to be imported
Open IdentityServiceConfig class and right click on class name and choose "Create ProvisionerApplication Run/Debug configuration"
To program arguments set:
--spring.config.location=../application-common.properties --eureka.instance.hostname=identity-ms
Click OK and then right click again on IdentityServiceConfig and select Run.
If you managed to do it correctly you should see in logs:
10:19:31.047 [main] INFO o.a.f.c.i.c.IdentityServiceConfig - Started IdentityServiceConfig in 7.874 seconds (JVM running for 9.701)
10:19:31.385 [DiscoveryClient-InstanceInfoReplicator-0] INFO c.netflix.discovery.DiscoveryClient - DiscoveryClient_IDENTITY-V1/192.168.1.116:identity-v1:2021 - registration status: 204
Verify Identity Micro Service has started
Open http://identity-ms:2021/ with your browser. You should get error 404.
Check if Identity has registered with Eureka
Wait a few minutes and open http://eureka:8761/ and make sure "identity-v1" is there in the list.
Hover the link and make sure it points to identity-ms:2021/info
→ What does it mean?
Fineract-CN micro services use client-side load balancing. This works like this:
- If micro service starts up it registers its location with Eureka. Remember we told to identity that its hostname is "identity-ms"
- If some micro service X wants to connect to Identity then it asks Eureka for a location of "identity-v1"
- In development we only have one copy of the service but in production there could be many copies of the same service running and micro service X would choose randomly one.
Provision Identity micro service
We provide a postman-request-collection as well as a postman-environment that defines variables that are used to hold values received in responses.
Both files are located under fineract-cn-docker-compose/postman-initial-requests folder:
postman_scripts/Fineract-Cn-Initial-Requests.postman_collection.json
postman_scripts/Fineract-Cn-Initial-Setup-Environment.postman_environment.json
Initialize Postman as follows:
- Start Postman and load both files into Postman by clicking
Import
and then selecting the file. - You will see the collection "Fineract-Cn-Initial-Requests" in the left sidebar.
- Open the collection by clicking on it.
- Select the environment "Fineract-Cn-Initial-Setup-Environment" in the environment drop-down (top right corner in Postman).
- Execute the requests one by one by selecting them in the collection and then pressing "Send".
The first request (01. Log in root user) will retrieve a token. The response should look like this, with a different token:
{
"token": "Bearer eyJhbGciOiJSUzUxMiJ9.eyJhdWQiOiJwcm92peWjpWZirFgcYLIzxsKv_-E5k6Gd0pv01OC0XpY3NSgfAolVVgvSXKoRnL3NwAMP2yuzX6i8hR_q82Q...",
"accessTokenExpiration": "2019-07-18T22:26:57.784"
}
If you don't get a token there is something wrong with your setup. The token is necessary for authentication in other requests thus be sure that this steps works. Important: Be sure to execute the requests in the right order! The outcome is often stored in variables - check the Tests section of the requests.
Only execute following steps (besides 01 that we already did)
02.01 Create identity-v1 application
03.1 Create first tenant 'playground'
Now wait a bit and verify the following has happened:
- In postgres database a new schema 'playground' is created
03.2 Assign identity-v1 for Tenant and obtain Tenant Admin (user antony) Password
03.3 Login Antony (tenant superadmin) with obtained password
03.4 Change Antony Password to 'antonyPassword'
03.5 LOGIN ANTONY (tenant SuperAdmin) with pwd 'antonyPassword'
05.1 Create administrator role for tenant "playground"
05.2 Create Admin User operator with password 'initialPassword'
05.3 Log in with initial password
05.4 Change user 'operator' password to 'operatorPassword'
05.5 LOG IN TENANT ADMIN (operator)
Verify user operator has been created
Run step:
05.6 Pull operator permissions
You have now set up Identity Micro service and provisioned it using Provisioner micro service.
You should have schemas 'seshat' and 'playground' in Cassandra and Postgres databases.