Blockchain Entwicklung mit Chainstack und Python

Chainstack ist eine robuste Plattform, die die Bereitstellung und Verwaltung von Blockchain-Knoten vereinfacht und Entwicklern eine zuverlässige Infrastruktur für die Erstellung von und Interaktion mit dezentralen Anwendungen (DApps) bietet. Durch die Integration von Chainstack mit Python können Sie Blockchain-Interaktionen innerhalb Ihrer Python-Anwendungen effizient verwalten. Dieses Tutorial führt Sie durch den Prozess der Einrichtung von Chainstack und der Verwendung von Python zur Interaktion mit Blockchain-Netzwerken.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Python: Auf Ihrem Rechner installiert. Sie können es von der offiziellen Website herunterladen.

• Chainstack-Konto: Melden Sie sich bei Chainstack an, um auf Blockchain-Knoten-Dienste zuzugreifen.

• Web3.py-Bibliothek: Dies ist eine Python-Bibliothek für die Interaktion mit Ethereum. Installieren Sie sie mit pip:

  pip install web3

Schritt 1: Bereitstellen eines Blockchain-Knotens auf Chainstack

1. Anmelden und Einloggen: Erstellen Sie ein Konto auf Chainstack und melden Sie sich an.

2. Einen Knoten bereitstellen:

   • Navigieren Sie zum Abschnitt Projekte und erstellen Sie ein neues Projekt.
   • Klicken Sie in Ihrem Projekt auf Knoten bereitstellen.
   • Wählen Sie das gewünschte Blockchain-Protokoll (z. B. Ethereum) und Netzwerk (z. B. Mainnet, Testnet) aus.
   • Wählen Sie den Knotentyp und die Bereitstellungsoptionen gemäß Ihren Anforderungen aus.
   • Stellen Sie den Knoten bereit und warten Sie, bis die Bereitstellung abgeschlossen ist.

3. Zugriff auf Knoten-Zugangsdaten:

   • Gehen Sie nach der Bereitstellung zum Abschnitt Knoten in Ihrem Projekt.
   • Klicken Sie auf Ihren Knoten, um dessen Details anzuzeigen.
   • Notieren Sie sich die RPC-Endpunkt-URL; Sie benötigen diese, um sich über Python zu verbinden.

Schritt 2: Verbinden mit dem Blockchain-Knoten über Python

1. Umgebungsvariablen einrichten:

   • Speichern Sie den RPC-Endpunkt Ihres Chainstack-Knotens aus Sicherheitsgründen in einer Umgebungsvariable.

   • Erstellen Sie eine .env-Datei in Ihrem Projektverzeichnis und fügen Sie Folgendes hinzu:

     WEB3_PROVIDER_URI=YOUR_CHAINSTACK_RPC_ENDPOINT
     

   • Ersetzen Sie YOUR_CHAINSTACK_RPC_ENDPOINT durch die tatsächliche Endpunkt-URL.

2. Umgebungsvariablen laden:

   • Installieren Sie das python-dotenv-Paket, um Umgebungsvariablen zu verwalten:

     pip install python-dotenv

   • Laden Sie in Ihrem Python-Skript die Umgebungsvariablen:

     import os
     from dotenv import load_dotenv
     
     load_dotenv()
     web3_provider_uri = os.getenv('WEB3_PROVIDER_URI')

3. Web3-Verbindung initialisieren:

   • Verwenden Sie Web3.py, um sich mit Ihrem Chainstack-Knoten zu verbinden:

     from web3 import Web3
     
     web3 = Web3(Web3.HTTPProvider(web3_provider_uri))
     
     if web3.isConnected():
         print("Erfolgreich mit der Blockchain verbunden.")
     else:
         print("Verbindung fehlgeschlagen.")

Schritt 3: Interaktion mit der Blockchain

Sobald die Verbindung hergestellt ist, können Sie verschiedene Blockchain-Operationen durchführen. Hier sind einige Beispiele:

1. Abrufen der letzten Blocknummer:

   latest_block = web3.eth.block_number
   print(f"Letzte Blocknummer: {latest_block}")

2. Blockdetails abrufen:

   block = web3.eth.get_block(latest_block)
   print(f"Blockdetails: {block}")

3. Eine Transaktion senden:

   • Stellen Sie sicher, dass Ihr Konto über ausreichend Guthaben verfügt und der private Schlüssel sicher verwaltet wird.

   from web3.middleware import geth_poa_middleware
   from eth_account import Account
   
   # Für Netzwerke wie BNB Smart Chain, injizieren Sie die PoA-Middleware
   web3.middleware_onion.inject(geth_poa_middleware, layer=0)
   
   # Ersetzen Sie dies durch Ihren privaten Schlüssel und Ihre Konto-Adresse
   private_key = 'YOUR_PRIVATE_KEY'
   account = Account.from_key(private_key)
   to_address = 'RECIPIENT_ADDRESS'
   value = web3.to_wei(0.01, 'ether')  # Zu sendender Betrag
   
   # Erstellen und signieren Sie die Transaktion
   transaction = {
       'to': to_address,
       'value': value,
       'gas': 21000,
       'gasPrice': web3.to_wei('5', 'gwei'),
       'nonce': web3.eth.get_transaction_count(account.address),
       'chainId': web3.eth.chain_id
   }
   
   signed_txn = web3.eth.account.sign_transaction(transaction, private_key=private_key)
   
   # Senden Sie die Transaktion
   tx_hash = web3.eth.send_raw_transaction(signed_txn.rawTransaction)
   print(f"Transaktion mit Hash gesendet: {tx_hash.hex()}")

   Hinweis: Ersetzen Sie 'YOUR_PRIVATE_KEY' und 'RECIPIENT_ADDRESS' durch Ihren tatsächlichen privaten Schlüssel und die Adresse des Empfängers. Behandeln Sie private Schlüssel sicher und vermeiden Sie es, sie in Ihren Skripten fest zu codieren.

Zusätzliche Ressourcen

• Chainstack-Dokumentation: Erfahren Sie mehr über die Funktionen und API-Möglichkeiten von Chainstack in ihrem Entwicklerportal.

• Web3.py-Dokumentation: Ausführliche Informationen zur Interaktion mit Ethereum mithilfe von Python finden Sie in der Web3.py-Dokumentation.

Fazit

Indem Sie diesem Tutorial folgen, haben Sie einen Blockchain-Knoten mit Chainstack eingerichtet und sich über Python damit verbunden. Dieses Setup ermöglicht es Ihnen, mit der Blockchain zu interagieren und Funktionen wie das Abfragen von Daten und das Senden von Transaktionen zu nutzen. Für fortgeschrittenere Anwendungsfälle sollten Sie die Chainstack-API und zusätzliche Dienste in Betracht ziehen, um Ihren Blockchain-Entwicklungs-Workflow zu verbessern.

Wir sind Leapcell, Ihre erste Wahl für die Bereitstellung von Python-Projekten in der Cloud.

Leapcell ist die Serverless-Plattform der nächsten Generation für Webhosting, asynchrone Aufgaben und Redis:

Multi-Sprachen-Unterstützung

• Entwickeln Sie mit Node.js, Python, Go oder Rust.

Setzen Sie unbegrenzt Projekte kostenlos ein

• zahlen Sie nur für die Nutzung - weder Anfragen noch Gebühren.

Unschlagbare Kosteneffizienz

• Pay-as-you-go ohne Leerlaufgebühren.
• Beispiel: 25 US-Dollar unterstützen 6,94 Millionen Anfragen bei einer durchschnittlichen Reaktionszeit von 60 ms.

Optimierte Entwicklererfahrung

• Intuitive Benutzeroberfläche für müheloses Setup.
• Vollautomatische CI/CD-Pipelines und GitOps-Integration.
• Echtzeit-Metriken und -Protokollierung für verwertbare Erkenntnisse.

Mühelose Skalierbarkeit und hohe Leistung

• Automatische Skalierung zur einfachen Bewältigung hoher Parallelität.
• Kein Betriebsaufwand - konzentrieren Sie sich einfach auf das Bauen.

Erfahren Sie mehr in der Dokumentation!

Folgen Sie uns auf X: @LeapcellHQ