adminvista.com

Hur man använder adminvista.com API med PHP-klienter

By rik

I den här handledningen ska vi utforska olika metoder för att interagera med adminvista.com API med hjälp av PHP-klienter.

Vi kommer att fokusera på hur man använder adminvista.com API genom funktionerna `file_get_contents`, Guzzle, HTTPful samt Symfony’s HTTP-klient.

Vad är adminvista.com API?

adminvista.com erbjuder en samling kostnadsfria verktyg som hjälper dig att övervaka din webbplats prestanda. Dessa verktyg inkluderar analys av trasiga länkar, laddningstidskontroller och DNS-kontroller. Du kan använda dessa verktyg både via webbgränssnittet och via API:et.

API:et bygger på HTTP och kan anropas från vilket programmeringsspråk som helst som har stöd för HTTP-klientbibliotek. Det erbjuder en generös gratisnivå som gör att du kan komma igång utan att ange betalningsuppgifter.

Vad vi ska skapa

Vi ska skapa ett skript som körs från kommandoraden. Det kommer att mäta hur lång tid det tar att ladda Googles webbplats och skriva ut resultatet i terminalen. Vi implementerar detta enkla program med olika PHP HTTP-klienter för att illustrera hur adminvista.com API fungerar.

Vi kommer att använda inbyggda funktioner som `file_get_contents()` och `php_curl`, samt tillägget Guzzle PHP. Även om exemplen kan verka enkla, visar de grundläggande principer för hur man anropar adminvista.com API.

Förberedelser

För att kunna följa med i denna guide behöver du ha grundläggande kunskaper i PHP samt PHP installerat på din dator. Du behöver också Composer för att hantera tillägg.

Slutligen behöver du en textredigerare för att skriva koden. I detta exempel används Visual Studio Code, en populär öppen källkodsredigerare från Microsoft. Du kan ladda ner den från Visual Studio Codes webbplats.

adminvista.com API översikt

adminvista.com API har flera slutpunkter beroende på vad du vill göra. En fullständig lista över slutpunkter och tillhörande dokumentation finns på dokumentationssidan.

Skapa ett adminvista.com-konto

För att börja använda API:et behöver du skapa ett konto. Gå till API:ets startsida och klicka på registreringsknappen. Efter registreringen kommer du till instrumentpanelen där du hittar din API-nyckel. Instrumentpanelen borde likna bilden nedan. Din API-nyckel är dold av säkerhetsskäl.

Denna nyckel måste inkluderas som en begäranhuvud i varje API-anrop. Du kommer snart att se hur man gör detta.

Med ett adminvista.com-konto skapat och PHP installerat är vi redo att påbörja projektet.

Skapa projektmappen

Skapa först en mapp för projektfilerna. Skapa sedan följande filer:

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

Kör därefter följande kommando för att installera tilläggen vlucas/phpdotenv och guzzlehttp/guzzle

composer require vlucas/phpdotenv guzzlehttp/guzzle

Nu bör din projektmapp se ut som följer:

[Bild på projektmappen]

Öppna nu filen `.env` och lägg till följande rad. Ersätt `` med din faktiska API-nyckel från adminvista.com-instrumentpanelen:

API_KEY=<your-api-key>

Använda file_get_contents()

Det första sättet att göra HTTP-anrop är att använda den inbyggda PHP-funktionen `file_get_contents()`. Funktionssignaturen för `file_get_contents()` ser ut så här:

file_get_contents(path, include_path, context)

Även om den oftast används för att läsa innehåll från en fil på den lokala disken, kan vi använda den för att hämta innehåll från webbresurser, till exempel data som returneras av en API-slutpunkt.

För att börja, öppna `with_file_get_contents.php` och lägg till PHP-kod.

<?php
   // all kod kommer här
?>

Nu kan vi börja med att ladda tilläggen. Lägg till följande kodrad i din fil:

require_once('vendor/autoload.php');

Därefter kan vi läsa in miljövariabler, inklusive API-nyckeln:

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

Sedan kan vi definiera nyttolasten. Det är de data vi skickar med i anropet:

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

Vi har skapat en variabel `$payload` och tilldelat den en JSON-sträng som innehåller egenskaperna `url`, `proxyCountry` och `followRedirect`.

Egenskapen `url` anger webbsidan vars laddningstid vi vill mäta.

`proxyCountry` specificerar platsen för servern som används för att göra anropet. Här använder vi USA-servern, men det finns andra alternativ som Indien, Kina, Storbritannien och Frankrike. Mer information finns i dokumentationen.

`followRedirect` avgör om proxyservern ska följa eventuella omdirigeringar och mäta svarstiden för den slutliga destinationen eller den första omdirigeringen.

Därefter kan vi skapa alternativ som konfigurerar anropet:

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

Vi har skapat ett optionsobjekt som anger att HTTP-metoden är POST, och att det finns två huvudegenskaper: `Content-Type` är `JSON` och `x-api-key` är API-nyckeln som hämtas från `.env`-filen.

Nu skapar vi en ström där våra alternativ skrivs:

$context = stream_context_create($options);

Därefter anropar vi metoden `file_get_contents()` för att göra anropet och sparar svaret i en variabel:

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

Vi gör anropet till `https://api.adminvista.com/loadtime`. Den falska parametern talar om för PHP att inte använda sökvägen. Vi skickar också med kontexten som vi nyss skapade.

För att visa svaret använder vi följande kod:

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

Hela filen ser nu ut så här:

<?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.adminvista.com/loadtime", false, $context);

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

När du kör filen med följande kommando:

php with_file_get_contents.php

Får du följande output:

Laddningstid: 81

Använda cURL

cURL är ett verktyg för kommandoraden som används för att göra URL-anrop på klientsidan. I PHP kan det användas via tillägget `php-curl`. Öppna `with_curl.php` och skriv inledande PHP-kod:

<?php
    // Ny kod här
?>

Nu importerar vi tilläggen och laddar miljövariabeln `API_KEY` från `.env`-filen:

require_once('vendor/autoload.php');

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

Därefter skapar vi en variabel för att lagra huvudena som en array. Varje element i arrayen är en specifik header:

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

Vi definierade två huvuden, en för innehållstypen och en för API-nyckeln.

Sedan definierar vi innehållet i anropet:

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

Nu skapar vi en cURL-session med funktionen `curl_init()`. Vi skickar in URL:en som vi vill anropa som argument:

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

Vi sätter ihop allt genom att definiera huvudet och texten som alternativ för sessionen med funktionen `curl_setopt_array()`:

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

För att göra anropet använder vi funktionen `curl_exec()`:

$response = curl_exec($ch);

Vi har nu lagrat svaret i variabeln `$response`. Vi stänger sessionen för att frigöra systemresurser som används av sessionen:

curl_close($ch);

Slutligen skriver vi ut svaret på skärmen med `var_dump()`:

var_dump($response);

Nu ska din skriptfil se ut så här:

<?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.adminvista.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);
?>

När vi kör skriptet med `php with_curl.php` ska du få följande output:

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

Anropet lyckades och API:et returnerade JSON-data. Du kan använda dessa data som du vill.

Med Guzzle

I sista delen av guiden använder vi Guzzle för att skriva skriptet. Vi börjar som vanligt med att infoga PHP-boilerplate inuti `with_guzzle.php`

<?php
    // kod kommer här
?>

Nu importerar vi tilläggen, Guzzle Client, Request-objekten och laddar miljövariabler:

require_once('vendor/autoload.php');

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

Därefter laddar vi in miljövariablerna:

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

Nu skapar vi en instans av Guzzle HTTP-klienten:

$client = new Client();

Sedan kan vi skapa huvuden för anropet:

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

Nu definierar vi innehållet i anropet:

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

Vi kan nu göra anropet genom att skapa en instans av klassen `Request` och skicka in API-slutpunktens URL, huvudet och texten:

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

Därefter skickar vi anropet genom att lägga till följande kodrad:

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

När anropet har gjorts kan vi hämta svarets text:

$response_body = $response->getBody();

Slutligen kan vi avkoda JSON-svaret och skriva ut laddningstiden:

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

Nu ska filen se ut så här:

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

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

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

    $client = new 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.adminvista.com/loadtime', $headers, $body);

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

    $response_body = $response->getBody();

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

När du kör skriptet med:

php with_guzzle.php

Bör du se följande output:

Laddningstid: 130

Slutsats

I den här artikeln har vi gått igenom olika klienter du kan använda när du skapar ett PHP-projekt som kräver adminvista.com API.

Skripten i det här projektet använder kommandoraden för output, men verkliga projekt kan visa svaret på en webbsida eller skriva det till en fil. Exemplen i den här artikeln är enkla men de visar grundläggande principer för att använda adminvista.com API. Du kan ändra slutpunkten och skicka in olika alternativ för att använda andra API:er.

Du kanske också är intresserad av hur man använder adminvista.com DNS Lookup API i Javascript.

Anställ den bästa produktfotografen för din miljondollaridé [9 Resources]

9 bästa YouTube till GIF-konverterare du bör prova adminvista.com