Step-By-Step Guide Building & Deploying A Private Blockchain Network On Windows

Global Open Versity Building & Deploying s Private Network on Windows Machine v1.
Global Open Versity

Blockchain DevOps Hands-on Labs Training Manual
Step-By-Step Guide Building & Deploying

a Private Blockchain Network on Windows
By Kefa Rabah, krabah@globalopenversity.org March 14, 2018 The Lake Institute
Introduction
A blockchain is a digital ledger of records that’s arranged in chunks of data called blocks. These blocks
then link with one another through a cryptographic validation known as a hashing function. Linked
together, these blocks form an unbroken chain — a blockchain.
The reason that this type of data structure is useful for things like cryptocurrencies is decentralization,
meaning the records inside this chain aren’t stored in any single location, are accessible by everyone, and
are immutable by any one party.
Applications
Although blockchain is most commonly associated with Bitcoin, there are many uses for this technology.
There are several broad categories of blockchain applications, a couple of which include:
Currency and Digital Assets

The Blockchain that makes up Bitcoin sends money globally to individuals and merchants. But
Blockchains can also create digital assets like stocks and bonds.
Verifiable Data and Smart Contracts

A Blockchain can create a verifiable record of any data, file, or contract. This can be useful in any industry
that uses big data, like the medical industry or government.
Hands-on
From time to time I plan to emulate an Ethereum environment. The idea behind is to observe how
Ethereum nodes work to each other, and how different accounts interact in transaction and contract
deployment. For testing, most contract deployment example nowadays is mainly on testrpc or
testnet, but how the contract works among nodes is still new to m
What you’ll have achieved at the end of this Hands-on lab”

1. Create a private Ethereum Blockchain
1
April 2007, Kefa Rabah, Global Open Versity, Vancouver Canada
www.globalopenversity.org
Global Open Versity Building & Deploying s Private Network on Windows Machine v1.0
2. Create a private network that will share this blockchain

3. Create externally owned account (EOA)
4. Mine some ether into our account so we can do really interesting things with our blockchain
Fig. 1
Background
Ethereum blockchain network is simply lots of EVM (Ethereum Virtual Machines) or “nodes” connected to
every other node to create a mesh. Each node runs a copy of the entire blockchain and competes to mine
the next block or validate a transaction. Whenever a new block is added, the blockchain updates and is
propagated to the entire network, such that each node is in sync. Ethereum’s Go implementation is
called Geth
Fig. 2
To become a node in the Ethereum network, your computer will have to download and update a copy of
the entire Ethereum blockchain. To achieve this Ethereum provides tools that you can download, connect
to the Ethereum network with and then interact with it. These are:
2
Geth — "……if you have experience with web development and are interested in
building frontends for dapps, you should experiment with Geth. "
Eth — "…If you want added security by running two different implementations
in parallel or are serious about GPU mining, then the C++ "Eth" client is
for you. "
Pyethapp — " …If you are a Python developer that wants to build
decentralized apps or are interested in Ethereum for research or an
academic purpose, this is a great client"
Each of these tools will eventually provide us access to a console — a JavaScript environment that
contains all of the main features that we’d need later so I am guessing no matter what tool you choose to
set up your blockchain, we should eventually converge on the console.
We decide to go with Geth or this labs, since our team have some understanding of web development.
The rest of this post assumes that we are using Geth to interact with the Ethereum Network.
Geth is a command line interface (CLI) tool that communicates with the Ethereum Network and acts as
the a link between your computer, its hardware and the rest of the Ethereum nodes or network computers.
If a block is mined by another node, your Geth program will pick it up and then pass on the new
information onto your GPU or CPU to update the blockchain. With Geth, you can
• mine ether (ether is the cryptocurrency fueling the Ethereum network)
• transfer funds between addresses
• create smart contracts and send transactions to them
• explore block history and much much more
How to Create a Private Ethereum Blockchain from Ground-up?

Ethereum is a decentralized platform that runs smart contracts, applications that run exactly as
programmed without possibility of downtime, censorship, fraud or third party interference. In this blog post
I will take you through all the steps required in setting up a fully functioning private ethereum blockchain,
inside your local network — which includes:
• Setting up a private blockchain with ethereum using geth.
• Setting up the MetaMask ethereum wallet to work with the private blockchain.
• Transfer funds between multiple accounts.

• Create, deploy and invoke a smart contract on the private blockchain using remix.
• Setting up ethereum block explorer over the private blockchain.
Ethereum Setup on Windows & Linux

Here are the latest stable binaries for windows and Linux for you to download. And here is what to do after
you’ve downloaded it.
3
Once you have installed Geth, you can technically connect to the Main or public Ethereum blockchain
Network and run a full ethereum node. But we don’t want to do that just yet because If you are reading
this article, chances are you have no ether (Ethereum’s cryptocurrency) − and without ether you cannot
really do much on the Main blockchain.
What if you have no ether to start with?

Initially when you start the lab, you won’t have any either available, but Ethereum lets you create your own
‘private’ blockchain network, sort of a dev/staging version of the main network. This private network is
exactly like the main Ethereum chain from a functionality standpoint, except any transactions and smart
contracts deployed on this network are only accessible to nodes that are connected t this private network.
So that’s what we’ll do — we will create a private blockchain.
Creating a Private Ethereum Blockchain

Geth enables you to set up a "private" or "testnet" Ethereum blockchain. It is the best way to learn
blockchain concepts that you hear and read about on the internet. You can build smart contracts, make
transactions an even distributed apps − without needing real ether. You can actually CREATE your own
fake ether, preassign ether to your account and then use it to make transactions , transfers or deploy
smart contracts.
Blockchain
Fig. 3: Blockchain and the Genesis Block
As you probably know by now, a blockchain is nothing but a digital ledger in which transactions are
recorded chronologically and publicly. These transactions are recorded in blocks, and nodes in a
distributed network compete to find the next valid block. Once a valid block is found, it is added to the
blockchain, and this information relayed to the network. Every node then updates their blockchain to the
latest copy.
Note: every blockchain starts with a Genesis Block, the very first block in
the chain; block ZERO— the only block that does not have a predecessor.
4
To create our private blockchain then, we will create a genesis block. To do this, we will create a custom
Genesis file, and ask Geth to use that genesis file to create our own genesis block , which in turn will be
the start of our custom private blockchain.
Here’s what a sample Genesis file looks like:
{
"config": {
"chainId": 987,
"homesteadBlock": 0,
"eip155Block": 0,
"eip158Block": 0
},
"difficulty": "0x400",
"gasLimit": "0x8000000", //set this really high for testing
"alloc": {}
}
}
and this is what the attributes mean…
• config: the config block defines the settings for our custom chain and has certain attributes to
create a private blockchain
• chainId: identifies our blockchain, the main Ethereum chain has its own ID, but we will set it to a
unique value for our private chain.
• homesteadBlock: Homestead is the second major version of the Ethereum platform and is the
first production release of Ethereum. It includes several protocol changes. Since we are already
on homestead version, this attribute is 0.
• eip155Block/eip158Block: Homestead version was released with a few backward-

incompatible protocol changes, and therefore requires a hard fork. These protocol
changes/improvements proposed through a process Ethereum Improvement Proposals (EIPs).
Our chain however won’t be hard-forking for these changes, so leave as 0
• difficulty: This value is used to control the Block generation time of a Blockchain. The higher
the difficulty, the statistically more calculations a Miner must perform to discover a valid block.On
our test network, we will keep this value low to avoid waiting during tests, since the generation of
a valid Block is required to execute a transaction on the Blockchain.
• gasLimit: this value specifies current chain-wide limit of 'Gas' expenditure per block. Gas is
Ethereum's fuel that is spent during transactions. We will mark this value high enough in our case
to avoid being limited during tests.
• alloc: This is where you can create your wallet and pre fill it with fake ether. For this post
however, we will mine our ether locally quickly so we don’t use this option.
5
At this point, lets go ahead and create our "myGenesis.json" file. I simply used a text editor and
stored it in a folder on my computer.
Next open terminal and assuming you have installed Geth, simply run this snippet
geth — identity “yourIdentity” — init /path_to_folder/myGenesis.json —

datadir /path_to_your_data_directory/ACPrivateChain
This snippet instructs Geth to use the "myGenesis.json" file you created as to be the first block of your
custom blockchain. Then, we also specify a data directory where our private chain data will be stored.
Geth will create the data directory for you. Just choose a location that is separate from the public
Ethereum chain folder, if you have one
Congratulations!
You just built your first private ethereum blockchain and mined some ether! Lots of details, but I am
hoping some of this made sense, and gave you a little more clarity on how blockchains work.
In the next post, we will add another node to our private blockchain, write and deploy smart contracts and
demonstrate how to call contract.
Part 2: described how to install Ethereum on your computer.

Our development environment requires the setup of a private Ethereum chain.
Note: It is important that what we mean by “private Ethereum blockchain” in this context has
absolutely nothing to do with the “private blockchain” championed by Hyperledger, Eris/Monax, or the
recently announced Enterprise Ethereum Alliance. These are different codebases with different client
applications, so they correspond to different implementations of a different set of concepts. They are
private in the sense that they limit who has access to their chain. They are also called permissioned
blockchains, and to be perfectly transparent, we wish they were not even called blockchains at all. In
this series of articles, what we call “private blockchain” is a private instance of the Ethereum
implementation. Same code base, same client application, different network identifier and genesis
block. In other words, what we will come to create in this series is a chain with the same rules as the
main chain, the same consensus algorithm too, but a different root block. This will become clearer in
part 3. For more information about the 3-layer model and differences between concepts,
implementations and instances, you can also watch our Devoxx talk and read this article.
Our private chain needs miners in order to validate and propagate blocks of transactions within the
blockchain. Miners will also be used to generate ether to pay for the gas required to process transactions
on the Ethereum blockchain. Note that this ether will only be usable within our private blockchain.
Unfortunately, the Raspberry pi is not powerful enough to be used as a miner. The mining process is just
too intense. This is why we will deploy at least two miners on our computer.
6
Why two miners and not only one?

At the time of writing this tutorial, Geth has an issue when it is deployed in a private chain. If you have only
one miner, some transactions will not be processed and will remain pending. Having two miners solves
this issue (check here for more information about the issue). By the way, two miners make sense to apply
the notion of consensus within the blockchain. Let’s start by describing how to create the first miner.
Requirements
Before we describe the steps to start the miners, it is important to understand the requirements for each
node to join the same private blockchain:
• Each node will use a distinct data directory to store the database and the wallet.
• Each node must initialize a blockchain based on the same genesis file.
• Each node must join the same network id different from the one reserved by Ethereum (0 to 3 are
already reserved).
• The port numbers must be different if different nodes are installed on the same computer.
All the operations must be performed from your computer.
Step 1: Create the datadir folder

When running a private blockchain, it is highly recommended to use a specific folder to store the data
(database and wallet) of the private blockchain without impacting the folders used to store the data
coming from the public blockchain.
1. From your computer, create the folder that will host your first miner, assume we want to place the
folder on the Desktop, right-click anywhere on the Desktop, and add name the new folder
PrviaceChain3.
Fig. 4a
Fig. 4b
7
2. Next right-click on the PrivateChain3 folder and open it with Git Bash Here cmd, as shown in Fig.
5
Fig. 5a
Fig. 5b
Step 2: Create the Genesis file

Each blockchain starts with a genesis block that is used to initialize the blockchain and defines the terms
and conditions to join the network.
Note: our genesis block is called "genesis.json" and is stored under PrivateChain3 folder.
3. Create a text file under PrivateChain3, called "genesis.json", with the following content:
{
"config": {
"chainId": 15,
"homesteadBlock": 0,
"eip155Block": 0,
"eip158Block": 0,
"byzantiumBlock": 0
},
"alloc": { },
"coinbase" : "0x0000000000000000000000000000000000000001",
"difficulty" : "0x440",
"extraData" : "",
"gasLimit" : "0x2fefd8",
8
"nonce" : "0x0000000000000042",
"mixhash" :
"0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash" :
"0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp" : "0x00"
}
Note: among the parameters, we have the following ones:

• difficulty: if the value is low, the transactions will be quickly processed within our private
blockchain.
• gasLimit: define the limit of Gas expenditure per block. The gasLimit is set to the maximum to
avoid being limited to our tests.
Step 3: Initialize the private blockchain

It’s time to initialize the private blockchain with the genesis block. (Note: this operation will create the
initial database stored under the data directory dedicated to each miner.)
4. To do this, type the following command to create the blockchain for the first miner:
$ geth --datadir=./chaindata/ init genesis.json
Fig. 6
I1226 00:44:16.572007 cmd/utils/flags.go:615] WARNING: No etherbase set and

no accounts found as default
9
...
I1226 00:44:16.604262 cmd/geth/chaincmd.go:131] successfully wrote genesis
block and/or chain rule set:
6e92f8b23bcdfdf34dc813cfaf1d84b71beac80530506b5d63a2df10fe23a660
Note:
The logs provide the following information:
• you need a default account
• the blockchain has been successfully created
If you list the content of the chaindata folder, you will notice the following subfolders:
• geth: contains the database of your private blockchain (chaindata).
• keystore: location of your wallet used to store the accounts that you will create on this node.
5. Start the geth console, by typing the following command:
$ geth --datadir=./chaindata/ --networkid 15 console 2>> myEth.log
Fig. 7
6. You’re done with this section
Step 4: Create accounts

Create the default account that will be used to run the node. This account will also receive all ethers
created by the miner in the private blockchain. These ethers will serve to test our solutions by paying the
gas required to process each transaction.
7. Now, to create the default account, type the following command. Keep the password in a safe place:
$ geth --datadir=./chaindata/ --networkid 15 account new

INFO [03-12|15:27:12] Maximum peer count ETH=25 LES=0
total=25
Your new account is locked with a password. Please give a password. Do not forget
this password.
!! Unsupported terminal, password will be echoed.
Passphrase: password
Repeat passphrase: password

Address: {e803ad99fbce665c0d71074406be1822460e58f4}
Note: the addresses are highlighted n red color fonts

10
Or graphically as shown in Fig. 8
Fig. 8
Add an additional account for testing purpose:

total=25
this password.
Address: {7712ef60c37f2daca3b7a6c18baeab9e44d91c8f}

total=25
this password.
Address: {f3750459561e7d928a55c1e688ac4788de4343f1}

total=25
this password.

Address: {fbbfff4bdcad3b6104e33098cf2ef30479b0aa04}
8. The wallet for these accounts is located right here:
11
Fig. 11
9. To list all accounts of your node, use the following command:
$ geth --datadir=./chaindata/ --networkid 15 account list
Fig. 9
$ geth --datadir=./chaindata/ --networkid 15 account list

total=25
Account #0: {e803ad99fbce665c0d71074406be1822460e58f4}
keystore://C:\Users\hp\Desktop\PrivateChain3\chaindata\keystore\UTC--2018-03-12T12-
27-34.374749300Z--e803ad99fbce665c0d71074406be1822460e58f4
Account #1: {7712ef60c37f2daca3b7a6c18baeab9e44d91c8f}

28-43.538142400Z--7712ef60c37f2daca3b7a6c18baeab9e44d91c8f
Account #2: {f3750459561e7d928a55c1e688ac4788de4343f1}

29-46.841696300Z--f3750459561e7d928a55c1e688ac4788de4343f1
Account #3: {fbbfff4bdcad3b6104e33098cf2ef30479b0aa04}
31-06.090505700Z--fbbfff4bdcad3b6104e33098cf2ef30479b0aa04
10. Which we can list as follows:
12
Account #0: {e803ad99fbce665c0d71074406be1822460e58f4}

Account #1: {7712ef60c37f2daca3b7a6c18baeab9e44d91c8f}
Account #2: {f3750459561e7d928a55c1e688ac4788de4343f1}
Account #3: {fbbfff4bdcad3b6104e33098cf2ef30479b0aa04}
Check balances before mining

11. Start geth console
12. Get the default account with “eth.coinbase”:
> eth.coinbase
"0xe803ad99fbce665c0d71074406be1822460e58f4"
>
List the accounts with “eth.accounts”:
> eth.accounts
["0xe803ad99fbce665c0d71074406be1822460e58f4",
"0x7712ef60c37f2daca3b7a6c18baeab9e44d91c8f",
"0xf3750459561e7d928a55c1e688ac4788de4343f1",
"0xfbbfff4bdcad3b6104e33098cf2ef30479b0aa04"]
>
Fig. 10
Note: of course, you will find addresses related to your environment.

13
13. Check balances with “eth.getBalance(<account id>)”:
> eth.getBalance(eth.coinbase)
> eth.getBalance("0xe803ad99fbce665c0d71074406be1822460e58f4")
eth.getBalance("0xf3750459561e7d928a55c1e688ac4788de4343f1")
Fig. 11
14. You’re done with this section.
Step 5: Prepare the miners

We are ready to start the miners from our computer and to mine some ethers that will reward our default
accounts.
15. To start the, we will require to run the following command:
$ geth --datadir=./chaindata/ --networkid 15 --mine
14
Fig. 12
Note: mining should start after sometimes as shown in Fig. 12b.
Fig. 12b
15
Fig. 12c
As the mining continues, let’s open a new geth console and attach it the mining one – Not working yet
Note
• You will notice that the server and the mining process start.
• You default account will receive ethers mined by the node.
• If you start Mist, you will see that the default account is rewarded by ethers.
• Remember that these ethers are fake money only available in your private blockchain and not on
the live main chain.
Stop Mining
Stop Mining and let check balance and also send ether
16. Issue ^C command
Checking or Balance and Sending Ether

To check or balance, perform the ollowing procedures:
1. Start the geth console
> eth.getBalance(eth.coinbase)
2.364e+21
>
Or
16
> eth.getBalance("0xe803ad99fbce665c0d71074406be1822460e58f4")
2.364e+21
>
Note: the default account has plenty of ethers obtained during the mining process. We will use
them to test our solutions.
2. You may also use the following command to get the balance in ether:
> web3.fromWei(eth.getBalance(eth.coinbase))
2364
Fig. 13
Note: by default, the balance is expressed in Wei that is the base unit of ether.
Set Password
3. From the geth console issue the following command
> personal.newAccount()
Fig. 14
> personal.newAccount()


"0x09a8f007d0f6af46b70f5e1820945e6d66d23823"
>
> personal.unlockAccount("0xe803ad99fbce665c0d71074406be1822460e58f4","password")
That is:
> personal.unlockAccount("0xe803ad99fbce665c0d71074406be1822460e58f4","password")
true
17
>
Sending ethers
Please ensure that the account is unlocked before performing the next steps, otherwise you’ll get error as
shown below.
Fig. 15
5. From the Geth console, we send 10 ethers from account #0 to account #1:
> eth.sendTransaction({from: eth.accounts[0], to: eth.accounts[1], value:

web3.toWei(10, "ether")})
"0x530a61b4c7560a0285b3c8a2a17e7b06adafc982cc6ff953528c204c77879d0a"
>
Fig. 16
Note: the command returns a transaction hash.
Check Pending Transactions

As the mining process has been stopped, we can review the list of pending transactions:
6. To view pending transactions, type:
> eth.pendingTransactions
18
Fig. 17
Note: we can easily identify the following information:

• The sender address
• The recipient address
• The value to transfer (expressed in Wei)
• The hash of the transaction
• The cost of the transaction (gas x gasPrice) in Wei
7. Let the miner process the transaction:
> miner.start()
true
or exit the exit and then restart the geth console, and then start mining
hp@hp-PC MINGW64 ~/Desktop/PrivateChain3

$ geth --datadir=./chaindata/ --networkid 15 --mine
8. After the mining process has started, stop mining, restart the geth console and proceed with next
steps
hp@hp-PC MINGW64 ~/Desktop/PrivateChain3

9. The transaction is processed:
> eth.pendingTransactions
[]
Note: no pending transaction available.
10. Now check the balance of the recipient account:
19
> web3.fromWei( eth.getBalance(eth.accounts[1]))
10
Note: the recipient address has received 10 ethers.
11. Let’s now check the balance of account #1

> eth.getBalance("0x7712ef60c37f2daca3b7a6c18baeab9e44d91c8f")
Note: which is the same amount send earlier from account #0
12. Congratulations your blockchain miner is properly installed and working beautifully.
Part 3: Install Tools to view your blockchain operations.

1. Point your browser to Here and download and install them.
Ethereum-Wallet-installer-0-9-3.exe
Mist-installer-0-9-3.exe
2. Now open the Ethereum Wallet, you should see Fig. 18.
20
Fig. 18
4. You’re done with this Hands-On Lab.
Congratulations!
You just built your first private ethereum blockchain and mined some ether! Lots of details, but hope that
some of this made sense, and gave you a little more clarity on how blockchains work.
In the next post, we will add another node to our private blockchain, write and deploy smart contracts and
demonstrate how to call contract.
A Creative Common Publication:
-----------------------------------------------
Kefa Rabah is the Founder of The Lake Institute. Kefa is knowledgeable in several fields of Science &
Technology, Information Security Compliance, Blockchain Technology, Distributed Ledger Technology
(DLT) and Project Management, and Renewable Energy Systems. He is also the founder of Global Open
Versity, a place to enhance your educating and career goals using the latest innovations and
technologies.
Fellow us on Twitter: GTS Institute and Kefa Rabah
A Globalopenversity Open Access Technical Academic Publications

Delivering Cutting-edge Technology at your Fingertips in the 21st Century
21

Step-By-Step Guide Building & Deploying A Private Blockchain Network On Windows

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Step-By-Step Guide Building & Deploying A Private Blockchain Network On Windows

Caricato da

Copyright:

Formati disponibili

Global Open Versity Building & Deploying s Private Network on Windows Machine v1.

Global Open Versity

Step-By-Step Guide Building & Deploying

Currency and Digital Assets

Verifiable Data and Smart Contracts

What you’ll have achieved at the end of this Hands-on lab”

2. Create a private network that will share this blockchain

How to Create a Private Ethereum Blockchain from Ground-up?

• Transfer funds between multiple accounts.

Ethereum Setup on Windows & Linux

What if you have no ether to start with?

Creating a Private Ethereum Blockchain

Fig. 3: Blockchain and the Genesis Block

Here’s what a sample Genesis file looks like:

and this is what the attributes mean…

• eip155Block/eip158Block: Homestead version was released with a few backward-

geth — identity “yourIdentity” — init /path_to_folder/myGenesis.json —

Part 2: described how to install Ethereum on your computer.

Why two miners and not only one?

All the operations must be performed from your computer.

Step 1: Create the datadir folder

Step 2: Create the Genesis file

Note: among the parameters, we have the following ones:

Step 3: Initialize the private blockchain

$ geth --datadir=./chaindata/ init genesis.json

I1226 00:44:16.572007 cmd/utils/flags.go:615] WARNING: No etherbase set and

5. Start the geth console, by typing the following command:

$ geth --datadir=./chaindata/ --networkid 15 console 2>> myEth.log

6. You’re done with this section

Step 4: Create accounts

$ geth --datadir=./chaindata/ --networkid 15 account new

Repeat passphrase: password

Note: the addresses are highlighted n red color fonts

Or graphically as shown in Fig. 8

$ geth --datadir=./chaindata/ --networkid 15 account new

Repeat passphrase: password

$ geth --datadir=./chaindata/ --networkid 15 account new

Repeat passphrase: password

$ geth --datadir=./chaindata/ --networkid 15 account new

Repeat passphrase: password

8. The wallet for these accounts is located right here:

9. To list all accounts of your node, use the following command:

$ geth --datadir=./chaindata/ --networkid 15 account list

$ geth --datadir=./chaindata/ --networkid 15 account list

Account #1: {7712ef60c37f2daca3b7a6c18baeab9e44d91c8f}

Account #2: {f3750459561e7d928a55c1e688ac4788de4343f1}

10. Which we can list as follows:

Account #0: {e803ad99fbce665c0d71074406be1822460e58f4}

Check balances before mining

$ geth --datadir=./chaindata/ --networkid 15 console 2>> myEth.log

12. Get the default account with “eth.coinbase”:

List the accounts with “eth.accounts”:

Note: of course, you will find addresses related to your environment.

13. Check balances with “eth.getBalance(<account id>)”:

14. You’re done with this section.

Step 5: Prepare the miners

15. To start the, we will require to run the following command:

$ geth --datadir=./chaindata/ --networkid 15 --mine

Note: mining should start after sometimes as shown in Fig. 12b.

16. Issue ^C command

Checking or Balance and Sending Ether

1. Start the geth console

!! Unsupported terminal, password will be echoed.