Dans ce guide, nous passerons en revue les différents clients PHP que vous pouvez utiliser pour vous connecter à l'API Geekflare.

Plus précisément, nous couvrirons l'utilisation de l'API Geekflare avec le file_get_contents fonction, Guzzle, HTTPful et le client HTTPS de Symfony.

Qu'est-ce que l'API Geekflare ?

Geekflare fournit un ensemble d'outils gratuits que vous pouvez utiliser pour surveiller les performances de votre site Web. Ces outils incluent un analyseur de lien rompu, le temps de chargement et un vérificateur DNS. Ces outils sont accessibles en ligne via l'interface web ou l'API.

L'API est basée sur HTTP et est accessible depuis n'importe quel langage de programmation avec une bibliothèque cliente HTTP. L'API dispose d'un niveau gratuit généreux que vous pouvez commencer à utiliser sans avoir à fournir d'informations de paiement.

Ce que nous allons construire

Nous allons écrire un script, exécutable depuis la ligne de commande, qui calculera le temps nécessaire pour charger le site Web de Google et les imprimer sur le terminal. Nous allons implémenter ce programme simple en utilisant différents clients HTTP PHP pour montrer à quoi ressemble l'utilisation de l'API.

Plus précisément, nous allons utiliser les fonctions intégrées - file_get_contents() et des tours php_curl, et l'extension Guzzle PHP. Aussi simples que ces exemples puissent paraître, ils démontrent les concepts de base de l'utilisation de l'API Geekflare.

Pré-requis

Pour suivre, vous devrez connaître PHP au préalable et l'avoir installé sur votre ordinateur. De plus, vous aurez besoin Compositeur pour gérer les extensions.

Enfin, vous aurez également besoin d'un éditeur de texte pour écrire du code. Dans mon cas, je vais utiliser Visual Studio Code, un éditeur de texte open source populaire de Microsoft. Vous pouvez le télécharger depuis le Site Web de Visual Studio Code.

Présentation de l'API Geekflare

La série API Geekflare a des points finaux différents selon ce que vous voulez faire. La liste complète des endpoints et leur documentation associée se trouvent sur le page de documentation.

Créer un compte Geekflare

Pour commencer à utiliser l'API, vous devrez créer un compte en vous rendant sur le Page de destination de l'API et en cliquant sur le bouton d'inscription. Une fois l'inscription terminée, vous serez redirigé vers le tableau de bord, où vous verrez votre clé API. Le tableau de bord devrait ressembler à l'image ci-dessous. J'ai masqué ma clé API pour des raisons de sécurité.

Geekflare-Tableau de bord-1

Dans chaque requête API que vous faites, vous devrez fournir cette clé comme en-tête de requête. Bientôt, vous verrez comment cela peut être fait.

Avec un compte Geekflare créé et PHP installé, nous pouvons commencer à créer le projet.

Création du dossier du projet

Tout d'abord, créez un dossier dans lequel nous stockerons les fichiers du projet. Après cela, créez les fichiers suivants

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

Ensuite, exécutez la commande suivante pour installer le vlucas/phpdotenv et des tours guzzlehttp/guzzle extension

composer require vlucas/phpdotenv guzzlehttp/guzzle

À ce stade, votre dossier de projet devrait ressembler à ceci :

Screenshot-from-2022-10-17-10-55-35

Maintenant, ouvrez le .env fichier et ajoutez la ligne de code suivante, en remplaçant <your-api-key> avec votre clé API réelle du tableau de bord Geekflare :

API_KEY=<your-api-key>

Using file_get_contents()

La première méthode que nous pourrions utiliser pour faire des requêtes HTTP est d'appeler le file_get_contents() fonction intégrée à PHP. La signature de fonction du file_get_contents() la fonction est la suivante :

file_get_contents(path, include_path, context)

Bien que la méthode soit souvent utilisée pour lire le contenu d'un fichier dans le stockage local, nous pouvons l'utiliser pour lire une ressource Web, telle que des données renvoyées par un point de terminaison d'API.

Maintenant, pour commencer, ouvrez le with_file_get_contents.php et ajoutez le code PHP passe-partout.

<?php
   // all the code to be inserted here
?>

Ensuite, nous pouvons commencer avec le chargement des extensions. Ajoutez la ligne de code suivante à votre fichier

require_once('vendor/autoload.php');

Ensuite, nous pouvons charger nos variables d'environnement, qui incluent la clé API

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

Ensuite, nous pouvons définir la charge utile. Ce seront des données que nous enverrons dans le cadre du corps de la demande

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

Nous avons créé une variable de charge utile et l'avons affectée à une chaîne JSON qui contient le url, proxyCountry et des tours followRedirect comme propriétés.

La série url La propriété spécifie la page Web dont nous voulons vérifier le temps de chargement.

La série proxyCountry est l'emplacement du serveur que nous voulons utiliser pour faire la demande. Dans ce cas, nous utilisons le serveur américain, mais vous pouvez choisir entre l'Inde, la Chine, le Royaume-Uni et la France. Tu peux lire la documentation pour plus de détails.

Ensuite followRedirect spécifie si le serveur proxy doit suivre les redirections et mesurer le temps de réponse de la réponse finale ou de la première redirection.

Par la suite, nous pouvons créer des options qui configureront notre requête en ajoutant ce code :

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

En faisant cela, nous avons créé un objet d'options qui spécifie que notre méthode HTTP est POST, et nous avons un en-tête qui spécifie deux propriétés, le type de contenu comme JSON et le x-api-key comme la clé API que vous avez spécifiée dans le .env fichier et a été chargé en tant que variable d'environnement.

Ensuite, nous pouvons faire la demande en créant un flux dans lequel nos options seront écrites :

$context = stream_context_create($options);

Ensuite, nous appelons le file_get_contents() méthode pour effectuer la requête et stocker la réponse sous forme de variable.

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

Nous avons fait la demande de https://api.geekflare.com/loadtime. Le false indique à PHP de ne pas utiliser le chemin. Et nous passons le contexte que nous avons créé à la méthode.

Pour afficher la réponse, nous utiliserons la sortie comme suit.

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

A la fin de ceci, votre fichier devrait ressembler à ceci :

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

    $dotenv = Dotenv\Dotenv::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.geekflare.com/loadtime", false, $context);

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

Lorsque vous exécutez le fichier à l'aide de la commande suivante :

$php with_file_get_contents.php

Vous obtiendrez la sortie suivante

Loadtime: 81

Using cURL

cURL est un utilitaire de ligne de commande utilisé pour effectuer des requêtes d'URL côté client. En PHP, il peut être utilisé en utilisant le php-curl utilitaire. Pour commencer à l'utiliser, ouvrez le with_curl.php fichier et écrire le passe-partout PHP

<?php
    // all new code will be written here
?>

Importons ensuite les extensions et chargeons la variable d'environnement API_KEY définie dans le .env filet

require_once('vendor/autoload.php');

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

Ensuite, nous allons créer une variable pour stocker les en-têtes de notre objet sous forme de tableau où chaque élément individuel du tableau est un en-tête spécifique.

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

Nous avons défini deux en-têtes, un pour le type de contenu et un pour la clé API.

Ensuite, nous pouvons définir le corps de la requête.

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

Après cela, nous pouvons créer une session curl en utilisant le curl_init() fonction. Nous pouvons transmettre l'URL à laquelle nous voulons faire la demande en tant qu'argument de l'appel de fonction.

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

Nous pouvons maintenant tout assembler en définissant l'en-tête et le corps comme options pour la session. Pour cela, nous utiliserons le curl_setopt_array() fonction

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

Pour faire la demande, nous appellerons curl_exec() fonction

$response = curl_exec($ch);

Nous avons stocké la réponse dans le $response variable, afin que nous puissions fermer la session pour libérer les ressources système utilisées par la session.

curl_close($ch);

Enfin, nous pouvons imprimer la réponse à l'écran en utilisant var_dump.

var_dump($response);

Au final, votre fichier de script devrait ressembler à ceci

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

    $dotenv = Dotenv\Dotenv::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.geekflare.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);
?>

Lorsque nous exécutons le script en utilisant php with_curl.php, vous devriez obtenir le résultat suivant :

{"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)

La requête s'est terminée avec succès et l'API a répondu avec des données JSON0. Vous pouvez utiliser ces données comme bon vous semble.

With Guzzle

Dans la dernière partie de ce tutoriel, nous utiliserons Bouffer pour écrire le scénario. Comme toujours, nous commençons par insérer le passe-partout PHP à l'intérieur du with_guzzle.php

<?php
    // all the code will go here
?>

Ensuite, nous pouvons importer des extensions et les objets Guzzle Client et Request et charger des variables d'environnement.

require_once('vendor/autoload.php');

use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Request;

Ensuite, nous pouvons charger des variables d'environnement.

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

Ensuite, nous pouvons instancier un client HTTP Guzzle

$client = new GuzzleHttp\Client();

Ensuite, nous pouvons procéder à la création d'en-têtes pour notre demande

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

Ensuite, nous pouvons définir le corps de la requête

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

Nous pouvons ensuite effectuer la demande en instanciant la classe Request et en transmettant l'URL, l'en-tête et le corps du point de terminaison de l'API.

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

Ensuite, nous pouvons envoyer la requête en ajoutant cette ligne de code :

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

Une fois la demande envoyée, nous pouvons recevoir le corps de la demande comme suit

$response_body = $response->getBody();

Au final, nous pouvons décoder la réponse JSON et imprimer le temps de chargement

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

Donc, au final, le fichier devrait ressembler à ceci :

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

    use GuzzleHttp\Client;
    use GuzzleHttp\Psr7\Request;

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

    $client = new GuzzleHttp\Client();

    $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.geekflare.com/loadtime', $headers, $body);

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

    $response_body = $response->getBody();

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

Et lorsque vous exécutez le script à l'aide de la commande suivante :

$php with_guzzle.php

Et vous verrez la réponse :

Loadtime: 130

Conclusion

Dans cet article, nous avons passé en revue les différents clients que vous voudrez peut-être utiliser lors de la création d'un projet PHP qui nécessitera l'API Geekflare.

Alors que les scripts de ce projet utilisent la ligne de commande comme principale forme de sortie, les projets du monde réel peuvent présenter la réponse sur une page Web ou l'écrire dans un fichier. Les exemples de scripts de cet article étaient simples, mais ils démontrent les concepts de base de l'utilisation de l'API Geekflare. Pour utiliser différentes API, vous pouvez modifier le point de terminaison et transmettre différentes options dans le corps de la requête.

Vous pouvez également être intéressé par comment utiliser l'API de recherche DNS Geekflare en Javascript.