cURL-Spickzettel

Nützliche cURL-Befehle mit Parametern

Hier ist eine Spickzettel-Sammlung für die nützlichsten cURL-Befehle mit deren Parametern:

eine Person mit einem cURL-Schild

Das obige Bild wurde generiert von Flux - Text-zu-Bild-KI-Modell.

cURL ist ein essentielles Befehlszeilen-Tool für das Senden von HTTP-Anfragen und die Übertragung von Daten. Für einen umfassenden Leitfaden zu Entwickler-Tools, einschließlich Git, Docker, VS Code, bash, Terraform, PostgreSQL, GitHub Actions und der Linux-Paketverwaltung, siehe Entwickler-Tools: Der komplette Leitfaden zu modernen Entwicklungs-Workflows.

Grundlegende Verwendung von cURL

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

Authentifizierung

  • Grundauthentifizierung: curl -u username:password http://example.com. CURL setzt daraus den Authorization: Basic-Header. Derselbe Header, erstellt mit printf und base64, befindet sich im Spickzettel für Base64-Codec.
  • .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

  • Custom-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-Rate begrenzen: curl --limit-rate 1000B -O http://example.com/file

Ausgabe-Kontrolle

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

Sonstiges

  • Fehlgeschlagene Übertragung fortsetzen: curl -C - -o partial_file.zip http://example.com/file.zip
  • Timeout festlegen: curl --connect-timeout 10 http://example.com
  • Konfigurationsdatei verwenden: curl -K config_file http://example.com

Dieser Spickzettel deckt die am häufigsten verwendeten cURL-Befehle und deren Parameter ab und bietet eine schnelle Referenz für verschiedene HTTP-Operationen und Datenübertragungen.

Fortgeschrittene cURL-Befehle

Hier sind einige fortgeschrittene cURL-Befehle zur Fehlersuche:

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

  2. Kompletter Trace-Dump: curl --trace - https://example.com Dies gibt einen Hexdump aller eingehenden und ausgehenden Daten aus, was eine umfassende Ansicht der gesamten Kommunikation bietet.

  3. Trace mit Zeitstempeln: curl --trace - --trace-time https://example.com Dies fügt dem Trace-Output Zeitstempel hinzu, was bei der Analyse von zeitbezogenen 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 für eine schnelle Header-Analyse nützlich ist.

  5. Nur Anfrage-Header ausgeben: curl -v -s -o /dev/null --stderr - https://example.com | grep '^>' Dieser komplexe Befehlt filtert nur die Anfrage-Header heraus, 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 nutzt den Debug-Header von Pantheon, um zusätzliche Informationen über eine Anfrage zu erhalten, nützlich für auf Pantheon gehostete Sites.

  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 HTTP/2-Unterstützung zu überprüfen.

  8. Fehlersuche mit netcat: 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 für die Fehlersuche in Nutzlasten nützlich ist.

Diese fortgeschrittenen Befehle bieten leistungsfähige Fehlersuchfunktionen und ermöglichen es Entwicklern, verschiedene Aspekte von HTTP-Kommunikationen zu inspizieren und komplexe Probleme zu beheben.

Häufige cURL-Anwendungsfälle

cURL ist ein vielseitiges Befehlszeilen-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 den Inhalt von Webseiten für Scraping-Zwecke abrufen.
  3. Websites testen: cURL ist nützlich, um zu prüfen, ob eine Website erreichbar ist, und ihren Inhalt abzurufen.

API-Interaktionen

  1. API-Anfragen senden: cURL unterstützt verschiedene HTTP-Methoden (GET, POST, PUT, DELETE) für die Interaktion mit APIs.
  2. API-Endpoints testen: cURL bietet einen schnellen Weg, API-Endpoints zu testen und zu debuggen, ohne einen dedizierten API-Client zu benötigen.

Netzwerk-Fehlersuche

  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 zur Fehlersuche bei DNS-bezogenen Problemen.
  3. Header inspizieren: cURL kann HTTP-Header anzeigen, was für die Fehlersuche 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 Fehlersuche

  1. Simulation verschiedener HTTP-Methoden: cURL ermöglicht es Entwicklern, verschiedene HTTP-Methoden einfach zu testen.
  2. Ausführliche Protokollierung: Der ausführliche Modus von cURL liefert detaillierte Informationen über den Anfrage-Antwort-Zyklus, was die Fehlersuche erleichtert.

Diese Anwendungsfälle demonstrieren die Flexibilität von cURL als Werkzeug für Web-Interaktionen, API-Tests, Netzwerk-Fehlersuche und Entwicklungsaufgaben.

Website-Leistungstestung mit cURL

cURL ist ein leistungsstarkes Werkzeug für die Testung der Website-Leistung. Hier ist, wie Sie es verwenden können, um verschiedene Aspekte der Ladezeit einer Website zu messen:

Basis-Leistungstest

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

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

Dieser Befehl gibt die Gesamtzeit aus, die für den Abruf der Website benötigt wurde[2].

Detaillierte Leistungsmetriken

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

curl -s -w 'Testing Website Response Time for :%{url_effective}\n\nLookup Time:\t\t%{time_namelookup}\nConnect Time:\t\t%{time_connect}\nPre-transfer Time:\t%{time_pretransfer}\nStart-transfer Time:\t%{time_starttransfer}\n\nTotal Time:\t\t%{time_total}\n' -o /dev/null https://example.com

Dieser Befehl liefert eine Aufschlüsselung der verschiedenen Stufen im Ladeprozess, einschließlich DNS-Lookup-Zeit, Verbindungszeit und Gesamtzeit[1].

Fortgeschrittene Metriken

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

curl -o /dev/null -w "HTTP Version: %{http_version}\nPage Size: %{size_download} bytes\nResponse Code: %{response_code}\nDNS Lookup: %{time_namelookup} sec\nConnect Time: %{time_connect} sec\nTime to First Byte: %{time_starttransfer} sec\nTotal Time: %{time_total} sec\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 die 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 "Request $i Total Time: %{time_total}\n" https://example.com; done

Dies führt den Test fünfmal aus und zeigt die Gesamtzeit für jede Anfrage[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 'Testing Website Response Time for :%{url_effective}\n\nLookup Time:\t\t%{time_namelookup}\nConnect Time:\t\t%{time_connect}\nPre-transfer Time:\t%{time_pretransfer}\nStart-transfer Time:\t%{time_starttransfer}\n\nTotal Time:\t\t%{time_total}\n' -o /dev/null URL > webspeedtest_"$(date)"

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

Durch die Verwendung dieser cURL-Befehle und Skripte können Sie die Leistung von Websites effektiv messen und überwachen, was Ihnen hilft, potenzielle Flaschenhälse zu identifizieren und Ladezeiten zu optimieren.

Abonnieren

Neue Beiträge zu Systemen, Infrastruktur und KI-Engineering.