M & M Family Farm in Swansea Ma

chiliad

With the growing interest in blockchain technology, software developers are looking into integrating smart contracts into their applications. The stop-to-end multi-step procedure of deploying a smart contract and integrating it into a Web application is fairly cumbersome. Project BlockHead takes advantage of the Open Service Broker API specification to build a service broker layer placed between the Web application and the blockchain network. The broker controls direction of the smart contract by automating cosmos and deployment of smart contracts and then exposing the required set of information to the Spider web applications.

@ nimak

Nima Kaviani

Senior Cloud Engineer

Project BlockHead: An Ethereum Smart Contract Service Broker for Kubernetes and Deject Foundry

This blogpost is co-authored past Swetha Repakula , morgan bauer , and Jonathan Berkhahn

With the growing interest in blockchain applied science, software developers are looking into integrating smart contracts into their applications. Applications adult and integrated with blockchain are typically composed of two parts:

• A smart contract deployed to the blockchain network
• A Web application that binds to the deployed contract and uses information technology.

A smart contract can be thought of equally a snippet of lawmaking available at a given address in the blockchain network which is capable of receiving and processing input data, retrieving or updating ledger land, and returning results to the requesting party. The web applications using the contract are commonly referred to as Web3 applications.

Despite all the excitement in using blockchain, the end-to-stop multi-step procedure of deploying a smart contract and integrating it into a Web application is adequately cumbersome. An application developer requires to:

1. develop or reuse a smart contract
2. compile the contract code
3. retrieve the executable binary and the application binary interface (ABI)
4. bring up a blockchain node (e.g., Ethereum)
5. create or import an account (i.e. Wallet) into the node
6. use the account to deploy the binary code into the blockchain network
7. verify deployment and retrieve the contract address
8. and finally employ the combination of the account address, the contract accost, and the contract ABI in a Spider web application to bind to the contract and use it

In that location have been efforts to simplify the process of developing smart contracts. Truffle, for example, offers a development framework that brings upward a local Ethereum network and allows developers to test-drive development of their smart contract applications.

Notwithstanding, when it comes to a deployment to the principal Ethereum network (mainnet) or a exam network (testnet), developers nevertheless need to manually get through the procedure of provisioning a blockchain node to ensure successful deployment and integration of their contracts with their applications.

As open source platform engineers, we strive to simplify the process of application development for software engineers. Platform-as-a-Service (PaaS) exists on the premise of making it easier for developers to deploy, scale, and manage their applications; and platforms like Kubernetes and Cloud Foundry have come a long way in simplifying application lifecycle management. Following the same premise, we believe PaaS platforms can and should simplify development of smart contract applications and make it integral to the lifecycle of smart contract applications deployed to PaaS. This is why projection BlockHead was born.

Project BlockHead takes advantage of the Open up Service Broker API specification to build a service broker layer placed betwixt the Web application and the blockchain network. Doing so, the broker controls direction of the smart contract by automating creation and deployment of smart contracts and so exposing the required set of information to the Spider web application.

Open Service Broker API

The Open Service Banker API (OSB API) specification offers a mutual interface for the creation and integration of a service marketplace into cloud applications in such a way that services can be maintained and managed independently from the applications and notwithstanding applications tin easily bind and use services through the exposed APIs. Service brokers are responsible for advertizing a catalog of service offerings and service plans to the marketplace, and acting on requests from the market for provisioning, bounden, unbinding, and deprovisioning.

Borrowing from the specification of the OSB API, provisioning reserves a resource on a service as an instance. In the context of the BlockHead broker, the service instance represents a blockchain node connected to the blockchain network. What a bounden represents may also vary by service. Creation of a bounden provides the service example with smart contract information for it to be compiled and deployed and become bachelor to the application using the service. A platform marketplace may expose services from one or many service brokers, and an individual service banker may back up one or many platform marketplaces using different URL prefixes and credentials. Motion picture above shows an example of interaction with the service broker API to provision a service."

More than details on how to interact with a service broker tin be found beneath:

BlockHead Service Banker

With project BlockHead, nosotros aim to translate each OSB API telephone call to a series of steps in the lifecycle of the smart contract and thus hide the complexity of interaction with a blockchain away from application developers.

The first version of the broker is built on top of the Container Service Banker, a Deject Foundry community project. Past utilizing the container service broker, blockchain nodes can be run within an isolated Docker container and operate independently when deploying and binding smart contracts.

We utilize the broker to deploy stateful Ethereum nodes on demand. Each step in provisioning and binding or unbinding and deprovisioning are then modified to deliver on creation / deletion of smart contracts or nodes. Picture below provides an overall compages for how the Blockhead service broker provisions Ethereum nodes and integrates with the Cloud Foundry applications:

The overall interaction model betwixt the BlockHead service broker and Cloud Foundry applications

1. Deploying the Broker

The initial version of the BlockHead broker is published as a BOSH release. A BOSH release is a versioned drove of configuration properties, configuration templates, startup scripts, source code, binary artifacts, and anything else required to build and deploy software in a reproducible style.

In this blogpost nosotros have the BlockHead service broker deployed alongside a Cloud Foundry deployment. This allows us to benefit from capabilities in Cloud Foundry to button Web3 applications and bind them to the contract service. For instructions on how to deploy Cloud Foundry consult the documentation below.

One time you have a BOSH deployment environment with Deject Foundry deployed on information technology, deploying the BlockHead broker is as elementary every bit running the following script:

Since Kubernetes integrates with Open Service Banker API compliant brokers, in case y'all have a Kubernetes deployment, you can hook up the deployed BlockHead broker to your Kubernetes platform and bind to deployed smart contracts using Web3 applications deployed to Kubernetes. You can notice out how to do the integration with Kubernetes Hither.

2. Service Marketplace and Contract MarketPlace

For the banker to appear in the Deject Foundry marketplace you demand to first register it using the following control:

                bosh run-errand -d docker-broker broker-registrar              

Once the banker is registered, you can query the marketplace and you will see the Ethereum service appear in the marketplace:

Further to this, nosotros have also developed a simple contract marketplace that would allow us to list contracts and then refer to them using their URL when bounden an awarding to an Ethereum node. To have the contract market place deployed, you can add your smart contracts to the marketplace, build the docker image, push it upwards to a docker registry and and so apply a control similar to the post-obit to download and utilize information technology:

cf push button contract-marketplace --docker-prototype nimak/contract-marketplace

You can verify that the application is up and running by checking cf apps:

In our example the market is available at the address below and navigating to the accost we can find the website:

Notice on elevation of each contract definition in that location is a hyperlink reference to the code for the contract. This contract URL is what nosotros utilize to bind the service to the application and deploy the contract. Note that deploying the contract marketplace is optional and if you have other means to supply a smart contract URL to the Ethereum service, it would totally piece of work as well.

3. Provision the Service Instance

When a request to provision a service instance is issued, the broker starts up an Ethereum node. The Ethereum node exposes its Remote Procedure Telephone call (RPC) api for interactions and makes the endpoints bachelor through a given address and port number.

For the node creation to occur, you lot need to first deploy a Web3 application that is intended to utilise the smart contract. For the case of this blog post, nosotros will be using our simple-node-application that only writes and reads a single value to and from the ledger. Notation that since the app does not have the contract continued to it notwithstanding, we do non start the app when pushing it otherwise the deploy will fail.

Verify that application nora is pushed to your Cloud Foundry deployment:

Next, we create the Ethereum service for the deployed application:

With the asking to create the service, the service banker creates a docker container with an Ethereum node running on it.

This can be verified with BOSH by connecting to the docker VM in the broker deployment and looking at the list of docker containers it is running (Note that each docker container runs an instance of the Ethereum node that corresponds to the created service).

You lot meet that the Ethereum node has its server running on port8545 which is mapped to port32771 externally and on the host vm.

4. Create Service Binding

When binding to the service, the location of a smart contract in the class of a URL is passed to the banker. The banker downloads the contract, compiles it, extracts the ABI and pushes the binary to the Ethereum node using the account created at the time of launching the service.

We mentioned earlier that the sample contract marketplace provides the link to the given contract, so we tin simply get the URL location of the contract and demark it to the application.

Note that when binding the service we pass the contract_url in the form of an inlined JSON configuration to cf bind-service.

With the service binding going through successfully, nosotros can issue a cf env command to see the updated list of environment variables for the application.

Under VCAP_SERVICES the configuration for eth involves credentials information for the eth_node such as contract abi, business relationship address, contract address, transaction hash for the deployed contract, besides as the host address and port mappings for the application to connect to the Ethereum node.

Going back to the sample node application referenced earlier, you see that the code in the application uses these surround variables to be able to demark to the smart contract and utilise information technology.

And VOILA! with that information, you tin define routes for you node.js application to go and fix values into the ledger using the smart contract:

five. Delete Service Binding

When unbinding the service, the broker assumes that the contract used during the demark stage is no longer required, as a issue, upon receiving an unbind asking, the broker detaches the service from the application and removes the injected contract data from VCAP_SERVICES, simply keeps the node around for it to mayhap take other contracts deployed to it. Newly deployed contracts will use the same Ethereum node with the aforementioned account created during the service cosmos phase.

In case of our running instance, the following control would unbind the contract:

cf unbind-service nora elementary

vi. Deprovision Service Instance

When a request is issued to deprovision the service, the service broker proceeds to delete the docker container:

Challenges and Hereafter Comeback Plans

1. Syncing the Ledger

Like many other blockchain networks, nodes in Ethereum crave the full ledger to be present for subsequent transactions to take result. This implies that the docker container created by the BlockHead service banker either needs to include the full ledger at the time it gets created or to sync the ledger afterward the container is created. The latter is very time intensive. The ledger size for the mainnet Ethereum is effectually 600GB and growing. Given the ledger size, it would take considerable amount of time for the provisioned Ethereum node to sync its ledger and be set up, making the integration impractical.

An alternative solution is for the service broker to maintain a warm docker prototype with a fairly upward-to-engagement copy of the ledger to employ when creating a service. This requires the broker to run a side node that constantly syncs its ledger with the ledger for the Ethereum network and to periodically create and publish an Ethereum node docker image.

Currently, the service broker launches the Ethereum node in developer mode which implies starting with a fresh ledger. This helps u.s. quickly bring upwardly a evolution environment to exam Web3 applications against while avoiding the long wait for ledger syncup. We plan to implement techniques that would let quick startup of an Ethereum node against the mainnet or testnet for production purposes likewise.

two. Memory footprint

Syncing the ledger involves reading transaction blocks from other peers in the network, validating them, and then calculation them to the local copy of the ledger. Since writing to the disk is I/O intensive, an Ethereum node maintains a subset of the ledger in memory while performing validation and chaining of the nodes before writing the new blocks to the deejay. This constrains retentiveness usage on the VMs deploying Ethereum nodes and puts an upper bound to the number of containers that can exist run and managed by the broker.

3. Account Direction

Equally mentioned earlier, Ethereum nodes demand to bind to an Ethereum account earlier being capable of deploying contracts. This implies that the broker either needs to manage Ethereum accounts by both internally creating and and then exposing them to the application developers or by allowing the developers to import their own accounts to use with the broker.

Currently accounts get discarded upon deleting the smart contract service and the corresponding Ethereum node. This volition be revised for the accounts to be exportable / downloadable.

Summary

In this blog post we discussed the implementation of Projection BlockHead as a service banker to be used in PaaS platforms such equally Cloud Foundry and Kubernetes. The goal of Project BlockHead is to simplify how smart contracts are deployed and used in Web3 applications by taking away the complication of deploying and managing blockchain nodes.

While nosotros described the stop-to-end process of deploying and using the banker, application developers need to only care about Steps 3 to six of the process described above. This involves creating a smart contract service and binding it to an application. Steps 1 and two of deploying the service broker and the contract marketplace would potentially be washed only in one case and typically managed by platform engineers and operations engineers, simplifying the overall process.

Project BlockHead came about as a hackathon project during Cloud Foundry Tiptop 2018 in Boston and as y'all might have noticed near of the repositories we shared in this web log mail service are personal github repositories of our team participating in the hackathon. Luckily the project has received good amount of involvement from the customs and hopefully in the nigh futurity it volition find a new domicile every bit an incubated project and be properly CI/CD-ed. So come up back to this blog post for further announcements equally to where yous can find the official projection repository. It is an open source project and we certainly welcome any contribution to brand it better.

Tags

# ethereum# project-blockhead# smart-contract-broker# smart-contracts# kubernetes

ashbolttwours.blogspot.com

Source: https://hackernoon.com/project-blockhead-an-ethereum-smart-contract-service-broker-for-kubernetes-and-cloud-foundry-88390a3ac63f

Share this post