Pengaturan proxy di curl dan wget: panduan lengkap

```html

Saat mengambil data dari situs, otomatisasi permintaan API, atau memantau harga pesaing di marketplace, Anda akan menghadapi pemblokiran berdasarkan IP. Alat curl dan wget adalah alat standar untuk bekerja dengan permintaan HTTP di command line, dan pengaturan proxy yang benar di dalamnya sangat penting untuk menghindari batasan. Dalam artikel ini, kita akan membahas semua cara menggunakan proxy di curl dan wget: dari perintah dasar hingga skenario lanjutan dengan rotasi IP dan penanganan kesalahan.

Sintaks dasar proxy di curl dan wget

Mari kita mulai dengan perintah yang paling sederhana untuk terhubung melalui proxy. Kedua alat mendukung parameter untuk menentukan server proxy, tetapi sintaksnya sedikit berbeda.

Menggunakan proxy di curl

Di curl, proxy ditentukan melalui parameter -x atau --proxy. Format dasar perintah:

curl -x http://proxy-server:port http://example.com

Contoh spesifik dengan server proxy nyata:

curl -x http://45.130.123.45:8080 http://api.ipify.org

Perintah ini akan mengirimkan permintaan ke api.ipify.org (layanan yang mengembalikan alamat IP Anda) melalui server proxy yang ditentukan. Anda akan melihat IP proxy, bukan alamat asli Anda.

Menggunakan proxy di wget

Di wget, proxy diatur melalui parameter -e use_proxy=yes dan variabel lingkungan, atau langsung melalui opsi:

wget -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 http://example.com

Atau versi yang lebih singkat melalui variabel lingkungan (lebih lanjut tentang ini di bagian bawah):

export http_proxy="http://45.130.123.45:8080"
wget http://example.com

Otorisasi di server proxy

Sebagian besar layanan proxy komersial memerlukan otorisasi dengan username dan password. Ini melindungi proxy dari penggunaan yang tidak sah dan memungkinkan pelacakan lalu lintas setiap klien. Mari kita lihat cara mengirimkan kredensial di curl dan wget.

Otorisasi di curl

Di curl, username dan password dapat ditentukan langsung dalam URL server proxy atau melalui parameter terpisah -U:

# Metode 1: username dan password dalam URL
curl -x http://username:password@proxy-server:port http://example.com

# Metode 2: melalui parameter -U
curl -x http://proxy-server:port -U username:password http://example.com

Contoh spesifik dengan kredensial:

curl -x http://user123:pass456@45.130.123.45:8080 http://api.ipify.org

Hal penting: jika password mengandung karakter khusus (@, :, /, ?), mereka harus dikodekan dalam format URL. Misalnya, karakter @ diganti dengan %40:

# Jika password mengandung @: pass@456
curl -x http://user123:pass%40456@45.130.123.45:8080 http://api.ipify.org

Otorisasi di wget

Di wget, otorisasi diatur melalui parameter --proxy-user dan --proxy-password:

wget --proxy-user=username --proxy-password=password \
     -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 \
     http://example.com

Atau melalui variabel lingkungan dengan kredensial dalam URL:

export http_proxy="http://username:password@45.130.123.45:8080"
wget http://example.com

Bekerja dengan berbagai jenis proxy: HTTP, HTTPS, SOCKS5

Server proxy bekerja dengan berbagai protokol, dan pemilihan jenis tergantung pada tugas. Proxy HTTP cocok untuk permintaan sederhana, HTTPS menyediakan enkripsi, sedangkan SOCKS5 bekerja pada tingkat yang lebih rendah dan mendukung semua jenis lalu lintas. Saat mengambil data dari marketplace seperti Wildberries atau Ozon, sering digunakan proxy residensial, yang dapat bekerja dengan salah satu dari protokol ini.

Proxy HTTP dan HTTPS

Proxy HTTP adalah jenis yang paling umum. Mereka bekerja pada tingkat protokol HTTP dan cocok untuk sebagian besar tugas pengambilan data web:

# Proxy HTTP di curl
curl -x http://proxy-server:8080 http://example.com

# Proxy HTTPS di curl (untuk koneksi aman)
curl -x https://proxy-server:8080 https://example.com

Penting: bahkan jika situs target menggunakan HTTPS, proxy bisa jadi HTTP. Curl secara otomatis akan membuat terowongan melalui metode CONNECT:

# Proxy HTTP untuk situs HTTPS (bekerja dengan benar)
curl -x http://proxy-server:8080 https://secure-site.com

Proxy SOCKS5

SOCKS5 adalah protokol yang lebih universal, yang bekerja pada tingkat TCP dan mendukung semua jenis lalu lintas (HTTP, HTTPS, FTP, bahkan UDP). Ini menjadikan SOCKS5 pilihan ideal untuk tugas otomatisasi yang kompleks:

# SOCKS5 di curl
curl -x socks5://proxy-server:1080 http://example.com

# SOCKS5 dengan otorisasi
curl -x socks5://username:password@proxy-server:1080 http://example.com

# SOCKS5h (resolusi DNS melalui proxy)
curl -x socks5h://proxy-server:1080 http://example.com

Perbedaan antara socks5 dan socks5h: pada yang pertama, permintaan DNS dilakukan dari komputer Anda, sedangkan pada yang kedua — melalui server proxy. Gunakan socks5h jika Anda ingin sepenuhnya menyembunyikan aktivitas Anda, termasuk permintaan DNS.

Di wget, dukungan SOCKS5 terbatas, jadi untuk tugas semacam itu lebih baik menggunakan curl atau utilitas tambahan seperti proxychains.

Tip: Untuk pengambilan data dari marketplace (Wildberries, Ozon, Yandex.Market) disarankan untuk menggunakan proxy residensial atau mobile dengan protokol HTTP/HTTPS — mereka lebih jarang terkena pemblokiran, karena memiliki IP pengguna nyata.

Pengaturan proxy melalui variabel lingkungan

Jika Anda secara teratur bekerja melalui proxy, lebih nyaman untuk mengatur variabel lingkungan sekali daripada menentukan parameter di setiap perintah. Curl dan wget secara otomatis membaca variabel ini.

Pengaturan untuk sesi saat ini

Ekspor variabel di terminal (berlaku hingga sesi ditutup):

# Untuk lalu lintas HTTP
export http_proxy="http://username:password@proxy-server:8080"

# Untuk lalu lintas HTTPS
export https_proxy="http://username:password@proxy-server:8080"

# Untuk lalu lintas FTP
export ftp_proxy="http://username:password@proxy-server:8080"

# Untuk SOCKS5
export all_proxy="socks5://username:password@proxy-server:1080"

Setelah itu, curl dan wget akan secara otomatis menggunakan proxy:

# Proxy akan diterapkan secara otomatis
curl http://api.ipify.org
wget http://example.com

Pengaturan permanen di .bashrc atau .zshrc

Agar proxy diterapkan setiap kali terminal dibuka, tambahkan variabel ke file konfigurasi shell Anda:

# Buka file di editor
nano ~/.bashrc  # untuk bash
# atau
nano ~/.zshrc   # untuk zsh

# Tambahkan di akhir file:
export http_proxy="http://username:password@proxy-server:8080"
export https_proxy="http://username:password@proxy-server:8080"

# Simpan dan terapkan perubahan:
source ~/.bashrc

Pengecualian: no_proxy

Terkadang perlu untuk mengecualikan alamat tertentu dari pemrosesan proxy (misalnya, localhost atau layanan internal):

export no_proxy="localhost,127.0.0.1,192.168.0.0/16,.local"

Sekarang permintaan ke alamat-alamat ini akan langsung dilakukan, melewati proxy.

Rotasi proxy dalam skrip bash

Saat melakukan pengambilan data massal (misalnya, mengumpulkan harga dari ribuan kartu produk di Wildberries), menggunakan satu proxy akan mengakibatkan pemblokiran. Solusinya adalah rotasi alamat IP. Mari kita lihat cara mengimplementasikannya dalam skrip bash.

Rotasi sederhana dari daftar proxy

Buat file proxies.txt dengan daftar server proxy (satu per baris):

http://user1:pass1@proxy1.example.com:8080
http://user2:pass2@proxy2.example.com:8080
http://user3:pass3@proxy3.example.com:8080

Skrip untuk rotasi proxy secara berurutan:

#!/bin/bash

# File dengan daftar URL untuk diambil
urls_file="urls.txt"
# File dengan daftar proxy
proxies_file="proxies.txt"

# Membaca proxy ke dalam array
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current_proxy=0

# Memproses setiap URL
while IFS= read -r url; do
    # Memilih proxy secara berurutan
    proxy="${proxies[$current_proxy]}"
    
    echo "Permintaan ke $url melalui $proxy"
    curl -x "$proxy" -s "$url" -o "output_$(basename $url).html"
    
    # Beralih ke proxy berikutnya
    current_proxy=$(( (current_proxy + 1) % proxy_count ))
    
    # Jeda antara permintaan (1-3 detik)
    sleep $((RANDOM % 3 + 1))
done < "$urls_file"

Skrip ini secara berurutan menggunakan proxy dari daftar, kembali ke yang pertama setelah yang terakhir. Jeda acak antara permintaan membuat aktivitas terlihat lebih alami.

Pemilihan proxy secara acak

Untuk meningkatkan ketidakpastian, Anda dapat memilih proxy secara acak:

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}

while IFS= read -r url; do
    # Pemilihan proxy secara acak
    random_index=$((RANDOM % proxy_count))
    proxy="${proxies[$random_index]}"
    
    echo "Permintaan ke $url melalui proxy #$random_index"
    curl -x "$proxy" -s "$url" -o "output_$(date +%s).html"
    
    sleep $((RANDOM % 3 + 1))
done < "urls.txt"

Rotasi otomatis melalui API layanan proxy

Banyak penyedia proxy (termasuk layanan yang menyediakan proxy residensial) menawarkan rotasi otomatis melalui satu titik akses. Anda menggunakan satu alamat proxy, dan IP berubah pada setiap permintaan atau berdasarkan timer:

# Proxy dengan rotasi otomatis
# IP berubah pada setiap permintaan
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org

# Dua permintaan di atas akan mendapatkan alamat IP yang berbeda

Ini adalah cara yang paling nyaman untuk pengambilan data berskala besar — tidak perlu mengelola daftar proxy secara manual.

Mengirim header dan User-Agent melalui proxy

Situs modern menganalisis tidak hanya alamat IP, tetapi juga header HTTP dari permintaan. Ketidakadaan User-Agent atau header yang mencurigakan dapat menyebabkan pemblokiran bahkan saat menggunakan proxy berkualitas. Mari kita lihat cara mengatur header dengan benar di curl dan wget.

User-Agent di curl

User-Agent adalah header yang mengidentifikasi browser dan sistem operasi. Curl secara default mengirimkan User-Agent-nya sendiri (curl/7.x.x), yang langsung menunjukkan otomatisasi. Gantilah dengan browser nyata:

# Chrome di Windows
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" \
     http://example.com

# Firefox di macOS
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0" \
     http://example.com

Header tambahan

Untuk permintaan yang lebih realistis, tambahkan header browser yang khas:

curl -x http://proxy:8080 \
     -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" \
     -H "Accept-Language: ru-RU,ru;q=0.9,en;q=0.8" \
     -H "Accept-Encoding: gzip, deflate, br" \
     -H "Connection: keep-alive" \
     -H "Upgrade-Insecure-Requests: 1" \
     http://example.com

User-Agent di wget

Di wget, User-Agent ditentukan melalui parameter --user-agent:

wget --user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -e use_proxy=yes -e http_proxy=http://proxy:8080 \
     http://example.com

Pengacakan User-Agent dalam skrip

Untuk pengambilan data berskala besar, berguna untuk bergantian User-Agent, agar permintaan terlihat seperti berasal dari pengguna yang berbeda:

#!/bin/bash

# Array User-Agent
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0 Safari/537.36"
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Safari/605.1.15"
    "Mozilla/5.0 (X11; Linux x86_64) Firefox/121.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) Safari/604.1"
)

while IFS= read -r url; do
    # User-Agent acak
    random_ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x http://proxy:8080 -A "$random_ua" -s "$url"
    sleep 2
done < "urls.txt"

Diagnosa masalah dan penanganan kesalahan

Saat bekerja dengan proxy, sering terjadi kesalahan: timeout, penolakan koneksi, otorisasi yang salah. Mari kita lihat cara mendiagnosis dan menangani situasi ini.

Memeriksa keberfungsian proxy

Cara paling sederhana untuk memeriksa proxy adalah dengan meminta layanan yang mengembalikan IP Anda:

# Memeriksa proxy HTTP
curl -x http://proxy:8080 http://api.ipify.org

# Memeriksa proxy SOCKS5
curl -x socks5://proxy:1080 http://api.ipify.org

# Dengan output informasi detail
curl -x http://proxy:8080 -v http://api.ipify.org

Parameter -v (verbose) akan menunjukkan detail koneksi, termasuk header dan kesalahan.

Penanganan timeout

Proxy yang lambat atau server yang kelebihan beban dapat menyebabkan timeout. Tetapkan batas waktu yang wajar:

# Timeout koneksi 10 detik, timeout total 30 detik
curl -x http://proxy:8080 --connect-timeout 10 --max-time 30 http://example.com

# Di wget
wget --timeout=30 --tries=3 -e http_proxy=http://proxy:8080 http://example.com

Penanganan kesalahan otomatis dalam skrip

Skrip untuk pengambilan data dengan otomatis beralih ke proxy berikutnya saat terjadi kesalahan:

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"

fetch_with_retry() {
    local url=$1
    local max_attempts=3
    
    for proxy in "${proxies[@]}"; do
        echo "Mencoba melalui proxy: $proxy"
        
        if curl -x "$proxy" \
                --connect-timeout 10 \
                --max-time 30 \
                -s -f "$url" -o output.html; then
            echo "Sukses dengan proxy: $proxy"
            return 0
        else
            echo "Kesalahan dengan proxy: $proxy, mencoba berikutnya"
        fi
    done
    
    echo "Semua proxy tidak tersedia untuk $url"
    return 1
}

# Penggunaan
fetch_with_retry "http://example.com/page1"

Parameter -f membuat curl mengembalikan kesalahan pada status HTTP 4xx dan 5xx, yang memungkinkan penanganan tidak hanya kesalahan jaringan, tetapi juga pemblokiran di tingkat aplikasi.

Logging untuk debugging

Simpan log permintaan yang detail untuk menganalisis masalah:

# Menyimpan header respons
curl -x http://proxy:8080 -D headers.txt http://example.com

# Log lengkap interaksi
curl -x http://proxy:8080 -v http://example.com 2>&1 | tee curl.log

# Hanya status HTTP
curl -x http://proxy:8080 -o /dev/null -s -w "%{http_code}\n" http://example.com

Skenario praktis penggunaan

Mari kita lihat tugas nyata di mana curl dan wget dengan proxy menyelesaikan masalah bisnis tertentu.

Pengambilan harga pesaing di marketplace

Tugas: mengumpulkan harga dari 500 produk pesaing di Wildberries untuk analisis strategi harga. Wildberries secara aktif memblokir permintaan massal dari satu IP.

Solusi: menggunakan proxy residensial dengan rotasi dan pengacakan User-Agent:

#!/bin/bash

# Proxy dengan rotasi otomatis
PROXY="http://user:pass@rotating-residential.proxy.com:8080"

# Array User-Agent
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1"
)

# Membaca ID produk dari file
while IFS= read -r product_id; do
    ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x "$PROXY" \
         -A "$ua" \
         -H "Accept-Language: ru-RU,ru;q=0.9" \
         -s "https://www.wildberries.ru/catalog/${product_id}/detail.aspx" \
         -o "products/${product_id}.html"
    
    echo "Produk $product_id telah diunduh"
    sleep $((RANDOM % 5 + 3))  # Jeda 3-8 detik
done < product_ids.txt

Memantau ketersediaan API dari berbagai wilayah

Tugas: memeriksa bagaimana API layanan Anda bekerja untuk pengguna dari berbagai negara (geoblocking, kecepatan respons).

Solusi: proxy dengan IP dari negara yang diperlukan:

#!/bin/bash

# Proxy dari berbagai negara
declare -A proxies=(
    ["US"]="http://user:pass@us-proxy.com:8080"
    ["DE"]="http://user:pass@de-proxy.com:8080"
    ["JP"]="http://user:pass@jp-proxy.com:8080"
)

API_URL="https://api.yourservice.com/v1/status"

for country in "${!proxies[@]}"; do
    echo "Memeriksa dari $country..."
    
    response_time=$(curl -x "${proxies[$country]}" \
                         -s -o /dev/null \
                         -w "%{time_total}" \
                         "$API_URL")
    
    http_code=$(curl -x "${proxies[$country]}" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     "$API_URL")
    
    echo "$country: HTTP $http_code, waktu respons ${response_time}s"
done

Mengunduh file melalui wget dengan rotasi proxy

Tugas: mengunduh arsip file (gambar produk, dokumen) dari situs yang membatasi kecepatan untuk satu IP.

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current=0

while IFS= read -r file_url; do
    proxy="${proxies[$current]}"
    filename=$(basename "$file_url")
    
    echo "Mengunduh $filename melalui proxy #$current"
    
    wget --proxy-user=username --proxy-password=password \
         -e use_proxy=yes -e http_proxy="$proxy" \
         -O "downloads/$filename" \
         "$file_url"
    
    current=$(( (current + 1) % proxy_count ))
    sleep 2
done < file_urls.txt

Pengujian kreatif iklan di berbagai GEO

Tugas: memeriksa bagaimana iklan Facebook Ads terlihat untuk pengguna dari AS, Kanada, dan Inggris (mata uang, bahasa, ketersediaan tawaran yang berbeda).

#!/bin/bash

# Proxy mobile dari berbagai negara untuk realisme
declare -A mobile_proxies=(
    ["US"]="http://user:pass@us-mobile.proxy.com:8080"
    ["CA"]="http://user:pass@ca-mobile.proxy.com:8080"
    ["GB"]="http://user:pass@gb-mobile.proxy.com:8080"
)

AD_URL="https://www.facebook.com/ads/library/?id=YOUR_AD_ID"

for country in "${!mobile_proxies[@]}"; do
    curl -x "${mobile_proxies[$country]}" \
         -A "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1" \
         -H "Accept-Language: en-US,en;q=0.9" \
         -s "$AD_URL" \
         -o "ads_preview_${country}.html"
    
    echo "Pratonton disimpan untuk $country"
done

Untuk tugas semacam ini, proxy mobile sangat efektif, karena mereka meniru pengguna nyata smartphone dan lebih jarang menarik perhatian sistem anti-fraud Facebook.

Penting untuk para arbitrator: Saat memeriksa kreatif iklan melalui proxy, gunakan IP mobile dan User-Agent yang sesuai dengan perangkat mobile. Facebook menganalisis konsistensi data (tipe perangkat berdasarkan User-Agent harus sesuai dengan tipe IP).

Automatisasi pemeriksaan ketersediaan situs

Tugas: memantau ketersediaan situs Anda setiap 5 menit, meniru permintaan dari pengguna nyata (bukan dari IP server).

#!/bin/bash

PROXY="http://user:pass@residential.proxy.com:8080"
SITE_URL="https://yoursite.com"
LOG_FILE="uptime.log"

while true; do
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    http_code=$(curl -x "$PROXY" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     --max-time 10 \
                     "$SITE_URL")
    
    if [ "$http_code" -eq 200 ]; then
        echo "[$timestamp] OK - HTTP $http_code" >> "$LOG_FILE"
    else
        echo "[$timestamp] ERROR - HTTP $http_code" >> "$LOG_FILE"
        # Mengirim alert (misalnya, melalui API Telegram)
        curl -s "https://api.telegram.org/botTOKEN/sendMessage" \
             -d "chat_id=CHAT_ID&text=Situs tidak tersedia: HTTP $http_code"
    fi
    
    sleep 300  # 5 menit
done

Kesimpulan

Curl dan wget adalah alat yang kuat untuk otomatisasi permintaan HTTP, dan pengaturan proxy yang benar membuatnya tak tergantikan untuk pengambilan data, pemantauan, dan pengujian. Kita telah membahas semua aspek kunci: dari sintaks dasar hingga skenario lanjutan dengan rotasi IP, penanganan kesalahan, dan pengacakan header.

Kesimpulan utama dari artikel ini:

Gunakan parameter -x di curl dan variabel lingkungan untuk mengatur proxy
Pilih jenis proxy sesuai dengan tugas: HTTP untuk permintaan sederhana, SOCKS5 untuk fleksibilitas
Selalu ganti User-Agent standar dengan yang realistis dari browser
Implementasikan rotasi proxy untuk pengambilan data berskala besar — ini krusial untuk menghindari pemblokiran
Tambahkan penanganan kesalahan dan timeout dalam skrip produksi
Gunakan jeda acak antara permintaan untuk meniru perilaku manusia

Untuk tugas yang memerlukan tingkat anonimitas tinggi dan risiko pemblokiran minimal (pengambilan data dari marketplace, pemeriksaan iklan, pemantauan pesaing), kami merekomendasikan menggunakan proxy residensial. Mereka memiliki IP pengguna rumah nyata, yang membuat permintaan Anda tidak dapat dibedakan dari lalu lintas biasa dan secara signifikan mengurangi kemungkinan masuk dalam daftar pemblokiran.

Sekarang Anda memiliki seperangkat alat dan pengetahuan lengkap untuk bekerja secara efektif dengan proxy di curl dan wget. Terapkan teknik-teknik ini dalam proyek Anda, sesuaikan contoh dengan tugas spesifik, dan skalakan otomatisasi tanpa takut akan pemblokiran.

```

Pengaturan Proxy di curl dan wget: Panduan Lengkap dengan Contoh untuk Pengambilan Data