cURL-Kurztaste

nützliche cUrl-Befehle mit Parametern

Hier ist ein Cheat Sheet für die nützlichsten cURL-Befehle mit ihren Parametern:

Eine Person mit einem curl-Schild

Dieses Bild oben wurde von Flux - Text-to-Image AI-Modell generiert.

Grundlegende cURL-Nutzung

  • Datei herunterladen: curl http://example.com/file.zip -o file.zip
  • Mehrere Dateien herunterladen: curl -O URL1 -O URL2
  • Umleitungen folgen: curl -L http://example.com/file
  • Nur Header anzeigen: curl -I http://example.com

Authentifizierung

  • Basic-Authentifizierung: curl -u username:password http://example.com
  • .netrc-Datei verwenden: curl --netrc-file .netrc http://example.com

HTTP-Methoden

  • POST-Anfrage: curl -X POST -d 'name=value' http://example.com
  • PUT-Anfrage: curl -X PUT -d @file http://example.com
  • Benutzerdefinierte Methode: curl -X METHOD http://example.com

Header und Daten

  • Benutzerdefinierten Header hinzufügen: curl -H "X-Header: Value" http://example.com
  • JSON-Daten senden: curl -H "Content-Type: application/json" -d '{"key":"value"}' http://example.com
  • Formulardaten senden: curl -F "key=value" -F "file=@localfile" http://example.com

SSL/TLS-Optionen

  • SSL-Zertifikatsprüfung ignorieren: curl -k https://example.com
  • Client-Zertifikat verwenden: curl --cert cert.pem --key key.pem https://example.com

Proxy und Netzwerk

  • Proxy verwenden: curl -x proxysever.server.com:PORT http://example.com
  • Download-Geschwindigkeit begrenzen: curl --limit-rate 1000B -O http://example.com/file

Ausgabesteuerung

  • Stille Modus: curl -s http://example.com
  • Ausführlicher Modus: curl -v http://example.com
  • Ausgabe in eine Datei schreiben: curl -o file.html http://example.com
  • Mit dem entfernten Dateinamen speichern: curl -O http://example.com/file.zip

Verschiedenes

  • Einen fehlgeschlagenen Download fortsetzen: curl -C - -o partial_file.zip http://example.com/file.zip
  • Timeout festlegen: curl --connect-timeout 10 http://example.com
  • Eine Konfigurationsdatei verwenden: curl -K config_file http://example.com

Dieses Cheat Sheet umfasst die am häufigsten verwendeten cURL-Befehle und ihre Parameter, wodurch ein schneller Referenzpunkt für verschiedene HTTP-Operationen und Datenübertragungen bereitgestellt wird.

Erweiterte cURL-Befehle

Hier sind einige erweiterte cURL-Befehle zum Debuggen:

  1. Ausführliche Ausgabe: curl -v https://example.com Dieser Befehl liefert detaillierte Informationen über die Anfrage und Antwort, einschließlich Header und Verbindungsdetails.

  2. Vollständige Trace-Ausgabe: curl --trace - https://example.com Dies erzeugt eine Hexdump-Ausgabe aller eingehenden und ausgehenden Daten, was einen umfassenden Überblick über die gesamte Kommunikation bietet.

  3. Trace mit Zeitstempeln: curl --trace - --trace-time https://example.com Dies fügt Zeitstempel zur Trace-Ausgabe hinzu, was bei der Analyse von Timing-Problemen hilfreich ist.

  4. Nur Antwort-Header ausgeben: curl -s -o /dev/null -D - https://example.com Dieser Befehl zeigt nur die Antwort-Header an, was nützlich ist, um Header schnell zu analysieren.

  5. Nur Anfrage-Header ausgeben: curl -v -s -o /dev/null --stderr - https://example.com | grep '^>' Dieser komplexe Befehl filtert nur die Anfrage-Header, was hilfreich ist, um zu prüfen, was gesendet wird.

  6. Pantheon Debugger verwenden: curl -I -H "Pantheon-Debug:1" https://example.com Dieser Befehl verwendet den Debug-Header von Pantheon, um zusätzliche Informationen über eine Anfrage zu erhalten, was für Pantheon-gehostete Websites nützlich ist.

  7. HTTP/2-Protokoll erzwingen: curl --http2 https://example.com Dies stellt sicher, dass das HTTP/2-Protokoll verwendet wird, was mit -I kombiniert werden kann, um die Unterstützung von HTTP/2 zu überprüfen.

  8. Mit netcat debuggen: In einem Terminal: nc -l 1234 In einem anderen: curl http://127.0.0.1:1234 Dies ermöglicht es, genau zu sehen, was cURL sendet, was bei der Debugging von Nutzlasten nützlich ist.

Diese erweiterten Befehle bieten leistungsstarke Debugging-Funktionen, die es Entwicklern ermöglichen, verschiedene Aspekte der HTTP-Kommunikation zu untersuchen und komplexe Probleme zu beheben.

Häufige cURL-Anwendungsfälle

cURL ist ein vielseitiges Kommandozeilen-Tool mit zahlreichen Anwendungen. Hier sind einige der häufigsten Anwendungsfälle für cURL:

Web-Interaktionen

  1. Dateien herunterladen: cURL kann Dateien von URLs herunterladen.
  2. Web-Scraping: cURL kann Webseiteninhalte für Scraping-Zwecke abrufen.
  3. Webseiten testen: cURL ist nützlich, um zu prüfen, ob eine Webseite zugänglich ist und deren Inhalt abzurufen.

API-Interaktionen

  1. API-Anfragen senden: cURL unterstützt verschiedene HTTP-Methoden (GET, POST, PUT, DELETE) zur Interaktion mit APIs.
  2. API-Endpunkte testen: cURL bietet eine schnelle Möglichkeit, API-Endpunkte zu testen und zu debuggen, ohne einen dedizierten API-Client zu benötigen.

Netzwerk-Problembehandlung

  1. Verbindungsprüfung: cURL kann verwendet werden, um Netzwerkverbindungen zu überprüfen und Probleme zu beheben.
  2. DNS-Testen: cURL erlaubt das Erzwingen spezifischer DNS-Server, um DNS-bezogene Probleme zu debuggen.
  3. Header prüfen: cURL kann HTTP-Header anzeigen, was bei der Debugging nützlich ist.

Datenübertragung

  1. FTP-Operationen: cURL unterstützt Dateiübertragungen über das File Transfer Protocol (FTP).
  2. SMTP-Interaktionen: cURL kann verwendet werden, um E-Mails über das Simple Mail Transfer Protocol (SMTP) zu senden.

Sicherheit und Authentifizierung

  1. SSL-Verbindungen: cURL unterstützt sichere Verbindungen über SSL/TLS.
  2. Authentifizierung: cURL kann verschiedene Authentifizierungsmethoden verarbeiten, einschließlich Basic-Auth und Client-Zertifikate.

Entwicklung und Debugging

  1. Verschiedene HTTP-Methoden simulieren: cURL ermöglicht Entwicklern, verschiedene HTTP-Methoden leicht zu testen.
  2. Ausführliche Protokollierung: Der ausführliche Modus von cURL liefert detaillierte Informationen über den Anfrage-Antwort-Zyklus, was bei der Debugging hilfreich ist.

Diese Anwendungsfälle zeigen die Flexibilität von cURL als Tool für Web-Interaktionen, API-Tests, Netzwerk-Problembehandlung und Entwicklungsaufgaben.

Website-Leistungstests mit cURL

cURL ist ein mächtiges Tool zur Leistungstestung von Webseiten. Hier ist, wie Sie es verwenden können, um verschiedene Aspekte der Ladegeschwindigkeit einer Webseite zu messen:

Grundlegender Leistungstest

Um eine einfache Messung der Ladezeit einer Webseite zu erhalten, verwenden Sie diesen Befehl:

curl -o /dev/null -s -w "Gesamtzeit: %{time_total}s\n" "https://example.com"

Dieser Befehl gibt die Gesamtzeit an, die benötigt wurde, um die Webseite zu laden[2].

Detaillierte Leistungsparameter

Für eine umfassendere Analyse können Sie cURL verwenden, um mehrere Leistungsparameter zu messen:

curl -s -w 'Test der Antwortzeit der Website für :%{url_effective}\n\nDNS-Lookup-Zeit:\t\t%{time_namelookup}\nVerbindungszeit:\t\t%{time_connect}\nVor-Übertragungszeit:\t%{time_pretransfer}\nStart-Übertragungszeit:\t%{time_starttransfer}\n\nGesamtzeit:\t\t%{time_total}\n' -o /dev/null https://example.com

Dieser Befehl bietet eine Aufschlüsselung der verschiedenen Phasen des Ladevorgangs, einschließlich der DNS-Lookup-Zeit, der Verbindungszeit und der Gesamtzeit[1].

Erweiterte Parameter

Für eine noch detailliertere Analyse können Sie zusätzliche Parameter einbeziehen:

curl -o /dev/null -w "HTTP-Version: %{http_version}\nSeitengröße: %{size_download} Bytes\nAntwortcode: %{response_code}\nDNS-Lookup: %{time_namelookup} Sekunden\nVerbindungszeit: %{time_connect} Sekunden\nZeit bis zum ersten Byte: %{time_starttransfer} Sekunden\nGesamtzeit: %{time_total} Sekunden\n" -s https://example.com

Dieser Befehl enthält Informationen über die HTTP-Version, die Seitengröße und den Antwortcode[3].

Benchmarking mehrerer Anfragen

Um Konsistenz zu testen oder die Leistung über die Zeit zu überwachen, können Sie eine Schleife verwenden, um mehrere Anfragen zu stellen:

for i in {1..5}; do curl -o /dev/null -s -w "Anfrage $i Gesamtzeit: %{time_total}\n" https://example.com; done

Dies führt den Test fünfmal durch und zeigt die Gesamtzeit für jede Anfrage an[3].

Erstellen eines Leistungstest-Skripts

Sie können ein einfaches Bash-Skript erstellen, um diese Tests zu automatisieren und die Ergebnisse zu speichern:

#!/bin/bash
curl -s -w 'Test der Antwortzeit der Website für :%{url_effective}\n\nLookup Zeit:\t\t%{time_namelookup}\nConnect Zeit:\t\t%{time_connect}\nPre-transfer Zeit:\t%{time_pretransfer}\nStart-transfer Zeit:\t%{time_starttransfer}\n\nTotal Zeit:\t\t%{time_total}\n' -o /dev/null URL > webspeedtest_"$(date)"

Ersetzen Sie “URL” mit der Webadresse, die Sie testen möchten. Dieses Skript speichert die Ergebnisse in einer mit dem Datum versehenen Datei[5].

Durch die Verwendung dieser cURL-Befehle und Skripte können Sie die Leistung einer Webseite effektiv messen und überwachen, wodurch Sie potenzielle Engpässe identifizieren und die Ladezeiten optimieren können.