Comment configurer un proxy dans AWS Lambda pour le scraping et les API : guide complet avec des exemples

AWS Lambda est une plateforme sans serveur qui permet d'exécuter du code sans gérer de serveurs. Cependant, lors du scraping de sites, des API de marketplaces ou de l'automatisation de tâches, un problème se pose souvent : les fonctions Lambda utilisent des adresses IP AWS, qui sont facilement détectables et bloquées. Dans ce guide, nous allons voir comment intégrer un proxy dans Lambda, configurer la rotation IP et éviter les erreurs courantes.

Cet article s'adresse aux développeurs qui automatisent des tâches via AWS Lambda : scraping de données à partir de sites protégés, surveillance des prix des concurrents, travail avec les API des réseaux sociaux ou des marketplaces. Vous obtiendrez des exemples de code prêts à l'emploi en Python et Node.js, que vous pourrez utiliser immédiatement après la lecture.

Pourquoi utiliser des proxies dans AWS Lambda

Par défaut, AWS Lambda utilise des adresses IP provenant du pool d'Amazon Web Services. Ces adresses figurent dans des listes publiques et sont facilement identifiables par les systèmes de protection contre les bots. Voici les principaux scénarios où les proxies deviennent nécessaires :

Principales raisons d'utiliser des proxies dans Lambda :

• Scraping de sites protégés : De nombreux sites bloquent les requêtes provenant des IP des centres de données AWS. Les proxies permettent de masquer Lambda en tant qu'utilisateurs ordinaires.
• Restrictions géolocalisées : Si vous devez obtenir des données d'un site accessible uniquement depuis un pays spécifique (par exemple, les prix régionaux sur Ozon), des proxies avec la géolocalisation requise résolvent le problème.
• Contourner la limitation de taux : Les API de nombreux services limitent le nombre de requêtes par IP. La rotation des proxies permet de répartir la charge.
• Tests A/B de publicités : Vérification de l'affichage des annonces publicitaires depuis différentes régions pour analyser les concurrents.
• Surveillance des marketplaces : Suivi des positions des produits, des prix des concurrents sur Wildberries, Ozon, Avito sans blocages.

Les fonctions Lambda sont souvent déclenchées par un calendrier (via CloudWatch Events) ou des déclencheurs, ce qui en fait un outil idéal pour l'automatisation. Cependant, sans proxies, ces tâches se heurtent rapidement à des blocages de la part des ressources cibles.

Quel type de proxy choisir pour Lambda

Le choix du type de proxy dépend de la tâche que votre fonction Lambda doit accomplir. Examinons trois types principaux et leur utilisation dans une architecture sans serveur :

Recommandations pour le choix :

• Pour le scraping de Wildberries, Ozon, Avito : Utilisez des proxies résidentiels avec une géolocalisation russe. Ces plateformes bloquent activement les IP des centres de données.
• Pour la surveillance d'API sans protection stricte : Les proxies de centres de données suffisent, ils sont moins chers et plus rapides.
• Pour travailler avec les API Instagram, Facebook, TikTok : Utilisez uniquement des proxies mobiles ou résidentiels — ces plateformes détectent et bannissent les centres de données.
• Pour contourner Cloudflare, PerimeterX : Proxies résidentiels avec rotation, de préférence avec des sessions collantes (conservation de l'IP pendant 5-30 minutes).

Configuration du proxy dans Lambda avec Python (requests, urllib3)

Python est le langage le plus populaire pour les fonctions Lambda, en particulier pour les tâches de scraping et d'automatisation. Examinons la configuration du proxy avec la bibliothèque requests, qui est utilisée dans 90 % des cas.

Configuration de base du proxy HTTP

La manière la plus simple de connecter un proxy est de passer le paramètre proxies dans la méthode requests.get() :

import requests
import os

def lambda_handler(event, context):
    # Obtenez les identifiants du proxy à partir des variables d'environnement
    proxy_host = os.environ['PROXY_HOST']  # Par exemple : proxy.example.com
    proxy_port = os.environ['PROXY_PORT']  # Par exemple : 8080
    proxy_user = os.environ['PROXY_USER']
    proxy_pass = os.environ['PROXY_PASS']
    
    # Formez l'URL du proxy avec authentification
    proxy_url = f"http://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}"
    
    proxies = {
        'http': proxy_url,
        'https': proxy_url
    }
    
    try:
        # Faites une requête via le proxy
        response = requests.get(
            'https://api.example.com/data',
            proxies=proxies,
            timeout=10  # Important ! Définissez un délai d'attente
        )
        
        return {
            'statusCode': 200,
            'body': response.text
        }
    
    except requests.exceptions.ProxyError as e:
        print(f"Erreur de proxy : {e}")
        return {
            'statusCode': 500,
            'body': 'Échec de la connexion au proxy'
        }
    
    except requests.exceptions.Timeout as e:
        print(f"Erreur de délai d'attente : {e}")
        return {
            'statusCode': 504,
            'body': 'Délai d\'attente de la requête'
        }

Points clés de ce code :

• Variables d'environnement : Ne stockez jamais les identifiants du proxy directement dans le code ! Utilisez les variables d'environnement dans les paramètres de Lambda.
• Délai d'attente : Assurez-vous de définir un délai d'attente (10-30 secondes). Sans cela, Lambda peut se bloquer jusqu'à l'expiration du temps d'exécution maximum.
• Gestion des erreurs : Les proxies peuvent être inaccessibles ou lents — traitez toujours les exceptions ProxyError et Timeout.
• HTTP et HTTPS : Indiquez les deux protocoles dans le dictionnaire proxies, même si vous utilisez uniquement HTTPS.

Configuration du proxy SOCKS5

Les proxies SOCKS5 offrent un niveau d'anonymat plus élevé et fonctionnent au niveau TCP, ce qui les rend invisibles pour certains systèmes de protection. Pour travailler avec SOCKS5 dans requests, vous aurez besoin de la bibliothèque 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 avec authentification
    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
        )
        
        # Scrape les données
        return {
            'statusCode': 200,
            'body': response.text
        }
    
    except Exception as e:
        print(f"Erreur : {e}")
        return {
            'statusCode': 500,
            'body': str(e)
        }

Important pour le déploiement dans Lambda : Lors de l'utilisation de SOCKS5, ajoutez dans requirements.txt :

requests[socks]
PySocks

Vérification de l'IP via le proxy

Avant de lancer la logique principale, il est utile de vérifier que le proxy fonctionne et renvoie l'IP souhaitée :

def check_proxy_ip(proxies):
    """Vérifie l'IP que le monde extérieur voit via le proxy"""
    try:
        response = requests.get(
            'https://api.ipify.org?format=json',
            proxies=proxies,
            timeout=10
        )
        ip_data = response.json()
        print(f"IP actuelle via le proxy : {ip_data['ip']}")
        return ip_data['ip']
    except Exception as e:
        print(f"Vérification du proxy échouée : {e}")
        return None

def lambda_handler(event, context):
    # ... configuration du proxy ...
    
    # Vérifions l'IP avant le travail principal
    current_ip = check_proxy_ip(proxies)
    if not current_ip:
        return {
            'statusCode': 500,
            'body': 'Échec de la vérification du proxy'
        }
    
    # Logique principale de scraping
    # ...

Configuration du proxy dans Lambda avec Node.js (axios, got)

Node.js est le deuxième langage le plus populaire pour les fonctions Lambda, surtout lorsque des performances élevées sont nécessaires lors de l'utilisation d'API. Examinons la configuration du proxy avec les bibliothèques axios et got.

Configuration avec axios

Axios est la bibliothèque HTTP la plus populaire pour Node.js. Pour travailler avec des proxies, vous aurez besoin d'un package supplémentaire https-proxy-agent :

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

exports.handler = async (event) => {
    // Obtenez les identifiants à partir des variables d'environnement
    const proxyHost = process.env.PROXY_HOST;
    const proxyPort = process.env.PROXY_PORT;
    const proxyUser = process.env.PROXY_USER;
    const proxyPass = process.env.PROXY_PASS;
    
    // Formez l'URL du proxy
    const proxyUrl = `http://${proxyUser}:${proxyPass}@${proxyHost}:${proxyPort}`;
    
    // Créez un agent pour le proxy
    const agent = new HttpsProxyAgent(proxyUrl);
    
    try {
        const response = await axios.get('https://api.example.com/data', {
            httpsAgent: agent,
            timeout: 10000  // 10 secondes
        });
        
        return {
            statusCode: 200,
            body: JSON.stringify(response.data)
        };
    } catch (error) {
        console.error('La requête a échoué :', error.message);
        
        return {
            statusCode: 500,
            body: JSON.stringify({
                error: error.message
            })
        };
    }
};

Installation des dépendances : Ajoutez dans package.json :

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

Configuration SOCKS5 avec axios

Pour les proxies SOCKS5, utilisez le package 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('Erreur :', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

Alternative : bibliothèque got

Got est une bibliothèque HTTP moderne avec un support natif pour les proxies (ne nécessite pas d'agents séparés) :

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

Rotation des proxies dans Lambda : comment changer d'IP automatiquement

La rotation des proxies est cruciale pour les tâches où il faut faire de nombreuses requêtes sans blocages. Il existe deux approches principales : utiliser des services de proxy avec rotation automatique ou gérer manuellement un pool de proxies.

Rotation automatique via le fournisseur

La plupart des fournisseurs de proxies résidentiels (y compris ProxyCove) fournissent un point de terminaison avec rotation automatique — chaque requête ou toutes les N minutes, l'IP change automatiquement :

import requests
import os

def lambda_handler(event, context):
    # Proxy avec rotation automatique
    # Format : rotating.proxy.com:port
    # Chaque requête = nouvelle 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 = []
    
    # Faites 10 requêtes — chacune avec une nouvelle IP
    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)
    }

Rotation manuelle depuis le pool de proxies

Si vous avez une liste de proxies, vous pouvez implémenter la rotation manuellement. Cela est utile lorsque vous avez besoin de contrôler quel proxy est utilisé pour chaque requête :

import requests
import random
import json

def lambda_handler(event, context):
    # Liste de proxies (peut être stockée dans DynamoDB ou 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):
        # Choisissez un proxy aléatoire du pool
        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)
    }

Sessions collantes pour conserver l'IP

Certaines tâches nécessitent de conserver une même IP pendant toute la session (par exemple, l'authentification sur un site). Les fournisseurs de proxies proposent des sessions collantes via un paramètre dans l'URL :

import requests
import uuid

def lambda_handler(event, context):
    # Générer un session_id unique
    session_id = str(uuid.uuid4())
    
    # Proxy avec session collante (IP conservée pendant 10 minutes)
    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
    }
    
    # Toutes les requêtes dans ce Lambda s'exécuteront avec une même IP
    # 1. Authentification
    login_response = requests.post(
        'https://example.com/login',
        data={'user': 'test', 'pass': 'test'},
        proxies=proxies
    )
    
    # 2. Récupération des données (la même IP est utilisée)
    data_response = requests.get(
        'https://example.com/dashboard',
        proxies=proxies,
        cookies=login_response.cookies
    )
    
    return {
        'statusCode': 200,
        'body': data_response.text
    }

Stockage des identifiants du proxy via les variables d'environnement

Ne stockez jamais les identifiants du proxy (login, mot de passe, hôte) directement dans le code de la fonction Lambda. AWS propose plusieurs moyens sécurisés de stocker des données sensibles :

1. Variables d'environnement (méthode de base)

Dans la console AWS Lambda → Configuration → Variables d'environnement, ajoutez :

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

AWS chiffre automatiquement les variables d'environnement au repos. Accédez-y dans le code :

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

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

2. AWS Secrets Manager (recommandé pour la production)

Pour une sécurité maximale, utilisez AWS Secrets Manager — il assure la rotation automatique des secrets et un contrôle d'accès détaillé :

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"Erreur lors de la récupération du secret : {e}")
        raise e

def lambda_handler(event, context):
    # Obtenez les identifiants à partir de Secrets Manager
    creds = get_proxy_credentials()
    
    proxy_url = f"http://{creds['user']}:{creds['password']}@{creds['host']}:{creds['port']}"
    
    # Utilisez le proxy
    # ...

Important : N'oubliez pas d'ajouter les droits IAM à la fonction Lambda pour accéder à Secrets Manager :

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

Erreurs courantes et leurs solutions

Lors de l'utilisation de proxies dans Lambda, les développeurs rencontrent souvent les mêmes problèmes. Examinons les plus courants et comment les résoudre :

Erreur : ProxyError / Délai d'attente de connexion

Solution :

# 1. Vérifiez les identifiants
print(f"Utilisation du proxy : {proxy_host}:{proxy_port}")
print(f"Utilisateur : {proxy_user}")

# 2. Augmentez le délai d'attente
response = requests.get(url, proxies=proxies, timeout=30)

# 3. Ajoutez une logique de réessai
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)

Erreur : Vérification du certificat SSL échouée

Solution (à utiliser avec précaution !) :

# Désactiver la vérification SSL (uniquement pour les tests !)
response = requests.get(
    url,
    proxies=proxies,
    verify=False  # NE PAS utiliser en production !
)

# Mieux : indiquez le chemin vers le certificat CA
response = requests.get(
    url,
    proxies=proxies,
    verify='/path/to/ca-bundle.crt'
)

Erreur : Délai d'attente de Lambda (Tâche expirée après X secondes)

Solution :

• Augmentez le délai d'attente de la fonction Lambda : Configuration → Configuration générale → Délai d'attente (maximum 15 minutes)
• Réduisez le nombre de requêtes par exécution
• Utilisez des requêtes asynchrones (asyncio en Python, Promise.all en Node.js)
• Changez pour des proxies plus rapides pour les tâches non critiques

# Python : requêtes asynchrones pour accélérer
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))

Erreur : 407 Authentification Proxy Requise

Solution :

# Vérifiez le format de l'URL du proxy
# Correct :
proxy_url = f"http://{user}:{password}@{host}:{port}"

# Incorrect (protocole omis) :
proxy_url = f"{user}:{password}@{host}:{port}"  # ❌

# Si le proxy exige une authentification par IP :
# 1. Découvrez l'IP externe de votre Lambda (peut changer !)
# 2. Ajoutez cette IP à la liste blanche du fournisseur de proxy
# 3. Utilisez le proxy sans user:pass

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

Optimisation des performances de Lambda avec des proxies

L'utilisation de proxies ajoute un délai à chaque requête. Voici des moyens éprouvés de minimiser l'impact sur les performances :

1. Pooling de connexions

Réutilisez les connexions TCP au lieu de créer une nouvelle pour chaque requête :

# Python : utilisez Session au lieu de requests.get()
import requests

# Créez une session une fois (peut être déplacée en dehors du handler)
session = requests.Session()
session.proxies = {
    'http': proxy_url,
    'https': proxy_url
}

def lambda_handler(event, context):
    # Toutes les requêtes réutilisent les connexions
    for i in range(100):
        response = session.get(f'https://api.example.com/item/{i}')
        # traiter la réponse...

2. Requêtes parallèles

Si vous devez faire de nombreuses requêtes indépendantes, exécutez-les en parallèle :

// Node.js : requêtes parallèles avec 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}`
    );
    
    // Toutes les requêtes sont exécutées en parallèle
    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('Erreur :', error.message);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

3. Mise en cache des résultats

Si les données changent rarement, mettez en cache les résultats dans DynamoDB ou 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):
    """Retourne les données du cache ou fait une requête via le proxy"""
    
    # Vérifiez le 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 pour {url}")
                return item['data']
    except Exception as e:
        print(f"Erreur de cache : {e}")
    
    # Le cache est vide ou obsolète — faites une requête
    print(f"Cache miss pour {url}, récupération...")
    response = requests.get(url, proxies=proxies, timeout=10)
    data = response.text
    
    # Sauvegardez dans le cache
    try:
        table.put_item(Item={
            'url': url,
            'data': data,
            'timestamp': int(time.time())
        })
    except Exception as e:
        print(f"Erreur de sauvegarde du cache : {e}")
    
    return data

4. Choix du bon type de proxy

Comparaison de la vitesse des différents types de proxies dans des conditions réelles :

Conclusion : Choisir le bon type de proxy est essentiel pour garantir des performances optimales lors de l'utilisation de AWS Lambda. En tenant compte des besoins spécifiques de votre projet, vous pouvez maximiser l'efficacité de vos tâches automatisées tout en évitant les blocages et les limitations.