Come utilizzare l’API winadmin.it in JavaScript (NodeJS)

0 Condivisioni

In questo tutorial, dimostrerò come utilizzare l’API winadmin.it in NodeJS.

Per dimostrarlo, creeremo un semplice script che, una volta eseguito, stampa l’indirizzo IP del server di ricerca di Google. Questo script utilizzerà l’endpoint del record DNS dell’API di winadmin.it.

Per costruirlo, utilizzeremo tre approcci, il primo utilizza il modulo https integrato in NodeJS. Il secondo utilizzerà il modulo node-fetch. Quindi l’ultimo utilizzerà la libreria client axios.

Che cos’è l’API winadmin.it?

winadmin.it è un sito Web che fornisce strumenti, API e risorse per creare, gestire e far crescere un’attività online. In questi strumenti è inclusa un’API che può essere sfruttata per gestire le prestazioni, la sicurezza e l’audit di un sito Web per i problemi del sito. L’API ha un generoso livello gratuito di cui puoi approfittare.

Prerequisiti

Per seguire questo tutorial, avrai bisogno di una conoscenza di JavaScript, incluse le promesse e la sintassi ES6. Per quanto riguarda il software, dovresti avere NodeJS e un editor di testo come Visual Studio Code installati.

Avrai bisogno di un account winadmin.it per ottenere una chiave API per l’autenticazione quando effettui richieste. Per ottenerne uno, vai alla pagina di destinazione dell’API e crea un account gratuito.

Dopo aver creato l’account, dovresti essere reindirizzato alla dashboard, dove troverai la tua chiave API.

Costruire il progetto

Per iniziare, crea una cartella di progetto e aprila con un terminale a tua scelta, quindi esegui il comando seguente.

npm init -y

Il comando precedente inizializzerà la directory del progetto come progetto NodeJS.

Quindi, esegui il comando seguente, che installerà tutte le dipendenze per il nostro progetto

npm install dotenv axios node-fetch

Dopo che le dipendenze sono state installate correttamente, crea tre script nella cartella principale del progetto, vale a dire vanilla.js, with-axios.js, with-fetch.js e un file .env per memorizzare le nostre variabili ambientali.

Alla fine, la radice del progetto dovrebbe assomigliare a questa:

Quindi, apri il file .env e aggiungi la tua chiave API winadmin.it con la seguente riga di codice:

API_KEY=<api key>

Sostituisci con la tua chiave API attuale.

Con Vanilla.js

NodeJS ha un modulo http e https integrato che possiamo usare per fare richieste ai client. Utilizzeremo prima questo approccio.

Apri il file vanilla.js e aggiungi le seguenti righe di codice in alto per importare le dipendenze del progetto.

import { request } from "https";
import { config } from "dotenv";

Successivamente, chiameremo la funzione config() per caricare le variabili ambientali. Quindi memorizzeremo la chiave API e il nome host nelle variabili.

config();

const apiKey = process.env.API_KEY;
const host="google.com";

Quando chiamiamo la funzione di richiesta per avviare una richiesta HTTP in NodeJS, dovremo fornire opzioni per l’host e l’endpoint a cui vogliamo connetterci, il metodo HTTP che utilizzeremo e le intestazioni per la richiesta. Quindi, creeremo una variabile che memorizzerà queste opzioni.

const options = {
  hostname: "api.winadmin.it.com",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

Finora, il codice nel file vanilla.js è simile a questo:

import { request } from "https";
import { config } from "dotenv";

config();

const apiKey = process.env.API_KEY;
const host="google.com"

const options = {
  hostname: "api.winadmin.it.com",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

Ora possiamo procedere a chiamare la funzione di richiesta passando il metodo delle opzioni:

const req = request(options, response => {

  // we are going to add response handlers here

});

Come puoi vedere, la funzione di richiesta accetta due argomenti. Il primo è l’oggetto opzioni che abbiamo definito in precedenza. La seconda è una funzione di callback che gestirà la risposta dal server. All’interno della funzione di callback, possiamo aggiungere listener di eventi per quando il server invia dati, termina l’invio di dati o invia un errore.

Per aggiungere i diversi gestori di risposta, aggiungi le seguenti righe di codice all’interno della funzione di callback:

let data = "";

response.on("data", chunk => {
  data += chunk;
});

response.on("end", () => {
  console.log(JSON.parse(data).data.A);
});

response.on("error", error => {
  console.log(error);
});

La variabile di dati è semplicemente una stringa in cui memorizzeremo la risposta JSON del server mentre ci viene trasmessa in streaming.

Per archiviare effettivamente i dati, ascolteremo l’evento sui dati dell’oggetto risposta. Ogni volta che questo evento viene attivato, aggiungeremo il blocco di dati inviato dal server alla variabile data.

Quindi, per utilizzare finalmente i dati, ascolteremo l’evento on-end sull’oggetto risposta. Questo verrà chiamato quando tutti i dati saranno stati inviati dal server e avrà terminato la sua risposta.

Infine, ascolteremo gli errori e li registreremo sulla console se si verificano.

Pertanto la chiamata alla funzione di richiesta dovrebbe essere simile a questa

const req = request(options, response => {

  let data = "";

  response.on("data", chunk => {
    data += chunk;
  });

  response.on("end", () => {
    console.log(JSON.parse(data).data.A);
  });

  response.on("error", error => {
    console.log(error);
  });

});

Infine, dobbiamo scrivere alcuni dati nel corpo della richiesta e terminare la richiesta.

req.write(JSON.stringify({ url: host, types: ["A"] }));
req.end();

Alla fine, il file dovrebbe assomigliare a questo:

import { request } from "https";
import { config } from "dotenv";

config();

const apiKey = process.env.API_KEY;
const host="google.com"

const options = {
  hostname: "api.winadmin.it.com",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

const req = request(options, response => {

  let data = "";

  response.on("data", chunk => {
    data += chunk;
  });

  response.on("end", () => {
    console.log(JSON.parse(data).data.A);
  });

  response.on("error", error => {
    console.log(error);
  });

});

req.write(JSON.stringify({ url: host, types: ["A"] }));
req.end();

Ora, se torni al terminale ed esegui lo script usando il comando node vanilla.js, dovresti ottenere il seguente output.

[
  { address: '172.253.122.101', ttl: 247 },
  { address: '172.253.122.113', ttl: 247 },
  { address: '172.253.122.100', ttl: 247 },
  { address: '172.253.122.102', ttl: 247 },
  { address: '172.253.122.138', ttl: 247 },
  { address: '172.253.122.139', ttl: 247 }
]

Questo è tutto per la prima parte. L’ovvio svantaggio dell’utilizzo dei moduli HTTP/S integrati è che è dettagliato. Le librerie client come node-fetch ti aiuteranno a creare lo stesso programma ma con un codice più chiaro e conciso.

Con node-fetch

Per creare lo stesso script ma con node-fetch, apri il file with-fetch.js e aggiungi le seguenti importazioni in alto.

import fetch from "node-fetch";
import { config } from "dotenv";

Quindi chiama la funzione di configurazione per configurare le variabili ambientali e impostare le costanti per API_KEY e l’host di cui richiederemo i record A.

config();

const apiKey = process.env.API_KEY;
const host="google.com"

Successivamente, definiremo una funzione per effettuare la chiamata API. Questa funzione sarà asincrona.

async function request() {
  // The function body will go here
}

All’interno del corpo della funzione, dobbiamo chiamare la funzione fetch che abbiamo importato in precedenza dal pacchetto node-fetch.

const response = await fetch("https://api.winadmin.it.com/dnsrecord", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": apiKey,
    },
    body: JSON.stringify({ url: host, types: ["A"] }),
});

Quindi, dopo la chiamata alla funzione di recupero, vorremmo analizzare la nostra risposta e gestire eventuali errori che potrebbero verificarsi.

if (response.ok) {
    const { data } = await response.json();

    console.log(data.A);
  } else {
    console.log(response);
  }

A questo punto, aggiungi una chiamata alla funzione dopo la sua richiesta.

request();

Il tuo file ora dovrebbe assomigliare a questo:

import fetch from "node-fetch";
import { config } from "dotenv";

config();

const apiKey = process.env.API_KEY;
const host = "google.com";

async function request() {
  const response = await fetch("https://api.winadmin.it.com/dnsrecord", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": apiKey,
    },
    body: JSON.stringify({ url: host, types: ["A"] }),
  });

  if (response.ok) {
    const { data } = await response.json();

    console.log(data.A);
  } else {
    console.log(response);
  }
}

request();

E l’esecuzione di quello script con node with-fetch.js dovrebbe produrre il seguente output:

[
  { address: '172.253.122.113', ttl: 134 },
  { address: '172.253.122.138', ttl: 134 },
  { address: '172.253.122.100', ttl: 134 },
  { address: '172.253.122.139', ttl: 134 },
  { address: '172.253.122.102', ttl: 134 },
  { address: '172.253.122.101', ttl: 134 }
]

Con Axios

Infine, utilizzeremo Axios per accedere all’API winadmin.it. Per iniziare, importiamo i pacchetti dotenv e axios.

import axios from "axios";
import { config } from "dotenv";

Quindi, chiamiamo la funzione di configurazione per impostare le variabili ambientali. Inoltre, memorizziamo il nome dell’host e la chiave API in costanti separate.

const host = "google.com";
const key = process.env.API_KEY;

Ora, archiviamo l’URL dell’endpoint API in un’altra costante

const url = "https://api.winadmin.it.com/dnsrecord";

Quindi, memorizziamo i dati che verranno inviati come parte del corpo della richiesta in un’altra costante

const data = { url: host, types: ["A"] };

Quindi l’ultima cosa da fare prima di inviare la richiesta sarà memorizzare anche le meta opzioni, come le intestazioni, in un’altra costante.

const options = {
  headers: {
    "Content-Type": "application/json",
    "x-api-key": key,
  },
};

Infine, facciamo la chiamata alla funzione post che abbiamo importato in precedenza, passando le variabili url, data e opzioni che abbiamo definito in precedenza come argomenti. Poiché questo restituirà una promessa, puoi quindi utilizzare quindi per gestire la risposta quando verrà infine restituita.

axios.post(url, data, options).then(({ data }) => {
  console.log(data.data.A);
});

Alla fine di tutto questo, il codice nel file with-axios dovrebbe assomigliare a questo:

import axios from "axios";
import { config } from "dotenv";

config();
const host = "google.com";
const key = process.env.API_KEY;

const url = "https://api.winadmin.it.com/dnsrecord";
const data = { url: host, types: ["A"] };
const options = {
  headers: {
    "Content-Type": "application/json",
    "x-api-key": key,
  },
};

axios.post(url, data, options).then(({ data }) => {
  console.log(data.data.A);
});

E quando esegui lo script usando node with-axios.js, dovrebbe visualizzare il seguente output:

[
  { address: '142.251.163.138', ttl: 60 },
  { address: '142.251.163.113', ttl: 60 },
  { address: '142.251.163.100', ttl: 60 },
  { address: '142.251.163.101', ttl: 60 },
  { address: '142.251.163.102', ttl: 60 },
  { address: '142.251.163.139', ttl: 60 }
]

Parole finali

In questo post, abbiamo creato lo stesso script con tre approcci diversi. L’obiettivo di questo era evidenziare quanto sia facile utilizzare l’API winadmin.it e come potremmo utilizzarla in Javascript, in particolare NodeJS.

Tutti gli altri endpoint possono essere utilizzati in modo simile; tutto ciò che cambia è l’endpoint e i parametri che devi inviare come parte del corpo della richiesta. La documentazione per l’API può essere trovata qui.

x