mirror of
https://github.com/corda/corda.git
synced 2025-01-18 10:46:38 +00:00
125 lines
5.1 KiB
ReStructuredText
125 lines
5.1 KiB
ReStructuredText
Deploying a node
|
||
================
|
||
|
||
Building nodes using Gradle
|
||
---------------------------
|
||
Nodes are usually built using a Gradle task. The canonical Gradle file for building nodes is the one used by the
|
||
CorDapp template. Both a `Java version <https://github.com/corda/cordapp-template-java/blob/master/build.gradle>`_ and
|
||
a `Kotlin version <https://github.com/corda/cordapp-template-kotlin/blob/master/build.gradle>`_ are available.
|
||
|
||
The buildscript
|
||
~~~~~~~~~~~~~~~
|
||
The buildscript is always located at the top of the build file. Among other things, this section determines which
|
||
version of Corda and the Corda gradle plugins are used to build the nodes and their CorDapps:
|
||
|
||
.. sourcecode:: groovy
|
||
|
||
ext.corda_release_version = '0.14-SNAPSHOT'
|
||
ext.corda_gradle_plugins_version = '0.14.2'
|
||
|
||
Release versions suffixed by ``-SNAPSHOT`` are based on the unstable Master branch
|
||
(see :doc:`building-against-master`). You should generally use the latest Milestone release instead.
|
||
|
||
``corda_gradle_plugins_versions`` are given in the form ``major.minor.patch``. You should use the same ``major`` and
|
||
``minor`` versions as the Corda version you are using, and the latest ``patch`` version. A list of all the available
|
||
versions can be found here: https://bintray.com/r3/corda/cordformation.
|
||
|
||
Project dependencies
|
||
~~~~~~~~~~~~~~~~~~~~
|
||
If your CorDapps have any additional external dependencies, they should be added to the ``dependencies`` section:`
|
||
|
||
.. sourcecode:: groovy
|
||
|
||
dependencies {
|
||
|
||
...
|
||
|
||
// Cordapp dependencies
|
||
// Specify your cordapp's dependencies below, including dependent cordapps
|
||
}
|
||
|
||
For further information about managing dependencies, see
|
||
`the Gradle docs <https://docs.gradle.org/current/userguide/dependency_management.html>`_.
|
||
|
||
Building the nodes
|
||
~~~~~~~~~~~~~~~~~~
|
||
Cordform is the local node deployment system for CorDapps. The nodes generated are intended for experimenting,
|
||
debugging, and testing node configurations, but not for production or testnet deployment.
|
||
|
||
Here is an example Gradle task called ``deployNodes`` that uses the Cordform plugin to deploy three nodes, plus a
|
||
notary/network map node:
|
||
|
||
.. sourcecode:: groovy
|
||
|
||
task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
|
||
directory "./build/nodes"
|
||
networkMap "CN=Controller,O=R3,OU=corda,L=London,C=UK"
|
||
node {
|
||
name "CN=Controller,O=R3,OU=corda,L=London,C=UK"
|
||
advertisedServices = ["corda.notary.validating"]
|
||
p2pPort 10002
|
||
rpcPort 10003
|
||
webPort 10004
|
||
cordapps = []
|
||
}
|
||
node {
|
||
name "CN=NodeA,O=NodeA,L=London,C=UK"
|
||
advertisedServices = []
|
||
p2pPort 10005
|
||
rpcPort 10006
|
||
webPort 10007
|
||
cordapps = []
|
||
rpcUsers = [[ user: "user1", "password": "test", "permissions": []]]
|
||
}
|
||
node {
|
||
name "CN=NodeB,O=NodeB,L=New York,C=US"
|
||
advertisedServices = []
|
||
p2pPort 10008
|
||
rpcPort 10009
|
||
webPort 10010
|
||
cordapps = []
|
||
rpcUsers = [[ user: "user1", "password": "test", "permissions": []]]
|
||
}
|
||
node {
|
||
name "CN=NodeC,O=NodeC,L=Paris,C=FR"
|
||
advertisedServices = []
|
||
p2pPort 10011
|
||
rpcPort 10012
|
||
webPort 10013
|
||
cordapps = []
|
||
rpcUsers = [[ user: "user1", "password": "test", "permissions": []]]
|
||
}
|
||
}
|
||
|
||
You can extend ``deployNodes`` to generate any number of nodes you like. The only requirement is that you must specify
|
||
one node as running the network map service, by putting their name in the ``networkMap`` field. In our example, the
|
||
``Controller`` is set as the network map service.
|
||
|
||
.. warning:: When adding nodes, make sure that there are no port clashes!
|
||
|
||
Any CorDapps defined in the project's source folders are also automatically registered with all the nodes defined in
|
||
``deployNodes``, even if the CorDapps are not listed in each node's ``cordapps`` entry.
|
||
|
||
Deploying your nodes
|
||
--------------------
|
||
You deploy a set of nodes by running your ``build.gradle`` file's Cordform task. For example, if we were using the
|
||
standard ``deployNodes`` task defined above, we'd create our nodes by running the following commands in a terminal
|
||
window from the root of the project:
|
||
|
||
* Unix/Mac OSX: ``./gradlew deployNodes``
|
||
* Windows: ``gradlew.bat deployNodes``
|
||
|
||
After the build process has finished, you will find the newly-built nodes under ``kotlin-source/build/nodes``. There
|
||
will be one folder generated for each node you built, plus a ``runnodes`` shell script (or batch file on Windows) to
|
||
run all the nodes at once. Each node in the ``nodes`` folder has the following structure:
|
||
|
||
.. sourcecode:: none
|
||
|
||
. nodeName
|
||
├── corda.jar // The Corda runtime
|
||
├── node.conf // The node's configuration
|
||
└── plugins // Any installed CorDapps
|
||
|
||
.. note:: Outside of development environments, do not store your node directories in the build folder.
|
||
|
||
If you make any changes to your ``deployNodes`` task, you will need to re-run the task to see the changes take effect. |