Proxy di Google Colab dan Jupyter untuk parsing: pengaturan

Google Colab dan Jupyter Notebook adalah alat yang nyaman untuk menulis dan menjalankan skrip parsing dengan cepat tanpa menginstal Python di mesin lokal. Namun, ada satu fitur dari notebook cloud yang sering dilupakan: semua permintaan berasal dari alamat IP pusat data Google, yang sudah lama dikenal oleh sistem anti-bot dan diblokir hampir seketika. Dalam artikel ini, kita akan membahas cara menghubungkan proxy dengan benar di Colab dan Jupyter, batasan yang diberlakukan oleh lingkungan cloud, dan cara membangun parsing agar tidak gagal setelah 50 permintaan pertama.

Mengapa Google Colab lebih sering diblokir dibandingkan PC biasa

Masalah utama Colab untuk parsing adalah kumpulan alamat IP yang umum. Setiap kali Anda menjalankan notebook, Google menyediakan mesin virtual dengan IP dari rentang cloud mereka (AS15169 dan yang serupa). Rentang ini sudah lama masuk dalam daftar hitam sebagian besar sistem anti-bot: Cloudflare, DataDome, PerimeterX, serta perlindungan bawaan Wildberries, Ozon, dan marketplace mengenal mereka dalam hitungan detik. Permintaan bahkan tidak sampai ke situs — disaring oleh filter berdasarkan ASN (Nomor Sistem Otonom) sebelum memeriksa User-Agent atau perilaku.

Alasan kedua adalah penggunaan massal. Ribuan pengembang secara bersamaan menjalankan parser, bot, dan skrip ML melalui Colab, sehingga reputasi IP ini di banyak situs target sudah "terbakar" jauh sebelum permintaan Anda. Bahkan jika Anda melakukan satu permintaan GET yang rapi setiap 10 detik, situs dapat mengembalikan 403 hanya karena dari rentang yang sama satu jam yang lalu, seseorang menyerang server dengan 500 thread.

Alasan ketiga adalah Jupyter yang dijalankan secara lokal biasanya tidak memiliki masalah ini (jika Anda memiliki IP rumah atau kantor biasa), tetapi begitu Anda mulai bekerja melalui JupyterHub di server hosting atau dalam kontainer penyedia cloud — situasinya menjadi sama seperti di Colab. Oleh karena itu, pertanyaan "apakah proxy diperlukan atau tidak" untuk notebook cloud dijawab dengan tegas: tanpa mereka, parsing hampir tidak berfungsi setelah beberapa permintaan pertama.

Jenis proxy apa yang cocok untuk parsing cloud

Pemilihan jenis proxy tergantung pada apa yang Anda parsing dan seberapa agresif perlindungan situs target. Untuk Colab dan Jupyter, penting untuk mempertimbangkan satu nuansa lagi: sesi notebook terbatas dalam waktu, sehingga sesi sticky proxy yang tahan lama tidak selalu kritis — lebih sering stabilitas koneksi dalam satu kali eksekusi yang penting.

Jenis Proxy	Kapan digunakan di Colab/Jupyter	Fitur
Proxy pusat data	Parsing situs tanpa perlindungan ketat, API terbuka, halaman statis	Kecepatan tinggi, harga rendah, tetapi juga dapat diblokir berdasarkan ASN di situs agresif
Proxy residensial	Parsing Wildberries, Ozon, Avito, Google, media sosial dengan perlindungan anti-bot	IP pengguna nyata, jarang masuk daftar hitam, latensi lebih tinggi
Proxy seluler	Parsing versi seluler situs, TikTok, Instagram melalui API	Kepercayaan tertinggi, tetapi lebih mahal dan rotasi lebih lambat

Untuk sebagian besar tugas parsing marketplace dan mesin pencari dari Colab, kombinasi proxy residensial dengan rotasi untuk setiap permintaan adalah keseimbangan optimal — ini mengurangi kemungkinan pemblokiran berdasarkan pola perilaku, bahkan jika permintaan itu sendiri dilakukan dari lingkungan cloud Google.

Pengaturan proxy di requests dan urllib

Pengaturan dasar proxy di Colab tidak berbeda dari lingkungan Python lokal. Perbedaannya hanya bahwa di Colab, pustaka biasanya perlu diinstal melalui !pip install, karena gambar standar tidak selalu mencakup semua yang diperlukan.

!pip install requests

import requests

proxy = {
    "http": "http://login:[email protected]:9000",
    "https": "http://login:[email protected]:9000"
}

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
}

response = requests.get(
    "https://example.com/catalog",
    proxies=proxy,
    headers=headers,
    timeout=15
)

print(response.status_code)
print(response.text[:500])

Poin penting: di Colab tidak ada file konfigurasi permanen, sehingga login dan kata sandi proxy harus di-hardcode (yang tidak aman saat menerbitkan notebook), atau disimpan dalam variabel lingkungan Colab melalui google.colab.userdata, atau dihubungkan melalui Colab Secrets. Ini lebih nyaman daripada menyimpan kata sandi langsung dalam kode, terutama jika Anda berbagi notebook dengan rekan kerja.

from google.colab import userdata

proxy_login = userdata.get('PROXY_LOGIN')
proxy_pass = userdata.get('PROXY_PASS')

proxy_url = f"http://{proxy_login}:{proxy_pass}@gate.proxycove.com:9000"
proxies = {"http": proxy_url, "https": proxy_url}

Proxy dengan Selenium dan headless Chrome di Colab

Jika situs merender konten melalui JavaScript (situasi umum untuk Wildberries, Ozon, Avito), requests sederhana tidak cukup — diperlukan browser headless. Di Colab, ini biasanya Selenium dengan Chromium, yang perlu diinstal secara manual, karena tidak ada dalam gambar dasar.

!apt-get update
!apt install chromium-chromedriver
!pip install selenium

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

chrome_options = Options()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--disable-dev-shm-usage')
chrome_options.add_argument('--proxy-server=http://gate.proxycove.com:9000')

driver = webdriver.Chrome(options=chrome_options)
driver.get("https://example.com/catalog")
print(driver.page_source[:500])
driver.quit()

Masalahnya adalah bahwa flag --proxy-server tidak mendukung otentikasi login dan kata sandi secara langsung. Untuk proxy dengan autentikasi di Selenium, Anda perlu menggunakan otentikasi IP (whitelisting berdasarkan IP statis notebook, yang di Colab tidak stabil, karena IP mesin berubah setiap kali dijalankan ulang), atau menghasilkan ekstensi Chrome "on the fly" dengan kredensial proxy yang ditulis, atau menggunakan tunnel proxy melalui pustaka seperti selenium-wire, yang mendukung authenticated proxy secara default.

!pip install selenium-wire

from seleniumwire import webdriver

proxy_options = {
    'proxy': {
        'http': 'http://login:[email protected]:9000',
        'https': 'http://login:[email protected]:9000',
    }
}

driver = webdriver.Chrome(seleniumwire_options=proxy_options, options=chrome_options)
driver.get("https://example.com/catalog")

Jupyter Notebook: lokal vs cloud

Jupyter Notebook yang dijalankan di mesin lokal (melalui Anaconda atau langsung melalui pip) menggunakan alamat IP rumah atau kantor Anda — dan dalam kasus ini, proxy hanya diperlukan untuk menyamarkan atau mengatasi batasan geo, bukan untuk melindungi dari pemblokiran berdasarkan ASN pusat data. Pengaturan dalam hal ini sepenuhnya identik dengan skrip Python biasa: sama dengan requests, sama dengan Selenium, tanpa batasan pada instalasi driver dan paket sistem.

Situasi berubah jika Anda menggunakan Jupyter melalui layanan cloud: JupyterHub di VPS, Kaggle Notebooks, Deepnote, Binder, atau kluster cloud perusahaan. Dalam kasus ini, IP kembali milik pusat data penyedia, dan semua masalah Colab berlaku satu per satu. Perbedaan utama dari Colab adalah bahwa layanan semacam ini sering memiliki IP yang lebih stabil selama sesi (tidak berubah setiap kali kernel di-restart), yang memudahkan pengaturan whitelisting berdasarkan IP, jika penyedia proxy Anda mendukungnya.

Kesimpulan praktis: jika parsing sangat penting untuk bisnis (misalnya, pemantauan harga pesaing harian di marketplace), lebih baik tidak bergantung pada notebook cloud gratis sebagai lingkungan produksi, tetapi menggunakannya hanya untuk pengembangan dan pengujian skrip, memindahkan parser akhir ke server dengan IP tetap dan proxy yang sudah diatur.

Batasan notebook cloud yang merusak parsing

Selain masalah reputasi IP, Google Colab memiliki sejumlah batasan teknis yang secara langsung memengaruhi stabilitas parsing:

Timeout tidak aktif. Versi gratis Colab mematikan notebook setelah ~90 menit tidak aktif dan secara paksa menyelesaikan sesi setelah 12 jam kerja terus menerus — parsing panjang ribuan halaman perlu dibagi menjadi bagian atau menyimpan hasil sementara di Google Drive.
Pergantian IP pada setiap runtime baru. Jika Anda mematikan dan menyambungkan kembali lingkungan eksekusi, alamat IP mesin virtual berubah — ini merusak pengaturan dengan whitelisting berdasarkan IP di sisi layanan proxy.
Batasan pada koneksi keluar. Google membatasi jumlah koneksi jaringan simultan dari satu mesin virtual, jadi multithreading agresif dengan puluhan permintaan paralel dapat terhambat bukan oleh pemblokiran situs, tetapi oleh batasan Colab itu sendiri.
Tidak ada penyimpanan persisten tanpa pemasangan disk. Cookie, sesi browser, dan cache koneksi proxy hilang pada setiap restart — untuk parsing dengan otorisasi, cookie perlu disimpan secara eksplisit dalam file di Google Drive.
Penundaan jaringan yang tidak terduga. Infrastruktur cloud Google kadang-kadang memberikan lonjakan latensi, sehingga timeout permintaan perlu diatur dengan cadangan (15-30 detik dibandingkan dengan standar 5-10).

Batasan ini menjadikan Colab alat yang sangat baik untuk pengembangan dan debugging logika parser, tetapi kurang cocok untuk tugas produksi jangka panjang — untuk itu lebih baik memindahkan skrip yang sudah siap ke VPS atau server khusus dengan IP sendiri.

Rotasi proxy dan penanganan kesalahan dalam loop

Agar parsing tidak gagal pada pemblokiran pertama, logika percobaan ulang dengan penggantian proxy diperlukan dalam kode. Berikut adalah contoh loop sederhana dengan rotasi dan penanganan kesalahan yang dapat dijalankan langsung di Colab.

import requests
import time
import random

proxy_pool = [
    "http://login:[email protected]:9000",
    "http://login:[email protected]:9001",
    "http://login:[email protected]:9002",
]

def get_with_retry(url, max_retries=5):
    for attempt in range(max_retries):
        proxy_url = random.choice(proxy_pool)
        proxies = {"http": proxy_url, "https": proxy_url}
        try:
            response = requests.get(url, proxies=proxies, timeout=20)
            if response.status_code == 200:
                return response
            else:
                print(f"Percobaan {attempt+1}: status {response.status_code}")
        except requests.exceptions.RequestException as e:
            print(f"Percobaan {attempt+1}: kesalahan {e}")
        time.sleep(random.uniform(2, 5))
    return None

result = get_with_retry("https://example.com/catalog")
if result:
    print(result.status_code)
else:
    print("Semua percobaan telah habis")

Untuk parsing katalog besar (misalnya, ribuan kartu produk di Wildberries), logika ini juga dibungkus dalam antrean tugas dengan jeda antara permintaan dan menyimpan hasil sementara dalam CSV atau database langsung di Google Drive, untuk tidak kehilangan kemajuan saat sesi Colab terputus.

Checklist sebelum menjalankan parser di Colab

Proxy terhubung dan diuji dengan permintaan uji terpisah sebelum loop utama
Login dan kata sandi proxy disimpan di Colab Secrets, bukan di kode terbuka
Untuk situs JS, digunakan Selenium dengan selenium-wire atau ekstensi otorisasi yang ditulis
Dalam kode terdapat logika retry dan rotasi proxy saat kesalahan 403/429
Hasil sementara disimpan di Google Drive setiap N entri
Timeout permintaan ditingkatkan dengan mempertimbangkan kemungkinan penundaan jaringan cloud
Paralelisme permintaan dibatasi agar tidak terjebak dalam batas koneksi keluar Colab
Untuk tugas produksi, disiapkan pemindahan skrip ke server terpisah dengan IP tetap

Kesimpulan

Google Colab dan Jupyter cloud sangat cocok untuk pengembangan cepat dan pengujian logika parser, tetapi karena IP umum pusat data hampir selalu memerlukan proxy sejak langkah awal. Untuk situs sederhana tanpa perlindungan agresif, proxy pusat data sudah cukup, sementara untuk parsing marketplace, mesin pencari, dan media sosial, IP residensial dan seluler bekerja lebih andal, yang lebih jarang masuk dalam filter berdasarkan ASN.

Jika Anda berencana untuk memantau harga secara teratur di Wildberries atau Ozon langsung dari Colab, kami sarankan untuk memulai dengan proxy residensial — mereka memberikan akses yang stabil tanpa pemblokiran yang sering, dan untuk skrip pengujian satu kali, Anda bisa menggunakan proxy pusat data yang lebih terjangkau, menghubungkannya dengan cara yang sama melalui requests atau Selenium.