Wenn Ihr Ziel nur darin besteht, einen stabilen Bitcoin-Knoten zum Laufen zu bringen und nicht zum Netzwerk beizutragen, können Sie listen=0Ihre bitcoin.conf-Datei ergänzen. Dies hält im Allgemeinen (wenn auch nicht immer) Ihre Upload-Bandbreite in Schach.

Wenn Sie jedoch zum Bitcoin-Netzwerk beitragen möchten, ohne zu viel Ihrer eigenen Bandbreite zu verbrauchen, gibt es Möglichkeiten, Ihre Upload-Geschwindigkeit nur für Bitcoin Core (Bitcoin-qt) zu begrenzen. Die Anweisungen hängen von Ihrem Betriebssystem ab. Im Folgenden finden Sie eine Aufschlüsselung dessen, was mit jedem Betriebssystem zu tun ist.

WICHTIGER HINWEIS: Wenn Sie die Bandbreite von Bitcoin Core weit unter Ihre tatsächliche Upload-Geschwindigkeit begrenzen, kann dies dem Bitcoin-Netzwerk tatsächlich schaden, anstatt ihm zu helfen. Um ein verantwortungsvoller Betreuer des Bitcoin-Netzwerks zu sein, sollten Sie Ihre Upload-Geschwindigkeit testen und dann Ihr ausgehendes Bandbreitenlimit so einstellen, dass es Ihrer tatsächlichen Geschwindigkeit so nahe wie möglich kommt (z. B. 90%). Diese Anleitung ist ausschließlich für Personen gedacht, deren Internetverbindungen nicht mehr reagieren, weil Bitcoin Core ihre Upload-Bandbreite vollständig auslastet.

Die folgende Anleitung ist ein Auszug aus diesem Artikel, den ich kürzlich geschrieben habe: https://www.maxlaumeister.com/blog/how-to-limit-bandwidth-of-bitcoin-core-on-windows-mac-os-and-linux/

Begrenzung der Bitcoin-Bandbreite unter Windows

1. Laden Sie NetBalancer herunter und installieren Sie es .

2. Starten Sie Bitcoin Core, falls es noch nicht läuft.

3. Führen Sie NetBalancer aus.

4. Suchen Sie „bitcoin-qt.exe“ in der Liste der laufenden Anwendungen im NetBalancer-Dialog und doppelklicken Sie darauf, um die Bandbreitenregeln zu ändern.

5. Wählen Sie unter „Upload Priority“ „Limited“, legen Sie die maximale Bandbreite fest, die Bitcoin Core verwenden soll, und bestätigen Sie.

Sie sind fertig! NetBalancer sitzt jetzt im Hintergrund und stellt sicher, dass Bitcoin Core nicht mehr Bandbreite verwendet, als Sie möchten.

Begrenzung der Bandbreite unter Mac OS X

OS X 10.10 Yosemite und höher

Für OS X 10.10 Yosemite und höher gibt es keine einfache Möglichkeit, die Bandbreite einer bestimmten Anwendung zu begrenzen, aber die Bandbreite des Gesamtsystems kann wie folgt begrenzt werden:

1. Besuchen Sie Apple Developer Downloads und melden Sie sich mit Ihrer Apple-ID an.

2. Suchen Sie nach „Hardware IO Tools for Xcode“ und laden Sie die neueste stabile Version (keine Beta-Version) herunter.

3. Öffnen Sie die .dmg-Datei und doppelklicken Sie auf „Network Link Conditioner.prefpane“, um das Prefpane zu installieren. Von nun an können Sie Network Link Conditioner in den Systemeinstellungen aktivieren/deaktivieren.

4. Klicken Sie im Bereich Network Link Conditioner in den Systemeinstellungen auf „Profile verwalten“ und dann auf die Schaltfläche „+“, um ein neues Profil hinzuzufügen.

5. Bearbeiten Sie das Profil und fügen Sie Ihre gewünschte maximale Upload-Geschwindigkeit hinzu.

6. Speichern Sie Ihre Bearbeitung, verlassen Sie den Profilmanager, wählen Sie Ihr neues Profil und drehen Sie den großen Schalter, um den Limiter zu aktivieren.

Mac OS platziert ein Symbol in Ihrer Benachrichtigungsleiste, damit Sie sich daran erinnern, dass es eingeschaltet ist. Im Gegensatz zu den Windows/Linux-Lösungen begrenzt dies die Bandbreite für Ihr gesamtes System, also stellen Sie sicher, dass Sie es ausschalten, wenn Sie Bitcoin Core nicht ausführen.

OS X 10.9 Mavericks und früher

Für OS X 10.9 Mavericks können Sie IceFloor verwenden, um Bandbreitenregeln zu konfigurieren . Verwenden Sie für 10.8 Mountain Lion und früher Waterroof . Wenn Sie alternativ eine einfache Möglichkeit suchen, die Bandbreitenbegrenzung des Gesamtsystems anstelle von Bitcoin Core zu steuern, befolgen Sie die obigen Anweisungen für OS X 10.10 Yosemite und höher.

Begrenzung der Bandbreite unter Linux

1. Stellen Sie sicher, dass Sie tc installiert haben, indem Sie tcin der Befehlszeile eingeben. Wenn Sie „Befehl nicht gefunden“ erhalten, installieren Sie tc mit Ihrem bevorzugten Paketmanager. Wenn Sie eine Debian-basierte Distribution verwenden, können Sie tc am einfachsten installieren, indem Sie Folgendes verwenden apt-get:

   sudo apt-get update

   sudo apt-get install iproute2

2. Laden Sie das tc.sh-Skript mit wget aus dem offiziellen Bitcoin Core-Repository herunter:

   wget https://raw.githubusercontent.com/bitcoin/bitcoin/master/contrib/qos/tc.sh

3. Öffnen Sie das Skript in einem Texteditor. Suchen Sie die Zeile, die sagt, IF="eth0"und ändern Sie eth0sie, um die Netzwerkschnittstelle widerzuspiegeln, über die Ihre Internetverbindung läuft. Um eine Liste der Netzwerkschnittstellen Ihres Computers zu erhalten, verwenden Sie ifconfigin der Befehlszeile. Mein Computer ist drahtlos über verbunden wlan1, daher sieht die IF-Zeile meiner tc.sh so aus:

   IF="wlan1"

4. LINKCEIL sollte die Grenze der Netzwerkschnittstelle widerspiegeln und muss höchstwahrscheinlich nicht geändert werden.

   LINKCEIL="1gbit"

5. Ändern Sie LIMIT auf die maximale Bandbreite, die Bitcoin Core verwenden soll (ich habe 1 Mbit gewählt). Wenn Sie keine anderen Bitcoin Core-Knoten in Ihrem lokalen Netzwerk haben, können Sie die Zeile mit der Aufschrift LOCALNET löschen. Diese Zeile dient dazu, eine Bandbreitenausnahme für die Kommunikation über Port 8333 innerhalb Ihres lokalen Netzwerks (dh nicht ins Internet) zu machen.

   LIMIT="1mbit"

   Lassen Sie die restlichen Befehle in tc.sh in Ruhe, es sei denn, Sie wissen, was Sie tun. Der letzte obere Abschnitt meiner tc.sh sah am Ende so aus:

   #network interface on which to limit traffic
   IF="wlan1"
   
   #limit of the network interface in question
   LINKCEIL="1gbit"
   
   #limit outbound Bitcoin protocol traffic to this rate
   LIMIT="1mbit"
   

6. Beenden Sie Ihren Editor und machen Sie das Skript mit dem folgenden Befehl ausführbar:

   chmod +x ./tc.sh

7. Führen Sie das Skript als Superuser aus:

   sudo ./tc.sh

   Ihre Bitcoin Core-Bandbreite wird gedrosselt, bis Sie Ihren Computer neu starten!

Optional können Sie das Skript so einstellen, dass es bei jedem Start Ihres Computers ausgeführt wird. Die Anweisungen zum Ausführen von Skripts beim Booten variieren je nach Ihrer Linux-Distribution. Unter Ubuntu besteht eine der Möglichkeiten zum Ausführen eines Skripts beim Booten/etc/rc.local darin, das Skript zu Ihrer Datei hinzuzufügen .

Fazit

Hoffentlich war dieser Beitrag hilfreich, um Ihnen zu zeigen, wie Sie die Bandbreite von Bitcoin Core begrenzen können! Die vollständige Version, einschließlich Bildern und zusätzlichen Informationen, finden Sie im Originalartikel hier .

Eine im Thread erwähnte Antwort ist hinzuzufügen

listen=0

zu Ihrer bitcoin.conf (die sich in {User}\AppData\Roaming\Bitcoin befindet).

Dadurch wird verhindert, dass sich andere Knoten mit Ihnen verbinden, um die Blockchain herunterzuladen, wodurch der große Upstream-Bandbreitenverbrauch gestoppt wird

Wenn Ihr Bitcoin-Client auf einem dedizierten Linux-Rechner läuft, sollten Sie Wondershaper ausprobieren . Damit können Sie die Bandbreite Ihres Netzwerkadapters begrenzen. Zum Beispiel

sudo wondershaper eth0 1024 56

begrenzt Ihre Bandbreite auf 1024 Kbps Download- und 56 Kbps Upload-Rate.

sudo wondershaper -c eth0

hebt Schnittstellengrenzen auf und bringt Sie wieder auf Hochtouren.

Sie können maxuploadtarget verwenden , indem Sie eine Zeile hinzufügen wie:

maxuploadtarget=5000

in die bitcoin.conf-Datei in Ihrem .bitcoin-Verzeichnis. Das obige Beispiel legt ein tägliches Soft-Upload-Limit von ~5 GB/Tag fest.

Noch besser könnte es sein, die maxconnections mit zu begrenzen

maxconnections=25

Unten ist ein von mir geschriebenes Perl-Skript, das unter Linux ausgeführt wird und die maximale Anzahl von Verbindungen (und damit die Bandbreite) während des Tages automatisch begrenzt, und sobald die Nacht hereinbricht, werden die Verbindungs-/Bandbreitenbeschränkungen entfernt. Auf diese Weise kann Ihr Bitcoin Full Node, während Sie schlafen, Ihre Bandbreite optimal nutzen, und wenn Sie wach sind, stört der Full Node tagsüber nicht Ihr Surfen im Internet.

 #!/usr/bin/perl
 use warnings;
 use strict;
 
 #############################################################################################################
 #Program purpose: To configure a Bitcoin full node so bandwidth use is restricted during the day.
 #
 #How it works: The bitcoin.conf file is periodically modified so that Bitcoin runs with fewer connections
 #during the day (using less bandwidth), and unlimited connections (higher bandwidth) at night.
 #
 #How to run: On Linux, run within the Bitcoin /bin directory (i.e. the directory holding 'bitcoind').
 #############################################################################################################
 
 #Set the path of Bitcoin's bitcoin.conf file here:
 my $path_of_bitcoin_conf_file = $ENV{"HOME"} . "/.bitcoin/bitcoin.conf";
 my $bitcoind_connection_max = 25; # The maximum number of connections for bitcoind to make during day hours.
 my $start_of_day_hour = 7; # 7 am.
 my $start_of_night_hour = 21; # 9 pm in 24 hour format.
 
 my $time_period_last = "hasn't been recorded yet"; #Records whether the last time check was "day" or "night".
 
 #Run indefinitely, configuring node bandwidth restrictions based on time of day.
 while (1) {
     my $time_period_current = night_or_day();
     #When the day becomes night or night becomes day, configure bitcoin bandwidth accordingly.
     if ( $time_period_last ne $time_period_current ) {
         modify_bitcoin_conf_file($time_period_current);
         restart_bitcoind();
     }
     else{} #Night/day hasn't changed, check again in another minute.
     $time_period_last = $time_period_current;
     sleep 60;
 }
 
 #Modify bitcoin.conf to limit bandwidth during the day, but unlimited during the night.
 sub modify_bitcoin_conf_file {
     my $night_or_day = shift;
     my $last_line_of_bitcoin_conf_file;
     if ($night_or_day eq "night"){
         $last_line_of_bitcoin_conf_file = ""; #No maxconnections limit at night.
     }
     elsif ($night_or_day eq "day"){
         $last_line_of_bitcoin_conf_file = "maxconnections=$bitcoind_connection_max\n";
     }
     else{die "Error, no night or day\n";}
 
     #Check that bitcoin.conf exists and then open it for editing.
     if (-e $path_of_bitcoin_conf_file){
         open (my $bitcoin_conf_fh, "<", $path_of_bitcoin_conf_file);
         my @bitcoin_conf = <$bitcoin_conf_fh>;
         close $bitcoin_conf_fh;
         open ($bitcoin_conf_fh, ">", $path_of_bitcoin_conf_file);
         foreach my $line (@bitcoin_conf){
             print $bitcoin_conf_fh $line unless $line =~ m/maxconnections/;
         }
         print $bitcoin_conf_fh $last_line_of_bitcoin_conf_file;
         close $bitcoin_conf_fh;
         print "The bitcoin.conf file has been changed to $night_or_day settings ", scalar localtime, "\n";
     }
     else {
         die "Could not locate the bitcoin.conf file: '$path_of_bitcoin_conf_file'\n";
     }
 }
 
 sub restart_bitcoind {
     shut_down_bitcoin_if_running();
     start_bitcoind();
 }
 
 sub shut_down_bitcoin_if_running {
     #Check if Bitcoin is running.
     if ( bitcoind_is_running() ){
         print "Bitcoin daemon is running, trying to shut down now. ", scalar localtime, "\n";
         shut_down_bitcoind();
     }
     else{
         print "Bitcoin daemon is not running at the moment. ", scalar localtime, "\n";
     }
 }
 
 sub shut_down_bitcoind {
     if ( program_running("./bitcoin-cli stop", "Bitcoin server stopping") ){
         sleep 10;
         #Verify bitcoind process has stopped.
         while ( bitcoind_is_running() ) {
             print "Still waiting for Bitcoin daemon to shut down. ", scalar localtime, "\n";
             sleep 10;
         }
         print "Bitcoin daemon successfully shut down. ", scalar localtime, "\n";
     }
     else{
         print "Having problems shutting down Bitcoin daemon. ", scalar localtime, "\n";
     }
 }
 
 sub bitcoind_is_running {
     if ( program_running("ps -e", "bitcoind") ){
         return 1;
     }
     else{
         return 0;
     }
 }
 
 sub start_bitcoind {
     unless ( system("./bitcoind -daemon") ){
         print "Bitcoin server booting up. ", scalar localtime, "\n";
         sleep 30;
         #Verify Bitcoin server has fully booted.
         until ( bitcoin_server_is_up() ) {
             print "Still waiting for Bitcoin server to fully load. ", scalar localtime, "\n";
             sleep 60;
 
         }
         print "Bitcoin server has successfully loaded. ", scalar localtime, "\n";
     }
     else{
         print "Having problems starting the Bitcoin daemon. ", scalar localtime, "\n";
     }
 }
 
 sub bitcoin_server_is_up {
     #If we can get a block count, then the server is booted.
     if ( program_running("./bitcoin-cli getblockcount", '^\d{6,}') ){
         return 1;
     }
     else{
         return 0;
     }
 }
 
 #Call a program with argument 1, and return true if its stdout matches argument 2.
 sub program_running {
     my ($shell_cmd, $stdout_match) = @_;
     open (my $prog_call, "-|", $shell_cmd);
     while (my $stdout = <$prog_call>){
         if ($stdout =~ m/$stdout_match/){
             return 1;
         }
         else{} #Keep searching for match.
     }
     return 0; #Match not found.
 }
 
 #Determine if it's nighttime or daytime.
 sub night_or_day {
     my @current_time = localtime();
     my $current_hour = $current_time[2];
     if ($current_hour >= $start_of_day_hour && $current_hour < $start_of_night_hour){
         return "day";
     }
     else {
         return "night";
     }
 }