คำแนะนำทีละขั้นตอนในการสร้าง Blockchain ด้วย Go (Golang)

by

คำแนะนำทีละขั้นตอนในการสร้าง Blockchain ด้วย Go (Golang)

บทนำ

ในขณะที่คุณอ่านคู่มือนี้ คุณไม่เพียงแต่สร้างแอปพลิเคชันบล็อกเชนที่ใช้งานได้โดยใช้ Go เท่านั้น แต่ยังได้รับข้อมูลเชิงลึกอันมีค่าเกี่ยวกับโลกแห่งเทคโนโลยีกระจายอำนาจอีกด้วย!

เทคโนโลยีบล็อคเชนเปลี่ยนมุมมองของเราเกี่ยวกับข้อมูลและความปลอดภัยอย่างมาก โดยพื้นฐานแล้ว บล็อกเชนคือระบบที่คอมพิวเตอร์หลายเครื่อง (หรือ ‘โหนด’) เก็บข้อมูลธุรกรรมไว้ด้วยกัน ทำให้ยากต่อการแก้ไขบันทึกเหล่านี้หลังจากได้รับการยืนยันแล้ว แนวคิดการปฏิวัตินี้ได้เปลี่ยนโฉมภาคการเงินอย่างมาก ซึ่งนำไปสู่การเกิดขึ้นของตลาดสกุลเงินดิจิทัล

แต่อิทธิพลของบล็อกเชนไม่ได้หยุดอยู่แค่นั้น แต่กำลังพลิกโฉมอุตสาหกรรม เช่น การดูแลสุขภาพ การจัดการห่วงโซ่อุปทาน และอื่นๆ

Go (Golang): การจับคู่ที่สมบูรณ์แบบสำหรับการพัฒนาบล็อคเชน

Go หรือที่มักเรียกกันว่า Golang เป็นภาษาโปรแกรมที่มีต้นกำเนิดจาก Google มีชื่อเสียงในด้านประสิทธิภาพและความสามารถในการปรับขนาดได้เมื่อพูดถึงโครงการพัฒนาซอฟต์แวร์ ด้วยการพิมพ์และคอมไพล์แบบคงที่ Go จะแปลงโค้ดเป็นภาษาเครื่องโดยตรง ซึ่งนำไปสู่การดำเนินการที่รวดเร็วยิ่งขึ้น ซึ่งเป็นคุณลักษณะที่เครือข่ายบล็อกเชนพบว่ามีประโยชน์อย่างยิ่ง

ระบบบล็อกเชนต้องการความเร็วและปริมาณงานสูง ซึ่งเป็นจุดที่ Go เป็นเลิศ

ลักษณะเด่นประการหนึ่งของภาษาการเขียนโปรแกรม Go คือความสามารถในการจัดการการทำงานพร้อมกัน ช่วยให้สามารถทำงานหลายอย่างพร้อมกันได้ จึงช่วยเพิ่มประสิทธิภาพของระบบให้เหมาะสม ในบริบทของบล็อกเชน ซึ่งบล็อกและธุรกรรมจำนวนมากสามารถเกิดขึ้นพร้อมกันได้ โมเดลการทำงานพร้อมกันของ Go จัดการงานเหล่านี้ได้อย่างมีประสิทธิภาพ โดยไม่เพิ่มความซับซ้อนในการจัดการหลายเธรด

ห้องสมุดสำหรับความต้องการบล็อคเชน

Go นำเสนอไลบรารีมาตรฐานที่ครอบคลุมซึ่งประกอบด้วยแพ็คเกจที่สำคัญสำหรับการดำเนินงานเครือข่าย การเข้ารหัส และการจัดการข้อมูล ซึ่งเป็นองค์ประกอบสำคัญในการสร้างโครงสร้างพื้นฐานบล็อกเชน นอกจากนี้ โครงสร้างที่ตรงไปตรงมาของ Go และไวยากรณ์ที่ชัดเจนยังช่วยให้นักพัฒนาเข้าใจภาษาและแบบแผนได้รวดเร็วยิ่งขึ้น

การสนับสนุนชุมชนที่เข้มแข็ง

พูดง่ายๆ ก็คือ เมื่อพูดถึงการพัฒนาบล็อคเชน ปัญหาต่างๆ จะถูกจัดการได้มากขึ้น เนื่องจากมีชุมชนที่เจริญรุ่งเรืองและมีส่วนร่วม รวมถึงการสนับสนุนจากอุตสาหกรรมที่เพิ่มขึ้น สำหรับนักพัฒนาที่ต้องการสร้างโครงการบล็อกเชนที่มีประสิทธิภาพและปรับขนาดได้ Go ถือเป็นฐานที่แข็งแกร่ง

คู่มือเชิงปฏิบัติสำหรับการพัฒนาบล็อกเชนด้วย Go

บทความนี้ออกแบบมาสำหรับผู้มาใหม่ที่ผจญภัยในอาณาจักรของภาษาการเขียนโปรแกรม Go และเทคโนโลยีบล็อกเชน คุณจะได้รับความรู้เกี่ยวกับวิธีการสร้างสภาพแวดล้อมการทำงาน กำหนดค่าข้อกำหนดเบื้องต้นที่จำเป็น เขียน คอมไพล์ และทดสอบแอปพลิเคชันบล็อกเชนของคุณเอง คุณกระตือรือร้นที่จะเจาะลึกการพัฒนาบล็อคเชนกับ Go หรือไม่? มาเริ่มต้นการเดินทางที่น่าตื่นเต้นนี้กันเถอะ!

ทำความเข้าใจแนวคิดบล็อคเชนด้วย Go

ในการเริ่มต้นด้วยการสำรวจความซับซ้อนของบล็อกเชน ขั้นแรก เรามาตรวจสอบรากฐานที่มั่นคงโดยการทำความเข้าใจหลักการพื้นฐานของบล็อกเชนกันก่อน การเรียนรู้พื้นฐานเหล่านี้จะทำให้ด้านเทคนิคที่ตามมาสามารถจัดการได้ง่ายขึ้น

พื้นฐานบล็อคเชนใน Go

บล็อคเชนมีองค์ประกอบสามส่วน: บล็อก ธุรกรรม และเชน

บล็อกในบล็อกเชน: บล็อกคือหน่วยการสร้างพื้นฐานของบล็อกเชน ซึ่งทำหน้าที่เป็นที่จัดเก็บข้อมูลถาวรสำหรับข้อมูลธุรกรรม แต่ละบล็อกประกอบด้วยข้อมูลเมตา เช่น ดัชนี การประทับเวลา ค่าแฮช และรายละเอียดธุรกรรม บล็อกเหล่านี้เชื่อมโยงเข้าด้วยกัน ทำให้เกิดบันทึกที่เปลี่ยนแปลงไม่ได้และตามลำดับเวลาที่เรียกว่าบัญชีแยกประเภท

การดำเนินการ: การดำเนินการทำหน้าที่เป็นแกนหลักของระบบ โดยครอบคลุมทุกรายละเอียดที่สำคัญเกี่ยวกับการเคลื่อนย้ายเงินทุน การส่งข้อมูล และอื่นๆ ทั่วทั้งเครือข่าย แต่ละบล็อกจะมีชุดการดำเนินการที่ได้รับการตรวจสอบและตรวจสอบโดยเครือข่ายบล็อกเชน

แต่ละบล็อกจะมีลิงก์ไปยังบล็อกก่อนหน้าเพื่อใช้เป็นข้อมูลอ้างอิง เมื่อลิงก์เหล่านี้เชื่อมโยงบล็อกทั้งหมดเข้าด้วยกัน เราจะเรียกบล็อกเหล่านั้นว่าเป็นชุดหรือลูกโซ่ของบล็อก จึงเป็นที่มาของคำว่า Blockchain

หลักการสำคัญของบล็อคเชน

เทคโนโลยีบล็อกเชนแตกต่างจากฐานข้อมูลทั่วไปตรงที่ไม่ต้องพึ่งพาหน่วยงานกลางเพียงแห่งเดียวในการจัดการ ในทางกลับกัน การควบคุมจะกระจายไปยังโหนดที่เข้าร่วมจำนวนมาก การตั้งค่านี้หมายความว่าแต่ละโหนดจะเก็บสำเนาบล็อกเชนของตัวเอง ส่งเสริมความโปร่งใสและลดความเสี่ยงที่เกี่ยวข้องกับความเสียหายหรือความล้มเหลวของระบบในการตั้งค่าแบบรวมศูนย์

ความไม่เปลี่ยนรูปของบล็อคเชน: ข้อมูลเมื่อเก็บไว้ในบล็อคเชนยังคงไม่สามารถเปลี่ยนแปลงได้ มั่นใจได้โดยการเชื่อมต่อแต่ละบล็อกกับบล็อกก่อนหน้าด้วยวิธีการเข้ารหัสที่ซับซ้อนที่เรียกว่าแฮชการเข้ารหัส ความพยายามใดๆ ในการจัดการกับบล็อกส่งผลให้เกิดการเปลี่ยนแปลงแฮช ขัดขวางห่วงโซ่และทำให้เกิดคำเตือนทั่วทั้งเครือข่าย

โปรโตคอลข้อตกลง: นี่คือชุดกฎที่ผู้ใช้ทุกคนปฏิบัติตามเพื่อตรวจสอบธุรกรรมและสถานะของสมุดบันทึก วิธีการทั่วไปบางวิธี ได้แก่ Proof of Labor (PoL – หมายถึง PoW), Proof of Ownership (PoO – หมายถึง PoS) และ Robust Byzantine Fault Tolerance (RBFT)

พร้อมสร้างบล็อคเชนด้วย Go แล้วหรือยัง

ถึงตอนนี้ คุณควรมีความเข้าใจพื้นฐานบล็อกเชนอย่างมั่นคงแล้ว มาถึงส่วนที่น่าตื่นเต้นแล้ว! ในส่วนต่อไปนี้ เราจะแนะนำคุณทีละขั้นตอนในการสร้างแอปพลิเคชันบล็อกเชนของคุณเองโดยใช้ Go

เตรียมลงมือปฏิบัติได้เลย! มาดำดิ่งสู่การปฏิบัติจริงของการพัฒนาบล็อคเชนด้วย Go

บทที่ 1: การตั้งค่าสภาพแวดล้อมการพัฒนา

ในการเริ่มต้นการเขียนโค้ดและการทำสัญญา จำเป็นต้องมีการตั้งค่าการพัฒนาที่เหมาะสมก่อน ต่อไปนี้เป็นคำแนะนำแบบทีละขั้นตอนเกี่ยวกับวิธีเริ่มต้น: มาเริ่มกันเลย!

การติดตั้ง Go

  • ดาวน์โหลดและติดตั้ง Go เวอร์ชันล่าสุดจากเว็บไซต์อย่างเป็นทางการ
  • ตรวจสอบให้แน่ใจว่าคุณดาวน์โหลดเวอร์ชันเฉพาะระบบ (Windows, Mac Os, Linux)
  • ตั้งค่าตัวแปรสภาพแวดล้อม:

บน Windows ตัวติดตั้ง Go จะรวม Go ไว้ใน PATH ของระบบของคุณโดยอัตโนมัติ อย่างไรก็ตาม หากจำเป็นต้องปรับเปลี่ยนด้วยตนเอง คุณสามารถทำได้โดยไปที่ คุณสมบัติระบบ > ตัวแปรสภาพแวดล้อม

MacOS/Linux: ส่งออก PATH=$PATH:/usr/local/go/bin (ใน bash หรือ zshrc)

ตรวจสอบการติดตั้งโดยใช้คำสั่ง: go version

สิ่งนี้จะให้ผลลัพธ์เช่น: go version go1.19.0 linux/amd64

การเลือก IDE

Programming Environment Integrated (IDE) เป็นสิ่งจำเป็นสำหรับงานเขียนโค้ดใดๆ พูดง่ายๆ ก็คือ มันทำหน้าที่เป็นทางเลือกแทนโปรแกรมแก้ไขข้อความพื้นฐาน เมื่อพูดถึงตัวเลือก คุณจะพบหลายตัวเลือก แต่ VSCode และ GoLand มักจะเป็นตัวเลือกอันดับต้น ๆ ในหมู่นักพัฒนา

VS Code: ซอฟต์แวร์นี้เรียกว่า VSCode เป็นเครื่องมือที่ยืดหยุ่นและมีน้ำหนักเบาซึ่งสร้างโดย Microsoft มันเข้ากันได้กับภาษาการเขียนโปรแกรมมากมาย มีคุณลักษณะที่มีประสิทธิภาพ เช่น การเติมโค้ดอัตโนมัติ ความสามารถในการดีบัก และการควบคุมเวอร์ชัน

  • ดาวน์โหลด VSCode จากเว็บไซต์อย่างเป็นทางการ
  • ทำตามคำแนะนำบนหน้าจอและทำการติดตั้งให้เสร็จสิ้นตามระบบของคุณ
  • ตั้งค่า VSCode จากแผงส่วนขยาย (Ctrl + Shift + X) และดาวน์โหลดไฟล์ที่จำเป็นทั้งหมดเช่น– Go extension, live share, Gitlens ฯลฯ

GoLand ของ JetBrains: GoLand สร้างขึ้นโดย JetBrains เป็นสภาพแวดล้อมการพัฒนาแบบผสมผสาน (IDE) ที่ออกแบบมาสำหรับการเขียนโปรแกรม Go โดยเฉพาะ มีความสามารถในการดีบัก การทดสอบ และการปรับโครงสร้างใหม่ที่แข็งแกร่ง พร้อมการรองรับฐานข้อมูลในตัว ทำให้เป็นตัวเลือกที่เชื่อถือได้สำหรับโปรเจ็กต์ที่ซับซ้อน

  • ดาวน์โหลด GoLand จากเว็บไซต์ทางการของ JetBrains
  • ตั้งค่าและติดตั้ง GoLAnd จากนั้นตั้งค่าตัวแปรเส้นทางอย่างถูกต้อง File →Settings →Go →GOROOT

ที่นี่คุณพร้อมที่จะสร้างโปรเจ็กต์ Go blockchain แล้ว !!

การติดตั้งไลบรารีที่จำเป็น

ใช้ go get เพื่อติดตั้งไลบรารี่ที่จำเป็น

บทที่ 2: การสร้างบล็อกเชนอย่างง่ายด้วย Go

ในฐานะนักลงทุน crypto ผู้ช่ำชอง ฉันได้เจาะลึกความซับซ้อนของการทำความเข้าใจ Building Block ที่เป็นรากฐานของ Blockchain อันยิ่งใหญ่ ซึ่งก็คือบล็อกนั่นเอง! แต่ละบล็อกทำหน้าที่เป็นที่เก็บข้อมูลธุรกรรมทั้งหมด ตัวระบุเฉพาะ และตัวชี้ที่เชื่อมโยงกับรุ่นก่อนในห่วงโซ่ ในเส้นทางแห่งการศึกษานี้ ให้เราวิเคราะห์สถาปัตยกรรมของบล็อกเหล่านี้ใน Golang โดยเปิดเผยผลงานภายในของพวกเขาทีละขั้นตอน

1. การสร้างโครงสร้างบล็อก

บล็อกถูกกำหนดโดยใช้โครงสร้างข้อมูลแบบกำหนดเองที่เรียกว่า struct ซึ่งสามารถกำหนดโดยผู้ใช้ได้ โครงสร้างสำหรับบล็อกมีคุณสมบัติเช่น:

  • ดัชนี: ดัชนีมีประโยชน์ในการระบุตำแหน่งของบล็อกใดๆ ในบล็อกเชน
  • ประทับเวลา: คือเวลาที่บล็อกถูกสร้างขึ้น
  • ข้อมูล: ประกอบด้วยข้อมูลประเภทใดก็ตามที่เกี่ยวข้องกับธุรกรรมหรือสถานะของบล็อก
  • แฮชก่อนหน้า: มันคือแฮชของบล็อกก่อนหน้าที่เชื่อมต่อกับบล็อกปัจจุบัน
  • แฮช: ตัวระบุคีย์เฉพาะของแต่ละบล็อกที่ตัดสินใจด้วยวิธีการเข้ารหัส

ในตัวอย่างโค้ดต่อไปนี้ เราได้นำโครงสร้างบล็อกไปใช้แล้ว

ประเภท Block struct {    
Index        int    
การประทับเวลา    string    
ข้อมูล         string    
สตริงแฮชก่อนหน้า    
แฮช         สตริง

ใช้วิธีการคำนวณแฮชของบล็อกโดยใช้ไวยากรณ์ Go:

นำเข้า (    
“crypto/sha256”    
“fmt”
)

func (b *Block) คำนวณสตริงแฮช {    
data := fmt.Sprintf(“%d%s%s%s”,
b.Index, b.Timestamp, b.Data, b.PreviousHash)    
hash := sha256.Sum256([]byte(data) ))    
ส่งคืน fmt.Sprintf(“%x”, แฮช)}

ฟังก์ชันการคำนวณ Hash ใช้เพื่อคำนวณการแฮชของบล็อกปัจจุบัน

<ข>2. การสร้างโครงสร้างบล็อคเชน

เมื่อคุณสร้างคลาสบล็อกและคุณลักษณะของมันแล้ว ให้สร้างบล็อก Genesis เริ่มต้นต่อไป บล็อก Genesis ทำหน้าที่เป็นบล็อกแรกในบล็อกเชนและต้องมีการเริ่มต้นด้วยดัชนีเป็นศูนย์ หลังจากตั้งค่าบล็อก Genesis แล้ว คุณสามารถดำเนินการต่อท้ายบล็อกเพิ่มเติมเข้ากับบล็อกเชนของคุณโดยใช้วิธี addblock อย่าลืมคำนวณแฮชของบล็อกที่เพิ่งเพิ่มเข้ามาด้วย นี่คือรหัส:

func createGenesisBlock Block {    
ส่งคืนบล็อก{ดัชนี: 0, การประทับเวลา: “2024-09-16”,
ข้อมูล: “ปฐมกาล บล็อก”, PreviousHash: “0”}
}
func createGenesisBlock บล็อก {    
ส่งคืนบล็อก{ ดัชนี: 0, การประทับเวลา: “2024-09-16”,
ข้อมูล: “Genesis Block”, PreviousHash: “0”}
}
func (bc *Blockchain) addBlock(สตริงข้อมูล) {    
prevBlock := bc.getLatestBlock    
newBlock := Block{        
ดัชนี:        prevBlock.Index + 1,        
ประทับเวลา:    “2024-09-16”,        
ข้อมูล:         ข้อมูล,        
PreviousHash: prevBlock.Hash,    
}    
newBlock.Hash = newBlock.calculateHash    
bc.Blocks = ผนวก(bc.Blocks, newBlock)
}

บทที่ 3: การใช้กลไกฉันทามติใน Go

หลักฐานการทำงาน

ก่อนหน้านี้ เราได้ให้ความเข้าใจทั่วไปเกี่ยวกับกลไกฉันทามติภายในบทความนี้ ตอนนี้ เรามาเจาะลึกเข้าไปในกลไกเหล่านี้ในส่วนนี้กัน โดยพื้นฐานแล้ว กลไกที่เป็นเอกฉันท์มีบทบาทสำคัญในการรับรองความปลอดภัยของธุรกรรมและตรวจสอบสถานะของฐานข้อมูล

กลไกฉันทามติหลักในการใช้งานอย่างแพร่หลายเรียกว่า Proof of Work (PoW) ในกลไกนี้ นักขุดจะมีส่วนร่วมในการแข่งขันภายใต้ข้อจำกัดด้านเวลาเพื่อแก้ไขปัญหาการเข้ารหัสที่ซับซ้อน เมื่อนักขุดแก้ปัญหาได้สำเร็จและพบ nonce ที่ถูกต้อง วิธีแก้ปัญหาของพวกเขาจะต้องได้รับการตรวจสอบ จากนั้นจะมีการเพิ่มบล็อกใหม่ ความพยายามอันเข้มข้นนี้ทำให้มั่นใจได้ว่าไม่มีบุคคลใดสามารถจัดการหรือเพิ่มบล็อกได้โดยไม่ต้องลงทุนทรัพยากรการคำนวณจำนวนมาก

ในขั้นตอนแรกเราต้องเพิ่มแอตทริบิวต์การพิสูจน์ให้กับโครงสร้าง:

}ประเภท Block struct {    
Index        int    
ประทับเวลา    string    
ธุรกรรม []ธุรกรรม    
พิสูจน์        int    
สตริงแฮชก่อนหน้า
}

ในขั้นตอนที่สอง ลองใช้เทคนิค Proof of Work เพื่อสร้างการตรวจสอบที่ตรงกับระดับความซับซ้อนที่ต้องการ

ประเภท Block struct {    
Index        int    
ประทับเวลา    string    
ธุรกรรม [ ]ธุรกรรม    
Proof        int    
สตริง PreviousHash
}
func (b *Block) proofOfWork(lastProof int) int {    
proof := 0    
สำหรับ !isValidProof(lastProof, พิสูจน์) {        
หลักฐาน++   
 }    
หลักฐานการคืนสินค้า
}
func isValidProof(lastProof, proof int) บูล {   
 guess := strconv.Itoa(lastProof) + strconv.Itoa(พิสูจน์)    
guessHash := sha256.New    
guessHash.Write([]byte(guess))    
guessHashString := fmt .Sprintf(“%x”,guessHash.Sum(nil))    
ส่งคืนguessHashString[:4] == “0000”
}

แก้ไขโครงสร้างบล็อคเชนเพื่อตรวจสอบหลักฐานก่อนที่จะผนวกบล็อคใหม่ เพื่อให้มั่นใจว่ามีเพียงบล็อคที่ถูกต้องเท่านั้นที่จะรวมอยู่ในบล็อคเชน

ประเภทโครงสร้าง Blockchain
{    Chain               []บล็อก    
CurrentTransactions []ธุรกรรม
}
func (bc *Blockchain) addBlock(พิสูจน์ int,
สตริงแฮชก่อนหน้า) {    
block := บล็อก{        
ดัชนี:        len(bc.Chain) + 1,        
ประทับเวลา:    time.Now.String,        
ธุรกรรม: bc.CurrentTransactions,        
พิสูจน์:        พิสูจน์,        
PreviousHash: PreviousHash,    
}    
bc.Chain = ผนวก(bc.Chain, บล็อก)    
bc.CurrentTransactions = ไม่มี< br/> }
func (bc *Blockchain) validProof(lastProof, proof int) บูล {    
เดา := strconv.Itoa (lastProof) + strconv.Itoa(พิสูจน์)    
guessHash := sha256.New    
guessHash.Write([]byte(guess))    
guessHashString := fmt.Sprintf(“%x”,guessHash.Sum(nil))    
ส่งคืนguessHashString[:4] == “0000 ”}

บทที่ 4: การสร้าง Blockchain API อย่างง่ายด้วย Go

Application Programming Interface หรือที่เรียกกันทั่วไปว่า API ทำหน้าที่เป็นส่วนสำคัญของซอฟต์แวร์หรือแอปพลิเคชันใดๆ ช่วยให้ซอฟต์แวร์หรือแพลตฟอร์มต่างๆ สามารถสื่อสารระหว่างกัน ส่งเสริมการเชื่อมต่อที่เป็นหนึ่งเดียวและราบรื่นผ่านเครือข่ายและระบบภายนอกนอกเหนือจากบล็อกเชน API มีบทบาทสำคัญในการแยกฟังก์ชันส่วนหน้าและส่วนหลังออก ในขณะที่ทำให้การโต้ตอบตรงไปตรงมามากขึ้น นอกจากนี้ API ยังทำให้การรวมคุณสมบัติบล็อกเชนเข้ากับระบบที่มีอยู่เป็นเรื่องง่าย

การตั้งค่าสภาพแวดล้อม API

เนื่องจาก Go ได้รับการตั้งค่าและพร้อมใช้งานบนระบบของคุณแล้ว คุณจึงสามารถดำเนินการกำหนดค่าการตั้งค่า API ต่อไปได้ แม้ว่าไลบรารีมาตรฐานของ Go จะมีทรัพยากรเพียงพอสำหรับการพัฒนา API แต่คุณอาจเลือกใช้ Gin และ Swagger เพื่อสร้างและจัดทำเอกสาร API ของคุณได้เช่นกัน

ติดตั้งและกำหนดค่าเครื่องมือที่จำเป็นสำหรับการสร้าง API ด้วย Go  

ไปรับ -u github.com/gin-gonic/gin //Gin
ไปรับ -u github.com/swaggo/swag/cmd/swag
//Swagger สำหรับเอกสาร

การสร้าง API

การพัฒนา Application Programming Interfaces (API) นำเสนอวิธีการแบบโมดูลาร์ที่ยืดหยุ่น ช่วยให้สามารถรวมความสามารถบล็อกเชนข้ามแพลตฟอร์มต่างๆ ได้อย่างราบรื่นและปรับขนาดได้

สร้าง API เพื่อกำหนดจุดสิ้นสุดสำหรับการเพิ่มบล็อกและการดูบล็อกเชนโดยใช้ Go

//การตั้งค่าเซิร์ฟเวอร์
แพ็คเกจหลัก
นำเข้า (    “github.com/gin-gonic/gin”    
“net/http”
)
ฟังก์ชั่นหลัก {    
r := gin.Default    
r.POST(“/mine”, mineBlock)    
r.GET(“/chain”, getChain)    
r.Run(“:8080”)
}

//เพิ่ม ตัวจัดการบล็อก
func addBlockHandler (ด้วย http.ResponseWriter, r
*http.Request) {    
var newBlock Block    
json.NewDecoder(r.Body).Decode(&newBlock)    
blockchain.addBlock(newBlock.Data)    
json.NewEncoder(w).เข้ารหัส(newBlock)
}
func getBlockchainHandler(w < br/>http.ResponseWriter, r *http.Request) {    
json.NewEncoder(w).Encode(blockchain)

//กำหนดจุดสิ้นสุด API
func mineBlock(c *gin.Context) {    
// ตรรกะในการขุดบล็อกใหม่    
c.JSON(http.StatusOK, gin.H{“message”:
“ บล็อกการขุดสำเร็จ”})
}
func getChain(c *gin.Context) {    
// ตรรกะในการส่งคืน blockchain    
c.JSON(http.StatusOK, gin.H{“chain”:
blockchain})
}

ในส่วนโค้ดที่ให้มา ตัวจัดการบล็อก API หมายถึงฟังก์ชันที่จัดการและจัดการคำขอที่เกี่ยวข้องกับงานบล็อกเชน เช่น การสร้างบล็อกใหม่หรือการดึงรายละเอียดบล็อก ในทางกลับกัน ตำแหน่งข้อมูล API คือ URL หรือเส้นทางที่ไม่ซ้ำกันภายใน API ที่ตรงกับการดำเนินการหรือทรัพยากรต่างๆ

บทที่ 5: การเรียกใช้และการทดสอบแอปพลิเคชัน

ในโครงการพัฒนาใดๆ ขั้นตอนสุดท้ายเกี่ยวข้องกับการทดสอบแอปพลิเคชันที่สร้างขึ้นอย่างละเอียดเพื่อทำความเข้าใจคุณลักษณะต่างๆ ให้ดีขึ้น มีเทคนิคการทดสอบที่หลากหลาย เช่น การทดสอบหน่วย การทดสอบแบบรวม และการทดสอบการประกันคุณภาพ ที่ช่วยให้แน่ใจว่าแอปทำงานได้อย่างถูกต้องก่อนการปรับใช้และฟังก์ชันการทำงานเต็มรูปแบบ

การเรียกใช้แอปพลิเคชัน

รวบรวมและเรียกใช้แอปพลิเคชัน Go blockchain

ไปรัน main.go

เมื่อใช้คำสั่งนี้ โค้ดของคุณจะได้รับทั้งการคอมไพล์และรัน ด้วยเหตุนี้ จึงตั้งค่าให้คุณรับคำขอขาเข้าที่พอร์ต 8080 ที่กำหนด

การทดสอบกับบุรุษไปรษณีย์

ทดสอบจุดสิ้นสุด API โดยใช้บุรุษไปรษณีย์หรือ Curl

curl -X POST -d ‘{“ข้อมูล”:”บล็อกใหม่”}’
http://localhost:8080/block

กด “ส่ง” เพื่อส่งคำขอของคุณ และคุณจะได้รับคำตอบว่าต่อท้ายบล็อกสำเร็จหรือไม่

บทที่ 6: ตัวอย่างสดของการสร้างแอปพลิเคชันบล็อกเชนด้วย Go

ไชโย! คุณมาถึงขั้นตอนสุดท้ายของการผจญภัยในการพัฒนาแล้ว! ก่อนที่เราจะสรุป เรามานำสิ่งที่เราได้เรียนรู้มาและนำไปใช้ในลักษณะที่ชัดเจนและต่อเนื่องกันโดยใช้ตัวอย่างโค้ดเดียว มาทำสิ่งนี้กัน!

การดำเนินการทีละขั้นตอน

  • ขั้นตอนที่ 1: สร้างโครงสร้าง Block ด้วยแอตทริบิวต์ที่จำเป็นโดยใช้ไวยากรณ์ Go
  • ขั้นตอนที่ 2: ใช้เมธอด Calculator_Hash
  • ขั้นตอนที่ 3: กำหนดและเริ่มต้นโครงสร้าง Blockchain ด้วย genesis block
  • ขั้นตอนที่ 4: ใช้วิธีการเพิ่มบล็อกใหม่และดึงข้อมูลบล็อกล่าสุดโดยใช้ Go
  • ขั้นตอนที่ 5: เพิ่มฟังก์ชัน Proof of Work ให้กับโครงสร้าง Block และอัปเดตโครงสร้าง Blockchain
  • ขั้นตอนที่ 6: ตั้งค่าสภาพแวดล้อม API เพื่อจัดการคำขอโดยใช้ Go
  • ขั้นตอนที่ 7: ทดสอบแอปพลิเคชันโดยขุดบล็อกใหม่และตรวจสอบบล็อกเชนโดยใช้บุรุษไปรษณีย์หรือ Curl
แพ็คเกจหลัก

นำเข้า (    
“crypto/sha256”    
“ การเข้ารหัส/hex”    
“การเข้ารหัส/json”    
“fmt”    
“บันทึก”    
“net/http”    
“strconv”    
“สตริง”    
“เวลา”
    “github.com/gorilla/mux”)

// บล็อกแสดงถึง ‘รายการ’ แต่ละรายการ ใน blockchaintype Block struct {    
Index        int    // ตำแหน่งของบล็อกในห่วงโซ่    
Timestamp    string // Timestamp ของการสร้างบล็อก    
ข้อมูล         string // ข้อมูลถูกเก็บไว้ในบล็อก    
สตริงแฮชก่อนหน้า // แฮชของบล็อกก่อนหน้า    
แฮช string // แฮชของบล็อกปัจจุบัน    
หลักฐาน        int    // หลักฐานการทำงาน

}
// Blockchain แสดงถึงห่วงโซ่ทั้งหมดของบล็อก
ประเภทโครงสร้าง Blockchain {    
Blocks []Block
}
// สร้าง genesis block (บล็อกแรกในเชน)
func createGenesisBlock Block {    
ส่งคืนบล็อก{        
ดัชนี:        0,        
ประทับเวลา:    time.Now.String,        
ข้อมูล:         “Genesis Block”,        
PreviousHash: “0”,        
พิสูจน์:        0,        
แฮช:         คำนวณHash(0, time.Now.String,
“Genesis Block”, “0”, 0),    
}
}
// คำนวณแฮชของบล็อก
func คำนวณHash(ดัชนี int, การประทับเวลา, ข้อมูล , PreviousHash
string, proof int) string {    
บันทึก := strconv.Itoa(index) + timestamp + data + PreviousHash + strconv.Itoa (พิสูจน์)    
hash := sha256.New    
hash.Write([]byte(record))    
hashed := hash.Sum(nil)    
ส่งคืน hex.EncodeToString(hashed)
}

// อัลกอริธึม Proof of Work – การใช้งาน PoW อย่างง่าย โดยเราจะค้นหาแฮชที่มีจำนวน zerosfunc นำหน้า (b *Block) proofOfWork(difficulty int) {    
สำหรับ {        
b.Hash = CalculatorHash(b.Index, b.Timestamp, b.Data,
b.PreviousHash, b. พิสูจน์)        
if strings.HasPrefix(b.Hash, strings.Repeat(“0”, ความยาก)) {            
break        
}        
b.Proof++    
}
}
// เพิ่มบล็อกใหม่ให้กับ blockchain
func (bc *Blockchain) addBlock(data string, problems int) {    
prevBlock := bc.getLatestBlock    
newBlock := Block{        
ดัชนี:        prevBlock.Index + 1,        
การประทับเวลา:    time.Now.String,        
ข้อมูล:         ข้อมูล,        
PreviousHash: prevBlock.Hash,        < br/>พิสูจน์:        0,    
}    
newBlock.proofOfWork(ความยาก)    
bc.Blocks = append(bc.Blocks, newBlock)
}
// รับบล็อกล่าสุดในเชน
func (bc *Blockchain) getLatestBlock Block {    
return bc.Blocks[len(bc.Blocks)-1]

// เริ่มต้น blockchain ด้วย genesis block
func InitializeBlockchain *Blockchain {    
genesisBlock := createGenesisBlock    
return &Blockchain{[]Block{genesisBlock}}}

// ตัวจัดการ API

// รับ blockchain ทั้งหมด
func getBlockchainHandler(w http.ResponseWriter, r *http.Request) {    
json.NewEncoder(w).Encode(blockchain.Blocks)}

// เพิ่มบล็อกใหม่ให้กับบล็อกเชน
func addBlockHandler(w http.ResponseWriter, r
*http.Request) {    
var newBlockData struct {        สตริงข้อมูล `json: ”ข้อมูล”`        _
= json.NewDecoder(r.Body).Decode(&newBlockData)    
blockchain.addBlock(newBlockData.Data, ความยาก)    
json.NewEncoder(w).Encode(blockchain.getLatestBlock)
}

// เริ่มต้น blockchain และระดับความยากสำหรับ Proof of Work
var blockchain = InitializeBlockchain
var ความยาก = 3 // ระดับความยากของ หลักฐานการทำงาน

// ตั้งค่าเซิร์ฟเวอร์ API
func main {    
เราเตอร์ := mux.NewRouter    
router.HandleFunc(“/blockchain”,
getBlockchainHandler).Methods(“GET”)    
router.HandleFunc(“/block”,
addBlockHandler).Methods(“POST”)

log.Println(“การฟังบนพอร์ต 8080 …”)    
log.Fatal(http.ListenAndServe(“:8080”, เราเตอร์))}

บทสรุปและทิศทางในอนาคต

ไชโย! คุณได้พัฒนาแอปพลิเคชั่นบล็อกเชนที่ใช้งานได้สำเร็จโดยใช้ Go! ด้วยคู่มือนี้ คุณจะได้รับทักษะที่จำเป็น เช่น การสร้างบล็อกเชนตั้งแต่เริ่มต้น การรวม Proof of Work และการกำหนดค่า REST API เพื่อโต้ตอบกับบล็อกเชนของคุณ ข้อมูลเชิงลึกหลักที่ได้รับตลอดการเดินทางครั้งนี้คือ:

  • การกำหนดและการจัดโครงสร้างบล็อก
  • การใช้กลไกฉันทามติ
  • การรวม API สำหรับการโต้ตอบบล็อคเชน

อย่างไรก็ตามนี่เป็นเพียงจุดเริ่มต้นเท่านั้น เมื่อคุณเจาะลึกเข้าไปในการพัฒนาบล็อกเชนโดยใช้ Go ยังมีแง่มุมที่น่าสนใจมากมายที่ยังรอการค้นพบและปรับให้เหมาะสม

การสำรวจโอกาสในอนาคตของ Go ในขอบเขตของการพัฒนาแอปแบบกระจายอำนาจ (dApp) นำเสนอโอกาสที่น่าตื่นเต้น การเจาะลึกลงไปในธีมที่ซับซ้อนบางอย่างอาจเป็นประโยชน์ เช่น:

  • การสำรวจกลไกฉันทามติขั้นสูง
  • การปรับปรุงความสามารถในการปรับขนาด
  • การทำงานร่วมกัน
  • แอปพลิเคชันในโลกแห่งความเป็นจริง

ก้าวหน้าไปข้างหน้า สำรวจ ปรับปรุง และสร้างสรรค์ได้อย่างอิสระ ภูมิทัศน์แบบไดนามิกของเทคโนโลยีบล็อกเชนมีการเปลี่ยนแปลงอย่างต่อเนื่อง และความสามารถของคุณในภาษาการเขียนโปรแกรม Go จะทำให้คุณก้าวนำหน้าอยู่เสมอ

ลองดูเพิ่มเติม: วิธีสร้างบล็อกเชนแรกของคุณด้วย Plutus: บทช่วยสอนทีละขั้นตอน

Sorry. No data so far.

2024-09-18 09:39