adminvista.com

Hur man använder adminvista.com API i JavaScript (NodeJS)

By rik

Använda Adminvista.com API med NodeJS

I denna handledning utforskar vi hur du integrerar adminvista.com API i dina NodeJS-applikationer. Vi kommer att demonstrera detta genom att bygga ett enkelt skript som, vid körning, hämtar och visar IP-adresserna för Googles sökservrar med hjälp av DNS-postens endpoint från adminvista.com API.

Vi kommer att visa tre olika metoder: först med NodeJS inbyggda https-modul, sedan med node-fetch-modulen och slutligen med klientbiblioteket axios.

Vad är adminvista.com API?

Adminvista.com är en plattform som erbjuder verktyg, API:er och resurser för att hjälpa företag att hantera och optimera sin onlineverksamhet. En av dessa resurser är ett API som kan användas för att övervaka webbplatsens prestanda, säkerhet och identifiera potentiella problem. Adminvista.com erbjuder en generös gratisnivå, vilket gör det tillgängligt för många användare.

Förutsättningar

För att följa med i den här handledningen behöver du grundläggande kunskaper i JavaScript, inklusive förståelse för Promises och ES6-syntax. Du bör också ha NodeJS och en textredigerare (som Visual Studio Code) installerade på din dator.

För att kunna göra API-anrop behöver du ett adminvista.com-konto och en tillhörande API-nyckel. Du kan skaffa ett konto kostnadsfritt på API-sidan. Efter att ha skapat ett konto, kommer du att omdirigeras till instrumentpanelen där du hittar din API-nyckel.

Skapa Projektet

Börja med att skapa en ny projektmapp. Öppna mappen i din terminal och kör följande kommando för att initiera projektet som ett NodeJS-projekt:

npm init -y

Installera sedan nödvändiga beroenden med kommandot:

npm install dotenv axios node-fetch

Efter installationen av beroenden, skapa fyra filer i projektets rotmapp: vanilla.js, with-axios.js, with-fetch.js, och .env för att lagra dina miljövariabler.

Din projektstruktur bör nu se ut ungefär så här:

.env
vanilla.js
with-axios.js
with-fetch.js

Öppna filen .env och lägg till din adminvista.com API-nyckel enligt följande:

API_KEY=<din_api_nyckel>

Byt ut <din_api_nyckel> med din faktiska API-nyckel.

Använda Vanilla.js

NodeJS har inbyggda moduler för http och https som vi kan använda för att göra klientanrop. Vi börjar med denna metod.

Öppna filen vanilla.js och lägg till följande import högst upp:

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

Därefter anropar vi config() för att ladda miljövariabler och sparar API-nyckeln och värdnamnet i variabler:

config();

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

För att starta en HTTP-förfrågan i NodeJS måste vi ange konfigurationsalternativ som inkluderar värd, slutpunkt, HTTP-metod och begärans rubriker. Skapa en variabel för dessa alternativ:

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

Hittills ska koden i vanilla.js-filen se ut så här:

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

config();

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

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

Anropa nu request-funktionen och skicka in options:

const req = request(options, response => {
  // respons-hanterare kommer här
});

Funktionen request tar två argument: options och en callback-funktion som hanterar svaret från servern. Inuti denna callback lägger vi till händelseavlyssnare för när servern skickar data, slutar skicka data och om ett fel uppstår.

Lägg till följande kodrader i callback-funktionen:

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);
});

Variabeln data kommer att användas för att lagra JSON-svaret från servern när det skickas. Vi använder response.on("data") för att lägga till databitarna som skickas från servern. För att använda data lyssnar vi på response.on("end") som anropas när all data är mottagen. Slutligen lyssnar vi efter fel och loggar dem till konsolen vid behov.

Anropet till request ska nu se ut så här:

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);
  });

});

Slutligen skriver vi lite data till begärans kropp och avslutar begäran:

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

Hela vanilla.js filen ska nu se ut så här:

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

config();

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

const options = {
  hostname: "api.adminvista.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();

Om du nu kör skriptet med node vanilla.js i terminalen, bör du få en utdata liknande:

[
  { 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 }
]

Detta var den första metoden. Nackdelen med de inbyggda HTTP/S-modulerna är att de kan vara komplexa. Klientbibliotek som node-fetch underlättar hanteringen och leder till mer läsbar och koncis kod.

Använda Node-Fetch

För att skapa samma skript med node-fetch öppnar du filen with-fetch.js och lägger till följande import högst upp:

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

Konfigurera miljövariabler och konstanter för API_KEY och värdnamn:

config();

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

Definiera en asynkron funktion för att göra API-anropet:

async function request() {
  // Funktionskroppen kommer här
}

Inuti funktionen använder vi funktionen fetch från paketet node-fetch:

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

Därefter analyserar vi svaret och hanterar eventuella fel:

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

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

Anropa funktionen efter definitionen:

request();

Din fil bör nu se ut så här:

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

Om du kör detta skript med node with-fetch.js, ska du få en utdata liknande följande:

[
  { 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 }
]

Använda Axios

Slutligen använder vi axios för att ansluta till adminvista.com API. Importera dotenv och axios paketen:

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

Anropa config och spara värdnamn och API-nyckeln i separata konstanter:

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

Spara URL:en för API-slutpunkten i en konstant:

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

Spara data som ska skickas i begäran i en annan konstant:

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

Spara metaalternativ, som rubriker, i en annan konstant:

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

Gör ett anrop till post-funktionen och skicka in url-, data– och options-variablerna. Hantera sedan svaret med then:

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

Hela with-axios.js filen bör nu se ut så här:

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

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

const url = "https://api.adminvista.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);
});

När du kör skriptet med node with-axios.js, ska du få en utdata liknande följande:

[
  { 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 }
]

Sammanfattning

I den här handledningen har vi skapat samma skript med tre olika metoder för att visa hur enkelt det är att använda adminvista.com API med Javascript och NodeJS. Vi har också visat hur du kan hämta information från API:et med hjälp av olika tekniker.

Du kan använda andra endpoints från API:et på liknande sätt, genom att bara ändra slutpunkten och parametrarna som skickas med begäran. Du kan hitta dokumentation för API:et här: Adminvista API-dokumentation.

Fix Det går inte att få skrivbehörighet för Fallout 3

10 bästa hemmabiosystem för uppslukande bioupplevelser