สถาปัตยกรรมบล็อคเชน: บล็อคเชนสาธารณะและบล็อคส่วนตัว

by

สถาปัตยกรรมบล็อคเชน: บล็อคเชนสาธารณะและบล็อคส่วนตัว

บทนำ

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

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

ประเภทสถาปัตยกรรมบล็อคเชน

  1. สถาปัตยกรรมบล็อกเชนสาธารณะ
    • การกระจายอำนาจ: ไม่มีหน่วยงานกลางที่เก็บข้อมูลที่จำเป็นทั้งหมดหรือการตรวจสอบความถูกต้องของธุรกรรม แต่มีการกระจายทั้งหมดผ่านเครือข่าย ทุกโหนดจะตรวจสอบธุรกรรมด้วยตัวเองและทำให้แน่ใจว่าระบบยังคงทำงานต่อไปแม้ว่าจะมีข้อผิดพลาดเกิดขึ้นก็ตาม
    • การกระจายอำนาจเป็นหัวใจสำคัญของบล็อคเชนที่ไม่มีหน่วยงานใดมีอำนาจครอบครอง
    • ความโปร่งใสและการเปลี่ยนแปลงไม่ได้: โหนดและผู้เข้าร่วมทั้งหมดสามารถดูบัญชีแยกประเภทเพื่อให้เกิดความโปร่งใสทั่วทั้งเครือข่าย นอกจากนี้ เราต้องระมัดระวังให้มากก่อนดำเนินการธุรกรรมใด ๆ เนื่องจากเมื่อดำเนินการเสร็จแล้วจะไม่สามารถเปลี่ยนแปลงเพิ่มเติมได้ คุณสมบัตินี้ค่อนข้างมีประโยชน์ในการป้องกันการฉ้อโกงและการใช้จ่ายซ้ำซ้อน 
    • กลไกฉันทามติ: กฎเหล่านี้เป็นกฎที่ทำให้แน่ใจว่าทุกส่วนของเครือข่ายเห็นด้วยกับข้อมูลเดียวกันและการทำงานของเครือข่าย ช่วยให้ทุกคนเข้าใจตรงกันเกี่ยวกับสิ่งที่เกิดขึ้น กลไกเหล่านี้ไม่ได้จำกัดอยู่เพียง PoS และ PoW เท่านั้น แต่ยังเกินกว่านั้นด้วย กลไกที่ใหม่กว่าคือ PoA (Proof-of Authority) และ  DPoS ใช้การลงคะแนนและผู้รับมอบสิทธิ์เพื่อตรวจสอบธุรกรรมและสร้างบล็อกใหม่ PBFT แลกเปลี่ยนข้อความระหว่างโหนดเพื่อให้ได้ฉันทามติ การเข้าใจและนำโปรโตคอลเหล่านี้ไปปฏิบัติถือเป็นสิ่งสำคัญในการรักษาเครือข่ายให้แข็งแกร่งและปลอดภัย
  1. สถาปัตยกรรมบล็อคเชนส่วนตัว
    • เครือข่ายที่อนุญาต: บล็อกเชนส่วนตัวทำงานในสภาพแวดล้อมที่มีการควบคุมด้วยโหนดการอนุญาต การกำหนดค่าการควบคุมการเข้าถึงและการจัดการบทบาทเป็นงานที่สำคัญ การเข้าถึงที่มีการควบคุมทำให้มั่นใจได้ว่าเฉพาะผู้ใช้ที่ได้รับอนุญาตเท่านั้นที่สามารถโต้ตอบกับเครือข่าย พิสูจน์ระดับความปลอดภัยและความเป็นส่วนตัว
    • ความเป็นส่วนตัวและการรักษาความลับ:  ความเป็นส่วนตัวเป็นหัวใจหลักของบล็อกเชนส่วนตัว เพื่อรักษาความลับบล็อคเชนเหล่านี้ใช้คุณสมบัติเช่นการพิสูจน์ความรู้เป็นศูนย์และการเข้ารหัสข้อมูล นี่เป็นสิ่งสำคัญสำหรับอุตสาหกรรมที่เกี่ยวข้องกับข้อมูลที่ละเอียดอ่อน เช่น การดูแลสุขภาพและการเงิน
    • ความสามารถในการปรับขนาดและประสิทธิภาพ: ความสามารถในการปรับขนาดและประสิทธิภาพได้รับการจัดการอย่างดีโดยบล็อกเชนส่วนตัว เนื่องจากเป็นการตั้งค่าที่มีการควบคุม วิธีการที่ใช้สำหรับสิ่งเดียวกันคือธุรกรรมนอกเครือข่าย การแบ่งส่วน และวิธีการที่เป็นเอกฉันท์อันชาญฉลาด (เช่น Practical Byzantine Fault Tolerance) เพื่อให้สิ่งต่าง ๆ ทำงานเร็วขึ้นและราบรื่นยิ่งขึ้น

การสร้างบล็อคเชนสาธารณะ

  1. การตั้งค่าและการกำหนดค่าโหนด

ติดตั้งซอฟต์แวร์ที่จำเป็น (เช่น Geth สำหรับ Ethereum)

เริ่มต้นและกำหนดค่าโหนด:
bash

geth init genesis.json
geth -networkid 1234 -nodiscover -maxpeers 0 -datadir ./node1

<ข>2. การพัฒนาสัญญาอัจฉริยะ

เขียนสัญญาอัจฉริยะอย่างง่ายใน Solidity (เช่น สัญญาโทเค็น):
solidity

ความมั่นคงของ pragma ^0.8.0;

สัญญา SimpleToken {
    string public name = “SimpleToken”;
    string public symbol = “STK”;
    uint8 public decimals = 18;
    uint256 public TotalSupply;

การทำแผนที่ (ที่อยู่ => uint256) public balanceOf;

    ตัวสร้าง (uint256 _initialSupply) {
TotalSupply = _initialSupply * 10 ** uint256(ทศนิยม);
        balanceOf[msg.sender] = TotalSupply;

รวบรวมและปรับใช้สัญญาอัจฉริยะโดยใช้ Truffle หรือ Hardhat:
bash
คัดลอกโค้ด

ทรัฟเฟิลคอมไพล์
ทรัฟเฟิลโยกย้าย – การพัฒนาเครือข่าย

3. การติดตั้งและบำรุงรักษาเครือข่าย

ปรับใช้เครือข่ายบล็อกเชนสาธารณะ:
bash

geth -networkid 1234 -mine -minerthreads=1 -datadir ./node1

ตรวจสอบและบำรุงรักษาเครือข่ายโดยตรวจสอบการซิงโครไนซ์และประสิทธิภาพของโหนด

4. การทำงานร่วมกันและการบูรณาการ

สร้างระบบที่เข้ากันได้ที่สามารถทำงานร่วมกันและเชื่อมต่อกับแอปกระจายอำนาจปัจจุบัน (dApps)

การสร้างบล็อคเชนส่วนตัว

  1. การออกแบบและการกำหนดค่าเครือข่าย

ออกแบบโทโพโลยีเครือข่ายและกำหนดค่าโหนดที่ได้รับอนุญาต:
bash
คัดลอกโค้ด

configtxgen -profile SampleDevModeSolo -outputBlock genesis.block
configtxgen -profile SampleDevModeSolo -outputChannelCreateTx channel.tx
-channelID mychannel
  1. เชนโค้ด/การพัฒนาสัญญาอัจฉริยะ

เขียนเชนโค้ดสำหรับตรรกะทางธุรกิจใน Go, Node.js หรือ Java:
go

แพ็คเกจหลัก

นำเข้า (
    “fmt”
    “github.com/hyperledger/fabric-contract-api-go/contractapi”
)
< br/>ประเภท SimpleAsset struct {
    contractapi.Contract
}

func (s *SimpleAsset) InitLedger(ctx Contractapi.TransactionContextInterface) ข้อผิดพลาด {
    asset := “ myAsset”
    value := “100”
    err := ctx.GetStub.PutState(asset, []byte(value))
    return ผิดพลาด
}
< br/>func main {
    chaincode, err := Contractapi.NewChaincode(new(SimpleAsset))
    if err != nil {
        fmt.Printf(“ข้อผิดพลาดในการสร้างโค้ดลูกโซ่ SimpleAsset: %s ”, err.Error)
        return
    }

    หากผิดพลาด := chaincode.Start; err != nil {
        fmt.Printf(“ข้อผิดพลาดในการเริ่มต้นรหัสลูกโซ่ SimpleAsset: %s”, err.Error)
    }
}

ปรับใช้เชนโค้ด:
bash

การติดตั้ง peer chaincode -n simpleasset -v 1.0 -p github.com/simpleassetpeer chaincode อินสแตนซ์ -o orderer.example.com:7050 -C mychannel -n simpleasset -v 1.0 -c ‘{“Args”: [“”]}’
  1. ความเป็นส่วนตัวและความปลอดภัยของข้อมูล

เพื่อปกป้องข้อมูลอย่างมีประสิทธิภาพ ให้ใช้เทคนิคการเข้ารหัสที่แข็งแกร่งและมาตรการรักษาความปลอดภัย รับรองกระบวนการถ่ายโอนข้อมูลแบบ end-to-end ที่ปลอดภัยโดยการเข้ารหัสข้อมูลที่ต้นทางและถอดรหัสที่ปลายทางเท่านั้น ปกปิดข้อมูลอย่างละเอียดอ่อนผ่านการมาสก์เพื่อรักษาความลับ นอกจากนี้ บังคับใช้การรับรองความถูกต้องแบบหลายปัจจัย (MFA) เพื่อเพิ่มการป้องกันอีกชั้น สุดท้าย ใช้ Transport Layer Security (TLS) ในระหว่างการสื่อสารเครือข่ายเพื่อความปลอดภัยในการส่งข้อมูลระหว่างโหนด

  1. การจัดการเครือข่ายและการปรับขนาด

การดูแลการทำงานของโหนดและการมีส่วนร่วม: กำหนดฟังก์ชันและระดับการเข้าถึงสำหรับโหนด โดยคงไว้ซึ่งการอนุญาตเฉพาะในโหนดที่ได้รับอนุมัติเท่านั้น การเฝ้าระวังและการประเมินอย่างต่อเนื่องถือเป็นสิ่งสำคัญในการระบุพฤติกรรมที่เป็นอันตราย สำหรับการขยาย มีการใช้เทคนิคเช่นโซลูชัน Sharding และ Layer 2 รวมถึง side chains เพื่อปรับปรุงกลไกฉันทามติ

เครื่องมือและกรอบงาน

  1. เครื่องมือพัฒนาบล็อคเชนสาธารณะ
    • Truffle Suite ใช้สำหรับ Ethereum โดยมีเฟรมเวิร์กสำหรับการทดสอบ เขียน และปรับใช้สัญญาอัจฉริยะ
    • Ganache ใช้สำหรับการทดสอบและพัฒนาบล็อกเชนในพื้นที่
    • Hardhaht ใช้สำหรับ Ethereum ให้สภาพแวดล้อมการพัฒนาที่ยืดหยุ่น และมีระบบปลั๊กอินและเครือข่าย Ethereum ท้องถิ่นในตัวเพื่อการพัฒนา
  2. เครื่องมือพัฒนาบล็อคเชนส่วนตัว
    • Hyperledger Composer สำหรับการสร้างแบบจำลองเครือข่ายธุรกิจเป็นภาษาระดับสูงสำหรับการกำหนดสินทรัพย์และธุรกรรม
    • Hyperledger ใช้ตรรกะจาวาสคริปต์และสร้าง REST API อัตโนมัติสำหรับเครือข่าย
    • ชุดพัฒนา Corda สำหรับแอปพลิเคชันทางการเงินมุ่งเน้นไปที่ธุรกรรมโดยตรงและส่วนตัว
    • Corda เขียนสัญญาอัจฉริยะใน Kotlin และมีเฟรมเวิร์ก Flow เพื่อจัดการเวิร์กโฟลว์

อ่านเพิ่มเติม: ทำความเข้าใจกับเครือข่ายและโหนด Blockchain

Sorry. No data so far.

2024-07-15 15:23