Post Przewodnik krok po kroku po tworzeniu łańcucha bloków z Go (Golang) pojawił się po raz pierwszy w Coinpedia Fintech News

Wstęp

Blockchain fundamentalnie zmienił sposób, w jaki postrzegamy dane i bezpieczeństwo. W swojej istocie blockchain jest rozproszonym rejestrem, który rejestruje transakcje w wielu węzłach, co sprawia, że ​​zmiana tych zapisów po ich potwierdzeniu jest niemal niemożliwa. Ta przełomowa innowacja zrewolucjonizowała sektor finansowy, dając początek rynkowi kryptowalut.

Jednak wpływ technologii blockchain na tym się nie kończy — zmienia ona takie branże jak opieka zdrowotna, zarządzanie łańcuchem dostaw i wiele innych.

Go (Golang): idealne dopasowanie do rozwoju Blockchain

Go, znany również jako Golang, to język programowania opracowany przez Google, ceniony za wydajność i skalowalność w rozwoju oprogramowania. Jako statycznie typowany, kompilowany język, Go tłumaczy kod bezpośrednio na język maszynowy, co skutkuje szybszym wykonywaniem — czego sieci blockchain bardzo potrzebują.

Systemy blockchain wymagają szybkości i dużej przepustowości, a w tym Go sprawdza się znakomicie.

Jedną z wyróżniających się cech języka Go jest jego zdolność do obsługi współbieżności. Oznacza to, że Go może obsługiwać wiele operacji jednocześnie, maksymalizując wykorzystanie systemu. W blockchain, gdzie wiele bloków i transakcji występuje jednocześnie, model współbieżności języka Go zarządza tymi zadaniami wydajnie, nie komplikując zarządzania wielowątkowego.

Biblioteka dla potrzeb Blockchain

Go jest wyposażony w kompleksową bibliotekę standardową, która zapewnia niezbędne pakiety do obsługi sieci, kryptografii i przetwarzania danych — kluczowe funkcjonalności dla każdego systemu blockchain. Ponadto prostota i czytelność Go skracają krzywą uczenia się, ułatwiając programistom szybkie zrozumienie języka i jego składni.

Silne wsparcie społeczności

Dzięki dużej, aktywnej społeczności i rosnącemu wsparciu branży rozwiązywanie wszelkich problemów pojawiających się podczas rozwoju blockchain staje się łatwiejsze. Go oferuje solidne podstawy dla deweloperów, którzy chcą budować skalowalne, wydajne rozwiązania blockchain.

Praktyczny przewodnik po rozwoju Blockchain z Go

Ten artykuł jest przeznaczony dla początkujących, którzy chcą zagłębić się w świat Go i blockchain. Nauczysz się wszystkiego, od konfiguracji środowiska po konfigurację wymagań wstępnych, kompilowanie i testowanie własnych aplikacji blockchain. Więc, czy jesteś gotowy, aby odkryć blockchain z Go? Zaczynajmy!

Zrozumienie koncepcji Blockchain z Go

Zanim zagłębimy się w składnię i funkcje, konieczne jest zrozumienie podstawowych koncepcji blockchain. Zrozumienie tych podstaw ułatwi śledzenie kolejnych kroków technicznych.

Podstawy Blockchain w Go

Blockchain składa się z trzech komponentów: bloków, transakcji i łańcuchów.

Bloki: Blok jest prymitywną jednostką blockchain, która trwale przechowuje dane transakcji. Każdy blok ma własne metadane – takie jak indeks, znacznik czasu, hash i rzeczywiste informacje o transakcji. Bloki te są połączone łańcuchowo, tworząc sekwencyjny i niezmienny rejestr.

Transakcja: Transakcje są siłą napędową systemu. Reprezentują wszystkie niezbędne informacje dotyczące wymiany walut, transferu informacji itp. w sieci. Każdy blok zawiera serię transakcji, które są przetwarzane i weryfikowane przez sieć blockchain.

Łańcuch: Każdy blok ma wskaźnik do poprzedniego bloku, który działa jako odniesienie. To ciągłe połączenie bloków nazywa się łańcuchem bloków, stąd nazwa Blockchain.

Podstawowe zasady Blockchain

Decentralizacja: W przeciwieństwie do tradycyjnych baz danych zarządzanych przez organ centralny, blockchain rozdziela kontrolę na wiele węzłów. Każdy węzeł przechowuje kopię blockchain, zapewniając przejrzystość i zmniejszając ryzyko scentralizowanej korupcji lub awarii.

Niezmienność: Po zapisaniu danych w blockchainie nie można ich zmienić. Osiąga się to poprzez połączenie każdego bloku z poprzednim za pomocą kryptograficznego skrótu. Każda próba manipulacji blokiem zmienia jego skrót, przerywając łańcuch i alarmując sieć.

Mechanizm konsensusu: Mechanizmy konsensusu to protokoły, których wszyscy uczestnicy używają do walidacji transakcji i stanu księgi. Do powszechnych mechanizmów należą Proof of Work (PoW), Proof of Stake (PoS) i Practical Byzantine Fault Tolerance (PBFT).

Gotowy do tworzenia technologii Blockchain w języku Go?

Teraz powinieneś mieć solidne pojęcie o podstawach blockchain. Teraz nadchodzi ekscytująca część! W poniższych sekcjach poprowadzimy Cię krok po kroku przez tworzenie własnych aplikacji blockchain przy użyciu Go.

Przygotuj się na praktyczne doświadczenie! Zanurzmy się w praktycznej stronie rozwoju blockchain z Go.

Rozdział 1: Konfigurowanie środowiska programistycznego

Zanim zaczniesz pisać kod i kontrakty, konieczne jest odpowiednie środowisko programistyczne. Obejmuje to kilka kroków. Poniżej znajduje się szczegółowy przewodnik, jak zacząć. Przygotuj się i ruszaj!!

Instalowanie Go

  • Pobierz i zainstaluj najnowszą wersję Go z oficjalnej strony internetowej

  • Upewnij się, że pobierasz wersję przeznaczoną dla konkretnego systemu (Windows, Mac Os, Linux)

  • Skonfiguruj zmienne środowiskowe:

Windows: Instalator Go automatycznie dodaje Go do ścieżki PATH systemu, ale w razie potrzeby można dodać go ręcznie, wybierając Właściwości systemu > Zmienne środowiskowe

MacOS/Linux: export PATH=$PATH:/usr/local/go/bin (w bash lub zshrc)

Sprawdź instalację za pomocą polecenia: go version

Spowoduje to wyświetlenie wyniku np.: wersja go go1.19.0 linux/amd64

Wybór środowiska IDE

Zintegrowane środowisko programistyczne jest najbardziej niezbędnym elementem każdego rodzaju programowania. Innymi słowy, jest to kolejny edytor kodu. Gdy wybierasz, jest wiele opcji, ale dwie najpopularniejsze to VSCode i GoLand.

Visual Studio Code: VSCode – opracowany przez Microsoft jest platformą typu open source, jest wszechstronny i lekki, a także używany w różnych językach programowania. Oferuje potężne funkcje, takie jak uzupełnianie kodu, debugowanie i kontrola wersji.

  • Pobierz VSCode z oficjalnej strony

  • Postępuj zgodnie z instrukcjami wyświetlanymi na ekranie i zakończ instalację zgodnie ze swoim systemem.

  • Skonfiguruj VSCode z panelu rozszerzeń (Ctrl + Shift + X) i pobierz wszystkie niezbędne rozszerzenia, takie jak: rozszerzenie Go, Live Share, Gitlens itp.

GoLand: GoLand – opracowany przez JetBrains, to IDE dostosowane specjalnie do programowania w Go. Zawiera potężne narzędzia do debugowania, testowania i refaktoryzacji, a także zintegrowane wsparcie dla baz danych, co czyni go solidnym wyborem dla większych projektów.

  • Pobierz GoLand z oficjalnej strony JetBrains

  • Skonfiguruj i zainstaluj GoLAnd, a następnie prawidłowo skonfiguruj zmienne ścieżki Plik → Ustawienia → Przejdź → GOROOT

Oto wszystko, czego potrzebujesz, aby tworzyć projekty Go blockchain!

Instalowanie wymaganych bibliotek

Użyj polecenia go get, aby zainstalować niezbędne biblioteki.

Rozdział 2: Tworzenie prostego łańcucha bloków za pomocą Go

Bloki są podstawowymi jednostkami Blockchain. Blok zawiera wszystkie informacje o transakcjach, unikalne identyfikatory i linki do poprzednich bloków. W tym rozdziale przyjrzymy się strukturze bloku w Golang bardziej szczegółowo.

1. Tworzenie struktury blokowej

Blok jest reprezentowany w formie typu danych zwanego strukturą, może to być typ danych zdefiniowany przez użytkownika. Struktura bloku zawiera atrybuty takie jak:

  • Indeks: Indeks jest przydatny do oznaczania pozycji dowolnego bloku w łańcuchu bloków.

  • Znak czasu: Jest to czas utworzenia bloku

  • Dane: Zawierają wszelkiego rodzaju informacje związane z transakcją lub stanem bloku.

  • Poprzedni hash: Jest to hash poprzedniego bloku połączonego z bieżącym.

  • Hash: Unikalny identyfikator klucza każdego bloku ustalany za pomocą metod kryptograficznych

W poniższym fragmencie kodu zaimplementowaliśmy strukturę bloku.

typ Block struct {    Indeks        int    Znacznik czasu    ciąg    Dane         ciąg    PoprzedniHash ciąg    Hash         ciąg}

Zaimplementuj metody obliczania skrótu bloku, używając składni Go:

import (    “crypto/sha256”    “fmt”)funkcja (b *Block) obliczHash() ciąg {    dane := fmt.Sprintf(“%d%s%s%s”, b.Indeks, b.Znacznik czasu, b.Dane, b.PoprzedniHash)    hash := sha256.Sum256([]bajt(dane))    zwróć fmt.Sprintf(“%x”, hash)}

Funkcja calculatorHash() służy do obliczania skrótu bieżącego bloku

2. Tworzenie struktury Blockchain

Po zdefiniowaniu blockclass i jego atrybutów możesz przejść dalej i utworzyć blok genesis. Blok Genesis jest pierwszym blokiem w blockchain, który musi zostać zainicjowany i ma indeks równy zero. Po zdefiniowaniu bloku genesis możesz przejść dalej i dodać nowe bloki do swojego blockchain, używając metody addblock(). Po dodaniu nowego bloku oblicz również hash tego bloku. Oto kod:

func createGenesisBlock() Block {    return Block{Indeks: 0, Znak czasu: „2024-09-16”, Dane: „Blok Genesis”, PreviousHash: „0”}} func createGenesisBlock() Block {    return Block{Indeks: 0, Znak czasu: „2024-09-16”, Dane: „Blok Genesis”, PreviousHash: „0”}} func (bc *Blockchain) addBlock(data string) {    prevBlock := bc.getLatestBlock()    newBlock := Block{        Indeks:        prevBlock.Index + 1,        Znacznik czasu:    ​​„2024-09-16”,       Dane:        dane,        PoprzedniHash: prevBlock.Hash,    }    nowyBlock.Hash = nowyBlock.calculateHash()    bc.Blocks = append(bc.Blocks, nowyBlock)}

Rozdział 3: Wdrażanie mechanizmów konsensusu w Go

Dowód pracy

Wcześniej w tym artykule przedstawiliśmy przegląd mechanizmów konsensusu, teraz przyjrzyjmy się im bliżej w tym rozdziale. Mechanizmy konsensusu są kluczowe dla zabezpieczenia i walidacji transakcji oraz stanu bazy danych.

Najczęściej używanym mechanizmem konsensusu jest Proof of Work. W PoW górnicy konkurują ze sobą w ograniczonej czasowo sytuacji, aby rozwiązać trudną zagadkę kryptograficzną. Dlatego też nowy blok zostanie dodany dopiero po znalezieniu najbardziej odpowiedniego nonce i jego zweryfikowaniu. Ten zwiększony wysiłek zapewnia, że ​​nikt nie może kontrolować ani wprowadzać bloków bez poświęcania tych wysiłków obliczeniowych.

W pierwszym kroku musimy dodać atrybut proof do struktury:

}typ Block struct {    Indeks        int    Znacznik czasu    ciąg    Transakcje []Dowód transakcji        int    PoprzedniHash ciąg}

W drugim kroku należy wdrożyć metodę dowodu pracy, aby wygenerować dowód spełniający poziom trudności.

typ Block struct {    Indeks        int    Znacznik czasu    ciąg    Transakcje []Transakcja    Dowód        int    PoprzedniHash ciąg}funkcja (b *Block) proofOfWork(lastProof int) int {    dowód := 0    dla !isValidProof(lastProof, proof) {       dowód++     }    zwróć dowód }funkcja isValidProof(lastProof, proof int) bool {    zgadnij := strconv.Itoa(lastProof) + strconv.Itoa(dowód)    dowódHash := sha256.New()    guessHash.Write([]byte(guess))    guessHashString := fmt.Sprintf(“%x”, guessHash.Sum(nil))    return guessHashString[:4] == “0000” }

Zaktualizuj strukturę Blockchain, aby sprawdzić poprawność dowodu przed dodaniem nowych bloków. Ten krok zapewnia, że ​​do łańcucha bloków dodawane są tylko prawidłowe bloki.

typ Blockchain struct {    Łańcuch               []Blok    BieżąceTransakcje []Transakcja }func (bc *Blockchain) addBlock(proof int, previousHash string) {    blok := Blok{        Indeks:        len(bc.Chain) + 1,        Znacznik czasu:    ​​time.Now().String(),        Transakcje: bc.CurrentTransactions,        Dowód:        proof,        PoprzedniHash: previousHash,     }    bc.Chain = append(bc.Chain, blok)    bc.CurrentTransactions = nil }func (bc *Blockchain) validProof(lastProof, proof int) bool {    guess := strconv.Itoa(lastProof) + strconv.Itoa(proof)    guessHash := sha256.New()    guessHash.Write([]byte(guess))    guessHashString := fmt.Sprintf(“%x”, guessHash.Sum(nil))    return guessHashString[:4] == “0000”}

Rozdział 4: Tworzenie prostego interfejsu API łańcucha bloków za pomocą języka Go

Interfejs programowania aplikacji znany również jako API jest sercem i duszą każdej aplikacji. API pomaga różnym oprogramowaniom/platformom w interakcji ze sobą. Wprowadza to spójną naturę i bezproblemową integrację sieci i systemów zewnętrznych względem łańcucha bloków. API różnicują część front-end i back-end i jeszcze bardziej upraszczają interakcję. API ułatwiają łatwą integrację funkcji łańcucha bloków z istniejącymi systemami

Konfigurowanie środowiska API

Ponieważ Go jest już zainstalowany i skonfigurowany w Twoim systemie, możesz przejść dalej i skonfigurować środowisko API. Go ma standardową bibliotekę, która jest wystarczająca dla API, ale nadal możesz użyć Gin i Swagger, aby zbudować i udokumentować swoje API.

Zainstaluj i skonfiguruj narzędzia wymagane do tworzenia interfejsów API w języku Go.

przejdź do -u github.com/gin-gonic/gin //Gingo get -u github.com/swaggo/swag/cmd/swag //Swagger dla dokumentacji

Budowanie API

Tworzenie interfejsów API zapewnia modułowe podejście, umożliwiające skalowalną i łatwą w utrzymaniu integrację funkcji blockchain z różnymi systemami.

Utwórz API w celu zdefiniowania punktów końcowych umożliwiających dodawanie bloków i przeglądanie łańcucha bloków za pomocą języka Go.

//Konfigurowanie pakietu serwera mainimport (    “github.com/gin-gonic/gin”    “net/http”)func main() {    r := gin.Default()    r.POST(“/mine”, mineBlock)    r.GET(“/chain”, getChain)    r.Run(“:8080”) } //dodanie obsługi blokufunc addBlockHandler(w http.ResponseWriter, r *http.Request) {    var newBlock Block    json.NewDecoder(r.Body).Decode(&newBlock)    blockchain.addBlock(newBlock.Data)    json.NewEncoder(w).Encode(newBlock) }func getBlockchainHandler(w http.ResponseWriter, r *http.Request) {    json.NewEncoder(w).Encode(blockchain) }//Definicja punktów końcowych API func mineBlock(c *gin.Context) {    // Logika wydobywania nowego bloku    c.JSON(http.StatusOK, gin.H{“message”: “Blok wydobyty pomyślnie”}) }func getChain(c *gin.Context) {    // Logika zwracająca blockchain    c.JSON(http.StatusOK, gin.H{“chain”: blockchain}) }

W powyższym fragmencie kodu API Block Handlers to funkcje, które przetwarzają żądania związane z operacjami blockchain, takimi jak dodawanie nowych bloków lub pobieranie danych bloków. Punkty końcowe API to określone adresy URL lub trasy w API, które odpowiadają różnym operacjom lub zasobom.

Rozdział 5: Uruchamianie i testowanie aplikacji

Ostatnim krokiem każdego procesu rozwoju jest testowanie aplikacji. Mówi nam to wiele o funkcjonalnościach aplikacji, którą stworzyliśmy. Istnieje kilka metod testowania – testowanie jednostkowe, testowanie zintegrowane i testowanie zapewnienia jakości. Testowanie aplikacji przed jej wdrożeniem i uzyskaniem pełnej funkcjonalności jest ważne.

Uruchamianie aplikacji

Skompiluj i uruchom aplikację blockchain Go.

idź i biegnij main.go

To polecenie kompiluje i wykonuje Twój kod. W rezultacie będziesz mieć żądania przychodzące na porcie 8080 zgodnie ze specyfikacją.

Testowanie za pomocą Postmana

Przetestuj punkty końcowe interfejsu API za pomocą narzędzia Postman lub curl.

curl -X POST -d ‘{“Data”:”Nowy blok”}’ http://localhost:8080/block

Kliknij Wyślij, aby wysłać żądanie. Powinieneś otrzymać odpowiedź wskazującą, czy blok został pomyślnie dodany.

Rozdział 6: Przykład budowania aplikacji Blockchain za pomocą Go na żywo

Triumf! Dotarłeś do końca podróży rozwojowej. Zanim zakończymy, połączmy wszystko, co do tej pory studiowaliśmy i zaimplementujmy to w jednym kodzie krok po kroku.

Wykonanie krok po kroku

  • Krok 1: Utwórz strukturę Block z niezbędnymi atrybutami, korzystając ze składni Go.

  • Krok 2: Implementacja metody calculator_hash.

  • Krok 3: Zdefiniuj i zainicjuj strukturę Blockchain za pomocą bloku genesis.

  • Krok 4: Wdróż metody dodawania nowych bloków i pobierania najnowszego bloku za pomocą Go.

  • Krok 5: Dodaj funkcjonalność Proof of Work do struktury Block i zaktualizuj strukturę Blockchain.

  • Krok 6: Skonfiguruj środowisko API do obsługi żądań za pomocą języka Go.

  • Krok 7: Przetestuj aplikację, wydobywając nowy blok i weryfikując blockchain za pomocą narzędzia Postman lub curl.

pakiet mainimport ( „crypto/sha256” „encoding/hex” „encoding/json” „fmt” „log” „net/http” „strconv” „strings” „time” „github.com/gorilla/mux”)// Blok reprezentuje każdy „element” w blockchaintype Block struct { Indeks int // Pozycja bloku w łańcuchu Znak czasu string // Znak czasu utworzenia bloku Dane string // Dane przechowywane w bloku PreviousHash string // Skrót poprzedniego bloku Hash string // Skrót bieżącego bloku Dowód int // Dowód pracy}// Blockchain reprezentuje cały łańcuch blokówtype Blockchain struct { Blocks [] Block }// Utwórz blok Genesis (pierwszy blok w łańcuchu) func createGenesisBlock() Block { return Block{ Index: 0, timestamp: time.Now().String(), Data: „Genesis Block”, PreviousHash: „0”, Proof: 0, countHash: calculatedHash(0, time.Now().String(), „Genesis Block”, 0), }}// Oblicz skrót funkcji blockfunc calculatedHash(index int, timestamp, data, previousHash string, proof int) string {    record := strconv.Itoa(index) + timestamp + data + previousHash + strconv.Itoa(proof)    hash := sha256.New()    hash.Write([]byte(record))    hashed := hash.Sum(nil)    return hex.EncodeToString(hashed) }// Algorytm Proof of Work – prosta implementacja PoW, w której znajdujemy skrót z określoną liczbą wiodących zerfunc (b *Block) proofOfWork(difficulty int) {    for {        b.Hash = calculatedHash(b.Index, b.Timestamp, b.Data, b.PreviousHash, b.Proof)        if strings.HasPrefix(b.Hash, strings.Repeat(“0”, challenging)) {           break          }         b.Proof++     }}// Dodaj nowy blok do blockchainfunc (bc *Blockchain) addBlock(data string, challenging int) {    prevBlock := bc.getLatestBlock()    newBlock := Block{        Index:        prevBlock.Index + 1,        Timestamp:    time.Now().String(),        Data:         data,        PreviousHash: prevBlock.Hash,        Proof:        0,     }    newBlock.proofOfWork(difficulty)    bc.Blocks = append(bc.Blocks, newBlock) }// Pobierz najnowszy blok w łańcuchufunkcja (bc *Blockchain) getLatestBlock() Block {    return bc.Blocks[len(bc.Blocks)-1] }// Zainicjuj blockchain za pomocą funkcji bloku genesis initializeBlockchain() *Blockchain {    genesisBlock := createGenesisBlock()    return &Blockchain{[]Block{genesisBlock}}}// Obsługujące API// Pobierz całą funkcję blockchain getBlockchainHandler(w http.ResponseWriter, r *http.Request) {    json.NewEncoder(w).Encode(blockchain.Blocks)}// Dodaj nowy blok do funkcji blockchain addBlockHandler(w http.ResponseWriter, r *http.Request) {    var newBlockData struct {        Data string `json:”data”`    }    _ = json.NewDecoder(r.Body).Decode(&newBlockData)    blockchain.addBlock(newBlockData.Data, challenging)    json.NewEncoder(w).Encode(blockchain.getLatestBlock()) }// Zainicjuj blockchain i poziom trudności dla Proof of Workvar blockchain = initializeBlockchain()var challenging = 3 // Poziom trudności Proof of Work// Skonfiguruj serwer API funnc main() {    router := mux.NewRouter()    router.HandleFunc(“/blockchain”, getBlockchainHandler).Methods(“GET”)    router.HandleFunc(“/block”, addBlockHandler).Methods(“POST”)    log.Println(“Nasłuchiwanie na porcie 8080…”)    log.Fatal(http.ListenAndServe(“:8080”, router))}

Wnioski i przyszłe kierunki

Gratulacje! Udało Ci się zbudować funkcjonalną aplikację blockchain przy użyciu Go! Dzięki temu przewodnikowi zdobyłeś podstawowe umiejętności, w tym tworzenie blockchain od podstaw, wdrażanie Proof of Work i konfigurowanie REST API do interakcji z Twoim blockchainem. Najważniejsze wnioski z tej podróży obejmują:

  • Definiowanie i strukturyzacja bloków

  • Wdrażanie mechanizmów konsensusu

  • Integrowanie interfejsów API w celu interakcji z blockchainem

Ale to dopiero początek. Kontynuując swoją podróż w rozwój blockchain z Go, są ekscytujące obszary do eksploracji i udoskonalania.

Przyszłość Go w rozwoju zdecentralizowanych aplikacji (dApp) ma ogromny potencjał. Niektóre zaawansowane tematy, w które warto się zagłębić, to:

  • Eksploracja zaawansowanych mechanizmów konsensusu

  • Ulepszenia skalowalności

  • Interoperacyjność

  • Zastosowania w świecie rzeczywistym

W miarę postępów nie wahaj się eksperymentować, udoskonalać i wprowadzać innowacji. Świat blockchain szybko ewoluuje, a Twoje umiejętności w Go pozwolą Ci pozostać na czele.

Dziękujemy za skorzystanie z tego przewodnika i życzymy przyjemnego kodowania podczas dalszej przygody z rozwojem blockchain!

Sprawdź także: Jak zbudować swój pierwszy blockchain z Plutus: samouczek krok po kroku