So verwenden Sie die wdzwdz-API mit PHP-Clients

von

Verschiedene PHP-Clients zur Nutzung der wdzwdz-API

Dieser Leitfaden erläutert verschiedene PHP-Clients, mit denen Sie eine Verbindung zur wdzwdz-API herstellen können. Wir werden uns insbesondere auf die Nutzung der wdzwdz-API mit den Funktionen `file_get_contents`, der Guzzle-Bibliothek, HTTPful sowie dem HTTPS-Client von Symfony konzentrieren.

Was ist die wdzwdz-API?

wdzwdz bietet eine Sammlung von kostenlosen Werkzeugen zur Überwachung der Leistung Ihrer Website. Dazu gehören unter anderem ein Analysetool für defekte Links, ein Ladezeit-Tester und ein DNS-Checker. Diese Tools sind sowohl über die Weboberfläche als auch über eine API zugänglich. Die API basiert auf HTTP und kann von jeder Programmiersprache mit einer geeigneten HTTP-Client-Bibliothek verwendet werden. Sie bietet ein großzügiges, kostenloses Kontingent, das ohne Angabe von Zahlungsinformationen genutzt werden kann.

Was wir entwickeln werden

Wir werden ein Skript erstellen, das über die Befehlszeile ausgeführt wird und die Ladezeit der Google-Website berechnet und das Ergebnis im Terminal ausgibt. Dieses einfache Programm implementieren wir mit verschiedenen PHP-HTTP-Clients, um die Nutzung der API zu demonstrieren. Insbesondere werden wir die eingebauten Funktionen `file_get_contents()` und `php-curl` sowie die Erweiterung Guzzle PHP verwenden. Diese einfachen Beispiele verdeutlichen die grundlegenden Konzepte der Nutzung der wdzwdz-API.

Voraussetzungen

Für dieses Tutorial sind grundlegende Kenntnisse in PHP und eine installierte PHP-Umgebung erforderlich. Darüber hinaus benötigen Sie Composer zur Verwaltung von Erweiterungen. Ein Texteditor Ihrer Wahl ist ebenfalls notwendig. Ich werde hier Visual Studio Code nutzen, ein beliebter Open-Source-Texteditor von Microsoft, den Sie von der offiziellen Webseite herunterladen können.

wdzwdz-API-Überblick

Die wdzwdz-API bietet verschiedene Endpunkte, abhängig davon, welche Funktion Sie nutzen möchten. Eine detaillierte Liste der Endpunkte sowie die zugehörige Dokumentation finden Sie auf der offiziellen Dokumentationsseite.

Ein wdzwdz-Konto erstellen

Um mit der Nutzung der API zu beginnen, müssen Sie ein Konto erstellen. Besuchen Sie dazu die API-Landingpage und klicken Sie auf die Schaltfläche „Anmelden“. Nach erfolgreicher Registrierung werden Sie zum Dashboard weitergeleitet, wo Ihr persönlicher API-Schlüssel angezeigt wird. Das Dashboard sollte dem unten dargestellten Bild ähneln. Aus Sicherheitsgründen habe ich meinen API-Schlüssel unkenntlich gemacht.

Bei jeder API-Anfrage muss dieser Schlüssel als Anfrage-Header angegeben werden. Wir werden Ihnen in Kürze zeigen, wie dies umgesetzt werden kann.

Sobald Sie ein wdzwdz-Konto erstellt und PHP installiert haben, können wir mit der Erstellung unseres Projekts beginnen.

Projektordner erstellen

Erstellen Sie zunächst einen Ordner, in dem wir die Projektdateien speichern. Erstellen Sie anschließend die folgenden Dateien:

  • .env
  • with_curl.php
  • with_file_get_contents.php
  • with_guzzle.php

Führen Sie nun den folgenden Befehl aus, um die Erweiterungen `vlucas/phpdotenv` und `guzzlehttp/guzzle` zu installieren:

composer require vlucas/phpdotenv guzzlehttp/guzzle

Ihr Projektordner sollte nun wie folgt aussehen:

Öffnen Sie die Datei `.env` und fügen Sie die folgende Zeile ein, wobei Sie `` durch Ihren tatsächlichen API-Schlüssel aus dem wdzwdz-Dashboard ersetzen:

API_KEY=<your-api-key>

Verwendung von `file_get_contents()`

Die erste Methode, die wir zur Durchführung von HTTP-Anfragen nutzen können, ist die Funktion `file_get_contents()`, die in PHP integriert ist. Die Signatur der Funktion `file_get_contents()` lautet:

file_get_contents(path, include_path, context)

Obwohl diese Methode häufig zum Lesen von Inhalten aus Dateien auf dem lokalen Speicher verwendet wird, können wir sie auch nutzen, um Webressourcen auszulesen, wie beispielsweise Daten, die von einem API-Endpunkt zurückgegeben werden.

Öffnen Sie zunächst die Datei `with_file_get_contents.php` und fügen Sie den grundlegenden PHP-Code hinzu:

<?php
    // Hier kommt der Code hinein
?>

Als Nächstes laden wir die benötigten Erweiterungen. Fügen Sie dazu die folgende Zeile in Ihre Datei ein:

require_once('vendor/autoload.php');

Nun können wir unsere Umgebungsvariablen laden, die den API-Schlüssel enthalten:

$dotenv = DotenvDotenv::createImmutable(__DIR__);
$dotenv->load();

Anschließend definieren wir die Payload. Dies sind die Daten, die wir als Teil des Anfragekörpers senden:

$payload = json_encode([
  "url" => "https://www.google.com",
  "proxyCountry" => "us",
  "followRedirect" => true
]);

Wir haben eine Variable `$payload` erstellt und ihr einen JSON-String zugewiesen, der die Eigenschaften `url`, `proxyCountry` und `followRedirect` enthält.

Die Eigenschaft `url` gibt die Webseite an, deren Ladezeit wir überprüfen möchten.

`proxyCountry` ist der Standort des Servers, den wir für die Anfrage nutzen wollen. In diesem Fall verwenden wir den Server in den USA, aber Sie können auch zwischen Indien, China, Großbritannien und Frankreich wählen. Weitere Informationen finden Sie in der Dokumentation.

`followRedirect` gibt an, ob der Proxyserver Weiterleitungen verfolgen soll und misst die Antwortzeit der endgültigen Antwort oder der ersten Weiterleitung.

Als Nächstes erstellen wir Optionen, die unsere Anfrage konfigurieren. Fügen Sie dazu den folgenden Code hinzu:

$options = [
  "http" => [
  "method" => "POST",
  "header" => array("Content-Type: application/json", "x-api-key : " . $_ENV['API_KEY']),
  "content" => $payload
  ]
];

Hierdurch haben wir ein Optionsobjekt erstellt, das angibt, dass unsere HTTP-Methode `POST` ist und einen Header mit zwei Eigenschaften enthält: den Inhaltstyp als JSON und den `x-api-key` als API-Schlüssel, den Sie in der `.env`-Datei definiert und als Umgebungsvariable geladen haben.

Jetzt können wir die Anfrage stellen, indem wir einen Stream erstellen, in den unsere Optionen geschrieben werden:

$context = stream_context_create($options);

Als Nächstes rufen wir die Funktion `file_get_contents()` auf, um die Anfrage zu senden und die Antwort in einer Variablen zu speichern.

$response = file_get_contents("https://api.wdzwdz.com/loadtime", false, $context);

Wir haben die Anfrage an `https://api.wdzwdz.com/loadtime` gesendet. Der Wert `false` weist PHP an, den Pfad nicht zu verwenden. Und wir übergeben den erstellten Kontext an die Methode.

Um die Antwort anzuzeigen, geben wir sie wie folgt aus:

echo "Ladezeit: " . json_decode($response)->data->total . "n";

Am Ende sollte Ihre Datei so aussehen:

<?php
    require_once('vendor/autoload.php');

    $dotenv = DotenvDotenv::createImmutable(__DIR__);
    $dotenv->load();

    $payload = json_encode([
        "url" => "https://www.google.com",
        "proxyCountry" => "us",
        "followRedirect" => true
    ]);

    $options = [
        "http" => [
            "method" => "POST",
            "header" => array("Content-Type: application/json", "x-api-key : " . $_ENV['API_KEY']),
            "content" => $payload
        ]
    ];

    $context = stream_context_create($options);

    $response = file_get_contents("https://api.wdzwdz.com/loadtime", false, $context);

    echo "Ladezeit: " . json_decode($response)->data->total . "n";
?>

Wenn Sie diese Datei mit dem Befehl ausführen:

php with_file_get_contents.php

Erhalten Sie die folgende Ausgabe:

Ladezeit: 81

Verwendung von cURL

cURL ist ein Befehlszeilenwerkzeug zum Senden von clientseitigen URL-Anfragen. In PHP kann es mit dem Dienstprogramm `php-curl` genutzt werden. Um es zu verwenden, öffnen Sie die Datei `with_curl.php` und fügen den grundlegenden PHP-Code ein:

<?php
    // Hier kommt der neue Code hinein
?>

Lassen Sie uns zunächst die Erweiterungen importieren und die Umgebungsvariable `API_KEY` laden, die in der Datei `.env` definiert ist:

require_once('vendor/autoload.php');

$dotenv = DotenvDotenv::createImmutable(__DIR__);
$dotenv->load();

Als Nächstes erstellen wir eine Variable, um die Header unseres Objekts als Array zu speichern, wobei jedes einzelne Element im Array einen bestimmten Header darstellt:

$header = ["Content-type: application/json", "x-api-key: " . $_ENV['API_KEY']];

Wir haben zwei Header definiert: einen für den Inhaltstyp und einen für den API-Schlüssel.

Jetzt können wir den Text der Anfrage definieren:

$body = json_encode([
  "url" => "google.com",
  "proxyCountry" => "us",
  "followRedirect" => true
]);

Anschließend können wir mit der Funktion `curl_init()` eine cURL-Sitzung erstellen. Die URL, an die wir die Anfrage senden wollen, wird als Argument an den Funktionsaufruf übergeben:

$ch = curl_init("https://api.wdzwdz.com/loadtime");

Jetzt können wir alles zusammenfügen, indem wir Header und Body als Optionen für die Sitzung definieren. Dazu verwenden wir die Funktion `curl_setopt_array()`:

curl_setopt_array($ch, [
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => $header,
  CURLOPT_POSTFIELDS => $body
]);

Um die Anfrage zu senden, rufen wir die Funktion `curl_exec()` auf:

$response = curl_exec($ch);

Wir haben die Antwort in der Variable `$response` gespeichert, sodass wir die Sitzung schließen können, um die von der Sitzung verwendeten Systemressourcen freizugeben:

curl_close($ch);

Schließlich können wir die Antwort mit `var_dump` auf dem Bildschirm ausgeben:

var_dump($response);

Am Ende sollte Ihre Skriptdatei wie folgt aussehen:

<?php
  require_once('vendor/autoload.php');

  $dotenv = DotenvDotenv::createImmutable(__DIR__);
  $dotenv->load();

  $header = ["Content-type: application/json", "x-api-key: " . $_ENV['API_KEY']];

  $body = json_encode([
  "url" => "google.com",
  "proxyCountry" => "us",
  "followRedirect" => true
  ]);

  $ch = curl_init("https://api.wdzwdz.com/loadtime");

  curl_setopt_array($ch, [
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => $header,
  CURLOPT_POSTFIELDS => $body
  ]);

  $response = curl_exec($ch);

  curl_close($ch);

  var_dump($response);
?>

Wenn wir das Skript mit `php with_curl.php` ausführen, erhalten wir die folgende Ausgabe:

{"timestamp":1666083632547,"apiStatus":"success","apiCode":200,"meta":{"url":"google.com","followRedirect":true,"redirectedURL":"https://www.google.com/?gws_rd=ssl","test":{"id":"d20h1hb409qbfwm0g534l51asugpi5hl"}},"data":{"dns":12,"connect":17,"tls":6,"send":21,"wait":110,"total":114}}bool(true)

Die Anfrage wurde erfolgreich abgeschlossen und die API hat mit JSON-Daten geantwortet. Sie können diese Daten nach Bedarf verwenden.

Mit Guzzle

Im letzten Teil dieses Tutorials verwenden wir Guzzle, um das Skript zu schreiben. Wie immer beginnen wir mit dem Einfügen des PHP-Boilerplate-Codes in die Datei `with_guzzle.php`:

<?php
    // Hier kommt der gesamte Code hinein
?>

Dann importieren wir die Erweiterungen, den Guzzle-Client und fordern Objekte an und laden Umgebungsvariablen:

require_once('vendor/autoload.php');

use GuzzleHttpClient;
use GuzzleHttpPsr7Request;

Als Nächstes können wir die Umgebungsvariablen laden:

$dotenv = DotenvDotenv::createImmutable(__DIR__);
$dotenv->load();

Danach instanziieren wir einen Guzzle-HTTP-Client:

$client = new GuzzleHttpClient();

Nun können wir mit der Erstellung der Header für unsere Anfrage fortfahren:

$headers = [
    'x-api-key' => $_ENV['API_KEY'],
    'Content-Type' => 'application/json'
  ];

Anschließend definieren wir den Text der Anfrage:

$body = json_encode([
    "url" => "google.com",
    "proxyCountry" => "us",
    "followRedirect" => true
  ]);

Jetzt können wir die Anfrage senden, indem wir die Request-Klasse instanziieren und die API-Endpunkt-URL, den Header und den Body übergeben:

$request = new Request('POST', 'https://api.wdzwdz.com/loadtime', $headers, $body);

Dann können wir die Anfrage senden, indem wir die folgende Zeile hinzufügen:

$response = $client->sendAsync($request)->wait();

Nachdem die Anfrage gesendet wurde, können wir den Text der Antwort folgendermaßen erhalten:

$response_body = $response->getBody();

Schließlich können wir die JSON-Antwort dekodieren und die Ladezeit ausgeben:

echo "Ladezeit: " . json_decode($response_body)->data->total . "n";

Am Ende sollte die Datei so aussehen:

<?php
    require_once('vendor/autoload.php');

    use GuzzleHttpClient;
    use GuzzleHttpPsr7Request;

    $dotenv = DotenvDotenv::createImmutable(__DIR__);
    $dotenv->load();


    $client = new GuzzleHttpClient();

    $headers = [
        'x-api-key' => $_ENV['API_KEY'],
        'Content-Type' => 'application/json'
    ];

    $body = json_encode([
        "url" => "google.com",
        "proxyCountry" => "us",
        "followRedirect" => true
    ]);

    $request = new Request('POST', 'https://api.wdzwdz.com/loadtime', $headers, $body);

    $response = $client->sendAsync($request)->wait();

    $response_body = $response->getBody();

    echo "Ladezeit: " . json_decode($response_body)->data->total . "n";
?>

Wenn Sie nun das Skript mit dem folgenden Befehl ausführen:

php with_guzzle.php

Wird die folgende Ausgabe angezeigt:

Ladezeit: 130

Zusammenfassung

In diesem Artikel haben wir verschiedene Clients behandelt, die Sie nutzen können, wenn Sie ein PHP-Projekt entwickeln, das die wdzwdz-API verwendet. Während die Skripte in diesem Projekt die Befehlszeile als primäre Ausgabemethode nutzen, können reale Projekte die Antwort auf einer Webseite darstellen oder in eine Datei schreiben. Die Skriptbeispiele in diesem Artikel waren einfach, veranschaulichen aber die Kernkonzepte der Nutzung der wdzwdz-API. Um andere APIs zu nutzen, können Sie den Endpunkt ändern und verschiedene Optionen im Anfragekörper übergeben.

Sie könnten auch daran interessiert sein, die wdzwdz-DNS-Lookup-API in Javascript zu nutzen.

Weitere Artikel:

  1. So verwenden Sie die wdzwdz-DNS-Lookup-API in JavaScript (NodeJS)
  2. So scrapen Sie eine Website mit der wdzwdz Web Scraping API
  3. So extrahieren Sie Website-Metadaten mit der wdzwdz Meta Scraping API
  4. Verwendung der wdzwdz-API in JavaScript (NodeJS)