Get best of the week

Implantar o Hyperledger Fabric 1.4 na AWS

O Hyperledger Fabric é uma plataforma de blockchain de código aberto da Linux Foundation. Com ele, você pode criar aplicativos blockchain e controlar o acesso e as permissões de dados no blockchain. O Hyperledger Fabric deve ser usado se você deseja criar uma rede blockchain privada ou definir restrições sobre quais transações cada lado pode ver.

Na documentação do Hyperledger Fabric, a criação de uma rede blockchain em uma máquina usando o Docker é bem planejada, onde cada membro da rede é um contêiner separado. Mas o processo de configuração de uma rede em várias máquinas físicas ou virtuais não é descrito. Isso será discutido neste artigo.

Nosso aplicativo blockchain é um serviço para armazenar alguns dados médicos de crianças em idade escolar e pré-escolar. Os dados devem permanecer inalterados. Eles serão apresentados na forma de informações sobre a vacinação e a concordância do paciente com um médico específico. A rede incluirá membros dos Pais (uma organização que representa os interesses dos pais), Hospital (um hospital cujos pais pediatras podem entrar em um acordo para cuidar de seus filhos / filhos) e Jardim de Infância (um jardim de infância que pode solicitar relatórios de saúde e vacinas para ou outra criança no hospital).

Blockchain gerenciado pela Amazon


A AWS tem um serviço Amazon Managed Blockchain. Ele permite implantar redes blockchain usando as interfaces de usuário do console da AWS. Mas, tendo adquirido alguma experiência trabalhando com o Amazon Managed Blockchain, tivemos que abandonar a ideia de usar o serviço em projetos comerciais. Havia várias razões para isso. Os principais são:

  1. Somente a versão do Hyperledger Fabric 1.2 estava disponível no Amazon Managed Blockchain e, no momento em que este artigo foi escrito, a versão 1.4 era usada para criar redes corporativas de blockchain. Também não permite o uso de versões modernas das ferramentas do SDK do Node.js.
  2. O Amazon Managed Blockchain não suporta o banco de dados do CouchDB, dificultando a criação de aplicativos que indexam dados armazenados.

Portanto, nossa opinião é que é melhor usar servidores virtuais ou físicos para construir redes usando a estrutura Hyperledger Fabric.

Sobre canais de aplicativos


O Hyperledger Fabric tem o conceito de "canal". Um canal é uma sub-rede para realizar transações confidenciais. Haverá dois canais em nosso aplicativo.

  • "Hospital de pais". Destina-se a transações entre membros de organizações de pais e hospitais: criação e modificação de registros médicos, criação de um contrato com um pediatra e assinatura de um contrato de pediatra.
  • "Paishospitalkindergarten." Nesse canal, os membros dos pais e do hospital irão interagir com os membros do jardim de infância. Além disso, os relatórios serão gerados com base nos dados dos registros médicos.

Ambiente de trabalho


Implementaremos nossa rede blockchain usando o Docker Swarm - este é o sistema nativo do Docker para implantar um cluster de host. Se você nunca trabalhou com o Docker (e especialmente com o Docker Swarm), verifique primeiro este produto e como orquestrar contêineres usando o Docker Swarm. A documentação descreve os conceitos básicos de trabalhar bem com essas ferramentas.

Toda a nossa rede estará localizada nos servidores AWS EC2. As informações na rede blockchain serão armazenadas no CouchDB. O Hyperledger Fabric também suporta o banco de dados LevelDB, mas o CouchDB, ao contrário do último, possibilita pesquisar por qualquer critério em uma coleção de documentos. Também usaremos a Autoridade de certificação de malha - este é um componente modular para gerenciar identificadores de rede de todas as organizações e seus usuários. Ele fornece o registro dos participantes da rede e a emissão de certificados.

Teremos quatro servidores EC2:

  1. Pedido, banco de dados MySQL (para armazenar informações de aplicativos que não se aplicam a registros médicos)
  2. Organização dos pais (Ponto0, Ponto1), CouchDB, Fabric-CA, CLI
  3. Organização hospitalar (Par0, Par1), CouchDB, Fabric-CA
  4. Organização do jardim de infância (Peer0, Peer1), CouchDB, Fabric-CA

Criando servidores EC2 na AWS


Precisamos de serviços t2.medium para funcionar. Esse tipo de servidor EC2 possui poder de computação suficiente para instalar todo o software necessário e funcionar com a ferramenta Hyperledger Fabric. No grupo de segurança Configurar, defina Todo o tráfego e Origem - 0.0.0.0/0, :: / 0.


Figura 1. Configure o Grupo de segurança no painel da AWS.

Temos quatro servidores EC2:

  1. ec2-18-232-164-119.compute-1.amazonaws.com
  2. ec2-54-145-203-186.compute-1.amazonaws.com
  3. ec2-54-80-241-117.compute-1.amazonaws.com
  4. ec2-52-87-193-235.compute-1.amazonaws.com

Naturalmente, você terá seus próprios caminhos para os servidores EC2.


Figura 2. Preparado para servidores EC2 operacionais.

Instalando o software de pré-requisito nos servidores EC2


Agora, em cada servidor EC2, precisamos instalar o Docker e o Git. Por conveniência, abra quatro abas no terminal. Vamos para cada serviço EC2 via SSH:

Terminal 1:

HOST1=ec2-18-232-164-119.compute-1.amazonaws.com
ssh ec2-user@$HOST1 -i ./key-poc.pem

Terminal 2:

HOST2=ec2-54-145-203-186.compute-1.amazonaws.com
ssh ec2-user@$HOST2 -i ./key-poc.pem

Terminal 3:

HOST3=ec2-54-80-241-117.compute-1.amazonaws.com
ssh ec2-user@$HOST3 -i ./key-poc.pem

Terminal 4:

HOST4=ec2-52-87-193-235.compute-1.amazonaws.com
ssh ec2-user@$HOST4 -i ./key-poc.pem

Em cada terminal, execute os seguintes comandos:

sudo yum update -y
sudo yum install -y docker
sudo service docker start
sudo docker info
sudo yum install git
sudo usermod -a -G docker ec2-user
newgrp docker

Agora temos o Docker e o Git instalados.

Rede


Precisamos clonar elementos de nossa rede do repositório. Para fazer isso, execute o comando em cada terminal:

git clone https://github.com/nixsolutions/blockchain-poc-network.git network

Também precisamos clonar contratos inteligentes do repositório que regularão os relacionamentos entre os participantes da rede. Os contratos inteligentes são escritos no idioma Golang.

Executamos essas etapas em cada um dos quatro servidores:

cd network && mkdir chaincode && cd chaincode
git clone https://github.com/nixsolutions/blockchain-poc-medical-contract.git medical-contract
git clone https://github.com/nixsolutions/blockchain-poc-kindergarten-contract.git kindergarten-contract

No primeiro terminal, precisamos gerar arquivos e certificados de configuração de canal para conectar organizações à rede:

cd network/poc-network
./1_generate_connection_files.sh
./2_generating_channel_configuration.sh

Agora copie as pastas de artefatos de canal e de configuração de criptografia para os outros três hosts na pasta poc-network do diretório pai da rede. Observação: ao copiar organizações para o servidor EC2, é necessário remover certificados de terceiros da pasta crypto-config / peerOrganizations que se relacionam ao trabalho de outras organizações. Por exemplo, ao copiar para o host Pais, precisamos deixar a pasta parents.poc-network.com nessa pasta, mas exclua hospital.poc-network.com e kindergarten.poc-network.com.

Criando uma pilha de enxame do Docker


Para que os contêineres pertencentes a organizações diferentes e localizados em servidores EC2 diferentes possam acessar um ao outro, precisamos combiná-los em uma pilha. Vejamos nossa rede de arquivos / poc-network / docker-compose-general.yaml. Ele contém a configuração de serviços, indica em quais hosts um serviço (chave node.hostname) específico será implantado , os aliases (chave aliases) são indicados .

Precisamos inicializar o enxame no primeiro terminal:

docker swarm init
docker swarm join-token manager

Um token aparecerá para conectar outro servidor EC2 à pilha. Algo como: docker swarm join --token SWMTKN-1-42ml0ohnnbidg8kflgp8xp9dkkus6mn1lslqc15hrxj4tk9e3q-5h4vbzbfk8p90n83oe08gbltf 172.31.46.214:2377.

Agora podemos executar nos demais terminais:

docker swarm join --token SWMTKN-1-2xzco7t7txohnzd09318eczpbgmm8woex80byxptpt1jl5i2ar-bsg37h40xze1gaabg80i96gw2 172.31.38.245:2377

Uma mensagem aparece no console:

This node joined a swarm as a manager.

Depois que todos os três hosts estiverem conectados ao Swarm, podemos vê-los no terminal do primeiro host executando o comando:

docker node ls


Fig. 3. Lista de servidores no Docker Swarm.

Na pasta network / poc-network, há um arquivo .env.template no qual você precisa especificar um nome de host para cada um dos hosts:

ORDERER=ip-172-31-38-245
PARENTS=ip-172-31-43-64
HOSPITAL=ip-172-31-38-130
KINDERGARTEN=ip-172-31-40-157

Para gerar um arquivo .env, é necessário executar o arquivo ./3_env_gen.sh.

Agora crie uma rede com um driver overlay:

docker network create --driver overlay --attachable stage_byfn

Execute o Swarm para criar uma pilha baseada no arquivo docker-compose-general.yaml:

env $(cat .env | grep ^[A-Z] | xargs) docker stack deploy -c docker-compose-general.yaml stage 2>&1

Com esse comando, também definimos variáveis ​​de ambiente, descritas no arquivo .env e necessárias para que a rede funcione corretamente.

Você pode executar o comando docker service lsno primeiro terminal. Você verá uma lista de todos os serviços em execução em todas as nossas instâncias do EC2.


Fig. 4. Lista de todos os serviços que estavam em execução em todos os servidores EC2.

Se você vê a mesma coisa no seu terminal e na captura de tela, está tudo bem. Agora execute nossa rede. No segundo terminal, você deve inserir o contêiner da CLI (afinal, esse contêiner é implantado no segundo host):

docker exec -ti stage_cli.1.owni217t53m53efjtikb5oa2f /bin/bash

O nome do contêiner pode ser visto executando o comando no terminal docker ps.

No contêiner, executamos todos os nossos comandos do arquivo 4_create_channels.sh, copiando-os um a um no terminal. Na pasta bin, temos os binários para criar a rede:

  • canal peer create - crie canais;
  • junção de canal de mesmo nível - associando um ponto a um canal;
  • atualização de canal de mesmo nível - atualizar configurações;
  • instalação de chaincode de pares - instale o código de código;
  • instale o código de cadeia especificado na rede.

Agora você pode deixar o recipiente executando o comando exit.

Parents Back Application


Instale o aplicativo no segundo host:

cd ~
git clone https://github.com/nixsolutions/blockchain-poc-backend.git back

Também precisamos instalar o NodeJS e o gcc-c ++ (compilador):

curl -sL https://rpm.nodesource.com/setup_10.x | sudo bash -
sudo yum install nodejs
cd back
sudo yum install gcc-c++ -y
npm install

Também podemos inserir nosso banco de dados através do administrador com os seguintes dados de autorização:

<HOST_1>:3306(onde <HOST_1>é o endereço do primeiro servidor EC2 no qual o banco de dados está armazenado)
dev
devpass
poc_database

Também é necessário conectar nosso aplicativo API ao banco de dados:

vim ~/back/config/config.json

Atribua o valor correto à chave host. Nossa aplicação de retorno preparou migrações e sementes. Você precisa executá-los:

npx sequelize-cli db:migrate
npx sequelize-cli db:seed:all

As tabelas devem aparecer no banco de dados. E na tabela de organizações, veremos três linhas com nossas organizações - pais, hospital, jardim de infância.

Ao gerar certificados desde o início, recebemos arquivos para conectar-se à rede para cada organização no primeiro host. Copie o arquivo connection-parents.json do primeiro host para o segundo. Para fazer isso, abra outro terminal da pasta onde o nosso keyestá localizado e execute os comandos:

HOST1=ec2-18-232-164-119.compute-1.amazonaws.com
HOST2=ec2-54-145-203-186.compute-1.amazonaws.com
scp -i ./key-poc.pem -r ec2-user@$HOST1:~/network/poc-network/connection-parents.json ~
scp -i ./key-poc.pem ~/connection-parents.json ec2-user@$HOST2:~/network/poc-network

Correção exports.hostNameem constants.js (valor para o host atual):

vim ~/back/constants.js

Execute nosso aplicativo no segundo terminal:

npm start

No arquivo userGenerator.sh, atribua o HOST_2valor correto à variável :

vim ~/back/generators/userGenerator.sh

Em seguida, você precisa executar o script que criará os usuários da organização Pais:

./back/generators/userGenerator.sh parents

Execute o script para gerar registros médicos:

node ~/back/generators/setCards.js

Dois cartões serão criados no blockchain, que também serão gravados no banco de dados SQL na tabela de cartões.

Aplicação de volta ao hospital


Por analogia com o aplicativo anterior, precisamos colocar o arquivo para conectar-se à rede no terceiro host. Para fazer isso, no quinto terminal, execute:

scp -i ./key-poc.pem -r ec2-user@$HOST1:~/network/poc-network/connection-hospital.json ~
scp -i ./key-poc.pem ~/connection-hospital.json ec2-user@$HOST3:~/network/poc-network

Clonaremos nosso aplicativo no terceiro host:

cd ~
git clone https://github.com/nixsolutions/blockchain-poc-backend.git back

Instale o NodeJS e o gcc-c ++ (compilador):

curl -sL https://rpm.nodesource.com/setup_10.x | sudo bash -
sudo yum install nodejs
cd back
sudo yum install gcc-c++ -y
npm install

Correção exports.hostNameem constants.js (valor para o host atual):

vim ~/back/constants.js

Execute nosso aplicativo no terceiro terminal:

npm start

No arquivo userGenerator.sh, atribua o HOST_3valor correto à variável :

vim ~/back/generators/userGenerator.sh

Em seguida, precisamos executar um script que crie usuários da organização do Hospital:

./back/generators/userGenerator.sh hospital

Agora temos um segundo usuário na tabela Usuários no banco de dados.

Jardim de infância aplicação de volta


Por analogia com o aplicativo anterior, precisamos colocar o arquivo para conectar-se à rede no terceiro host. Para fazer isso, no quinto terminal, execute:

scp -i ./key-poc.pem -r ec2-user@$HOST1:~/network/poc-network/connection-kindergarten.json ~
scp -i ./key-poc.pem ~/connection-kindergarten.json ec2-user@$HOST4:~/network/poc-network

Clonaremos nosso aplicativo no terceiro host:

cd ~
git clone https://github.com/nixsolutions/blockchain-poc-backend.git back

Instale o NodeJS e o Gcc-c ++ (compilador):

curl -sL https://rpm.nodesource.com/setup_10.x | sudo bash -
sudo yum install nodejs
cd back
sudo yum install gcc-c++ -y
npm install

Correção exports.hostNameem constants.js (valor para o host atual):

vim ~/back/constants.js

Execute nosso aplicativo no terceiro terminal:

npm start

No arquivo userGenerator.sh, atribua o HOST_4valor correto à variável :

vim ~/back/generators/userGenerator.sh

Em seguida, precisamos executar um script que crie usuários da organização do Hospital:

./back/generators/userGenerator.sh kindergarten

Agora temos um terceiro usuário na tabela Usuários no banco de dados.

Instale o wkhtmltopdf no segundo, terceiro e quarto servidores EC2


O aplicativo posterior usa a biblioteca wkhtmltopdf para gerar um relatório em PDF sobre o status de saúde da criança.

Precisamos instalar a libpng - a biblioteca oficial para trabalhar com gráficos raster no formato PNG. A biblioteca é independente da plataforma e consiste em funções escritas na linguagem C.

A primeira equipe instalará o wkhtmltox - a biblioteca LGPLv3 de código aberto para renderizar HTML para PDF e vários formatos de imagem usando o mecanismo de renderização QtWebKit:

wget https://downloads.wkhtmltopdf.org/0.12/0.12.5/wkhtmltox-0.12.5-1.centos7.x86_64.rpm
sudo yum install -y wkhtmltox-0.12.5-1.centos7.x86_64.rpm

O segundo bloco de comandos fará o download e implantará a biblioteca libpng15:

wget https://sourceforge.net/projects/libpng/files/libpng15/older-releases/1.5.15/libpng-1.5.15.tar.gz/download -O libpng-1.5.15.tar.gz
tar -zxvf libpng-1.5.15.tar.gz
cd libpng-1.5.15

O terceiro bloco de comandos é necessário para instalar o compilador:

sudo yum groupinstall -y "Development Tools"
./configure --prefix=/usr
sudo make install

Você ainda precisa instalar o LibTIFF:

sudo yum install -y libtiff

Podemos testar:

wkhtmltopdf https://majestic.cloud majestic.pdf

Agora você pode gerar e visualizar documentos PDF.

Um pouco sobre o SDK do nó


As ferramentas NodeJS para trabalhar com a rede Hyperledger Fabric são apresentadas na forma dos pacotes "fabric-ca-client -v 1.4.0" e "fabric-network" v 1.4.0 ". Todos os serviços do aplicativo back-end que interagem com a rede usando o SDK do Nó estão localizados na pasta Serviços, na raiz do projeto.

Você pode ler sobre essas ferramentas e seus métodos na documentação oficial .

Processos de negócios de aplicativos


Agora, falaremos sobre como os membros da rede interagem entre si neste aplicativo. Todos os processos são descritos em um diagrama UML. Vamos considerar cada um deles com mais detalhes.


Fig.5. Uma descrição gráfica dos processos de negócios no aplicativo.

Portanto, existem várias organizações na rede: pais, hospital e jardim de infância.

Um membro dos Pais cria registros eletrônicos de saúde para dois de seus filhos. Esses dados serão armazenados (e complementados) na rede blockchain. Em seguida, os pais enviam uma solicitação de acordo com o pediatra, que observará seus filhos até atingirem a idade adulta (no diagrama - solicitação de acordo com um médico ).

Um membro da organização do hospital assina um acordo (no diagrama - o médico assina um acordo ).

Em seguida, os pais enviam uma solicitação ao jardim de infância com uma solicitação para matricular seu filho (no diagrama - solicitação de jardim de infância para receber um filho ).


Fig. 6. Uma página com uma lista de instituições de ensino disponíveis na conta dos pais.

O jardim de infância vê a solicitação na lista de novas solicitações:


Fig. 7. Uma página com uma lista de pedidos de admissão na conta pessoal da instituição educacional.

O jardim de infância antes de decidir sobre a admissão da criança deve garantir seu estado de saúde satisfatório. Para fazer isso, o jardim de infância envia uma solicitação para a clínica em que essa criança é observada (no diagrama - solicitação de relatório de saúde infantil ). O pedido ao pediatra é executado automaticamente depois que o pedido de admissão no jardim é movido para a guia "Aceito".


Fig. 8. Uma página com uma lista de pedidos aprovados para admissão na conta pessoal da instituição educacional.

O pediatra vê a solicitação e forma um relatório que contém dados sobre a saúde da criança (no diagrama - criação do relatório de saúde infantil ).


Fig. 9. Uma página com uma lista de aplicativos para criar um relatório sobre o estado de saúde da criança na conta pessoal do hospital.

Os pais veem que o pediatra gerou um relatório:


Fig. 10. Uma página na conta pessoal dos pais, que exibe o status dos relatórios sobre o status de saúde da criança.

... e decide conceder acesso à instituição educacional pré-escolar para visualizar e fazer o download do relatório (no diagrama - dê permissão para visualizar o relatório ).


Fig. 11. Uma janela pop-up para escolher uma instituição educacional que pode visualizar o relatório médico gerado.

O pai clica em "Confirmar":


Fig. 12. Notificação de que a instituição educacional selecionada recebeu permissão para visualizar o relatório médico.

Na lista de relatórios no aplicativo da instituição educacional, aparecem as informações de que o relatório foi gerado e está disponível para visualização e download em formato PDF.


Fig. 13. Link para baixar o relatório em formato PDF na linha com o aplicativo aprovado.

Aqui está um relatório que você verá em uma nova guia no seu computador:


Fig. 14. Um relatório de saúde gerado por um funcionário do hospital.

Criando registros médicos e acordos com um pediatra, assinando um acordo


Como o aplicativo foi projetado mais para demonstrar a implantação da rede em servidores EC2 separados, executaremos alguns comandos a partir dos scripts preparados.

Primeiro servidor EC2:

node ~/back/generators/setCards.js

Nós nos conectamos anteriormente ao banco de dados. Depois de executar o comando, você verá duas entradas na tabela Cartões. Além disso, as informações sobre os dados médicos dessas duas crianças foram registradas no blockchain.

Nesse servidor EC2, precisamos criar um contrato com um pediatra que observará as crianças:

node ~/back/generators/createAgreement.js

Agora, este contrato deve ser assinado pelo usuário que criamos para a organização Hospital. Executamos o comando a partir do segundo host:

node ~/back/generators/signAgreement.js

Nosso contrato é assinado pelo médico e podemos continuar trabalhando em nosso aplicativo. Em seguida, precisamos instalar o aplicativo front-end no segundo, terceiro e quarto servidores EC2.

PS: Você pode encontrar todos os comandos para gerar usuários, cartões, acordos e acordos de assinatura na pasta ~ / back / generators.

Aplicativo para pais


Execute no segundo host (onde a organização Pais está localizada):

cd ~
git clone https://github.com/nixsolutions/blockchain-poc-frontend.git front

Criamos o arquivo .env e especificamos o nome do host no qual nosso aplicativo front-end estará localizado:

vim ~ /front/.env:



VUE_APP_API_BASE_URL='http://ec2-107-22-75-46.compute-1.amazonaws.com:3006/'

É necessário estabelecer as dependências:

cd front
npm install

Você também deve criar o aplicativo e executá-lo na porta 8080:

docker build . -t my-app
docker run -d -p 8080:80 my-app

Nosso aplicativo estará disponível em: http://<HOST_2>:8080onde <HOST_2>é o endereço do segundo servidor EC2 no qual nosso aplicativo está localizado.

Login: parentssenha: password.

É assim que o frontend será. Aqui você verá informações sobre os cartões médicos que criamos no terminal:


Fig. 15. Informações sobre os registros médicos de crianças na conta pessoal dos pais.

Aplicação Hospital Frontend


Execute no segundo host (onde a organização do Hospital está localizada):

cd ~
git clone https://github.com/nixsolutions/blockchain-poc-frontend.git front

Criamos o arquivo .env e especificamos o nome do host no qual nosso aplicativo front-end estará localizado:

vim ~ /front/.env:



VUE_APP_API_BASE_URL='http://ec2-3-91-238-161.compute-1.amazonaws.com:3006/'

É necessário estabelecer as dependências:

cd front
npm install

Você também deve criar o aplicativo e executá-lo na porta 8080:

docker build . -t my-app
docker run -d -p 8080:80 my-app

Nosso aplicativo estará disponível em: http://<HOST_3>:8080onde <HOST_3>é o endereço do terceiro servidor EC2.

Login: hospitalsenha: password.

Aplicação de front-end do jardim de infância


Execute no segundo host (onde a organização do jardim de infância está localizada):

cd ~
git clone https://github.com/nixsolutions/blockchain-poc-frontend.git front

Criamos o arquivo .env e especificamos o nome do host no qual nosso aplicativo front-end estará localizado:

vim ~ /front/.env:



VUE_APP_API_BASE_URL='http://ec2-107-22-12-137.compute-1.amazonaws.com:3006/'

É necessário estabelecer as dependências:

cd front
npm install

Você também deve criar o aplicativo e executá-lo na porta 8080:

docker build . -t my-app
docker run -d -p 8080:80 my-app

Nosso aplicativo estará disponível em: http://<HOST_4>:8080onde <HOST_4>é o endereço do quarto servidor EC2.

Login: kindergartensenha: password.

Conclusão


Examinamos como implantar uma rede de aplicativos blockchain em vários servidores virtuais ou físicos. O artigo foi desenvolvido para familiarizá-lo com os conceitos básicos da tecnologia blockchain, conhecer o que são contratos inteligentes e, pelo menos superficialmente, familiarizar-se com a estrutura Hyperledger Fabric e seu aplicativo padrão de amostras de tecido.

More articles:


All Articles