2026-11-15 · 12 min
Verifikasi Googlebot Asli dengan Reverse DNS dan Format Log Nginx
Di log Nginx Anda ada baris seperti ini: "user_agent":"Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)", 900 request dalam lima menit, ke halaman pencarian internal. Lalu Anda jalankan lookup pada IP-nya dan hasilnya ternyata milik penyedia hosting, bukan Google. Itu bukan Googlebot. Tapi kalau aturan rate limit Anda hanya membaca User-Agent, bot itu baru saja mendapat jalur istimewa.
Artikel ini membahas cara verifikasi googlebot yang benar untuk developer backend: log_format Nginx JSON yang siap diolah mesin, skrip Node.js yang mengikuti langkah di dokumentasi Google, cache dengan TTL, dan cara memakai hasilnya tanpa membuka celah baru. Analisis pola crawl dan pemilihan tool pembaca log tidak dibahas di sini, itu ada di artikel log file analyzer kami.
Definisi singkat: verifikasi Googlebot adalah memastikan IP yang mengirim request benar-benar milik Google, lewat reverse DNS lalu forward DNS (atau pencocokan ke daftar IP resmi), bukan lewat teks User-Agent.
Kenapa Googlebot Palsu User Agent Jadi Masalah Nyata
Mengetik string Googlebot sebagai User-Agent tidak butuh izin siapa pun. Scraper harga, bot SEO pihak ketiga, dan pemindai kerentanan memakainya karena banyak sistem memberi keringanan pada apa pun yang mengaku Googlebot. Googlebot palsu user agent merusak dua arah:
- Bot palsu lolos. Aturan yang hanya mencocokkan teks memberi jalur bebas hambatan kepada penyamar.
- Crawler asli ikut terblokir. Kalau Anda kapok lalu memblokir semua yang ber-User-Agent Googlebot, crawler asli ikut terkena.
Akarnya sama: mempercayai identitas dari header yang ditulis klien sendiri. Yang bisa dipercaya adalah IP yang benar-benar mengirim request.
Ukur Dulu: Berapa Persen “Googlebot” di Log Anda yang Palsu
Sebagai reviewer, saya tidak mau memasang apa pun sebelum ada angka dasar. Begitu log JSON dari Langkah 1 berjalan dan verified_bot terisi, satu perintah jq menghitung sebarannya:
jq -r 'select(.user_agent | test("googlebot"; "i")) | .verified_bot' \
/var/log/nginx/access.json.log | sort | uniq -c
Hasilnya tiga ember: true, false, dan unknown (verifikasi gagal sementara). Rasio false terhadap total adalah ukuran seberapa besar masalah di situs Anda, dan nilai pembandingnya untuk audit bulan depan. Saya sengaja tidak menyebut angka “umum”: proporsinya sangat bergantung pada niche dan popularitas situs, jadi ukur sendiri.
Langkah 1: Format Log Nginx JSON yang Siap Diolah Mesin
Log combined default harus dibongkar dengan regex rapuh. Direktif log_format dengan escape=json membuat tiap baris menjadi JSON valid, dan inilah nginx log_format json yang saya pakai:
# /etc/nginx/nginx.conf (di dalam blok http {})
log_format bot_json escape=json
'{'
'"time":"$time_iso8601",'
'"remote_addr":"$remote_addr",'
'"method":"$request_method",'
'"uri":"$request_uri",'
'"status":$status,'
'"upstream_status":"$upstream_status",'
'"request_time":$request_time,'
'"user_agent":"$http_user_agent",'
'"verified_bot":"$verified_bot"'
'}';
statusdanrequest_timetanpa tanda kutip, supaya jadi number asli dan bisa langsung dihitung.upstream_statusdiberi kutip karena bisa berisi beberapa status dipisah koma (retry) atau-.verified_botkosong sampai Langkah 3, saat variabelnya diisi dari hasil layanan verifikasi.
Pastikan $remote_addr Adalah IP Klien Asli
Di belakang load balancer atau CDN, $remote_addr berisi IP perangkat di depan Nginx, dan verifikasi terhadap IP itu pasti gagal. Perbaiki dengan ngx_http_realip_module:
server {
# Percayai hanya IP proxy/load balancer Anda sendiri, bukan 0.0.0.0/0.
set_real_ip_from 10.0.0.0/8;
real_ip_header X-Forwarded-For;
real_ip_recursive on;
access_log /var/log/nginx/access.json.log bot_json;
}
$remote_addr kini berisi IP klien asli dari X-Forwarded-For, selama request datang dari IP di set_real_ip_from. Kalau Nginx menghadap internet langsung, lewati bagian ini.
Langkah 2: Cara Verifikasi Googlebot Asli dengan Reverse DNS di Node.js
Ini inti verifikasi googlebot reverse dns. Dokumentasi Google yang saya cek saat menulis artikel ini menjelaskan empat langkah:
- Reverse DNS lookup pada IP di log.
- Pastikan hostname hasilnya berakhiran
googlebot.com,google.com, ataugoogleusercontent.com. - Forward DNS lookup pada hostname itu.
- Pastikan hasilnya mengandung IP yang sama dengan IP di log.
Cek ulang daftar domain dan nama file di dokumentasi resmi sebelum deploy, karena Google bisa mengubahnya. Implementasi dns reverse lookup nodejs berikut membedakan tiga hasil, bukan dua: verified, unverified (jelas bukan Google), dan error (resolver bermasalah, belum bisa disimpulkan):
// services/verify-bot/verify-googlebot.ts
import dns from 'node:dns/promises';
import { BlockList, isIP, isIPv4 } from 'node:net';
export type Verdict = 'verified' | 'unverified' | 'error';
const ALLOWED_SUFFIXES = ['.googlebot.com', '.google.com', '.googleusercontent.com'];
const NOT_FOUND = new Set(['ENOTFOUND', 'ENODATA']); // jawaban DNS yang sah: "tidak ada"
// Samakan notasi IPv6 (huruf besar/kecil, bentuk ::) sebelum dibandingkan sebagai string.
export function normalizeIp(ip: string): string {
return isIP(ip) === 6 ? new URL(`http://[${ip}]`).hostname.slice(1, -1) : ip;
}
export async function verifyGooglebotByDns(rawIp: string): Promise<Verdict> {
const ip = normalizeIp(rawIp);
let hostnames: string[];
try {
hostnames = await dns.reverse(ip);
} catch (err) {
const code = (err as NodeJS.ErrnoException).code ?? '';
return NOT_FOUND.has(code) ? 'unverified' : 'error';
}
let sawError = false;
for (const raw of hostnames) {
const hostname = raw.endsWith('.') ? raw.slice(0, -1) : raw;
const isGoogleDomain = ALLOWED_SUFFIXES.some(
(suffix) => hostname === suffix.slice(1) || hostname.endsWith(suffix),
);
if (!isGoogleDomain) continue;
try {
const forward = await dns.lookup(hostname, { all: true });
if (forward.some((a) => normalizeIp(a.address) === ip)) return 'verified';
} catch (err) {
const code = (err as NodeJS.ErrnoException).code ?? '';
if (!NOT_FOUND.has(code)) sawError = true;
}
}
return sawError ? 'error' : 'unverified';
}
Tiga detail yang perlu dicatat:
dns.reversebisa mengembalikan beberapa hostname, jadi semuanya diperiksa, bukan hanya yang pertama.- Titik akhir FQDN dibuang (
googlebot.com.), kalau tidak pencocokan suffix bisa gagal. - Perbandingan IP dinormalisasi. IPv6 yang sama bisa ditulis dalam notasi berbeda, dan tanpa normalisasi
===menolak Googlebot asli.
Alternatif Lebih Cepat: Cocokkan ke Daftar IP Googlebot JSON Resmi
Google juga menerbitkan daftar ip googlebot json berisi rentang CIDR yang bisa dicocokkan lokal tanpa DNS. Saat menulis artikel ini, file untuk Googlebot dan crawler umum ada di https://developers.google.com/static/crawling/ipranges/common-crawlers.json. Struktur berikut hanya ilustrasi; nilai creationTime dan prefix-nya bukan data asli:
{
"creationTime": "<timestamp>",
"prefixes": [
{ "ipv4Prefix": "<contoh-ipv4>/<panjang-prefix>" },
{ "ipv6Prefix": "<contoh-ipv6>/<panjang-prefix>" }
]
}
Google menerbitkan file terpisah untuk kategori lain (crawler kasus khusus, fetcher yang dipicu pengguna). Cek halaman dokumentasi untuk nama file terbaru sebelum menghardcode URL. Pencocokannya memakai net.BlockList bawaan Node.js:
// services/verify-bot/verify-googlebot.ts (lanjutan)
type IpRangeFile = { prefixes: Array<{ ipv4Prefix?: string; ipv6Prefix?: string }> };
export async function loadBlockList(url: string): Promise<BlockList> {
const res = await fetch(url);
if (!res.ok) throw new Error(`Gagal mengambil ${url}: HTTP ${res.status}`);
const data = (await res.json()) as IpRangeFile;
const list = new BlockList();
for (const p of data.prefixes) {
const prefix = p.ipv4Prefix ?? p.ipv6Prefix;
if (!prefix) continue;
const [addr, bits] = prefix.split('/');
list.addSubnet(addr, Number(bits), p.ipv4Prefix ? 'ipv4' : 'ipv6');
}
return list;
}
export async function verifyGooglebot(ip: string, list: BlockList): Promise<Verdict> {
if (list.check(ip, isIPv4(ip) ? 'ipv4' : 'ipv6')) return 'verified'; // jalur cepat
return verifyGooglebotByDns(ip); // jalur otoritatif
}
DNS vs CIDR: Perbandingan Berdasarkan Kriteria
| Kriteria | Reverse + forward DNS | Cocokkan CIDR (file JSON) |
|---|---|---|
| Latensi | Dua lookup keluar jaringan per IP baru | Pencocokan di memori, tanpa jaringan |
| Akurasi | Mengikuti metode yang didokumentasikan Google | Akurat selama file Anda segar |
| Perawatan | Hampir nol | Perlu unduh ulang berkala dan handling kegagalan unduh |
| Titik gagal | Resolver DNS (timeout, SERVFAIL) | File basi atau URL berubah |
| Cocok untuk | Jaring pengaman dan IP baru | Jalur cepat trafik berulang |
Rekomendasi saya: pakai keduanya. CIDR sebagai jalur cepat, DNS sebagai jaring pengaman untuk IP yang belum masuk file. Ukur latensi DNS di resolver Anda sendiri, karena angkanya sangat bergantung pada lokasi dan resolver.
Langkah 3: Cache Hasil Verifikasi dengan TTL
Googlebot yang merayapi situs aktif datang dari IP yang sama berkali-kali. Tanpa cache, tiap request memicu DNS lookup baru. Simpan hasil per IP di Redis (banyak instance) atau Map (satu instance). Aturannya: hasil verified disimpan lama, unverified disimpan lebih singkat, dan error tidak disimpan sama sekali, supaya gangguan resolver sesaat tidak mengunci crawler asli selama berjam-jam:
// services/verify-bot/cache.ts
import Redis from 'ioredis';
import type { Verdict } from './verify-googlebot.js';
export const redis = process.env.REDIS_URL ? new Redis(process.env.REDIS_URL) : null;
const TTL_SECONDS = { verified: 60 * 60 * 12, unverified: 60 * 30 } as const;
const PREFIX = 'verified-bot:';
type Cached = Exclude<Verdict, 'error'>;
const memoryCache = new Map<string, { value: Cached; expiresAt: number }>();
export async function getCachedVerification(ip: string): Promise<Cached | undefined> {
if (redis) {
const raw = await redis.get(PREFIX + ip);
return raw === 'verified' || raw === 'unverified' ? raw : undefined;
}
const entry = memoryCache.get(ip);
if (!entry) return undefined;
if (entry.expiresAt < Date.now()) {
memoryCache.delete(ip);
return undefined;
}
return entry.value;
}
export async function setCachedVerification(ip: string, verdict: Verdict): Promise<void> {
if (verdict === 'error') return; // kegagalan sementara: jangan di-cache
const ttl = TTL_SECONDS[verdict];
if (redis) {
await redis.set(PREFIX + ip, verdict, 'EX', ttl);
return;
}
memoryCache.set(ip, { value: verdict, expiresAt: Date.now() + ttl * 1000 });
}
Fallback Map hanya membuang entry kedaluwarsa secara lazy saat dibaca. Untuk situs dengan banyak IP unik, tambahkan setInterval pembersih supaya memori tidak tumbuh tanpa batas. Redis tidak punya masalah ini karena TTL ditangani opsi EX.
Menghubungkan Semuanya: Layanan Verifikasi di Belakang Nginx
Layanan Node.js: Verifikasi, Rate Limit, dan Penandaan verified_bot
Layanan HTTP kecil ini dipanggil Nginx lewat auth_request, dan sekaligus tempat keputusan rate limit, karena status verifikasi dan hitungan request per IP paling masuk akal disimpan berdampingan. Rate limit fixed-window berikut sengaja sederhana; untuk trafik tinggi pertimbangkan sliding window atau token bucket:
// services/verify-bot/rate-limit.ts
import { redis } from './cache.js';
const WINDOW_SECONDS = 60;
const MAX_REQUESTS = 60; // sesuaikan dengan kapasitas upstream Anda
const memoryBuckets = new Map<string, { count: number; resetAt: number }>();
export async function checkRateLimit(ip: string): Promise<boolean> {
if (redis) {
const key = `rate:${ip}`;
const count = await redis.incr(key);
if (count === 1) await redis.expire(key, WINDOW_SECONDS);
return count <= MAX_REQUESTS;
}
const now = Date.now();
const bucket = memoryBuckets.get(ip);
if (!bucket || bucket.resetAt < now) {
memoryBuckets.set(ip, { count: 1, resetAt: now + WINDOW_SECONDS * 1000 });
return true;
}
bucket.count += 1;
return bucket.count <= MAX_REQUESTS;
}
// services/verify-bot/server.ts
import { createServer } from 'node:http';
import { loadBlockList, verifyGooglebot, type Verdict } from './verify-googlebot.js';
import { getCachedVerification, setCachedVerification } from './cache.js';
import { checkRateLimit } from './rate-limit.js';
const BOT_UA_PATTERN = /googlebot/i;
const COMMON_CRAWLERS_URL = 'https://developers.google.com/static/crawling/ipranges/common-crawlers.json';
let blockList = await loadBlockList(COMMON_CRAWLERS_URL);
setInterval(async () => {
try {
blockList = await loadBlockList(COMMON_CRAWLERS_URL);
} catch (err) {
console.error('Gagal menyegarkan daftar IP Googlebot, tetap pakai daftar lama', err);
}
}, 24 * 60 * 60 * 1000).unref();
const server = createServer(async (req, res) => {
const ip = String(req.headers['x-original-ip'] ?? '');
const ua = String(req.headers['x-original-ua'] ?? '');
// IP kosong berarti konfigurasi proxy salah. Jangan memasukkan semua
// request ke satu bucket rate limit bersama; loloskan dan catat.
if (!ip) {
console.error('x-original-ip kosong, cek konfigurasi proxy_set_header');
res.writeHead(200, { 'X-Verified-Bot': 'n/a' }).end();
return;
}
let verified: 'true' | 'false' | 'unknown' | 'n/a' = 'n/a';
if (BOT_UA_PATTERN.test(ua)) {
let verdict: Verdict | undefined = await getCachedVerification(ip);
if (verdict === undefined) {
verdict = await verifyGooglebot(ip, blockList);
await setCachedVerification(ip, verdict);
}
verified = verdict === 'verified' ? 'true' : verdict === 'unverified' ? 'false' : 'unknown';
}
// Pengecualian rate limit HANYA untuk verified === 'true'. Yang lain,
// termasuk 'unknown', memakai rate limit normal.
const allowed = verified === 'true' || (await checkRateLimit(ip));
res.writeHead(allowed ? 200 : 403, { 'X-Verified-Bot': verified }).end();
});
server.listen(4001, () => console.log('verify-bot service berjalan di :4001'));
Jalankan dengan REDIS_URL=redis://127.0.0.1:6379 npx tsx services/verify-bot/server.ts (tanpa REDIS_URL untuk fallback in-memory). Pakai "type": "module" di package.json karena ada top-level await, dan npm i ioredis kalau memakai Redis.
Konfigurasi Nginx
Panggil layanan lewat auth_request hanya untuk endpoint yang memang butuh rate limit, bukan location / untuk seluruh situs:
server {
# ... server_name, ssl, real_ip seperti sebelumnya ...
location = /internal/verify-bot {
internal;
proxy_pass http://127.0.0.1:4001/verify-bot;
proxy_pass_request_body off;
proxy_set_header Content-Length "";
proxy_set_header X-Original-IP $remote_addr;
proxy_set_header X-Original-UA $http_user_agent;
proxy_connect_timeout 500ms;
proxy_read_timeout 1s; # layanan lambat jangan menahan request pengunjung
}
# Hanya endpoint yang mahal: pencarian internal dan API publik.
location ~ ^/(cari|api)/ {
auth_request /internal/verify-bot;
auth_request_set $verified_bot $upstream_http_x_verified_bot;
# 403 dari layanan = kena rate limit. Kegagalan layanan (500/502/504)
# jatuh ke fallback tanpa verifikasi supaya situs tetap jalan.
error_page 403 = @terlalu_banyak_request;
error_page 500 502 503 504 = @tanpa_verifikasi;
proxy_pass http://127.0.0.1:3000;
}
location @tanpa_verifikasi {
proxy_pass http://127.0.0.1:3000;
}
location @terlalu_banyak_request {
default_type application/json;
return 429 '{"error":"too_many_requests"}';
}
location / {
proxy_pass http://127.0.0.1:3000;
}
}
Dua hal yang perlu diperhatikan:
ngx_http_auth_request_moduleharus aktif. Paket resmi nginx.org dan kebanyakan distro menyertakannya, tapi paket minimal sepertinginx-lightdi Debian tidak. Cek dengannginx -V 2>&1 | grep -o http_auth_request_module.- Jangan membaca
$verified_botlewatlimit_reqbawaan Nginx.limit_reqjalan di fase preaccess, sebelumauth_requestdi fase access, jadi variabelnya belum terisi. Itu sebabnya keputusan rate limit dipindah ke layanan Node.js.
Risiko produksinya nyata: tanpa batasan location dan fallback error_page, layanan verifikasi yang mati atau lambat membuat setiap request situs gagal dengan 500 atau 504. Dengan konfigurasi di atas, trade-off-nya disengaja: saat layanan mati, endpoint itu sementara tanpa rate limit, tapi situs tetap hidup. Pasang alert pada layanan ini.
Baris log yang kini membawa verified_bot bisa difilter tool analisis log mana pun; perbandingan toolnya ada di artikel pendamping kami.
Cara Memakai Hasil Verifikasi dengan Aman
- Jangan pernah memblokir hanya berdasarkan User-Agent, baik untuk mengizinkan maupun menolak. Keputusan akses harus melewati verifikasi IP.
- Beri pengecualian rate limit hanya untuk
verified_bot = true, bukan semua yang User-Agent-nya mengandung “Googlebot”. Yang mengaku Googlebot tapi gagal verifikasi layak lebih dicurigai karena sedang menyamar. - Fail closed untuk pengecualian, bukan untuk hukuman. Gagal verifikasi berarti tidak dapat pengecualian, bukan diblokir permanen. Karena itu
errortidak di-cache: crawler asli yang kena gangguan DNS tetap dilayani di bawah rate limit normal dan terverifikasi pada request berikutnya. - Simpan log mentah dengan field
verified_botcukup lama untuk audit, karena alokasi IP bisa berpindah dan verifikasi ulang terhadap log lama tidak lagi akurat.
Checklist Implementasi
- Pasang
log_formatJSON denganescape=json, danrealipkalau di belakang proxy. - Ukur baseline: berapa persen baris ber-User-Agent Googlebot yang
verified_bot-nyafalse. - Tulis verifikasi reverse DNS mengikuti langkah dokumentasi Google, dengan hasil
verified,unverified, danerror. - Tambahkan jalur cepat CIDR dari file JSON resmi, dan jadwalkan penyegarannya.
- Cache dengan TTL: lama untuk
verified, singkat untukunverified, tanpa cache untukerror. - Hubungkan lewat
auth_requesthanya di endpoint target, dengan timeout pendek dan fallback. - Audit berkala: pastikan tidak ada bot asli terblokir atau bot palsu lolos.
Rentang IP berubah dan dokumentasi Google bisa diperbarui, jadi anggap ini perawatan rutin, bukan proyek sekali jadi. Setelah datanya bersih, langkah berikutnya adalah membaca pola crawl di artikel log file analyzer kami.
Ditulis oleh Putri Andini