quarta-feira, 17 de maio de 2017

Blockchain chaincode para desenvolvedores Java – parte 01a

Por Steve Perry
Em 08/05/2017 no site iMasters.

Você provavelmente já ouviu falar sobre blockchain, mas talvez você não tenha certeza de como ele se aplica a você enquanto um desenvolvedor Java. Este tutorial irá esclarecer qualquer confusão. Em uma abordagem passo a passo, vou mostrar como usar o Hyperledger Fabric v0.6 para criar, executar e realizar contratos inteligentes, ou chaincode, escritos na linguagem Java. Você instalará ferramentas, definirá sua rede de blockchain local e, finalmente, criará e executará um contrato inteligente de chaincode.

Pré-requisitos

Para este tutorial, presumo que você tem os seguintes pré-requisitos:
  • Você já ouviu falar de blockchain ou do framework Hyperledger Fabric
  • Você possui conhecimento e experiência intermediária em programação Java tanto com a linguagem quanto com a plataforma
  • Você está familiarizado com ou (idealmente) proficiente em usar:
  • Eclipse IDE
  • Docker e Docker Compose
  • Gradle
  • Linha de comando do Linux
  • SoapUI ou outro software de cliente HTTP, como o Postman
Você também deve estar confortável instalando software em seu computador com mínima orientação. No que concerne a espaço, eu não estou incluindo instruções detalhadas de instalação para todo o software que você precisa; os sites onde você pode obter o software fornecem instruções de instalação.
Antes de mergulhar neste tutorial, quero falar um pouco sobre blockchain.

Princípios do Blockchain

Blockchain está no hype, mas é bem merecido. Não é só a tecnologia em si que é legal, ela é perturbadora e tem o potencial de revolucionar a forma como negócios são feitos na Internet.
Como? Bem, vamos pensar sobre os atributos fundamentais de um acordo de negócio bem-sucedido:
  • Confiança: Temos um acordo, mas posso realmente confiar que você irá honrá-lo (ou me honrar)?
  • Transparência: Permite um olhar “por trás dos panos” (o que pode tanto construir a confiança como diminuir a necessidade dela).
  • Responsabilidade: Define critérios para determinar se todas as partes concordam que o negócio foi honrado ou não.
A saúde de qualquer relacionamento comercial entre duas ou mais partes significará níveis variáveis dos três atributos acima (por exemplo, mais confiança significa menos transparência exigida, e vice-versa), mas um pouco de todos eles deve estar presente, ou haverá problemas.
Como o blockchain ajuda? Em primeiro lugar, através da utilização de um framework comum, os parceiros de negócios podem estabelecer uma rede de confiança inicial. Em seguida, através do uso de um ledger que é visível para todas as partes empresariais, blockchain fornece transparência. Finalmente, através do uso do consenso de todas as partes na forma de contratos inteligentes (ou chaincode), há responsabilidade.
Então, o que isso significa para você enquanto um desenvolvedor Java?
O rápido crescimento da comunidade Hyperledger e da Hyperledger Fabric significa que a tecnologia blockchain está rapidamente chegando em um projeto de desenvolvimento de software perto de você. Você estará preparado?

O panorama da tecnologia blockchain

Às vezes, a tecnologia de desenvolvimento pode atrapalhar a solução do problema empresarial. Meu objetivo principal neste tutorial é mostrar-lhe como escrever chaincode em Java, então eu escolhi a pilha de desenvolvimento mais simples para esse fim.
Dito isto, existem outras opções para os componentes da pilha. Para este tutorial, usarei o Docker como o ambiente de contêiner de rede, mas outra opção é Vagrant com VirtualBox. Se você nunca usou Vagrant, você deveria pelo menos experimentá-lo.
Considerando que Docker é um ambiente de contêiner, Vagrant usa a virtualização. Quando combinado com VirtualBox, um ambiente de virtualização fornece um nível diferente de controle sobre o ambiente computacional que alguns desenvolvedores preferem (o que o torna uma escolha ideal para desenvolvedores do fabric).
Se você está com a impressão de que o panorama da tecnologia blockchain é muito fluida no momento, você está correto. No entanto, isso significa que você está entrando em blockchain e chaincode no momento certo: no piso térreo. Como esta tecnologia amadurece, o seu investimento em aprendê-la nesta fase inicial vai pagar belos dividendos no caminho.
Blockchain é uma dessas tecnologias disruptivas que tem o potencial de revolucionar a maneira como todos fazem negócios. Não apenas B2B, mas B2C e, eventualmente, C2C. Este é um momento muito emocionante, de fato.
Vamos começar!

Configure o seu ambiente de desenvolvimento

Para executar o chaincode, primeiro você precisa configurar o seu ambiente de desenvolvimento.
Depois de concluir esta seção, você estará pronto para executar um dos exemplos do chaincode do Hyperledger Java, onde você implantará e invocará transações no chaincode real. Depois disso, vou mostrar-lhe como escrever um novo programa chaincode do zero (bem, quase).
Nesta seção você irá:
  1. Configurar o ambiente de rede – para executar a sua rede blockchain local.
  2. Instalar o software de compilação – para fazer o build do seu chaincode.
  3. Instalar um cliente HTTP – para invocar transações no seu chaincode.
  4. Iniciar a rede blockchain.
  5. Construir o cliente JAR Java shim.
Não vou mentir para você; há um pouco de trabalho de configuração a ser feito para escrever chaincode. Mas se você seguir estas instruções e aplicar um pouco de diligência, valerá a pena.

1. Configure o ambiente de rede

Neste tutorial, você usará o Docker, junto com as imagens de componentes de rede blockchain pré-construídas do Docker Hub, para executar sua rede blockchain local. Você poderia construir o fabric a partir do zero se você quisesse (é código aberto, afinal), mas nesta fase, é mais fácil usar as imagens pré-construídas Hyperledger Fabric disponíveis no Docker Hub.
Como mencionei na introdução, outra opção (e você pode ver nos documentos do Hyperledger) é usar Vagrant e VirtualBox. Vagrant é uma ótima opção para os desenvolvedores de fabric, embora como desenvolvedores de chaincode, estarmos mais preocupados com a construção, execução e teste de nosso chaincode do que trabalhar com o fabric em si.
Se você já tem a versão 1.12 ou superior do Docker instalada, você pode pular para a próxima parte. Nas instruções que seguem, eu entenderei que você não tem o Docker instalado (isto é, você não está atualizando de uma versão anterior do Docker). A instalação do Docker também instalará o Docker Compose, uma ferramenta para definir e executar aplicativos que exigem vários contêineres, assim como a rede de blockchain Hyperledger local que você executará neste tutorial o faz.

Instale o Docker

Instruções de instalação para Mac, Windows e Linux podem ser encontradas aqui: Docker em Mac, Windows e Linux

Verifique a instalação do Docker

Para testar a sua instalação do Docker, abra uma janela de terminal (ou prompt de comando no Windows) e digite os seguintes comandos:
1docker -v
2docker-compose -v
Você deve obter um resultado como este:
1$ docker -v
2Docker version 1.13.1, build 092cba3
3$ docker-compose -v
4docker-compose version 1.11.1, build 7c5d5e4
Se você quiser ver Docker em ação, você pode executar a imagem de hello-world assim:
1$ docker run hello-world
2Unable to find image 'hello-world:latest' locally
3latest: Pulling from library/hello-world
478445dd45222: Pull complete
5Digest: sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7
6Status: Downloaded newer image for hello-world:latest
7  
8Hello from Docker!
9This message shows that your installation appears to be working correctly.
10  
11To generate this message, Docker took the following steps:
12 1. The Docker client contacted the Docker daemon.
13 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
14 3. The Docker daemon created a new container from that image which runs the
15    executable that produces the output you are currently reading.
16 4. The Docker daemon streamed that output to the Docker client, which sent it
17    to your terminal.
18  
19To try something more ambitious, you can run an Ubuntu container with:
20 $ docker run -it ubuntu bash
21  
22Share images, automate workflows, and more with a free Docker ID:
24  
25For more examples and ideas, visit:

2. Instale o software de compilação

Para o sistema de compilação, o Hyperledger Fabric utiliza Gradle, e você usará isso também para este tutorial. O Gradle é um sistema de automação de compilação que combina sintaxe simples para especificar componentes de compilação, juntamente com os melhores recursos do Apache Ant e do Apache Maven para criar um poderoso sistema de compilação fácil de usar. Não é de admirar que muitos desenvolvedores estejam mudando seus projetos para Gradle.
Leia mais sobre o Gradle (e alguns de seus usuários de alto perfil) na página principal do Gradle.

Instale o Gradle

Para instalar o Gradle, siga as instruções para Mac, Windows e Linux

Verifique a instalação do Gradle

Para verificar a sua instalação do Gradle, abra uma janela de terminal e execute este comando:
1gradle -v
Você deve obter um resultado como este:
1$ gradle -v
2  
3------------------------------------------------------------
4Gradle 3.3
5------------------------------------------------------------
6  
7Build time:   2017-01-03 15:31:04 UTC
8Revision:     075893a3d0798c0c1f322899b41ceca82e4e134b
9  
10Groovy:       2.4.7
11Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015
12JVM:          1.8.0_102 (Oracle Corporation 25.102-b14)
13OS:           Mac OS X 10.12.3 x86_64

3. Instale um cliente HTTP

O próximo passo é o software de cliente HTTP, que permite que o seu chaincode se comunique com a interface REST do Hyperledger blockchain fabric. Seu navegador pode emitir um HTTP GET, mas para interagir com o fabric você precisa ser capaz de fazer POST nas mensagens. Isso significa que você precisa de um cliente HTTP.
O cliente HTTP que eu escolhi para este tutorial é SoapUI, que fornece uma edição comunitária livre que é poderosa, fácil de usar e contém muitos recursos.

Instale o SoapUI

Para instalar o SoapUI, siga as instruções de instalação para Mac OS, Windows e Linux

Verifique a instalação do SoapUI

Para verificar se o SoapUI está instalado, inicie o aplicativo em seu computador. No Mac OS, o SoapUI deve abrir para a Página Inicial do SoapUI, mostrada na Figura 1.

4. Inicie a rede de blockchain

Agora que você instalou o software necessário para desenvolver e testar o seu chaincode, é hora de iniciar sua rede de blockchain local. O primeiro passo é definir a configuração da rede.
Primeiro, crie um diretório que servirá como a raiz de todo o código fonte que você usará para o desenvolvimento do chaincode. Neste tutorial, usarei ~/home/mychaincode (ou C:\home\chaincode no Windows).
Em seguida, defina a variável de ambiente GOPATH para este caminho. Não estaremos compilando nenhum código Go, nem construindo pacotes Golang ou outros binários, mas a terminologia Golang é criada em Hyperledger. Então, é uma boa ideia ficar confortável com o pensar em termos da linguagem Go e do GOPATH.
O GOPATH
 
O Hyperledger Fabric é escrito em Go, e o GOPATH é um termo que você verá frequentemente nos documentos do Hyperledger. Então, se você planeja fazer muito desenvolvimento de chaincode usando o Hyperledger, você deve se sentir confortável com ele.
 
O GOPATH é a raiz do seu ambiente Go. Código fonte, binários e outros pacotes Golang são todos referenciados em relação a este caminho.
No Linux, você executaria este comando:
1export GOPATH=~/home/mychaincode
Ou no Windows, você deve usar algo como:
1SET GOPATH=C:\home\mychaincode
Em seguida, você deve informar ao Docker Compose como compor e executar a rede de blockchain. A definição da rede está em YAML, e você deve nomeá-la docker-compose.yml. Você pode chamar o arquivo de outra coisa, mas quando você inicia o Docker Compose, você deve especificar o sinalizador -f. Eu recomendo permanecer com o padrão, que é docker-compose.yml.
Crie o arquivo docker-compose.yml na raiz do seu GOPATH. Cole os seguintes conteúdos:
1membersrvc:
2  image: hyperledger/fabric-membersrvc
3  ports:
4    - "7054:7054"
5  command: membersrvc
6vp0:
7  image: hyperledger/fabric-peer
8  ports:
9    - "7050:7050"
10    - "7051:7051"
11    - "7053:7053"
12  environment:
13    - CORE_PEER_ADDRESSAUTODETECT=true
14    - CORE_VM_ENDPOINT=unix:///var/run/docker.sock
15    - CORE_LOGGING_LEVEL=DEBUG
16    - CORE_PEER_ID=vp0
17    - CORE_PEER_PKI_ECA_PADDR=membersrvc:7054
18    - CORE_PEER_PKI_TCA_PADDR=membersrvc:7054
19    - CORE_PEER_PKI_TLSCA_PADDR=membersrvc:7054
20    - CORE_SECURITY_ENABLED=false
21    - CORE_SECURITY_ENROLLID=test_vp0
22    - CORE_SECURITY_ENROLLSECRET=MwYpmSRjupbT
23  links:
24    - membersrvc
25  command: sh -c "sleep 5; peer node start --peer-chaincodedev"
Há muita coisa acontecendo aqui, a maioria delas está além do escopo deste tutorial, mas eu quero explicar algumas coisas.
Esse arquivo diz ao Docker Compose para definir dois serviços:
  • membersrvc: O node de serviços integrantes que fornece serviços de associação, especificamente uma autoridade de certificação/certificate authority (CA), que é responsável pelo manuseio de toda a logística criptográfica (como emissão e revogação de certificados). A imagem Docker pré-construída que você usará para isso é chamada hyperledger/fabric-membersrvc.
  • vp0: O único node de pares de validação na rede. Para fins de desenvolvimento, não precisamos de uma rede de pares de validação extravagante; um único par será suficiente. A imagem Docker pré-construída que você usará para isso é chamada de hyperledger/fabric-peer.
Um grande número de variáveis de ambiente são definidas pelo par vp0. Repare que a variável CORE_LOGGING_LEVEL está definida como DEBUG. Isso produz uma grande quantidade de resultado, que pode ser útil às vezes. No entanto, se desejar menos resultado, altere o nível para INFO. Consulte “Controle de log” nos documentos de Configuração do Hyperledger para obter mais informações sobre os níveis de log.
Mais informações podem ser encontradas sobre a definição do arquivo Docker Compose YML no site do Docker.
Em seguida, repare que o valor CORE_SECURITY_ENABLED é false. Isso significa que o fabric não exigirá que você envie qualquer tipo de credenciais de usuário final. A segurança está além do escopo deste tutorial, mas se você estiver interessado em aprender mais, você pode verificar esta nota sobre a funcionalidade de segurança para suas solicitações chaincode.
Finalmente, uma palavra de cautela: alterar qualquer um desses valores de seus padrões (especialmente os valores de porta) pode fazer com que os exemplos neste tutorial não funcionem. Uma rede de blockchain é um conjunto de componentes de software distribuídos que requerem uma comunicação coordenada precisa. Eu recomendo que você não altere os valores de porta de seus valores padrão até que você entenda como todos os componentes do fabric interoperam.
Agora que a definição de rede blockchain está feita, você está pronto para iniciar sua rede blockchain local. Para fazer isso, execute Docker Compose. Navegue até o seu $GOPATH e execute este comando:
1docker-compose up
Você deve obter resultado na janela do terminal como este:
1$ docker-compose up
2.
3.
4Pulling membersrvc (hyperledger/fabric-membersrvc:latest)...
5latest: Pulling from hyperledger/fabric-membersrvc
6.
7.
8Status: Downloaded newer image for hyperledger/fabric-membersrvc:latest
9Pulling vp0 (hyperledger/fabric-peer:latest)...
10latest: Pulling from hyperledger/fabric-peer
11.
12.
13Status: Downloaded newer image for hyperledger/fabric-peer:latest
14Creating mychaincode_membersrvc_1
15Creating mychaincode_vp0_1
16Attaching to mychaincode_membersrvc_1, mychaincode_vp0_1
17vp0_1         | 19:30:03.773 [logging] LoggingInit -> DEBU 001 Setting default logging level to DEBUG for command 'node'
18vp0_1         | 19:30:03.773 [nodeCmd] serve -> INFO 002 Running in chaincode development mode
19.
20.
21.
22vp0_1         | 19:30:04.146 [peer] chatWithSomePeers -> DEBU 07c Starting up the first peer of a new network
23vp0_1         | 19:30:04.146 [consensus/statetransfer] verifyAndRecoverBlockchain -> DEBU 07d Validating existing blockchain, highest validated block is 0, valid through 0
24vp0_1         | 19:30:04.146 [consensus/statetransfer] blockThread -> INFO 07e Validated blockchain to the genesis block
25vp0_1         | 19:30:04.146 [consensus/handler] 1 -> DEBU 07f Starting up message thread for consenter
26vp0_1         | 19:30:04.146 [nodeCmd] serve -> INFO 080 Starting peer with ID=name:"vp0" , network ID=dev, address=172.17.0.3:7051, rootnodes=, validator=true
27vp0_1         | 19:30:04.146 [rest] StartOpenchainRESTServer -> INFO 081 Initializing the REST service on 0.0.0.0:7050, TLS is disabled.
28vp0_1         | 19:30:04.147 [peer] ensureConnected -> DEBU 082 Starting Peer reconnect service (touch service), with period = 6s
29.
30.
Este resultado informa que a rede está funcionando e em execução, e pronta para aceitar solicitações de registro de chaincode.
Nota: as linhas realçadas só devem aparecer na primeira vez que você executar sua rede blockchain, porque Docker tem que baixar as imagens do Docker Hub. Uma vez que elas estão baixadas no seu computador, Docker só as puxará se as imagens do Docker Hub forem mais recentes do que as que você tem no seu computador.
Agora você está pronto para construir o cliente JAR Java shim, que permite que o seu chaincode de linguagem Java se comunique com o framework Hyperledger Fabric.

5. Crie o cliente JAR Java shim

Antes de poder executar os exemplos chaincode, você precisa obter o código-fonte mais recente do repositório GitHub da Hyperledger.
Primeiro, você precisará clonar o Hyperledger Fabric em sua máquina local para construir o seu chaincode (Nota: Esta é uma medida temporária; em algum momento, o cliente JAR Java shim deverá ser acessível a partir do repositório Maven central).
Nota: Lembre-se de que você configurou seu GOPATH para ~/home/mychaincode no Linux (ou Mac) ou C:\home\mychaincode no Windows.
Execute este comando para criar a estrutura de diretórios que os scripts de build de fabric esperados:
1mkdir -p $GOPATH/src/github.com/hyperledger
Em seguida, navegue até a parte inferior da nova estrutura de diretórios que você criou:
1cd $GOPATH/src/github.com/hyperledger
A partir daqui você precisa recuperar o código-fonte do Hyperledger para que você possa construir o cliente JAR Java shim.
Há duas maneiras de acessar a fonte Hyperledger.
  • Sem git: navegue até o espelho do Hyperledger no GitHub e clique no botão Clone ou download e depois Download ZIP (veja a Figura 2). Um arquivo ZIP chamado fabric-master.zip será baixado para o seu computador, que você pode extrair para $GOPATH/src/github.com/hyperledger. Nota: certifique-se de alterar o nome do diretório raiz do fabric-master para fabric quando você extrair o arquivo.
  • Com git: navegue até $GOPATH/src/github.com/hyperledger, copie o URL do campo de texto na caixa “Clone com HTTPS” (ver Figura 2) e execute este comando usando o URL copiado:
Você deve ver o resultado da janela de terminal como este do comando git:
2Cloning into 'fabric'...
3remote: Counting objects: 29272, done.
4remote: Compressing objects: 100% (128/128), done.
5remote: Total 29272 (delta 55), reused 0 (delta 0), pack-reused 29142
6Receiving objects: 100% (29272/29272), 44.95 MiB | 5.67 MiB/s, done.
7Resolving deltas: 100% (16671/16671), done.
Figura 2. Espelho Hyperledger no GitHub
Agora você está pronto para criar o cliente JAR shim do chaincode Java. Navegue até $GOPATH/src/github.com/hyperledger/fabric/core/chaincode/shim/java e execute estes dois comandos:
1gradle -b build.gradle clean
2gradle -b build.gradle build
O resultado de compilação Gradle deve ficar assim:
1$ cd $GOPATH/src/github.com/hyperledger/fabric/core/chaincode/shim/java
2$ gradle -b build.gradle clean
3Starting a Gradle Daemon (subsequent builds will be faster)
4:core:chaincode:shim:java:clean
5  
6BUILD SUCCESSFUL
7  
8Total time: 5.422 secs
9$ gradle -b build.gradle build
10:core:chaincode:shim:java:copyProtos UP-TO-DATE
11:core:chaincode:shim:java:extractIncludeProto
12:core:chaincode:shim:java:extractProto UP-TO-DATE
13:core:chaincode:shim:java:generateProto UP-TO-DATE
14:core:chaincode:shim:java:compileJava
15:core:chaincode:shim:java:processResources
16:core:chaincode:shim:java:classes
17:core:chaincode:shim:java:jar
18:core:chaincode:shim:java:assemble
19:core:chaincode:shim:java:extractIncludeTestProto
20:core:chaincode:shim:java:extractTestProto UP-TO-DATE
21:core:chaincode:shim:java:generateTestProto UP-TO-DATE
22:core:chaincode:shim:java:compileTestJava UP-TO-DATE
23:core:chaincode:shim:java:processTestResources UP-TO-DATE
24:core:chaincode:shim:java:testClasses UP-TO-DATE
25:core:chaincode:shim:java:test UP-TO-DATE
26:core:chaincode:shim:java:check UP-TO-DATE
27:core:chaincode:shim:java:build
28:core:chaincode:shim:java:copyToLib
29:core:chaincode:shim:java:generatePomFileForMavenJavaPublication
30:core:chaincode:shim:java:publishMavenJavaPublicationToMavenLocal
31:core:chaincode:shim:java:publishToMavenLocal
32  
33BUILD SUCCESSFUL
34  
35Total time: 4.521 secs
A última coisa que a compilação faz é adicionar o cliente JAR shim ao seu repositório Maven local. Neste ponto, você está pronto para criar o seu chaincode. A menos que você atualize o código fonte do fabric em algum momento no futuro, ou apenas queira reconstruir o cliente JAR shim novamente por algum motivo, você não terá que executar o cliente JAR Java shim compilado novamente.


Nenhum comentário:

Postar um comentário