I M Not Gonna Ask You Again

thousand

With the growing involvement in blockchain technology, software developers are looking into integrating smart contracts into their applications. The cease-to-cease multi-step process of deploying a smart contract and integrating it into a Web awarding 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 management of the smart contract by automating creation and deployment of smart contracts and so exposing the required set of information to the Web applications.

@ nimak

Nima Kaviani

Senior Cloud Engineer

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

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

With the growing interest in blockchain engineering science, software developers are looking into integrating smart contracts into their applications. Applications developed and integrated with blockchain are typically equanimous of 2 parts:

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

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 state, and returning results to the requesting party. The web applications using the contract are commonly referred to equally Web3 applications.

Despite all the excitement in using blockchain, the stop-to-terminate multi-step procedure of deploying a smart contract and integrating information technology into a Web awarding is fairly cumbersome. An awarding developer requires to:

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

At that place take been efforts to simplify the process of developing smart contracts. Truffle, for example, offers a development framework that brings upwardly a local Ethereum network and allows developers to test-bulldoze development of their smart contract applications.

However, when it comes to a deployment to the main Ethereum network (mainnet) or a test network (testnet), developers all the same need to manually become through the procedure of provisioning a blockchain node to ensure successful deployment and integration of their contracts with their applications.

Equally open source platform engineers, we strive to simplify the process of application development for software engineers. Platform-every bit-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 style in simplifying application lifecycle management. Following the aforementioned 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 project BlockHead was built-in.

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

Open Service Broker API

The Open Service Broker API (OSB API) specification offers a common interface for the cosmos 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 all the same applications can easily demark and use services through the exposed APIs. Service brokers are responsible for advertising a catalog of service offerings and service plans to the marketplace, and acting on requests from the market place for provisioning, binding, unbinding, and deprovisioning.

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

More than details on how to collaborate with a service broker can exist establish below:

BlockHead Service Broker

With project BlockHead, we aim to translate each OSB API phone call to a series of steps in the lifecycle of the smart contract and thus hide the complication of interaction with a blockchain abroad from application developers.

The starting time version of the broker is built on top of the Container Service Broker, a Cloud Foundry community project. By utilizing the container service broker, blockchain nodes can exist run inside 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 stride in provisioning and binding or unbinding and deprovisioning are then modified to deliver on creation / deletion of smart contracts or nodes. Moving-picture show 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 banker is published equally a BOSH release. A BOSH release is a versioned collection of configuration backdrop, configuration templates, startup scripts, source code, binary artifacts, and anything else required to build and deploy software in a reproducible mode.

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

Once yous have a BOSH deployment environment with Deject Foundry deployed on it, deploying the BlockHead broker is every bit simple as running the following script:

Since Kubernetes integrates with Open Service Broker API compliant brokers, in case you have a Kubernetes deployment, you can hook upward the deployed BlockHead broker to your Kubernetes platform and bind to deployed smart contracts using Web3 applications deployed to Kubernetes. You tin find 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 need to first register it using the following command:

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

One time the broker is registered, you can query the marketplace and you will see the Ethereum service appear in the marketplace:

Further to this, we take also adult a simple contract marketplace that would allow united states of america to listing contracts and and so refer to them using their URL when binding an application to an Ethereum node. To have the contract marketplace deployed, you can add together your smart contracts to the marketplace, build the docker image, push information technology upwardly to a docker registry and so use a command similar to the following to download and utilize it:

cf push contract-market --docker-image nimak/contract-marketplace

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

In our example the marketplace is available at the accost below and navigating to the accost we tin find the website:

Detect on top of each contract definition there is a hyperlink reference to the lawmaking for the contract. This contract URL is what nosotros use to demark the service to the application and deploy the contract. Notation that deploying the contract marketplace is optional and if you accept other ways to supply a smart contract URL to the Ethereum service, it would totally work equally well.

iii. Provision the Service Instance

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

For the node cosmos to occur, yous need to first deploy a Web3 application that is intended to employ the smart contract. For the example of this blog postal service, 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 take the contract connected to it yet, nosotros do non outset the app when pushing it otherwise the deploy volition fail.

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

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

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

This can be verified with BOSH past connecting to the docker VM in the banker 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 see that the Ethereum node has its server running on port8545 which is mapped to port32771 externally and on the host vm.

four. Create Service Binding

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

Nosotros mentioned before that the sample contract marketplace provides the link to the given contract, so we can simply become the URL location of the contract and bind it to the application.

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

With the service bounden going through successfully, nosotros can upshot a cf env control to see the updated listing of environment variables for the application.

Under VCAP_SERVICES the configuration for eth involves credentials data for the eth_node such every bit contract abi, account address, contract address, transaction hash for the deployed contract, also equally the host address and port mappings for the awarding to connect to the Ethereum node.

Going dorsum to the sample node application referenced earlier, you run across that the lawmaking in the application uses these environment variables to be able to bind to the smart contract and use it.

And VOILA! with that information, you lot tin can define routes for you node.js application to get and gear up values into the ledger using the smart contract:

5. Delete Service Binding

When unbinding the service, the broker assumes that the contract used during the bind phase is no longer required, as a event, upon receiving an unbind request, the broker detaches the service from the application and removes the injected contract information from VCAP_SERVICES, but keeps the node around for it to possibly have other contracts deployed to it. Newly deployed contracts will utilize the aforementioned Ethereum node with the aforementioned account created during the service cosmos stage.

In case of our running example, the following command would unbind the contract:

cf unbind-service nora uncomplicated

6. Deprovision Service Case

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

Challenges and Future Comeback Plans

ane. Syncing the Ledger

Like many other blockchain networks, nodes in Ethereum require the full ledger to be present for subsequent transactions to accept effect. This implies that the docker container created by the BlockHead service broker either needs to include the full ledger at the time information technology gets created or to sync the ledger after 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 corporeality of time for the provisioned Ethereum node to sync its ledger and be prepare, making the integration impractical.

An alternative solution is for the service broker to maintain a warm docker prototype with a fairly up-to-engagement copy of the ledger to use 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 prototype.

Currently, the service banker launches the Ethereum node in programmer mode which implies starting with a fresh ledger. This helps united states quickly bring up a evolution environment to test Web3 applications against while fugitive the long wait for ledger syncup. Nosotros programme to implement techniques that would allow quick startup of an Ethereum node confronting the mainnet or testnet for product purposes as well.

2. Retentivity footprint

Syncing the ledger involves reading transaction blocks from other peers in the network, validating them, then adding 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 retentivity while performing validation and chaining of the nodes before writing the new blocks to the disk. This constrains memory usage on the VMs deploying Ethereum nodes and puts an upper bound to the number of containers that tin be run and managed by the broker.

3. Business relationship Management

As mentioned earlier, Ethereum nodes need to demark to an Ethereum business relationship before being capable of deploying contracts. This implies that the broker either needs to manage Ethereum accounts by both internally creating so exposing them to the application developers or by allowing the developers to import their own accounts to use with the broker.

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

Summary

In this web log mail service we discussed the implementation of Project BlockHead as a service broker to exist used in PaaS platforms such every bit 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 complexity of deploying and managing blockchain nodes.

While we described the end-to-finish procedure of deploying and using the banker, awarding developers demand to but care about Steps iii to 6 of the process described higher up. This involves creating a smart contract service and binding information technology to an application. Steps 1 and 2 of deploying the service broker and the contract marketplace would potentially be done only once and typically managed by platform engineers and operations engineers, simplifying the overall process.

Project BlockHead came nearly as a hackathon project during Deject Foundry Summit 2018 in Boston and as y'all might have noticed most of the repositories we shared in this blog mail service are personal github repositories of our team participating in the hackathon. Luckily the project has received good corporeality of interest from the community and hopefully in the near time to come it will find a new home as an incubated projection and be properly CI/CD-ed. So come back to this blog post for further announcements every bit to where you can find the official project repository. It is an open source projection and nosotros certainly welcome whatever contribution to brand it better.

Tags

# ethereum# projection-blockhead# smart-contract-banker# smart-contracts# kubernetes

Related Stories

escototheriest.blogspot.com

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

Share this post