Conteúdo


Implemente um aplicativo de amostra no IBM Blockchain Platform

Entre em funcionamento rapidamente com o Enterprise Membership Plan

Comments

Neste tutorial, veja como criar uma rede no IBM Blockchain Platform, instalar um contrato inteligente (chaincode) em um canal na rede e implementar um aplicativo de amostra nele. Você verá como preencher o livro-razão compartilhado e comunicar-se com ele fazendo chamadas de um aplicativo cliente local para consultar e atualizar o livro razão.

O IBM Blockchain Platform, antigo High Security Business Network (HSBN), é um serviço corporativo totalmente integrado em execução na Nuvem IBM. A plataforma foi projetada para acelerar o desenvolvimento, o controle e a operação de uma rede de negócios com diversas instituições.

O aplicativo de amostra que usaremos neste tutorial é uma amostra do Hyperledger Fabric chamada "fabcar" e, embora você possa executá-la localmente em um contêiner do Docker, neste tutorial você verá como instalar esse aplicativo e executá-lo no IBM Blockchain Platform na Nuvem IBM. Hyperledger é uma iniciativa colaborativa, global, de software livre, hospedada pela Linux Foundation, para promover tecnologias blockchain para vários segmentos de mercados. Hyperledger Fabric é um projeto e uma implementação de estrutura da Hyperledger cuja arquitetura modular capacita o IBM Blockchain Platform.

1

Crie uma rede no IBM Blockchain Platform

Para concluir este tutorial, é necessária uma conta da Nuvem IBM e uma assinatura paga do Enterprise Membership Plan do IBM Blockchain Platform, o que permitirá que você ative uma rede de blockchain na produção. Observe que o Platform é atualizado com frequência e as capturas de tela neste tutorial poderão não corresponder exatamente àquelas que você vê.

  1. Iniciando na página Desenvolva rapidamente com o IBM Blockchain Platform , selecione Planos de Serviço. Em seguida, clique em Fazer Upgrade (se você já tiver uma conta para teste) ou Criar (se você não tiver uma conta para teste). Agora é possível ver a tela de boas-vindas. Clique em Criar Rede para ver o painel para sua rede. Welcome screen
    Welcome screen
  2. Agora é possível ver o assistente para Criar Rede. Preencha o assistente. Create network wizard
    Create network wizard
  3. Na página seguinte, é possível convidar membros incluindo o nome da instituição e o endereço de e-mail. No entanto, para este tutorial, não será necessário convidar nenhum membro; basta clicar em Avançar. Na próxima página, é possível aceitar as regras e políticas de controle padrão clicando em Avançar. Na última página, é possível revisar o resumo dos detalhes fornecidos e clicar em Concluído.
  4. Quando tiver concluído, você verá uma página de resumo; clique em Entrar na Rede para obter uma visão geral de sua rede de blockchain e dos recursos que acabou de criar. The network dashboard page
    The network dashboard page
  5. Clique em Incluir Peers na página Visão Geral e inclua o número de peers. Para este tutorial, 2 peers são suficientes. The add peers page
    The add peers page
  6. Os peers agora aparecerão na página Visão Geral. Added peers on the resources page
    Added peers on the resources page
2

Crie um canal

A próxima etapa é criar um canal chamado "fabcar". Um canal é um agrupamento lógico de peers selecionados na rede de blockchain. Um canal permite que peers associados a esse canal vejam as transações uns dos outros, mas peers fora do canal não podem ver essas transações. Ele fornece um nível de privacidade e segurança da transação entre os peers. Cada canal pode ter um chaincode igual ou diferente instanciado, com base nas necessidades de negócios.

  1. Na rede de blockchain, clique na guia Canais à esquerda e selecione Criar Canal. Insira o nome do canal fabcar e, em seguida, clique em Avançar. The Create a new channel page
    The Create a new channel page
  2. Designe uma função a cada membro e clique em Avançar. Certifique-se de que todas as opções estejam selecionadas para essa etapa. The select members and set roles subpage
    The select members and set roles subpage
  3. Revise a política de atualização do canal e clique em Enviar Solicitação. The review channel update policy subpage
    The review channel update policy subpage
  4. Você localizará uma notificação na guia Notificações . Selecione a caixa de seleção Solicitação de Canal e clique em Revisar Solicitação. The Notifications tab
    The Notifications tab
  5. Revise a política e os membros do canal. Clique em Aceitar para aceitar o convite do canal. The channel invitation for fabcar
    The channel invitation for fabcar
  6. Na guia Notificações , selecione o canal e clique em Enviar Solicitação. The invite was accepted
    The invite was accepted
  7. Selecione a guia Canais e clique em Enviar. Join peers to this                     channel
    Join peers to this channel
  8. Clique em Associar Peers na guia Canais . List of peers
    List of peers
  9. Selecione os peers que devem se associar a esse canal. Clique em Incluir Selecionado. List of peers
    List of peers
  10. Agora é possível ver que o canal foi criado. List of channels
    List of channels
3

Instale o chaincode no canal

Após a criação do canal, a próxima etapa é instalar o chaincode. Usaremos o chaincode do aplicativo de amostra "fabcar".

  1. Para obter o chaincode, siga as instruções para "Obter uma Rede de Teste" ou git clone este repositório:
    git clone https://github.com/hyperledger/fabric-samples.git
  2. Para instalar o chaincode, selecione a guia Chaincode , escolha um peer e clique em Instalar chaincode. Insira "fabcar" para o nome do chaincode, insira "v3" para a versão do chaincode e clique em Escolher Arquivos para selecionar o arquivo de chaincode fabcar.go na pasta fabric-samples/chaincode/fabcar transferida por download do GitHub. Clique em Enviar. Install chaincode page
    Install chaincode page
  3. O chaincode agora está instalado no peer. Completed chaincode
    Completed chaincode
  4. A próxima etapa é instanciar o chaincode em um canal chamando o método init do chaincode. Para esta etapa, nenhum argumento é necessário, então você pode simplesmente escolher o canal fabcar e deixar o campo de argumentos vazio. Instantiate the chaincode page
    Instantiate the chaincode page
  5. O chaincode instanciado será semelhante a este: The chaincode list
    The chaincode list
  6. Quando o chaincode tiver sido instanciado no canal, selecione a guia lateral Canais e escolha a opção Chaincode . Será possível, então, ver três botões sob fabcar:
    • JSON: este arquivo JSON contém as informações de credenciais e peer para a rede de blockchain.
    • Logs: todos os logs do chaincode são impressos aqui.
    • Excluir: isto exclui/para a instância do chaincode.
    The channel activity and configuration page
    The channel activity and configuration page

    Na pasta fabric-samples/fabcar, crie uma nova pasta chamada config. Clique no botão JSON e uma nova guia será aberta. Copie todos os dados mostrados nesta guia em um novo arquivo chamado blockchain_creds.json e salve este arquivo dentro da pasta config.

4

Configure seu aplicativo para execução no IBM Blockchain Platform

Para executar seu aplicativo no IBM Blockchain Platform, é necessário fazer algumas mudanças na amostra fabcar.

Comece copiando os arquivos extractCerts.js e enrollUser.js na raiz da pasta fabcar, fabric-samples/fabcar.

Execute npm install

Execute npm install dentro da pasta fabcar:

cd fabric-samples/fabcar
npm install

No Windows, pode ser necessário instalar o Windows Build Tools se forem obtidos erros:
npm install --global windows-build-tools

Extraia certificados

No IBM Blockchain Platform, a Segurança da Camada de Transporte (TLS) está ativada e, portanto, é necessário extrair os certificados TLS fornecidos pelo serviço para que você possa estabelecer uma conexão seguindo essas etapas.

Crie um diretório chamado network no diretório fabcar e, em seguida, execute extractCerts.js conforme mostrado abaixo. Isso criará um certificado de autoridade de certificação e um certificado de peer no caminho especificado ou, por padrão, na pasta ./network/tls dentro do diretório fabcar. Por padrão, isso levará a entrada de /config/blockchain_creds.json para o diretório fabcar.

node extractCerts.js

ou

node extractCerts.js --input= /config/blockchain_creds.json --cert_path=./network/tls

Além de criar os arquivos de certificado, este comando gera um EnrollId, um EnrollSecret e uma CA_URL a serem usados na próxima etapa. Ele também gera três URLs a serem usadas a seguir para inscrever usuários (peer-url, peer-event-url e orderer-url).

Inscrever usurários

Usando EnrollId, EnrollSecret e CA_URL da seção prévia, execute o comando a seguir. Isso gerará um certificado no caminho de carteira eletrônica fornecido para o usuário especificado.

node enrollUser.js --wallet_path=./network/creds --user_id=admin --user_secret=secret --ca_url=https://fft-zbcxxx.4.secure.blockchain.ibm.com:15185

Inicialize o chaincode

Antes que seja possível consultar e atualizar o livro razão, é necessário executar uma transação de configuração para preencher o livro-razão com alguns dados de amostra. Faça uma cópia do arquivo invoke.js que está na pasta fabric-samples/fabcar e chame a cópia de invokeNetwork.js. Certifique-se de que a cópia esteja na mesma pasta que o arquivo original. Em seguida, faça as seguintes mudanças no comando invokeNetwork.js .

  1. Inclua o parâmetro require a seguir logo abaixo da variável util .
    var fs = require("fs")
  2. Modifique a variável options conforme mostrado abaixo. Certifique-se de atualizar os campos peer_url, event-url e orderer-url com os valores que foram retornados da execução de extractCerts.js acima.
    var options = {
        wallet_path: path.join(__dirname, './network/creds'),
        user_id: 'admin',
        channel_id: 'fabcar',
        chaincode_id: 'fabcar',
        peer_url: '<peer_url>',
        event_url: '<peer-event-url>',
        orderer_url: '<orderer-url>',
        tls_cert: {
            pem: fs.readFileSync(path.join(__dirname, './network/tls') + '/peer.cert').toString(),
        }
    };
  3. Para ativar o TLS, substitua este código:
    var peerObj = client.newPeer(options.peer_url);

    por:

    var peerObj = client.newPeer(options.peer_url, {
        pem: options.tls_cert.pem
    });
  4. Substitua este código:
    channel.addOrderer(client.newOrderer(options.orderer_url));

    por:

    channel.addOrderer(client.newOrderer(options.orderer_url, {
        pem: options.tls_cert.pem
    }));
  5. Substitua este código:
    eh.setPeerAddr(options.event_url);

    por:

    eh.setPeerAddr(options.event_url, {
        pem: options.tls_cert.pem
    });
  6. Por fim, mude o valor do campo fcn na variável request de createCar para initLedger e torne args uma array vazia. A variável da solicitação mudada agora deve ser semelhante ao seguinte:
    var request = {
            targets: targets,
            chaincodeId: options.chaincode_id,
            fcn: 'initLedger',
            args: [''],
            chainId: options.channel_id,
            txId: tx_id
    };
  7. Agora salve o arquivo e execute o novo comando usando node invokeNetwork.js. A saída esperada é:
    …
    Successfully sent transaction to the orderer.

Consulte o livro razão

O comando invokeNetwork.js agora preencheu o livro-razão com alguns dados de amostra, portanto, vamos consultar o livro-razão para ver os dados. Faça uma cópia do arquivo query.js que está na pasta fabric-samples/fabcar e chame a cópia de queryNetwork.js. Certifique-se de que a cópia esteja na mesma pasta que o arquivo original. Em seguida, faça as seguintes mudanças no comando queryNetwork.js .

  1. Inclua o parâmetro require a seguir logo abaixo da variável path .
    var fs = require("fs")
  2. Modifique a variável options conforme mostrado abaixo. Certifique-se de atualizar o valor do campo network_url com o valor de peer_url que foi retornado da execução de extractCerts.js acima.
    var options = {
        wallet_path: path.join(__dirname, './network/creds'),
        user_id: 'admin',
        channel_id: 'fabcar',
        chaincode_id: 'fabcar',
        network_url: '<peer_url>',
        tls_cert: {
            pem: fs.readFileSync(path.join(__dirname, './network/tls') + '/peer.cert').toString(),
        }
    };
  3. Substitua este código:
    channel.addPeer(client.newPeer(options.network_url));

    por:

    channel.addPeer(client.newPeer(options.network_url, {
        pem: options.tls_cert.pem
    }));

    Agora salve o arquivo e execute o novo comando usando node queryNetwork.js. A saída esperada é:

    …
    Query result count =  1
    Response is  [{"Key":"CAR0","Record":{"make":"Toyota","model":"Prius","colour":"blue","owner":"Tomoko"}},{"Key":"CAR1","Record":{"make":"Ford","model":"Mustang","colour":"red","owner":"Brad"}},{"Key":"CAR10","Record":{"make":"","model":"","colour":"","owner":"Tom"}},{"Key":"CAR11","Record":{"make":"Honda","model":"Accord","colour":"Black","owner":"yog"}},{"Key":"CAR12","Record":{"make":"Honda","model":"Accord","colour":"Black","owner":"Tom"}},{"Key":"CAR2","Record":{"make":"Hyundai","model":"Tucson","colour":"green","owner":"JinSoo"}},{"Key":"CAR3","Record":{"make":"Volkswagen","model":"Passat","colour":"yellow","owner":"Max"}},{"Key":"CAR4","Record":{"make":"Tesla","model":"S","colour":"black","owner":"Adriana"}},{"Key":"CAR5","Record":{"make":"Peugeot","model":"205","colour":"purple","owner":"Michel"}},{"Key":"CAR6","Record":{"make":"Chery","model":"S22L","colour":"white","owner":"Aarav"}},{"Key":"CAR7","Record":{"make":"Fiat","model":"Punto","colour":"violet","owner":"Pari"}},{"Key":"CAR8","Record":{"make":"Tata","model":"Nano","colour":"indigo","owner":"Valeria"}},{"Key":"CAR9","Record":{"make":"Holden","model":"Barina","colour":"brown","owner":"Shotaro"}}]

Atualize o livro razão

Finalmente, vamos fazer uma atualização no livro razão. Para fazer isso, é possível fazer outra mudança simples no novo comando invokeNetwork.js que você criou acima.

  1. Edite a variável request conforme mostrado abaixo para que ela chame o chaincode createCar com um conjunto de argumentos que descrevem o carro a ser criado. A variável da solicitação mudada deve ser semelhante a esta:
    var request = {
            targets: targets,
            chaincodeId: options.chaincode_id,
            fcn: 'createCar',
            args: ['CAR11', 'Honda', 'Accord', 'Black', 'Tom'],
            chainId: options.channel_id,
            txId: tx_id
    };
  2. Salve o arquivo e execute o comando usando node invokeNetwork.js. A saída esperada é:
    …
    Successfully sent transaction to the orderer.

    Isto criou um novo veículo com o proprietário "Tom" e o armazenou no livro razão. É possível ver o novo carro no livro-razão executando o comando queryNetwork.js novamente. Agora é possível experimentar a criação de novos carros no livro-razão com nomes e proprietários diferentes.

  3. Finalmente, você pode desejar experimentar o chaincode changeOwner para mudar o proprietário de um veículo. Para fazer isso, mude a variável request no invokeNetwork.js novamente para ser semelhante a isto:
    var request = {
            targets: targets,
            chaincodeId: options.chaincode_id,
            fcn: 'changeCarOwner',
            args: ['CAR11', 'MGK'],
            chainId: options.channel_id,
            txId: tx_id
    };
  4. Agora salve o arquivo e execute o comando novamente usando node invokeNetwork.js. A saída esperada é:
    …
    Successfully sent transaction to the orderer.
  5. É possível ver o proprietário atualizado no livro-razão executando o comando queryNetwork.js novamente. É possível ver que o proprietário mudou de "Tom" para "MGK".
  6. Se desejar consultar um único carro em vez de todos os carros, faça esta mudança na variável request no comando queryNetwork.js e execute-o novamente:
    const request = {
            chaincodeId: options.chaincode_id,
            txId: transaction_id,
            fcn: 'queryCar',
            args: ['CAR11']
    };

    Agora deve-se ver as informações para um único carro:

    …
    Query result count =  1
    Response is  {"make":"Honda","model":"Accord","colour":"Black","owner":"MGK"}

Resumo

Agora você tem uma rede ativa no IBM Blockchain Platform, com chaincode de amostra em um canal na rede e um aplicativo em execução com o qual é possível trabalhar facilmente. Você preencheu o livro-razão com dados de amostra e agora seu aplicativo pode se comunicar com (consultar e atualizar) o blockchain no IBM Blockchain Platform. Feliz blockchain!

Agradecimentos

Os autores agradecem Anthony O'Dowd e David Gorman da equipe IBM Blockchain Labs Global Engagement por sua orientação e suporte especializados durante todo o desenvolvimento desse tutorial.


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Cloud computing
ArticleID=1056822
ArticleTitle=Implemente um aplicativo de amostra no IBM Blockchain Platform
publish-date=01192018