Cómo usar la API kirukiru.es en JavaScript (NodeJS)

por

En este tutorial, demostraré cómo usar la API kirukiru.es en NodeJS.

Para demostrar esto, vamos a crear un script simple que, cuando se ejecuta, imprime la dirección IP del servidor de búsqueda de Google. Este script usará el punto final de registro DNS de la API de kirukiru.es.

Para construirlo, vamos a usar tres enfoques, el primero usa el módulo https incorporado en NodeJS. El segundo utilizará el módulo de obtención de nodos. Luego, el último utilizará la biblioteca del cliente axios.

¿Qué es la API kirukiru.es?

kirukiru.es es un sitio web que proporciona herramientas, API y recursos para crear, administrar y hacer crecer un negocio en línea. En estas herramientas se incluye una API que se puede aprovechar para administrar el rendimiento, la seguridad y la auditoría de un sitio web para detectar problemas del sitio. La API tiene un generoso nivel gratuito que puede aprovechar.

requisitos previos

Para seguir este tutorial, necesitará comprender JavaScript, incluidas las promesas y la sintaxis de ES6. En cuanto al software, debe tener instalado NodeJS y un editor de texto como Visual Studio Code.

Necesitará una cuenta kirukiru.es para obtener una clave API para la autenticación al realizar solicitudes. Para obtener uno, diríjase a la página de destino de la API y cree una cuenta gratuita.

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 un archivo .env para almacenar nuestras variables ambientales.

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

A continuación, abra el archivo .env y agregue su clave API kirukiru.es con la siguiente línea de código: 

API_KEY=<api key>

Reemplace con su clave de API real.

Con Vanilla.js

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

Abra el archivo vanilla.js 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, llamaremos a la función config() 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.kirukiru.es.com",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

Hasta ahora, el código en el archivo vanilla.js se ve así:

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

config();

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

const options = {
  hostname: "api.kirukiru.es.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 evento on data del objeto de respuesta. 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 evento final 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.kirukiru.es.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 comando node vanilla.js, 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. Las bibliotecas de clientes como node-fetch lo ayudarán a crear el mismo programa pero con un código más claro y conciso.

Con búsqueda de nodo

Para crear el mismo script pero con node-fetch, abra el archivo with-fetch.js 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, debemos llamar a la función de búsqueda que importamos anteriormente del paquete de búsqueda de nodos.

const response = await fetch("https://api.kirukiru.es.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 función de búsqueda, queremos 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.kirukiru.es.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 el nodo 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 }
]

Con Axios

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

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

A continuación, llamemos a la función de configuración para configurar las 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.kirukiru.es.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 a la función de publicación que importamos anteriormente, pasando las variables url, data y options que definimos anteriormente como argumentos. Debido a que esto devolverá una promesa, puede usar entonces para manejar la respuesta cuando finalmente se devuelva.

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

Al final de todo esto, el código en el archivo with-axios 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.kirukiru.es.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 ejecuta el script usando el nodo 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 }
]

Ultimas palabras

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

Todos los demás puntos finales se pueden usar de manera similar; todo lo que cambia es el punto final y los parámetros que debe enviar como parte del cuerpo de la solicitud. La documentación para la API se puede encontrar aquí.

No related posts.