Ben je op zoek naar een gids waarin je kunt leren hoe je een blockchain-app bouwt? Hier is een gids die u kan helpen om vanaf nul een blockchain-app te bouwen.

In dit artikel gaan we onze blockchain-app bouwen. Onlangs hebben we besproken hoe u een blockchain kunt bouwen. Het was een complete gids voor het bouwen van een blockchain in de programmeertaal Python. De belangrijkste focus van de tutorial is om te leren over blockchain-technologie en de interne werking ervan.

Deze tutorial gaat echter over het bouwen van een app met blockchain. De gedecentraliseerde app (dApp) kan profiteren van de blockchain-eigenschappen.

We zullen een eenvoudige blockchain-app bouwen met Ethereum. Ethereum is een blockchain-technologie van de tweede generatie die geavanceerde functies biedt, zoals slimme contracten, Proof-of-Stake en, belangrijker nog, de mogelijkheid om gedecentraliseerde apps (dApps) te maken.

Laten we dus aan de slag gaan met onze zelfstudie ‘Hoe bouw je een blockchain-app’. Deze tutorial is ook bedoeld voor degenen die een eenvoudige blockchain-app willen bouwen. Om een ​​eenvoudige blockchain-app te bouwen, gaan we het Ethereum-netwerk gebruiken.

Maar laten we, voordat we aan de slag gaan, eerst onze basis goed doornemen.

Schrijf nu in: Enterprise Blockchains Fundamentals-cursus

Wat is dApp?

De eerste stap die we gaan nemen bij het bouwen van een blockchain-app-tutorial is om eerst het concept van de gedecentraliseerde applicatie (dApp) te leren..

dApp staat voor gedecentraliseerde applicatie. Het is een ander type app dat belangrijke kenmerken biedt, waaronder de mogelijkheid om autonoom te werken. De app slaat ook gegevens cryptografisch op, zodat geen enkele niet-geautoriseerde entiteit er toegang toe heeft zonder de juiste autorisatie.

Al deze kenmerken maken gedecentraliseerde apps erg handig in de huidige bedrijfsomgeving. De apps kunnen ook tokens gebruiken die kunnen worden gebruikt om te profiteren van de functies die door de app worden aangeboden. Bovendien kan de app ook tokens distribueren om de nodes te stimuleren die deelnemen aan het functioneel maken van de dApp.

Een platform kiezen – waarom we kiezen voor het Ethereum-platform

Op dit moment zijn er veel platforms die u kunt kiezen om uw dApp te bouwen. Ze omvatten populaire blockchain-platforms zoals Ethereum, Hyperledger Fabric en Cardano. Van al deze dingen lijkt Ethereum de beste keuze vanwege de actieve community, tools en tutorials die online beschikbaar zijn.

Een andere reden waarom we Ethereum kiezen, is dat het Solidity gebruikt. Soliditeit wordt expliciet gemaakt om dApps en slimme contracten te implementeren en te creëren. Het is gemakkelijk te leren en geeft u de flexibiliteit om te experimenteren.


Praktische gids voor het bouwen van een gedecentraliseerde Blockchain-app

Voordat we diep in de code gaan duiken, wil ik de stappen noemen die het proces van het bouwen van een blockchain-app schetsen. Laten we het hieronder doornemen.

Vind een idee

De eerste stap is om een ​​idee te vinden om aan te werken. Decentralisatie is een cool nieuw concept dat veel use-cases kan hebben. Als leerling of ingenieur moet u een nuttig idee bedenken waar u of uw bedrijf van kan profiteren. Maak je ook geen zorgen als je niet met een idee kunt komen dat het landschap verandert. Het is oké om eenvoudige dApps te bouwen om te leren en te oefenen.

U kunt ook zoeken naar problemen waarmee u te maken krijgt met blockchain en deze misschien zo goed mogelijk proberen op te lossen. Het gaat er hier om het probleem vanuit uw pijnpunt te bekijken en het vervolgens te proberen op te lossen.

Als u een dApp probeert te bouwen voor uw bedrijf of volgens uw zakelijke vereisten, dan moet u een goede kosten-batenanalyse uitvoeren. U moet ook de risico’s van het project onderzoeken en kijken of uw zakelijke team de app met de nodige zorgvuldigheid kan beheren.

In geen geval mag u overhaaste beslissingen nemen waar u later spijt van krijgt. Dit komt omdat blockchain-ontwikkeling kostbaar is, vooral als het gaat om het vinden van talent om het te ontwikkelen en te beheren. Bovendien is er een schaarste aan ontwikkelaars die aan de blockchain werken. Kortom, u moet de juiste stappen nemen als het gaat om de ontwikkeling van blockchain- of blockchain-apps.

Hier is een gids voor de ontwikkeling van dApps waarmee u de mechanismen achter het maken van een nieuwe gedecentraliseerde applicatie kunt begrijpen.

Kies een consensusmethode

Elke gedecentraliseerde app vereist een goed consensusalgoritme om te werken. Het zorgt ervoor dat de transacties worden gevalideerd en dat er geen fraude kan plaatsvinden. Als ontwikkelaar of leerling moet u kiezen uit een van de beschikbare consensusmethoden, inclusief Proof of Stake, Delegated Proof of Stake, Byzantijns fouttolerant, enzovoort! De keuze moet afhangen van uw bekendheid en app-vereisten.

Een platform kiezen

Hier moet u een platform naar keuze kiezen. Het is duidelijk dat we het bovenstaande punt al hebben behandeld. Je hebt voornamelijk drie platforms om uit te kiezen, waaronder Ethereum, Hyperledger Fabric en Cardano.

Er zijn veel enterprise blockchain-frameworks die je hiervoor kunt gebruiken, maar we gaan voor Ethereum.

Beheerdersconsole en gebruikersinterface

Apps moeten een goede gebruikerservaring hebben. Daarom zou je een blockchain-app moeten bouwen met een goede gebruikersinterface. De app moet ook een beheerdersconsole hebben, zodat u deze zonder problemen kunt beheren.

Inzicht in Blockchain-principes

Het is gebruikelijk dat ontwikkelaars een tutorial voor het ontwikkelen van blockchain-apps starten zonder de onderliggende concepten en principes te begrijpen. Daarom raad ik de basisprincipes van blockchain volledig aan voordat ik begin met de tutorials voor app-ontwikkeling. Misschien wilt u ook lezen over het ecosysteem, inclusief blockchain-tools, platforms en cryptocurrencies.

Oefen en ontwikkel

Oefen uw vaardigheden zo veel mogelijk. Dit geeft je de vaardigheden om in de toekomst complexere apps te ontwikkelen.

Hoe bouw je een Blockchain-app? De gemakkelijke aanpak

Ja, je leest het goed. In dit gedeelte zouden we ons concentreren op het maken van een eenvoudige blockchain-app in slechts vijf eenvoudige stappen. Als je nog nooit een blockchain-app hebt gebouwd, zullen deze vijf stappen je helpen het proces beter te begrijpen.

De vijf stappen zijn als volgt.

  • Installeer afhankelijkheden en kloon opslagplaatsen.
  • Ganache CLI uitvoeren
  • Contractsamenstelling
  • Contract implementatie
  • Contract interactie

En dat is alles. U kunt meer gedetailleerde stappen op de post zelf vinden. Het is een eenvoudige stem-app op blockchain.

Hoe bouw je een Blockchain-app? De harde aanpak

Oké! Je hebt me! Je wilt niet de gemakkelijke manier, maar blockchain op de harde manier leren. Maak je geen zorgen, want in dit gedeelte gaan we een takenlijst-app maken met behulp van slimme Ethereum-contracten.

Blockchain applicatie werking

Voordat we diep ingaan op het maken van een blockchain-app, moeten we eerst proberen te begrijpen hoe een blockchain-app zou werken.

Laten we, om dat te begrijpen, eens kijken hoe een eenvoudige app werkt. Elke app die op internet werkt, wordt op de computer van de gebruiker weergegeven met een browser of een speciale app in Windows. In elk geval vraagt ​​het de server om de pagina’s of informatie, die vervolgens wordt weergegeven op de computer van de gebruiker.

In het geval van de webapplicatie is alles gecentraliseerd. Dit biedt enkele voordelen; het laat echter veel te wensen over als het om beveiliging gaat. Blockchain-apps werken heel anders. Alles is gedecentraliseerd, ook de code en de data die in de app is opgeslagen.

Slimme contracten

De sleutel hier is het slimme contract. Een slim contract faciliteert de app zelf. Het bevat alle code die ervoor zorgt dat de app werkt. Het automatiseert ook het proces en zorgt ervoor dat het werkt zoals bedoeld. In onze tutorial gaan we slimme contracten gebruiken om de verschillende functionaliteiten van de to-do-lijst te schrijven.

Slimme contracten maken gebruik van de programmeertaal Solidity. Het is vergelijkbaar met JavaScript. Zodra een smart contract is geschreven, wordt de code onveranderlijk en onveranderlijk. U bent vrij om de code te wijzigen terwijl u implementeert. Als de app eenmaal is geïmplementeerd, kunt u de code echter niet meer wijzigen. Dit wordt gedaan om betrouwbaarheid en veiligheid te bieden aan blockchain-apps. De aanpak betekent ook dat u extra voorzichtig moet zijn en alle tests moet doen voordat u het slimme contract implementeert. Slimme contractcodes zijn ook openbaar van aard.

Wil je leren hoe je een blockchain bouwt met Python? Hier is een tutorial voor het bouwen van een blockchain met Python die je kunt volgen.

Onze Blockchain To-Do List-app maken

Om er zeker van te zijn dat je het concept begrijpt, moet je eerst leren hoe de Todo blockchain-app werkt. We zullen Ethereum gebruiken om de app te maken. Onze app gebruikt een enkel Ethereum-knooppunt en heeft ook een client-side applicatie. We gaan Solidity gebruiken om het slimme contract te schrijven en het vervolgens in te zetten.

Als ontwikkelaar moet u een Ethereum-portemonnee gebruiken – die is gemakkelijk te maken.

Voorbereiding – Creatie van de omgeving

Om een ​​lokale omgeving te creëren, hebben we meerdere tools en pakketten nodig. Laten we ze een voor een doornemen.

Ganache

Ganache is een Ethereum-ontwikkeltool. Hiermee kunt u applicaties, slimme contracten en tests beheren, implementeren en ontwikkelen. We gaan de Windows-versie gebruiken voor de zelfstudie. Als u een ander besturingssysteem heeft, kunt u ook de Mac- of de Linux-versie downloaden. Eenmaal geïnstalleerd, zou u het moeten kunnen gebruiken via de opdrachtregelhulpprogramma.

Node.js

De Node.js is onze volgende tool die moet worden geïnstalleerd. Om de private blockchain op uw computer te laten draaien, moet u het Knooppunt Pakketbeheer.

Eenmaal geïnstalleerd, open je je terminal en typ je de onderstaande opdracht. Als het werkt, ben je klaar om te gaan.

$ node -v

MetaMask Ethereum-portemonnee

Omdat we aan de Ethereum-blockchain gaan werken, hebben we een wallet nodig die vanuit de browser kan werken. Metamask is een webbrowser-portemonnee waarmee u kunt communiceren met de Ethereum-blockchain.

Truffel Framework

De laatste software die we gaan installeren is het Truffel Framework. Het biedt een breed scala aan tools waarmee u effectief aan uw dApp kunt werken. U kunt de programmeertaal Solidity gebruiken om een ​​Ethereum smart contract te ontwikkelen.

Enkele van de belangrijkste Truffle Framework-functies zijn onder meer de volgende

  • Goed slim contractbeheer
  • Netwerkbeheer
  • Geautomatiseerd testen
  • Ontwikkelingsconsole
  • Script Runner
  • Implementatie en migraties
  • Ontwikkeling aan de clientzijde.

Om te installeren, moet u de npm-opdracht. Voer gewoon de volgende opdracht uit op de opdrachtregel.

$ npm install -g [email protected]

Het duurt even voordat de installatie is voltooid. Houd er ook rekening mee dat u de exacte versie moet installeren om de zelfstudie te volgen.

Wil je een expert op het gebied van blockchain worden? Schrijf je in voor ons gecertificeerde professionele blockchain-cursus nu!

Het project opzetten

Stoer! We hebben nu onze ontwikkelomgeving klaar voor gebruik. Nu hoeven we alleen nog maar ons project te maken. Om dit te doen, moeten we de projectdirectory maken. Laten we het hieronder doen.

$ mkdir dapp-todo

$ cd dapp-todo

Als u zich eenmaal in de map bevindt, moet u het truffelproject starten door de onderstaande opdracht uit te voeren.

$ truffel init

Als u klaar bent, krijgt u een bericht zoals hierboven te zien. Dit betekent dat de map en bestanden met succes zijn aangemaakt. Nu kunt u de map openen in uw favoriete teksteditor. Maar voordat u dat doet, moet u het package.json het dossier. Dit zal u helpen bij het installeren van de afhankelijkheden die nodig zijn voor het project.

U kunt het bestand handmatig maken en vervolgens de onderstaande inhoud opslaan.

  “Name”: “dapp-todo”,

  “Version”: “1.0.0”,

  “Description”: “Door Ethereum aangedreven takenlijst”,

  “Main”: “truffle-config.js”,

  “Directories”: {

    “Test”: “test”

  ​,

  “Scripts”: {

    “Dev”: “lite-server”,

    “Test”: “echo \” Fout: geen test opgegeven \ ” && sexit 1 ″

  ​,

  “Author”: “[email protected]”,

  “Licentie”: “ISC”,

  “DevDependencies”: {

    “Bootstrap”: “4.1.3”,

    “Chai”: “^ 4.1.2”,

    “Chai-as-beloofd”: “^ 7.1.1”,

    “Chai-bignumber”: “^ 2.0.2”,

    “Lite-server”: “^ 2.3.0”,

    “Nodemon”: “^ 1.17.3”,

    “Truffle”: “5.0.2”,

    “Truffel-contract”: “3.0.6”

  ​

Als u klaar bent, voert u nu de volgende opdracht uit om de afhankelijkheden te installeren.

$ npm installeren

Inzicht in de directorystructuur

De directorystructuur ziet er als volgt uit.

Laten we elke map een voor een bekijken.

  • Contracten: De directory bevat alle slimme contracten. Het migrations.sol-contract behandelt de migraties naar de blockchain.
  • Migraties: De migratiedirectory bevat de migratiegegevens. Vanaf hier vinden de migraties plaats.
  • knooppuntmodules: Het bevat alle knooppuntmodules / afhankelijkheden.
  • Test: Deze map bevat de testbestanden.
  • truffel-config.js: Dit bestand bevat de configuratie van het truffelproject.

Het slimme contract maken

Het is nu tijd dat we beginnen met onze slimme contractcreatie. Onze slimme contracten worden opgeslagen in de map met contracten. Laten we een slim contractbestand maken met de naam todo.sol

Als u klaar bent, moet u nu de onderstaande code schrijven.

pragma stevigheid ^ 0,5,0;

contract Todo {

// Code hier

De eerste regel code geeft aan welke versie van Solidity we gebruiken om het slimme contract te schrijven. Vervolgens moeten we het trefwoord contract gebruiken en een Todo-contract maken. Hierin staat de code voor het slimme contract.

Laten we nu een variabele toevoegen om te zien of alles werkt zoals bedoeld.

pragma stevigheid ^ 0,5,0;

contract Todo {

uint-taken = 0;

Hier definiëren we de taakvariabele die het aantal taken telt dat we in onze Todo-app hebben.

Verbinden met Ganache

Nu ons slimme contract correct is ingesteld in Truffle, moeten we nu verbinding maken met de privé-blockchain van Ganache die we hebben gemaakt. Om dit te doen, moeten enkele configuratiebestanden worden bijgewerkt. We moeten ook een migratiescript maken en dit uitvoeren zodat we verbinding kunnen maken met het persoonlijke blockchain-netwerk.

Om te beginnen, moeten we het bestand truffle-config.json bijwerken. Het moet in de kernprojectdirectory staan. Zodra je het hebt geopend, kopieer en plak je de volgende code.

module.exports = {

netwerken: {

ontwikkeling: {

host: “127.0.0.1”,

poort: 7545,

network_id: “*” // Netwerk-ID-overeenkomst

​,

solc: {

optimizer: {

ingeschakeld: waar,

runs: 200

Nu het truffle-config.js-bestand is gemaakt, is het nu tijd voor ons om het migratiescript te maken, zodat het slimme contract dat we maken kan worden gemigreerd naar het persoonlijke blockchain-netwerk.

We zullen de naam opslaan als 2_deploy_contracts.js

De migraties zijn erg belangrijk voor onze Todo-app. Omdat blockchain een type database is, moeten we deze van de ene staat naar de andere veranderen. Dit is waar migraties helpen.

Om de migratiebestanden te koppelen, moeten we de volgende code bijwerken en de volgende code toevoegen aan het nieuw gemaakte migratiebestand.

var Todo = artifacts.require (“./ Todo.sol”);

module.exports = functie (implementator) {

deployer.deploy (Todo)

De eerste regel code creëert eenvoudig een variabele die verwijst naar ons slimme contract. Eenmaal gedaan, implementeren we het.

Als u klaar bent, gaan we nu de migratieopdracht uitvoeren.

$ Truffel migreren

U kunt de console ook uitvoeren met de onderstaande opdracht.

$ truffelconsole

Onze Todo List-app ontwikkelen

Nu we ons eerste slimme Ethereum-contract met succes hebben uitgevoerd, is het nu tijd voor ons om functies toe te voegen aan onze dApp. Onze dApp is eenvoudig. Het zal de taken in onze Todo-lijst weergeven. We moeten het slimme contract gebruiken om het te laten gebeuren.

Laten we het hieronder doen.

pragma stevigheid ^ 0,5,0;

contract Todo {

uint openbare taken = 0;

 

struct-taak {

uint id;

string inhoud;

bool voltooid;

Hier hebben we een struct-trefwoord gebruikt om een ​​nieuwe struct-taak te maken. We gebruiken het om de structuur van onze taak te definiëren, die de id, inhoud en de voltooide booleaanse waarde bevat.

Vervolgens moeten we nu onze taakstructuur in kaart brengen en openbaar maken, zodat deze toegankelijk is voor de blockchain. Om dit te doen, moeten we de volgende regel code toevoegen.

De slimme contractcode ziet er nu uit zoals hieronder.

pragma stevigheid ^ 0,5,0;

contract Todo {

uint openbare taken = 0;

struct-taak {

uint id;

string inhoud;

bool voltooid;

mapping (uint => Taak) publieke taken;

Ten slotte moeten we nu een functie maken die de taken afhandelt.

functie createTask (string memory _content) public {

taskCount ++;

taken [taskCount] = Taak (taskCount, _content, false)

De functie spreekt voor het grootste deel voor zich. We hebben de functie gemaakt zodat deze het aantal taken kan tellen dat op de Todo dApp wordt vermeld.

Ten slotte moeten we een constructor maken om de Todo-klasse te initialiseren.

constructor () openbaar {

createTask (“Dit is onze eerste taak”)

Ons todo.sol-bestand zou er nu als volgt uit moeten zien.

pragma stevigheid ^ 0,5,0;

contract Todo {

uint openbare taken = 0;

struct-taak {

uint id;

string inhoud;

bool voltooid;

constructor () openbaar {

createTask (“Dit is onze eerste taak”)

mapping (uint => Taak) publieke taken;

functie createTask (string memory _content) public {

taskCount ++;

taken [taskCount] = Taak (taskCount, _content, false)

Maak taken

We kunnen ook taken aanmaken in onze Todo dApp. Om dit te doen, moeten we een trigger maken wanneer een nieuwe taak wordt gemaakt. Onze aanpak is om een ​​nieuwe gebeurtenis TaskCreated te maken en deze vervolgens toe te voegen aan onze bestaande createTask () functie.

evenement TaskCreated (

uint id;

string inhoud,

bool voltooid

Voeg nu de volgende regel toe aan de functie createTask ().

TaskCreated uitzenden (taskCount, _content, false);

Taken voltooien

Het voltooien van taken kan ook worden toegevoegd met behulp van een evenement. Je moet het volgende evenement toevoegen aan het Todo-contract.

evenement TaskCompleted (

uint id,

bool voltooid

Om het te laten werken, moet u ook een nieuwe functie toevoegen.

functie toggleCompleted (uint _id) public {

Taakgeheugen _task = taken [_id];

_task.completed =! _task.completed;

taken [_id] = _task;

stuur TaskCompleted (_id, _task.completed)

Proficiat! Je hebt je eerste Todo-lijst dApp gemaakt op Ethereum blockchain.

Eindnoot

Dit leidt ons ook tot het einde van onze tutorial over het bouwen van een blockchain-app. Dit is hoe je vanuit het niets een build-blockchain-app bouwt.

Van daaruit moet u het contract goed testen voordat u het uiteindelijk naar de blockchain migreert. U kunt ook de front-end van de app maken en deze testen. Als je hier geen interesse in hebt, kun je de console opstarten en toegang krijgen tot de variabelen en functies om dingen uit te testen!

Maar als u zich nog steeds niet bewust bent van de implicaties van blockchain, dan raden we u aan om onze gratis blockchain-cursus te starten om er meer over te leren. Zonder te leren of te begrijpen hoe het werkt, zal het erg moeilijk voor je zijn om het programmeerconcept te begrijpen.

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me