Cara Mengatur Proxy di AWS Lambda untuk Pengambilan Data dan API: Panduan Lengkap dengan Contoh

AWS Lambda adalah platform tanpa server yang memungkinkan Anda menjalankan kode tanpa mengelola server. Namun, saat bekerja dengan pengambilan data dari situs web, API marketplace, atau otomatisasi tugas, sering kali muncul masalah: fungsi Lambda menggunakan alamat IP AWS yang mudah terdeteksi dan diblokir. Dalam panduan ini, kita akan membahas cara mengintegrasikan proxy ke dalam Lambda, mengatur rotasi IP, dan menghindari kesalahan umum.

Artikel ini ditujukan untuk pengembang yang mengotomatiskan tugas melalui AWS Lambda: pengambilan data dari situs yang dilindungi, pemantauan harga pesaing, bekerja dengan API media sosial atau marketplace. Anda akan mendapatkan contoh kode siap pakai dalam Python dan Node.js yang dapat digunakan segera setelah membaca.

Mengapa menggunakan proxy di AWS Lambda

AWS Lambda secara default menggunakan alamat IP dari kumpulan Amazon Web Services. Alamat-alamat ini terdapat dalam daftar publik dan mudah dikenali oleh sistem perlindungan dari bot. Berikut adalah skenario utama ketika proxy menjadi diperlukan:

Alasan utama menggunakan proxy di Lambda:

• Pengambilan data dari situs yang dilindungi: Banyak situs memblokir permintaan dari IP pusat data AWS. Proxy memungkinkan untuk menyamarkan Lambda sebagai pengguna biasa.
• Pembatasan geolokasi: Jika Anda perlu mendapatkan data dari situs yang hanya dapat diakses dari negara tertentu (misalnya, harga regional di Ozon), proxy dengan geolokasi yang tepat menyelesaikan masalah ini.
• Menghindari pembatasan jumlah permintaan: API banyak layanan membatasi jumlah permintaan dari satu IP. Rotasi proxy memungkinkan untuk mendistribusikan beban.
• Pengujian A/B iklan: Memeriksa tampilan iklan dari berbagai wilayah untuk analisis pesaing.
• Memantau marketplace: Melacak posisi produk, harga pesaing di Wildberries, Ozon, Avito tanpa pemblokiran.

Fungsi Lambda sering dijalankan berdasarkan jadwal (melalui CloudWatch Events) atau pemicu, yang menjadikannya alat yang ideal untuk otomatisasi. Namun, tanpa proxy, tugas-tugas tersebut cepat mengalami pemblokiran dari sumber daya yang dituju.

Jenis proxy apa yang dipilih untuk Lambda

Pemilihan jenis proxy tergantung pada tugas yang diselesaikan oleh fungsi Lambda Anda. Mari kita bahas tiga jenis utama dan penerapannya dalam arsitektur tanpa server:

Rekomendasi pemilihan:

• Untuk pengambilan data Wildberries, Ozon, Avito: Gunakan proxy residensial dengan geolokasi Rusia. Platform ini aktif memblokir IP pusat data.
• Untuk pemantauan API tanpa perlindungan ketat: Proxy pusat data sudah cukup, mereka lebih murah dan lebih cepat.
• Untuk bekerja dengan API Instagram, Facebook, TikTok: Hanya proxy seluler atau residensial — platform ini mendeteksi dan memblokir pusat data.
• Untuk menghindari Cloudflare, PerimeterX: Proxy residensial dengan rotasi, sebaiknya dengan sesi lengket (menyimpan IP selama 5-30 menit).

Pengaturan proxy di Lambda menggunakan Python (requests, urllib3)

Python adalah bahasa paling populer untuk fungsi Lambda, terutama untuk tugas pengambilan data dan otomatisasi. Mari kita lihat pengaturan proxy dengan pustaka requests, yang digunakan dalam 90% kasus.

Pengaturan dasar proxy HTTP

Cara termudah untuk menghubungkan proxy adalah dengan mengirimkan parameter proxies ke metode requests.get():

import requests
import os

def lambda_handler(event, context):
    # Mendapatkan kredensial proxy dari variabel lingkungan
    proxy_host = os.environ['PROXY_HOST']  # Misalnya: proxy.example.com
    proxy_port = os.environ['PROXY_PORT']  # Misalnya: 8080
    proxy_user = os.environ['PROXY_USER']
    proxy_pass = os.environ['PROXY_PASS']
    
    # Membentuk URL proxy dengan otorisasi
    proxy_url = f"http://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    try:
        # Melakukan permintaan melalui proxy
        response = requests.get(
            'https://api.example.com/data',
            proxies=proxies,
            timeout=10  # Penting! Tetapkan timeout
        )
        
        return {
            'statusCode': 200,
            'body': response.text
        }
    
    except requests.exceptions.ProxyError as e:
        print(f"Kesalahan proxy: {e}")
        return {
            'statusCode': 500,
            'body': 'Koneksi proxy gagal'
        }
    
    except requests.exceptions.Timeout as e:
        print(f"Kesalahan timeout: {e}")
        return {
            'statusCode': 504,
            'body': 'Permintaan timeout'
        }

Poin kunci dari kode ini:

• Variabel lingkungan: Jangan pernah menyimpan kredensial proxy langsung dalam kode! Gunakan Variabel Lingkungan dalam pengaturan Lambda.
• Timeout: Pastikan untuk menetapkan timeout (10-30 detik). Tanpa itu, Lambda dapat menggantung hingga batas waktu maksimum tercapai.
• Penanganan kesalahan: Proxy mungkin tidak tersedia atau lambat — selalu tangani pengecualian ProxyError dan Timeout.
• HTTP dan HTTPS: Tentukan kedua protokol dalam kamus proxies, bahkan jika Anda hanya menggunakan HTTPS.

Pengaturan proxy SOCKS5

Proxy SOCKS5 memberikan tingkat anonimitas yang lebih tinggi dan bekerja pada tingkat TCP, sehingga tidak terdeteksi oleh beberapa sistem perlindungan. Untuk bekerja dengan SOCKS5 dalam requests, Anda memerlukan pustaka requests[socks]:

import requests
import os

def lambda_handler(event, context):
    proxy_host = os.environ['PROXY_HOST']
    proxy_port = os.environ['PROXY_PORT']
    proxy_user = os.environ['PROXY_USER']
    proxy_pass = os.environ['PROXY_PASS']
    
    # Proxy SOCKS5 dengan otorisasi
    proxy_url = f"socks5://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    try:
        response = requests.get(
            'https://www.wildberries.ru/catalog/12345/detail.aspx',
            proxies=proxies,
            timeout=15
        )
        
        # Mengambil data
        return {
            'statusCode': 200,
            'body': response.text
        }
    
    except Exception as e:
        print(f"Kesalahan: {e}")
        return {
            'statusCode': 500,
            'body': str(e)
        }

Penting untuk deployment di Lambda: Saat menggunakan SOCKS5, tambahkan ke requirements.txt:

requests[socks]
PySocks

Memeriksa IP melalui proxy

Sebelum menjalankan logika utama, berguna untuk memeriksa bahwa proxy berfungsi dan mengembalikan IP yang benar:

def check_proxy_ip(proxies):
    """Memeriksa IP yang dilihat dunia luar melalui proxy"""
    try:
        response = requests.get(
            'https://api.ipify.org?format=json',
            proxies=proxies,
            timeout=10
        )
        ip_data = response.json()
        print(f"IP saat ini melalui proxy: {ip_data['ip']}")
        return ip_data['ip']
    except Exception as e:
        print(f"Pemeriksaan proxy gagal: {e}")
        return None

def lambda_handler(event, context):
    # ... pengaturan proxy ...
    
    # Memeriksa IP sebelum pekerjaan utama
    current_ip = check_proxy_ip(proxies)
    if not current_ip:
        return {
            'statusCode': 500,
            'body': 'Verifikasi proxy gagal'
        }
    
    # Logika utama pengambilan data
    # ...

Pengaturan proxy di Lambda menggunakan Node.js (axios, got)

Node.js adalah bahasa kedua yang paling populer untuk fungsi Lambda, terutama ketika kinerja tinggi diperlukan saat bekerja dengan API. Mari kita lihat pengaturan proxy dengan pustaka axios dan got.

Pengaturan dengan axios

Axios adalah pustaka HTTP paling populer untuk Node.js. Untuk bekerja dengan proxy, Anda memerlukan paket tambahan https-proxy-agent:

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

exports.handler = async (event) => {
    // Mendapatkan kredensial dari variabel lingkungan
    const proxyHost = process.env.PROXY_HOST;
    const proxyPort = process.env.PROXY_PORT;
    const proxyUser = process.env.PROXY_USER;
    const proxyPass = process.env.PROXY_PASS;
    
    // Membentuk URL proxy
    const proxyUrl = `http://${proxyUser}:${proxyPass}@${proxyHost}:${proxyPort}`;
    
    // Membuat agen untuk proxy
    const agent = new HttpsProxyAgent(proxyUrl);
    
    try {
        const response = await axios.get('https://api.example.com/data', {
            httpsAgent: agent,
            timeout: 10000  // 10 detik
        });
        
        return {
            statusCode: 200,
            body: JSON.stringify(response.data)
        };
    } catch (error) {
        console.error('Permintaan gagal:', error.message);
        
        return {
            statusCode: 500,
            body: JSON.stringify({
                error: error.message
            })
        };
    }
};

Pemasangan dependensi: Tambahkan ke package.json:

{
  "dependencies": {
    "axios": "^1.6.0",
    "https-proxy-agent": "^7.0.0"
  }
}

Pengaturan SOCKS5 dengan axios

Untuk proxy SOCKS5, gunakan paket socks-proxy-agent:

const axios = require('axios');
const { SocksProxyAgent } = require('socks-proxy-agent');

exports.handler = async (event) => {
    const proxyUrl = `socks5://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
    
    const agent = new SocksProxyAgent(proxyUrl);
    
    try {
        const response = await axios.get('https://www.ozon.ru/api/products', {
            httpAgent: agent,
            httpsAgent: agent,
            timeout: 15000
        });
        
        return {
            statusCode: 200,
            body: JSON.stringify(response.data)
        };
    } catch (error) {
        console.error('Kesalahan:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

Alternatif: pustaka got

Got adalah pustaka HTTP modern dengan dukungan bawaan untuk proxy (tidak memerlukan agen terpisah):

const got = require('got');

exports.handler = async (event) => {
    const proxyUrl = `http://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:${process.env.PROXY_PORT}`;
    
    try {
        const response = await got('https://api.example.com/data', {
            agent: {
                http: new (require('http-proxy-agent'))(proxyUrl),
                https: new (require('https-proxy-agent'))(proxyUrl)
            },
            timeout: {
                request: 10000
            },
            responseType: 'json'
        });
        
        return {
            statusCode: 200,
            body: JSON.stringify(response.body)
        };
    } catch (error) {
        console.error('Kesalahan:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

Rotasi proxy di Lambda: cara mengubah IP secara otomatis

Rotasi proxy sangat penting untuk tugas-tugas yang memerlukan banyak permintaan tanpa pemblokiran. Ada dua pendekatan utama: menggunakan layanan proxy dengan rotasi otomatis atau mengelola kumpulan proxy secara manual.

Rotasi otomatis melalui penyedia

Sebagian besar penyedia proxy residensial (termasuk ProxyCove) menyediakan endpoint dengan rotasi otomatis — setiap permintaan atau setiap N menit IP berubah secara otomatis:

import requests
import os

def lambda_handler(event, context):
    # Proxy dengan rotasi otomatis
    # Format: rotating.proxy.com:port
    # Setiap permintaan = IP baru
    proxy_url = f"http://{os.environ['PROXY_USER']}:{os.environ['PROXY_PASS']}@rotating.proxycove.com:8080"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    results = []
    
    # Melakukan 10 permintaan — setiap dengan IP baru
    for i in range(10):
        try:
            response = requests.get(
                f'https://api.wildberries.ru/products/{i}',
                proxies=proxies,
                timeout=10
            )
            results.append({
                'product_id': i,
                'status': response.status_code,
                'data': response.json()
            })
        except Exception as e:
            results.append({
                'product_id': i,
                'error': str(e)
            })
    
    return {
        'statusCode': 200,
        'body': json.dumps(results)
    }

Rotasi manual dari kumpulan proxy

Jika Anda memiliki daftar proxy, Anda dapat mengimplementasikan rotasi secara manual. Ini berguna ketika Anda memerlukan kontrol atas proxy mana yang digunakan untuk setiap permintaan:

import requests
import random
import json

def lambda_handler(event, context):
    # Daftar proxy (dapat disimpan di DynamoDB atau S3)
    proxy_pool = [
        {
            'host': 'proxy1.example.com',
            'port': '8080',
            'user': 'user1',
            'pass': 'pass1'
        },
        {
            'host': 'proxy2.example.com',
            'port': '8080',
            'user': 'user2',
            'pass': 'pass2'
        },
        {
            'host': 'proxy3.example.com',
            'port': '8080',
            'user': 'user3',
            'pass': 'pass3'
        }
    ]
    
    results = []
    
    for i in range(10):
        # Memilih proxy acak dari kumpulan
        proxy = random.choice(proxy_pool)
        proxy_url = f"http://{proxy['user']}:{proxy['pass']}@{proxy['host']}:{proxy['port']}"
        
        proxies = {
            'http': proxy_url,
            'https': proxy_url
        }
        
        try:
            response = requests.get(
                f'https://api.example.com/item/{i}',
                proxies=proxies,
                timeout=10
            )
            results.append({
                'item': i,
                'proxy_used': proxy['host'],
                'status': response.status_code
            })
        except Exception as e:
            results.append({
                'item': i,
                'proxy_used': proxy['host'],
                'error': str(e)
            })
    
    return {
        'statusCode': 200,
        'body': json.dumps(results)
    }

Sesi lengket untuk menyimpan IP

Beberapa tugas memerlukan penyimpanan satu IP selama sesi (misalnya, otorisasi di situs). Penyedia proxy menawarkan sesi lengket melalui parameter dalam URL:

import requests
import uuid

def lambda_handler(event, context):
    # Menghasilkan session_id unik
    session_id = str(uuid.uuid4())
    
    # Proxy dengan sesi lengket (IP disimpan selama 10 menit)
    proxy_url = f"http://{os.environ['PROXY_USER']}-session-{session_id}:{os.environ['PROXY_PASS']}@sticky.proxycove.com:8080"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    # Semua permintaan dalam Lambda ini akan dilakukan dengan satu IP
    # 1. Otorisasi
    login_response = requests.post(
        'https://example.com/login',
        data={'user': 'test', 'pass': 'test'},
        proxies=proxies
    )
    
    # 2. Mengambil data (menggunakan IP yang sama)
    data_response = requests.get(
        'https://example.com/dashboard',
        proxies=proxies,
        cookies=login_response.cookies
    )
    
    return {
        'statusCode': 200,
        'body': data_response.text
    }

Menyimpan kredensial proxy melalui Variabel Lingkungan

Jangan pernah menyimpan kredensial proxy (username, password, host) langsung dalam kode fungsi Lambda. AWS menyediakan beberapa cara aman untuk menyimpan data sensitif:

1. Variabel Lingkungan (cara dasar)

Di konsol AWS Lambda → Konfigurasi → Variabel lingkungan, tambahkan:

• PROXY_HOST = proxy.example.com
• PROXY_PORT = 8080
• PROXY_USER = your_username
• PROXY_PASS = your_password

AWS secara otomatis mengenkripsi Variabel Lingkungan saat tidak aktif. Akses ke mereka dalam kode:

# Python
import os
proxy_host = os.environ['PROXY_HOST']

// Node.js
const proxyHost = process.env.PROXY_HOST;

2. AWS Secrets Manager (direkomendasikan untuk produksi)

Untuk keamanan maksimal, gunakan AWS Secrets Manager — ia menyediakan rotasi otomatis untuk rahasia dan kontrol akses yang detail:

import boto3
import json
from botocore.exceptions import ClientError

def get_proxy_credentials():
    secret_name = "proxy-credentials"
    region_name = "us-east-1"
    
    session = boto3.session.Session()
    client = session.client(
        service_name='secretsmanager',
        region_name=region_name
    )
    
    try:
        get_secret_value_response = client.get_secret_value(
            SecretId=secret_name
        )
        secret = json.loads(get_secret_value_response['SecretString'])
        return secret
    except ClientError as e:
        print(f"Kesalahan saat mengambil rahasia: {e}")
        raise e

def lambda_handler(event, context):
    # Mendapatkan kredensial dari Secrets Manager
    creds = get_proxy_credentials()
    
    proxy_url = f"http://{creds['user']}:{creds['password']}@{creds['host']}:{creds['port']}"
    
    # Menggunakan proxy
    # ...

Penting: Jangan lupa untuk menambahkan hak IAM untuk fungsi Lambda agar dapat mengakses Secrets Manager:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "secretsmanager:GetSecretValue"
      ],
      "Resource": "arn:aws:secretsmanager:us-east-1:123456789:secret:proxy-credentials-*"
    }
  ]
}

Kesalahan umum dan solusinya

Saat bekerja dengan proxy di Lambda, pengembang sering menghadapi masalah yang sama. Mari kita bahas kesalahan yang paling umum dan cara mengatasinya:

Kesalahan: ProxyError / Waktu koneksi habis

Solusi:

# 1. Periksa kredensial
print(f"Menggunakan proxy: {proxy_host}:{proxy_port}")
print(f"User: {proxy_user}")

# 2. Tingkatkan timeout
response = requests.get(url, proxies=proxies, timeout=30)

# 3. Tambahkan logika retry
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

session = requests.Session()
retry = Retry(
    total=3,
    backoff_factor=1,
    status_forcelist=[500, 502, 503, 504]
)
adapter = HTTPAdapter(max_retries=retry)
session.mount('http://', adapter)
session.mount('https://', adapter)

response = session.get(url, proxies=proxies, timeout=30)

Kesalahan: Verifikasi Sertifikat SSL gagal

Solusi (gunakan dengan hati-hati!):

# Menonaktifkan verifikasi SSL (hanya untuk pengujian!)
response = requests.get(
    url,
    proxies=proxies,
    verify=False  # JANGAN gunakan di produksi!
)

# Lebih baik: tentukan jalur ke sertifikat CA
response = requests.get(
    url,
    proxies=proxies,
    verify='/path/to/ca-bundle.crt'
)

Kesalahan: Waktu habis Lambda (Tugas waktu habis setelah X detik)

Solusi:

• Tingkatkan timeout fungsi Lambda: Konfigurasi → Konfigurasi umum → Timeout (maksimum 15 menit)
• Kurangi jumlah permintaan dalam satu eksekusi
• Gunakan permintaan asinkron (asyncio di Python, Promise.all di Node.js)
• Pindah ke proxy yang lebih cepat untuk tugas yang tidak kritis

# Python: permintaan asinkron untuk mempercepat
import asyncio
import aiohttp

async def fetch_url(session, url, proxy):
    async with session.get(url, proxy=proxy, timeout=10) as response:
        return await response.text()

async def lambda_handler_async(event, context):
    proxy_url = f"http://{os.environ['PROXY_USER']}:{os.environ['PROXY_PASS']}@{os.environ['PROXY_HOST']}:{os.environ['PROXY_PORT']}"
    
    urls = [f'https://api.example.com/item/{i}' for i in range(50)]
    
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url, proxy_url) for url in urls]
        results = await asyncio.gather(*tasks)
    
    return {
        'statusCode': 200,
        'body': json.dumps({'count': len(results)})
    }

def lambda_handler(event, context):
    return asyncio.run(lambda_handler_async(event, context))

Kesalahan: 407 Autentikasi Proxy Diperlukan

Solusi:

# Periksa format URL proxy
# Benar:
proxy_url = f"http://{user}:{password}@{host}:{port}"

# Salah (protokol terlewat):
proxy_url = f"{user}:{password}@{host}:{port}"  # ❌

# Jika proxy memerlukan otorisasi IP:
# 1. Temukan IP eksternal Lambda Anda (mungkin berubah!)
# 2. Tambahkan IP ini ke whitelist penyedia proxy
# 3. Gunakan proxy tanpa user:pass

# Mendapatkan IP eksternal Lambda:
response = requests.get('https://api.ipify.org?format=json')
lambda_ip = response.json()['ip']
print(f"IP eksternal Lambda: {lambda_ip}")

Optimasi kinerja Lambda dengan proxy

Penggunaan proxy menambah keterlambatan pada setiap permintaan. Berikut adalah cara yang terbukti untuk meminimalkan dampak pada kinerja:

1. Pooling koneksi

Gunakan kembali koneksi TCP alih-alih membuat yang baru untuk setiap permintaan:

# Python: gunakan Session alih-alih requests.get()
import requests

# Buat session satu kali (dapat dipindahkan di luar handler)
session = requests.Session()
session.proxies = {
    'http': proxy_url,
    'https': proxy_url
}

def lambda_handler(event, context):
    # Semua permintaan menggunakan kembali koneksi
    for i in range(100):
        response = session.get(f'https://api.example.com/item/{i}')
        # proses respons...

2. Permintaan paralel

Jika perlu melakukan banyak permintaan independen, lakukan secara paralel:

// Node.js: permintaan paralel dengan Promise.all
const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

const agent = new HttpsProxyAgent(proxyUrl);

exports.handler = async (event) => {
    const urls = Array.from({length: 50}, (_, i) => 
        `https://api.example.com/item/${i}`
    );
    
    // Semua permintaan dilakukan secara paralel
    const promises = urls.map(url => 
        axios.get(url, { 
            httpsAgent: agent,
            timeout: 10000
        })
    );
    
    try {
        const results = await Promise.all(promises);
        return {
            statusCode: 200,
            body: JSON.stringify({
                count: results.length,
                data: results.map(r => r.data)
            })
        };
    } catch (error) {
        console.error('Kesalahan:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

3. Cache hasil

Jika data jarang berubah, cache hasil di DynamoDB atau S3:

import boto3
import json
import time

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('proxy-cache')

def get_cached_or_fetch(url, proxies, cache_ttl=3600):
    """Mengembalikan data dari cache atau melakukan permintaan melalui proxy"""
    
    # Memeriksa cache
    try:
        response = table.get_item(Key={'url': url})
        if 'Item' in response:
            item = response['Item']
            if time.time() - item['timestamp'] < cache_ttl:
                print(f"Cache hit untuk {url}")
                return item['data']
    except Exception as e:
        print(f"Kesalahan cache: {e}")
    
    # Cache kosong atau kadaluarsa — melakukan permintaan
    print(f"Cache miss untuk {url}, mengambil...")
    response = requests.get(url, proxies=proxies, timeout=10)
    data = response.text
    
    # Menyimpan dalam cache
    try:
        table.put_item(Item={
            'url': url,
            'data': data,
            'timestamp': int(time.time())
        })
    except Exception as e:
        print(f"Kesalahan menyimpan cache: {e}")
    
    return data

4. Memilih jenis proxy yang tepat

Perbandingan kecepatan berbagai jenis proxy dalam kondisi nyata:

Kesimpulan: Menggunakan proxy dalam AWS Lambda sangat penting untuk menghindari pemblokiran dan memastikan pengambilan data yang efektif. Dengan memahami berbagai jenis proxy dan cara mengaturnya, Anda dapat meningkatkan kinerja dan keandalan aplikasi Anda.