Cómo utilizar la API de búsqueda de DNS de Geekflare en JavaScript (NodeJS)

En este tutorial, demostraré cómo usar la API de Geekflare en NodeJS para verificar los registros DNS de cualquier dominio.

Vamos a construir un script simple que, cuando se ejecuta, imprime el Dirección IP del servidor de búsqueda de Google.

Este script usará el API de búsqueda de DNS de Geekflare.

Para construirlo, vamos a usar tres enfoques, el primero usa el https módulo en NodeJS. El segundo utilizará el node-fetch módulo. Entonces el último usará el axios biblioteca cliente.

¿Qué es la API de Geekflare?

API de Geekflare ofrece conjuntos de API REST para pruebas de rendimiento de sitios web, DNS y métricas de seguridad. Puede hacer cosas como tomar una captura de pantalla, generar archivos PDF, raspar web, escanear puertos y mucho más.

Requisitos previos

Para seguir este tutorial, necesitará comprender JavaScript, incluidas las promesas y la sintaxis de ES6. En cuanto al software, deberías tener NodeJS y un editor de texto como Código de Visual Studio instalado.

Necesitará una cuenta de Geekflare para obtener una clave API para la autenticación al realizar solicitudes. Para conseguir uno, dirígete a la Página de destino de la API y crea una cuenta gratis.

Después de crear la cuenta, debe ser redirigido al panel de control, donde encontrará su clave API.

Construyendo el proyecto

Para comenzar, cree una carpeta de proyecto y ábrala con una terminal de su elección, luego ejecute el siguiente comando.

npm init -y

El comando anterior inicializará el directorio del proyecto como un proyecto de NodeJS.

A continuación, ejecute el siguiente comando, que instalará todas las dependencias de nuestro proyecto

npm install dotenv axios node-fetch

Una vez que las dependencias se hayan instalado correctamente, cree tres scripts en la carpeta raíz del proyecto, a saber vanilla.js, with-axios.js, with-fetch.js y .env para almacenar nuestras variables ambientales.

Al final, la raíz del proyecto debería verse así:

Luego, abre el .env y agregue su clave API de Geekflare con la siguiente línea de código:

API_KEY=<api key>

Reemplaza <API key> con su clave API real.

Vanilla.js

NodeJS tiene un incorporado http y https módulo que podemos usar para hacer solicitudes de clientes. Vamos a utilizar este enfoque primero.

Abra la vainilla.js archivo y agregue las siguientes líneas de código en la parte superior para importar las dependencias del proyecto.

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

A continuación, vamos a llamar a la config() Función para cargar variables ambientales. Luego vamos a almacenar la clave API y el nombre de host en variables.

config();

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

Cuando llamamos a la función de solicitud para iniciar una solicitud HTTP en NodeJS, debemos proporcionar opciones para el host y el punto final al que queremos conectarnos, el método HTTP que vamos a utilizar y los encabezados de la solicitud. A continuación, vamos a crear una variable que almacenará estas opciones.

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

Hasta ahora, el código en el vanilla.js archivo tiene este aspecto:

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

config();

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

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

Ahora podemos proceder a llamar a la función de solicitud pasando el método de opciones:

const req = request(options, response => {

  // we are going to add response handlers here

});

Como puede ver, la función de solicitud acepta dos argumentos. El primero es el objeto de opciones que definimos anteriormente. La segunda es una función de devolución de llamada que manejará la respuesta del servidor. Dentro de la función de devolución de llamada, podemos agregar detectores de eventos para cuando el servidor envía datos, termina de enviar datos o envía un error.

Para agregar los diferentes controladores de respuesta, agregue las siguientes líneas de código dentro de la función de devolución de llamada:

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 variable de datos es simplemente una cadena donde vamos a almacenar la respuesta JSON del servidor a medida que nos la transmiten.

Para almacenar realmente los datos, vamos a escuchar el objeto de respuesta on data evento. Cada vez que se active este evento, agregaremos la porción de datos enviados por el servidor a la variable de datos.

Luego, para finalmente usar los datos, vamos a escuchar el on end evento en el objeto de respuesta. Este se llamará cuando todos los datos hayan sido enviados desde el servidor y haya finalizado su respuesta.

Por último, escucharemos los errores y los registraremos en la consola si surgen.

Por lo tanto, la llamada a la función de solicitud debería verse así

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

});

Por último, necesitamos escribir algunos datos en el cuerpo de la solicitud y finalizar la solicitud.

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

Al final, el archivo debería verse así:

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

config();

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

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

Ahora, si regresa a la terminal y ejecuta el script usando el node vanilla.js comando, debería obtener el siguiente resultado.

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

Eso es todo por la primera parte. La desventaja obvia de usar los módulos HTTP/S incorporados es que es detallado. Bibliotecas cliente como node-fetch te ayudará a crear el mismo programa pero con un código más claro y conciso.

node-fetch

Para crear el mismo script pero con node-fetch, Abierta la with-fetch.js archivo y agregue las siguientes importaciones en la parte superior.

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

Luego llame a la función de configuración para configurar variables ambientales y establecer constantes para API_KEY y el host cuyos registros A vamos a solicitar.

config();

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

A continuación, vamos a definir una función para realizar la llamada a la API. Esta función será asíncrona.

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

Dentro del cuerpo de la función, necesitamos llamar al fetch función que importamos antes de la node-fetch paquete.

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

Luego, después de la llamada a la fetch función, nos gustaría analizar nuestra respuesta y manejar cualquier error que pueda surgir.

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

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

En este punto, agregue una llamada a la función después de su solicitud.

request();

Su archivo ahora debería verse así:

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

Y ejecutar ese script con node with-fetch.js debería producir el siguiente resultado:

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

Axios

Por último, vamos a utilizar Axios para acceder a la API de Geekflare. Para comenzar, importemos el dotenv y axios paquetes

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

A continuación, llamemos al config función para configurar variables ambientales. Además, almacenemos el nombre del host y la clave API en constantes separadas.

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

Ahora, almacenemos la URL del extremo de la API en otra constante

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

A continuación, almacenemos los datos que se enviarán como parte del cuerpo de la solicitud en otra constante

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

Luego, lo último que debe hacer antes de enviar la solicitud será almacenar también las opciones meta, como los encabezados, en otra constante.

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

Por último, hagamos la llamada al post función que importamos anteriormente, pasando en el url, data y options variables que definimos anteriormente como argumentos. Debido a que esto devolverá una promesa, puede usar then para manejar la respuesta cuando finalmente se devuelve.

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

Al final de todo esto, el código en el with-axios el archivo debería verse así:

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

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

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

Y cuando ejecutas el script usando node with-axios.js, debería mostrar el siguiente resultado:

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

Palabras finales

En esta publicación, creamos el guión con tres enfoques diferentes. El objetivo de esto era resaltar lo fácil que es usar la API de Geekflare y cómo podríamos usarla en Javascript, específicamente NodeJS.

Explorar Documentación de la API de Geekflare para más.