openblockchain
1.0.0
O projeto está dividido em vários serviços:
Cada serviço contém 1 ou mais contêineres e pode ser dimensionado independentemente um do outro.
Todas as imagens do Docker estão hospedadas: https://hub.docker.com/u/openblockchaininfo/
As instruções a seguir orientarão você na instalação de todo o aplicativo openblockchain, incluindo todas as dependências e requisitos do sistema, permitindo que você execute o openblockchain na maioria dos sistemas básicos (Linux, OSX, Windows).
As instruções começarão orientando você na instalação do Ubuntu no VirtualBox.
Devido aos requisitos de poder computacional e espaço em disco, o armazenamento e processamento de dados do projeto foi projetado para ser executado em diversas máquinas, preferencialmente em nuvem com gerenciamento local a partir de uma máquina host.
As instruções a seguir orientam você na configuração de sua máquina host com Ubuntu e docker-engine, docker-machine e docker-compose.
Primeiro você precisa instalar o VirtualBox seguindo estas instruções
Você então precisa baixar o Ubuntu 16.04.1 LTS - 64 bits seguindo estas instruções
Você precisa criar uma nova máquina virtual usando o VirtualBox. A máquina virtual (doravante denominada 'máquina host') será usada para implantar o aplicativo. A máquina host requer:
Ao iniciar a máquina host pela primeira vez, selecione Ubuntu 16.04.1 LTS - 64 bits (que você baixou na etapa anterior) como disco de inicialização (é possível executar o projeto em outras versões do Ubuntu e até mesmo em outros sistemas operacionais como Windows e OS X, mas as instruções para eles não foram incluídas aqui).
A máquina host será usada apenas para enviar comandos ao cluster.
As máquinas do cluster (onde os serviços serão implantados) requerem (cada uma):
Depois de configurar a máquina host (consulte a seção "Pré-requisitos" a seguir), as instruções de "Configuração do cluster" guiarão você pelas etapas necessárias para criar 3 máquinas no Scaleway.
Eles devem ser instalados somente na máquina host. Certifique-se de que sua máquina host tenha o Ubuntu instalado (o que você terá se tiver seguido as etapas anteriores).
1. Instale o Docker Engine
Docker Engine inclui o cliente docker. docker será usado para se comunicar com os daemons do docker que são executados em todas as máquinas do cluster.
Atualize as informações do pacote. Certifique-se de que o APT funcione com o método https e que os certificados CA estejam instalados:
$ sudo apt-get update
$ sudo apt-get install apt-transport-https ca-certificates
Adicione a chave GPG oficial e o repositório APT:
$ sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
$ sudo echo "deb https://apt.dockerproject.org/repo ubuntu-wily main" > /etc/apt/sources.list.d/docker.list
Atualize o índice do pacote APT e instale o Docker:
$ sudo apt-get update
$ sudo apt-get install docker-engine
Inicie o daemon docker e verifique se ele está instalado corretamente:
$ sudo service docker start
$ sudo docker run hello-world
Instruções sempre atualizadas estão disponíveis em docker.com.
2. Instale a máquina Docker
docker-machine é usado para provisionar máquinas para o cluster.
Baixe o binário Docker Machine 0.8 e extraia-o para seu PATH:
$ sudo curl -L https://github.com/docker/machine/releases/download/v0.8.0/docker-machine-`uname -s`-`uname -m` > /usr/local/bin/docker-machine
$ sudo chmod +x /usr/local/bin/docker-machine
Verifique a instalação exibindo a versão da Máquina:
$ docker-machine version
Instruções sempre atualizadas estão disponíveis em docker.com.
3. Instale o Docker Compose
Docker Compose é usado para gerenciar os serviços.
$ sudo curl -L https://github.com/docker/compose/releases/download/1.8.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
$ sudo chmod +x /usr/local/bin/docker-compose
Verifique a instalação exibindo a versão do Compose:
$ docker-compose --version
Instruções sempre atualizadas estão disponíveis em docker.com.
Agora você configurou sua máquina host. Você tem:
Isso permitirá que você gerencie todos os microsserviços que constituem o aplicativo openblockchain de dentro da máquina host.
As instruções a seguir orientam você na implantação do cluster na nuvem, usando o Scaleway. O cluster conterá os seguintes serviços:
Os microsserviços são gerenciados via docker-* na sua máquina host.
1. Crie o serviço de descoberta
Usando Scaleway
Para usar o Scaleway, primeiro você precisa instalar o driver Scaleway para Docker Machine:
$ wget https://github.com/scaleway/docker-machine-driver-scaleway/releases/download/v1.2.1/docker-machine-driver-scaleway_1.2.1_linux_amd64.tar.gz
$ tar -xvf docker-machine-driver-scaleway_1.2.1_linux_amd64.tar.gz
$ sudo cp docker-machine-driver-scaleway_1.2.1_linux_amd64/docker-machine-driver-scaleway /usr/local/bin/
$ sudo chmod +x /usr/local/bin/docker-machine-driver-scaleway
Crie uma máquina para hospedar um serviço de descoberta Consul:
$ docker-machine create -d scaleway
--scaleway-commercial-type=C2S --scaleway-name=obc-consul
--scaleway-organization=<SCALEWAY-ACCESS-KEY> --scaleway-token=<SCALEWAY-SECRET-KEY>
obc-consul
Aponte seu cliente docker para a nova máquina:
$ eval $(docker-machine env obc-consul)
Crie e inicie o serviço:
$ docker run --name consul --restart=always -p 8400:8400 -p 8500:8500
-p 53:53/udp -d progrium/consul -server -bootstrap-expect 1 -ui-dir /ui
2. Inicie o Docker Swarm (cluster)
Usando Scaleway
Você pode provisionar as máquinas do Scaleway, que fornece servidores de ponta acessíveis e perfeitos para este projeto.
Obtenha suas credenciais do Scaleway (chave de acesso e chave secreta) nesta página e, em seguida, implante 3 máquinas:
$ docker-machine create -d scaleway
--scaleway-commercial-type=C2L --scaleway-name=obc
--scaleway-organization=<SCALEWAY-ACCESS-KEY> --scaleway-token=<SCALEWAY-SECRET-KEY>
--swarm --swarm-master
--swarm-discovery consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-store=consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-advertise=eth0:2376
obc
$ docker-machine create -d scaleway
--scaleway-commercial-type=C2L --scaleway-name=obc-01
--scaleway-organization=<SCALEWAY-ACCESS-KEY> --scaleway-token=<SCALEWAY-SECRET-KEY>
--swarm
--swarm-discovery consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-store=consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-advertise=eth0:2376
obc-01
$ docker-machine create -d scaleway
--scaleway-commercial-type=C2L --scaleway-name=obc-02
--scaleway-organization=<SCALEWAY-ACCESS-KEY> --scaleway-token=<SCALEWAY-SECRET-KEY>
--swarm
--swarm-discovery consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-store=consul://`docker-machine ip obc-consul`:8500
--engine-opt cluster-advertise=eth0:2376
obc-02
Por padrão as máquinas Scaleway possuem um disco de 50GB. No entanto, o Scaleway também anexa um SSD de 250 GB, que precisa ser montado manualmente:
$ printf "obcnobc-01nobc-02" |
xargs -n 1 -I CONT_NAME docker-machine ssh CONT_NAME
"echo ; echo ; echo CONT_NAME ;"`
`"echo 'Formatting...' ;"`
`"yes | mkfs -t ext4 /dev/sda ;"`
`"echo 'Mounting...' ;"`
`"mkdir -p /openblockchain ;"`
`"mount /dev/sda /openblockchain ;"`
`"echo 'Adding to fstab...' ;"`
`"echo '/dev/sda /openblockchain auto defaults,nobootwait,errors=remount-ro 0 2' >> /etc/fstab ;"`
`"echo 'Done' ;"
Esse armazenamento adicional não estará visível na IU da sua conta Scaleway. Você pode verificar manualmente se o armazenamento adicional foi montado (neste caso, verificando obc):
$ docker-machine ssh obc
$ cat /etc/fstab
$ ls -al /openblockchain
3. Verifique o enxame
Aponte seu ambiente Docker para a máquina que executa o swarm master:
$ eval $(docker-machine env --swarm obc)
Imprimir informações do cluster:
$ docker info
Você também pode listar os IPs que o Consul “descobriu”:
$ docker run --rm swarm list consul://`docker-machine ip obc-consul`:8500
1. Crie a rede padrão
Crie uma rede de sobreposição que permita que os contêineres "vejam" uns aos outros, independentemente do nó em que estejam:
$ docker network create --driver overlay --subnet 10.0.9.0/24 obcnet
Liste todas as redes, obcnet deve ser mostrado como overlay :
$ docker network ls
openblockchain foi projetado com vários microsserviços que estão vinculados ao mecanismo Docker principal como submódulos git.
O comando a seguir clona o projeto e todos os módulos git necessários.
$ git clone --recursive https://github.com/open-blockchain/openblockchain.git
Depois de clonar o repositório, certifique-se de entrar no diretório.
$ cd openblockchain
2. Para cima!
Na pasta raiz (que contém docker-compose.yml ), execute:
$ docker-compose up -d --build
Docker implantará todos os serviços. Por padrão, ele será iniciado:
3. Verifique os serviços
Mostrar todos os contêineres e seus status (todos devem estar "Ativos"):
$ docker-compose ps
Mostre o status do cluster Cassandra (você deverá ver 3 nós):
$ docker-compose exec cassandra-seed nodetool status
Enquanto isso, o servidor Bitcoin já deveria ter verificado algumas centenas de blocos. Vamos ver isso funcionando ao vivo:
$ docker-compose logs -f --tail 100 bitcoin
Você deverá ver algo assim, o que significa que ele baixou todos os blocos de 0 a 187591 (neste exemplo):
bitcoin_1 | 2016-08-25 15:03:16 UpdateTip: new best=00000000000006edbd5920f77c4aeced0b8d84e25bb5123547bc6125bffcc830 height=187589 log2_work=68.352088 tx=4696226 date=2012-07-05 03:45:13 progress=0.015804 cache=48.7MiB(122719tx)
bitcoin_1 | 2016-08-25 15:03:16 UpdateTip: new best=00000000000003f07c1227f986f4687d291af311a346f66247c504b332510931 height=187590 log2_work=68.352117 tx=4696509 date=2012-07-05 03:52:33 progress=0.015805 cache=48.7MiB(122815tx)
bitcoin_1 | 2016-08-25 15:03:16 UpdateTip: new best=00000000000002b34a755d25a5fee4c0ad0c018cf94f4b0afef6aabe823d304a height=187591 log2_work=68.352146 tx=4696593 date=2012-07-05 04:01:11 progress=0.015805 cache=48.7MiB(122839tx)
Agora vamos ver os painéis do Spark, que devem estar vazios agora. Execute o seguinte comando para obter a URL do painel de cada mestre e trabalhador do Spark:
$ echo "master: "`docker-machine ip obc`":8080"
$ echo "worker 1: "`docker-machine ip obc-01`":8081"
$ echo "worker 2: "`docker-machine ip obc-02`":8081"
1. Digitalize o blockchain
Mostre os registros dos scanners:
$ docker-compose logs -f --tail 100 scanner-01
$ docker-compose logs -f --tail 100 scanner-02
Os scanners foram configurados (em docker-compose.yml ) para indexar um intervalo fixo de blocos. Porém, no início, quando o nó bitcoin ainda não atingiu o bloco 330.000, scanner-02 (que está configurado para escanear blocos de 330.000 a 400.000) não será capaz de escanear nada. Portanto, ele aguardará 10 minutos e tentará novamente até que esses blocos estejam disponíveis.
2. Análise de faísca
O serviço spark-submit executa vários scripts Spark a cada hora. Esses scripts geram visualizações (ou seja, pontos de dados) que a API fornecerá ao frontend. Você pode ver seu progresso observando os registros:
$ docker-compose logs -f --tail 100 spark-submit
Vamos executar um script personalizado que conta todos os blocos e transações no Cassandra:
$ docker-compose exec spark-submit sbt submit-Counter
Quando o script terminar, você deverá ver algo assim (ignore os logs que começam com um carimbo de data/hora):
Blocks: 239699
Transactions: 18941698
3. Acesse a API
Encontre o nome da máquina em que o contêiner da API está sendo executado:
$ docker ps --filter "name=node-api" --format "{{.Names}}"
Isso produzirá algo como obc-02/api , onde a parte antes da barra é o nome da máquina.
Agora obtenha o URL da API, substituindo <machine-name-from-above> adequadamente:
$ echo "http://"`docker-machine ip <machine-name-from-above>`":10010"
4. Acesse o frontend do aplicativo web
Encontre o nome da máquina em que o contêiner de front-end está sendo executado:
$ docker ps --filter "name=frontend" --format "{{.Names}}"
Isso produzirá algo como obc-01/frontend , onde a parte antes da barra é o nome da máquina.
Agora obtenha a URL do frontend, substituindo <machine-name-from-above> de acordo:
$ echo "http://"`docker-machine ip <machine-name-from-above>`":80"
5. Visualizações
Dependendo se o serviço spark-submit teve tempo para concluir os scripts Spark ou não, você poderá ver visualizações no frontend, em http://<frontend-ip>:80/blocks .
Se as visualizações ainda não estiverem disponíveis, verifique o progresso do spark-submit :
$ docker-compose logs -f --tail 100 spark-submit
Se estiver ocioso, reinicie o serviço ( docker-compose restart spark-submit ). Caso contrário, provavelmente está processando dados do Cassandra. Deixe-o terminar o trabalho e atualizar a página (vá embora e faça uma xícara de chá - em 60 minutos ele certamente terá processado alguns números).
Direitos autorais (C) 2016 Dan Hassan
Projetado, desenvolvido e mantido por Dan Hassan [email protected]
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Dependências do serviço API
https://github.com/scalatra/scalatra
Direitos autorais (c) Alan Dipert [email protected]. Todos os direitos reservados.
Dependências do serviço front-end
https://github.com/gaearon/react-redux-universal-hot-example
A Licença MIT (MIT), Copyright (c) 2015 Erik Rasmussen
dependências da API do nó
https://github.com/nodejs/node/blob/master/LICENSE
Colaboradores com direitos autorais do Node.js. Todos os direitos reservados.
Dependências de serviço openblockchain
https://github.com/docker/docker
Licença Apache, versão 2.0, janeiro de 2004, http://www.apache.org/licenses/
Dependências do serviço de scanner
https://github.com/outworkers/phantom
Direitos autorais 2013-2016 Websudos, Limited. , Todos os direitos reservados.
Dependências do serviço Spark
https://github.com/apache/spark
Licença Apache, versão 2.0, janeiro de 2004, http://www.apache.org/licenses/
