AWS Lambda'da Proxy Ayarları: Parsing ve API için Örneklerle Tam Kılavuz

AWS Lambda, sunucusuz bir platformdur ve kodu sunucuları yönetmeden çalıştırmanıza olanak tanır. Ancak, web sitelerinden veri çekme, pazar yerlerinin API'leri ile çalışma veya görevleri otomatikleştirme gibi işlemler yaparken sıkça karşılaşılan bir sorun vardır: Lambda fonksiyonları, kolayca tespit edilen ve engellenen AWS IP adreslerini kullanır. Bu kılavuzda, Lambda'ya proxy entegrasyonu, IP döngüsünün nasıl ayarlanacağı ve yaygın hatalardan nasıl kaçınılacağı ele alınacaktır.

Makale, AWS Lambda üzerinden görevleri otomatikleştiren geliştiricilere yöneliktir: korumalı web sitelerinden veri çekme, rakip fiyatlarını izleme, sosyal medya veya pazar yeri API'leri ile çalışma. Okuduktan sonra hemen kullanabileceğiniz Python ve Node.js için hazır kod örnekleri alacaksınız.

AWS Lambda'da Proxy Neden Gereklidir

AWS Lambda varsayılan olarak Amazon Web Services havuzundan IP adresleri kullanır. Bu adresler kamuya açık listelerde yer alır ve bot koruma sistemleri tarafından kolayca tespit edilir. İşte proxy'lerin gerekli olduğu temel senaryolar:

Lambda'da Proxy Kullanmanın Temel Nedenleri:

• Korumalı Web Sitelerinden Veri Çekme: Birçok web sitesi AWS veri merkezi IP'lerinden gelen istekleri engeller. Proxy'ler, Lambda'yı normal kullanıcılar gibi gizlemeye olanak tanır.
• Coğrafi Kısıtlamalar: Belirli bir ülkeden (örneğin, Ozon'daki bölgesel fiyatlar) yalnızca erişilebilen bir web sitesinden veri almanız gerekiyorsa, gerekli coğrafi konumda proxy'ler sorunu çözer.
• Rate Limiting'i Aşma: Birçok hizmetin API'si, bir IP'den gelen istek sayısını sınırlar. Proxy döngüsü, yükü dağıtmayı sağlar.
• A/B Testi Reklamları: Rakip analizi için farklı bölgelerden reklamların görüntülenmesini kontrol etme.
• Pazar Yerlerini İzleme: Wildberries, Ozon, Avito'daki ürünlerin sıralamalarını, rakip fiyatlarını engellemeden izleme.

Lambda fonksiyonları genellikle zamanlama ile çalıştırılır (CloudWatch Events üzerinden) veya tetikleyicilere bağlıdır, bu da onları otomasyon için ideal bir araç haline getirir. Ancak, proxy olmadan bu tür görevler hedef kaynaklar tarafından hızla engellenir.

Lambda için Hangi Proxy Türünü Seçmelisiniz

Proxy türünün seçimi, Lambda fonksiyonunuzun çözdüğü göreve bağlıdır. Sunucusuz mimaride üç ana türü ve bunların kullanımını inceleyelim:

Seçim için Öneriler:

• Wildberries, Ozon, Avito'dan veri çekmek için: Rus coğrafi konumuna sahip yerel proxy'ler kullanın. Bu platformlar veri merkezi IP'lerini aktif olarak engellemektedir.
• Sıkı koruma olmayan API'leri izlemek için: Veri merkezi proxy'leri yeterlidir, daha ucuz ve daha hızlıdır.
• Instagram, Facebook, TikTok API ile çalışmak için: Sadece mobil veya yerel proxy'ler — bu platformlar veri merkezlerini tespit eder ve yasaklar.
• Cloudflare, PerimeterX'i aşmak için: Döngü ile yerel proxy'ler, tercihen sticky sessions (IP'yi 5-30 dakika koruma) ile.

Python'da (requests, urllib3) Lambda'da Proxy Ayarı

Python, Lambda fonksiyonları için en popüler dildir, özellikle veri çekme ve otomasyon görevleri için. %90 durumlarda kullanılan requests kütüphanesi ile proxy ayarını inceleyelim.

Temel HTTP Proxy Ayarı

Proxy'yi bağlamanın en basit yolu, proxies parametresini requests.get() metoduna iletmektir:

import requests
import os

def lambda_handler(event, context):
    # Proxy kimlik bilgilerini çevre değişkenlerinden alıyoruz
    proxy_host = os.environ['PROXY_HOST']  # Örneğin: proxy.example.com
    proxy_port = os.environ['PROXY_PORT']  # Örneğin: 8080
    proxy_user = os.environ['PROXY_USER']
    proxy_pass = os.environ['PROXY_PASS']
    
    # Yetkilendirme ile proxy URL'sini oluşturuyoruz
    proxy_url = f"http://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    try:
        # Proxy üzerinden istek yapıyoruz
        response = requests.get(
            'https://api.example.com/data',
            proxies=proxies,
            timeout=10  # Önemli! Zaman aşımını ayarlayın
        )
        
        return {
            'statusCode': 200,
            'body': response.text
        }
    
    except requests.exceptions.ProxyError as e:
        print(f"Proxy hatası: {e}")
        return {
            'statusCode': 500,
            'body': 'Proxy bağlantısı başarısız oldu'
        }
    
    except requests.exceptions.Timeout as e:
        print(f"Zaman aşımı hatası: {e}")
        return {
            'statusCode': 504,
            'body': 'İstek zaman aşımına uğradı'
        }

Bu kodun ana noktaları:

• Çevre Değişkenleri: Proxy kimlik bilgilerini asla doğrudan kodda saklamayın! Lambda ayarlarında Environment Variables kullanın.
• Zaman Aşımı: Zaman aşımını mutlaka ayarlayın (10-30 saniye). Aksi takdirde, Lambda maksimum çalışma süresi dolmadan takılabilir.
• Hata Yönetimi: Proxy'ler erişilemez veya yavaş olabilir — her zaman ProxyError ve Timeout istisnalarını yönetin.
• HTTP ve HTTPS: Kullanıyorsanız, proxies sözlüğünde her iki protokolü de belirtin, yalnızca HTTPS kullanıyorsanız bile.

SOCKS5 Proxy Ayarı

SOCKS5 proxy'ler daha yüksek bir anonimlik seviyesi sağlar ve TCP seviyesinde çalıştıkları için bazı koruma sistemleri tarafından tespit edilmezler. SOCKS5 ile çalışmak için requests kütüphanesine requests[socks] kütüphanesi eklenmelidir:

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']
    
    # Yetkilendirme ile SOCKS5 proxy
    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
        )
        
        # Verileri çekiyoruz
        return {
            'statusCode': 200,
            'body': response.text
        }
    
    except Exception as e:
        print(f"Hata: {e}")
        return {
            'statusCode': 500,
            'body': str(e)
        }

Lambda'da dağıtım için önemli: SOCKS5 kullanırken requirements.txt dosyasına ekleyin:

requests[socks]
PySocks

Proxy Üzerinden IP Kontrolü

Ana mantığı çalıştırmadan önce, proxy'nin çalıştığını ve gereken IP'yi döndürdüğünü kontrol etmek faydalıdır:

def check_proxy_ip(proxies):
    """Proxy üzerinden dış dünyanın gördüğü IP'yi kontrol eder"""
    try:
        response = requests.get(
            'https://api.ipify.org?format=json',
            proxies=proxies,
            timeout=10
        )
        ip_data = response.json()
        print(f"Proxy üzerinden mevcut IP: {ip_data['ip']}")
        return ip_data['ip']
    except Exception as e:
        print(f"Proxy kontrolü başarısız oldu: {e}")
        return None

def lambda_handler(event, context):
    # ... proxy ayarları ...
    
    # Ana işten önce IP'yi kontrol et
    current_ip = check_proxy_ip(proxies)
    if not current_ip:
        return {
            'statusCode': 500,
            'body': 'Proxy doğrulaması başarısız oldu'
        }
    
    # Veri çekme ana mantığı
    # ...

Node.js'de (axios, got) Lambda'da Proxy Ayarı

Node.js, özellikle API ile çalışırken yüksek performans gerektiğinde Lambda fonksiyonları için ikinci en popüler dildir. Proxy ayarını axios ve got kütüphaneleri ile inceleyelim.

Axios ile Ayar

Axios, Node.js için en popüler HTTP kütüphanesidir. Proxy ile çalışmak için ek bir paket olan https-proxy-agent gereklidir:

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

exports.handler = async (event) => {
    // Çevre değişkenlerinden kimlik bilgilerini alıyoruz
    const proxyHost = process.env.PROXY_HOST;
    const proxyPort = process.env.PROXY_PORT;
    const proxyUser = process.env.PROXY_USER;
    const proxyPass = process.env.PROXY_PASS;
    
    // Proxy URL'sini oluşturuyoruz
    const proxyUrl = `http://${proxyUser}:${proxyPass}@${proxyHost}:${proxyPort}`;
    
    // Proxy için bir ajan oluşturuyoruz
    const agent = new HttpsProxyAgent(proxyUrl);
    
    try {
        const response = await axios.get('https://api.example.com/data', {
            httpsAgent: agent,
            timeout: 10000  // 10 saniye
        });
        
        return {
            statusCode: 200,
            body: JSON.stringify(response.data)
        };
    } catch (error) {
        console.error('İstek başarısız oldu:', error.message);
        
        return {
            statusCode: 500,
            body: JSON.stringify({
                error: error.message
            })
        };
    }
};

Bağımlılıkların Kurulumu: package.json dosyasına ekleyin:

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

Axios ile SOCKS5 Ayarı

SOCKS5 proxy'ler için socks-proxy-agent paketini kullanın:

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('Hata:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

Alternatif: got Kütüphanesi

Got, proxy desteği ile modern bir HTTP kütüphanesidir (ayrı ajanlar gerektirmez):

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('Hata:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

Lambda'da Proxy Döngüsü: IP'yi Otomatik Olarak Nasıl Değiştirirsiniz

Proxy döngüsü, engellemeler olmadan çok sayıda istek yapmanız gereken görevler için kritik öneme sahiptir. İki ana yaklaşım vardır: otomatik döngü sağlayıcıları kullanmak veya proxy havuzunu manuel olarak yönetmek.

Sağlayıcı Üzerinden Otomatik Döngü

Çoğu yerel proxy sağlayıcısı (ProxyCove dahil) her istekte veya her N dakikada IP'nin otomatik olarak değiştiği bir uç nokta sağlar:

import requests
import os

def lambda_handler(event, context):
    # Otomatik döngü ile proxy
    # Format: rotating.proxy.com:port
    # Her istek = yeni IP
    proxy_url = f"http://{os.environ['PROXY_USER']}:{os.environ['PROXY_PASS']}@rotating.proxycove.com:8080"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    results = []
    
    # 10 istek yapıyoruz — her biri yeni IP ile
    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)
    }

Proxy Havuzundan Manuel Döngü

Eğer bir proxy listeniz varsa, döngüyü manuel olarak uygulayabilirsiniz. Bu, her istek için hangi proxy'nin kullanıldığını kontrol etmeniz gerektiğinde faydalıdır:

import requests
import random
import json

def lambda_handler(event, context):
    # Proxy havuzu (DynamoDB veya S3'te saklanabilir)
    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):
        # Havuzdan rastgele bir proxy seçiyoruz
        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)
    }

IP'yi Saklamak için Sticky Sessions

Bazı görevler, bir oturum boyunca tek bir IP'nin korunmasını gerektirir (örneğin, bir web sitesinde oturum açma). Proxy sağlayıcıları, URL'de bir parametre aracılığıyla sticky sessions sunar:

import requests
import uuid

def lambda_handler(event, context):
    # Benzersiz bir session_id oluşturuyoruz
    session_id = str(uuid.uuid4())
    
    # Sticky session ile proxy (IP 10 dakika korunur)
    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
    }
    
    # Bu Lambda'daki tüm istekler tek bir IP ile gerçekleştirilecektir
    # 1. Oturum açma
    login_response = requests.post(
        'https://example.com/login',
        data={'user': 'test', 'pass': 'test'},
        proxies=proxies
    )
    
    # 2. Veri alma (aynı IP kullanılır)
    data_response = requests.get(
        'https://example.com/dashboard',
        proxies=proxies,
        cookies=login_response.cookies
    )
    
    return {
        'statusCode': 200,
        'body': data_response.text
    }

Environment Variables ile Proxy Kimlik Bilgilerini Saklama

Proxy kimlik bilgilerini (kullanıcı adı, şifre, host) asla Lambda fonksiyonunun kodunda saklamayın. AWS, hassas verileri saklamak için birkaç güvenli yöntem sunar:

1. Environment Variables (Temel Yöntem)

AWS Lambda konsolunda → Yapılandırma → Çevre değişkenleri kısmına ekleyin:

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

AWS, çevre değişkenlerini dinlenme durumunda otomatik olarak şifreler. Koda erişim:

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

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

2. AWS Secrets Manager (Üretim için önerilir)

Maksimum güvenlik için AWS Secrets Manager kullanın — otomatik gizli döngü ve ayrıntılı erişim kontrolü sağlar:

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"Gizli bilgiyi alma hatası: {e}")
        raise e

def lambda_handler(event, context):
    # Secrets Manager'dan kimlik bilgilerini alıyoruz
    creds = get_proxy_credentials()
    
    proxy_url = f"http://{creds['user']}:{creds['password']}@{creds['host']}:{creds['port']}"
    
    # Proxy kullanımı
    # ...

Önemli: Lambda fonksiyonunun Secrets Manager'a erişim için IAM izinlerini eklemeyi unutmayın:

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

Yaygın Hatalar ve Çözümleri

Lambda'da proxy kullanırken geliştiriciler genellikle aynı sorunlarla karşılaşır. En yaygın olanları ve bunların nasıl çözüleceğini inceleyelim:

Hata: ProxyError / Bağlantı zaman aşımı

Çözüm:

# 1. Kimlik bilgilerini kontrol edin
print(f"Proxy kullanılıyor: {proxy_host}:{proxy_port}")
print(f"Kullanıcı: {proxy_user}")

# 2. Zaman aşımını artırın
response = requests.get(url, proxies=proxies, timeout=30)

# 3. Yeniden deneme mantığı ekleyin
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)

Hata: SSL Sertifika doğrulaması başarısız oldu

Çözüm (dikkatli kullanın!):

# SSL doğrulamasını devre dışı bırakma (yalnızca test için!)
response = requests.get(
    url,
    proxies=proxies,
    verify=False  # Üretimde kullanmayın!
)

# Daha iyi: CA sertifikasının yolunu belirtin
response = requests.get(
    url,
    proxies=proxies,
    verify='/path/to/ca-bundle.crt'
)

Hata: Lambda zaman aşımı (Görev X saniye sonra zaman aşımına uğradı)

Çözüm:

• Lambda fonksiyonunun zaman aşımını artırın: Yapılandırma → Genel yapılandırma → Zaman aşımı (maksimum 15 dakika)
• Tek bir çalıştırmada yapılan istek sayısını azaltın
• Asenkron istekler kullanın (Python'da asyncio, Node.js'de Promise.all)
• Önemli olmayan görevler için daha hızlı proxy'lere geçin

# Python: Hızı artırmak için asenkron istekler
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))

Hata: 407 Proxy Kimlik Doğrulaması Gerekiyor

Çözüm:

# Proxy URL formatını kontrol edin
# Doğru:
proxy_url = f"http://{user}:{password}@{host}:{port}"

# Yanlış (protokol atlandı):
proxy_url = f"{user}:{password}@{host}:{port}"  # ❌

# Eğer proxy IP kimlik doğrulaması gerektiriyorsa:
# 1. Lambda'nın dış IP'sini öğrenin (değişebilir!)
# 2. Bu IP'yi proxy sağlayıcısının beyaz listesini ekleyin
# 3. Kullanıcı:şifre olmadan proxy kullanın

# Lambda'nın dış IP'sini alma:
response = requests.get('https://api.ipify.org?format=json')
lambda_ip = response.json()['ip']
print(f"Lambda dış IP'si: {lambda_ip}")

Proxy ile Lambda Performansını Optimize Etme

Proxy kullanımı, her isteğe gecikme ekler. Performans üzerindeki etkisini en aza indirmek için işte kanıtlanmış yöntemler:

1. Bağlantı Havuzu

Her istek için yeni bir bağlantı oluşturmak yerine TCP bağlantılarını yeniden kullanın:

# Python: requests.get() yerine Session kullanın
import requests

# Session'ı bir kez oluşturun (handler'ın dışına alabilirsiniz)
session = requests.Session()
session.proxies = {
    'http': proxy_url,
    'https': proxy_url
}

def lambda_handler(event, context):
    # Tüm istekler bağlantıları yeniden kullanır
    for i in range(100):
        response = session.get(f'https://api.example.com/item/{i}')
        # yanıtı işleyin...

2. Paralel İstekler

Çok sayıda bağımsız istek yapmanız gerekiyorsa, bunları paralel olarak gerçekleştirin:

// Node.js: Promise.all ile paralel istekler
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}`
    );
    
    // Tüm istekler paralel olarak gerçekleştirilir
    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('Hata:', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

3. Sonuçların Önbelleğe Alınması

Veriler nadiren değişiyorsa, sonuçları DynamoDB veya S3'te önbelleğe alın:

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):
    """Önbellekten veri döndürür veya proxy üzerinden istek yapar"""
    
    # Önbelleği kontrol et
    try:
        response = table.get_item(Key={'url': url})
        if 'Item' in response:
            item = response['Item']
            if time.time() - item['timestamp'] < cache_ttl:
                print(f"{url} için önbellek bulundu")
                return item['data']
    except Exception as e:
        print(f"Önbellek hatası: {e}")
    
    # Önbellek boş veya süresi dolmuş — istek yap
    print(f"{url} için önbellek bulunamadı, alınıyor...")
    response = requests.get(url, proxies=proxies, timeout=10)
    data = response.text
    
    # Önbelleğe kaydet
    try:
        table.put_item(Item={
            'url': url,
            'data': data,
            'timestamp': int(time.time())
        })
    except Exception as e:
        print(f"Önbellek kaydetme hatası: {e}")
    
    return data

4. Doğru Proxy Türünü Seçme

Farklı proxy türlerinin gerçek koşullardaki hızlarını karşılaştırma:

Sonuç: Proxy kullanımı, Lambda fonksiyonlarının verimliliğini artırabilir, ancak doğru proxy türünü seçmek ve uygun ayarları yapmak önemlidir.