PHP & tipsbilk.net API: Guide til effektiv integrasjon

by
Tweet
Share
Share
Pin
0 Shares

Utforsk ulike PHP-klienter for tipsbilk.net API

Denne veiledningen gir en oversikt over de ulike PHP-klientene som kan benyttes for å koble seg til tipsbilk.net API.

Vi går spesifikt gjennom hvordan du kan bruke tipsbilk.net API med funksjonene `file_get_contents`, `Guzzle`, `HTTPful` og `Symfonys HTTPS-klient`.

Hva er egentlig tipsbilk.net API?

tipsbilk.net tilbyr en rekke kostnadsfrie verktøy som lar deg overvåke ytelsen til nettstedet ditt. Dette inkluderer blant annet en analysator for ødelagte lenker, verktøy for å måle lastetid og en DNS-kontroller. Disse verktøyene er tilgjengelige via et webgrensesnitt, men også gjennom et API.

API-et er basert på HTTP og kan brukes fra alle programmeringsspråk som har et HTTP-klientbibliotek. Det finnes et gratis nivå med god kapasitet som du kan ta i bruk uten å måtte oppgi betalingsinformasjon.

Hva vi skal utvikle

Vi skal lage et skript som kan kjøres fra kommandolinjen, og som beregner hvor lang tid det tar å laste inn Google.com. Dette resultatet skal deretter skrives ut i terminalen. Dette enkle programmet implementeres ved hjelp av ulike PHP HTTP-klienter for å illustrere hvordan bruken av API-et fungerer i praksis.

Mer spesifikt skal vi ta i bruk de innebygde funksjonene `file_get_contents()` og `php_curl`, i tillegg til Guzzle PHP-utvidelsen. Selv om disse eksemplene er enkle, viser de de sentrale prinsippene for bruk av tipsbilk.net API.

Forutsetninger

For å følge denne guiden, må du ha grunnleggende kunnskaper i PHP, og PHP må være installert på maskinen din. I tillegg trenger du Composer for å administrere utvidelser.

Du trenger også et tekstredigeringsprogram for å skrive koden. I dette tilfellet bruker jeg Visual Studio Code, en populær, åpen kildekode-tekstredigerer fra Microsoft. Du kan laste den ned fra Visual Studio Code sin offisielle nettside.

En oversikt over tipsbilk.net API

tipsbilk.net API tilbyr forskjellige endepunkter avhengig av hva du ønsker å gjøre. Du finner en fullstendig oversikt over alle endepunkter og tilhørende dokumentasjon på den offisielle dokumentasjonssiden.

Opprettelse av en tipsbilk.net-konto

For å komme i gang med API-et, må du opprette en konto. Dette gjøres ved å besøke API-landingssiden og klikke på registreringsknappen. Etter at registreringen er fullført, vil du bli ført til et dashbord der du finner din personlige API-nøkkel. Dashbordet skal ligne på bildet under. Merk at min API-nøkkel er skjult av sikkerhetsmessige årsaker.

Denne nøkkelen må inkluderes som en forespørselsoverskrift i hver API-forespørsel du sender. Vi skal se hvordan dette gjøres om kort tid.

Med en tipsbilk.net-konto opprettet og PHP installert, er vi klare til å begynne med prosjektet vårt.

Opprettelse av prosjektmappen

Start med å opprette en mappe der vi kan lagre prosjektfilene. I denne mappen oppretter du følgende filer:

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

Kjør deretter følgende kommando for å installere utvidelsene `vlucas/phpdotenv` og `guzzlehttp/guzzle`:

composer require vlucas/phpdotenv guzzlehttp/guzzle

På dette tidspunktet skal prosjektmappen din se omtrent slik ut:

Åpne `.env`-filen og legg til følgende linje, og erstatt `` med din faktiske API-nøkkel fra tipsbilk.net-dashbordet:

API_KEY=<your-api-key>

Bruk av `file_get_contents()`

Den første metoden vi kan benytte for å gjøre HTTP-forespørsler, er ved å bruke funksjonen `file_get_contents()`, som er innebygd i PHP. Funksjonssignaturen for `file_get_contents()` ser slik ut:

file_get_contents(path, include_path, context)

Selv om denne metoden oftest brukes til å lese innhold fra filer i lokalt lager, kan den også brukes til å lese fra nettressurser, slik som data som returneres av et API-endepunkt.

For å komme i gang, åpne `with_file_get_contents.php` og legg til følgende PHP-kode:

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

La oss begynne med å laste inn nødvendige utvidelser. Legg til følgende linje i filen din:

require_once('vendor/autoload.php');

Deretter laster vi inn miljøvariablene våre, som inkluderer API-nøkkelen:

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

Nå definerer vi nyttelasten, som er dataene vi sender som en del av forespørselsorganet:

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

Vi har nå opprettet en variabel som inneholder en JSON-streng med `url`, `proxyCountry` og `followRedirect` som egenskaper.

Egenskapen `url` angir nettstedet vi ønsker å sjekke lastetiden for.

`proxyCountry` er plasseringen til serveren vi ønsker å bruke til å sende forespørselen. I dette tilfellet bruker vi en server i USA, men du kan velge mellom India, Kina, Storbritannia og Frankrike. Se dokumentasjonen for mer informasjon.

`followRedirect` angir om proxyserveren skal følge eventuelle omdirigeringer og måle responstiden til det endelige svaret, eller den første omdirigeringen.

Deretter kan vi opprette et sett med alternativer som konfigurerer forespørselen vår. Legg til følgende kode:

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

Dette oppretter et opsjonsobjekt som sier at HTTP-metoden vår skal være `POST`, og at vi har en overskrift som spesifiserer to egenskaper: innholdstypen som JSON, og `x-api-key` som skal være API-nøkkelen som vi definerte i `.env`-filen og som nå er lastet som en miljøvariabel.

Deretter kan vi sende forespørselen ved å opprette en strøm som alternativene våre blir skrevet til:

$context = stream_context_create($options);

Nå kan vi kalle funksjonen `file_get_contents()` for å utføre forespørselen, og vi lagrer svaret i en variabel:

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

Vi sendte forespørselen til `https://api.tipsbilk.net.com/loadtime`. `false` forteller PHP om ikke å bruke banen, og vi overfører konteksten vi opprettet til metoden.

Til slutt viser vi resultatet ved hjelp av følgende kode:

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

Når alt er fullført, skal filen din se slik ut:

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

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

Når du kjører filen med kommandoen:

php with_file_get_contents.php

Du skal få følgende utskrift:

Loadtime: 81

Bruk av cURL

cURL er et kommandolinjeverktøy som brukes til å sende URL-forespørsler fra klientsiden. I PHP kan dette gjøres ved hjelp av php-curl-verktøyet. For å begynne, åpne `with_curl.php` og legg til følgende PHP-boilerplate:

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

Deretter importerer vi utvidelser og laster inn `API_KEY`-miljøvariabelen fra `.env`-filen:

require_once('vendor/autoload.php');

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

Nå lager vi en variabel for å lagre overskriftene i form av en matrise. Hvert element i matrisen vil representere en spesifikk overskrift:

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

Vi har definert to overskrifter: en for innholdstypen og en for API-nøkkelen.

Nå definerer vi innholdet i selve forespørselen:

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

Etter dette oppretter vi en cURL-økt ved hjelp av `curl_init()`. Vi sender inn URL-en vi ønsker å sende forespørselen til som et argument:

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

La oss sette sammen alle delene ved å definere overskriften og innholdet som alternativer for økten. Her bruker vi `curl_setopt_array()`-funksjonen:

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

For å utføre selve forespørselen bruker vi funksjonen `curl_exec()`:

$response = curl_exec($ch);

Vi har nå lagret svaret i variabelen `$response`. Nå lukker vi økten for å frigjøre systemressursene som den brukte:

curl_close($ch);

Til slutt kan vi skrive ut svaret på skjermen med `var_dump()`:

var_dump($response);

Den ferdige skriptfilen skal nå se slik ut:

<?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.tipsbilk.net.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 du kjører skriptet med `php with_curl.php`, skal du få følgende utskrift:

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

Forespørselen ble fullført, og API-et svarte med JSON-data. Du kan nå bruke disse dataene slik du ønsker.

Med Guzzle

I den siste delen av denne veiledningen skal vi bruke Guzzle til å lage skriptet. Som vanlig starter vi med å legge til PHP-boilerplate i filen `with_guzzle.php`:

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

Deretter importerer vi utvidelser og Guzzle Client og Request-objekter, og laster inn miljøvariablene våre:

require_once('vendor/autoload.php');

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

La oss også laste inn miljøvariablene:

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

Etter dette oppretter vi en instans av en Guzzle HTTP-klient:

$client = new Client();

Nå definerer vi overskriftene for forespørselen vår:

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

La oss også definere innholdet i forespørselen:

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

Nå kan vi sende forespørselen ved å opprette en instans av `Request`-klassen. Vi sender inn API-endepunktets URL, overskrifter og innhold som argumenter:

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

Deretter kan vi sende selve forespørselen med følgende linje:

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

Når forespørselen er sendt, kan vi hente ut innholdet i svaret på følgende måte:

$response_body = $response->getBody();

Til slutt kan vi dekode JSON-svaret og skrive ut lastetiden:

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

Nå skal den ferdige filen se slik ut:

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

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

    $response_body = $response->getBody();

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

Når du kjører skriptet med kommandoen:

php with_guzzle.php

Du skal se følgende svar:

Loadtime: 130

Konklusjon

I denne artikkelen har vi gått gjennom ulike klienter du kan bruke når du lager et PHP-prosjekt som skal bruke tipsbilk.net API.

Selv om skriptene i dette prosjektet primært bruker kommandolinjen som utdata, kan faktiske prosjekter presentere resultatet på en nettside eller skrive det til en fil. Eksemplene som er presentert i denne artikkelen er enkle, men de viser de grunnleggende konseptene for bruk av tipsbilk.net API. For å bruke andre APIer kan du endre endepunktet og sende inn andre parametere i forespørselen.

Du kan også være interessert i å lære hvordan du bruker tipsbilk.net DNS Lookup API i Javascript.