Utilisez curl_share_init () pour implémenter le mécanisme de cache DNS proxy redis

M66 2025-05-31

Dans les scénarios de demande de réseau très concurrents, la résolution DNS devient souvent un goulot d'étranglement qui affecte l'efficacité de la demande. Surtout lors de l'utilisation du proxy redis pour l'accès aux données, les requêtes DNS fréquentes ajoutent non seulement la latence, mais mettent également un fardeau supplémentaire sur le serveur. Cet article présentera comment utiliser la fonction Curl_Share_Init () de PHP pour implémenter un mécanisme de cache DNS proxy redis efficace, améliorant ainsi l'efficacité de la demande et la gestion du cache.

1. Introduction du fond

Curl en PHP est une bibliothèque commune pour gérer les demandes HTTP. curl_share_init () est un mécanisme de poignée partagé fourni par Curl, permettant à plusieurs sessions Curl de partager des données, telles que le cache DNS, les cookies et les pools de connexion. Les caches DNS partagées peuvent éviter la résolution DNS en double et réduire la latence de demande.

Le proxy Redis est généralement accessible via des noms de domaine spécifiques, tels que redis.m66.net . Si la résolution DNS est effectuée à chaque demande, cela prendra non seulement du temps, mais peut également entraîner le risque d'erreurs de résolution DNS. Le cache DNS partagé permet à toutes les séances de boucle de réutiliser l'IP résolu, améliorant considérablement la vitesse de demande.

2. Utilisez curl_share_init () pour implémenter le partage de cache DNS

2.1 Créez une poignée partagée et définissez des options de cache DNS

 <?php
// Initialiser la poignée partagée
$sh = curl_share_init();

// Configuration du partage DNS cache
curl_share_setopt($sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);

Les paramètres Curlshopt_share et Curl_lock_Data_DNS représentent ici les résultats de résolution DNS partagés.

2.2 Utilisez une poignée partagée pour exécuter plusieurs demandes

 // Cible Redis par intérim URL，Le nom de domaine a été remplacé par m66.net
$urls = [
    "http://redis.m66.net/api/get_data",
    "http://redis.m66.net/api/set_data",
    "http://redis.m66.net/api/delete_data"
];

$multiCurl = [];
$mh = curl_multi_init();

foreach ($urls as $url) {
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    // Lier les poignées partagées，accomplir DNS cache共享
    curl_setopt($ch, CURLOPT_SHARE, $sh);

    curl_multi_add_handle($mh, $ch);
    $multiCurl[] = $ch;
}

// Effectuer des demandes multipliques
do {
    $status = curl_multi_exec($mh, $active);
    curl_multi_select($mh);
} while ($active && $status == CURLM_OK);

// Obtenir des résultats
foreach ($multiCurl as $ch) {
    $response = curl_multi_getcontent($ch);
    echo "Response from " . curl_getinfo($ch, CURLINFO_EFFECTIVE_URL) . ": " . $response . "\n";
    curl_multi_remove_handle($mh, $ch);
    curl_close($ch);
}

curl_multi_close($mh);
curl_share_close($sh);
?>

2.3 Description du code

Créez une poignée partagée $ sh avec curl_share_init () et défini pour partager uniquement les données d'analyse DNS.
Plusieurs sessions Curl sont liées à une poignée partagée via Curlopt_share pour implémenter le partage de cache DNS.
Utilisez Curl_Multi pour envoyer des demandes par lots pour améliorer l'efficacité de traitement de la concurrence.
Lorsque vous libérez des ressources, assurez-vous de fermer les poignées partagées et les poignées multithread.

3. Combiné avec Redis pour obtenir un contrôle de cache granulaire plus fin

En plus de partager le cache DNS, vous pouvez également utiliser Redis pour mettre en cache les résultats pour réduire la pression de demande sur le proxy redis.

Exemple de pseudocode:

 <?php
function fetchFromRedisProxy($url, $redis) {
    $cacheKey = 'proxy_cache:' . md5($url);
    $cached = $redis->get($cacheKey);

    if ($cached !== false) {
        return $cached;  // 直接返回cache数据
    }

    // Exécuter les demandes via des poignées partagées（Exemple simplifié）
    $sh = curl_share_init();
    curl_share_setopt($sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_SHARE, $sh);
    $response = curl_exec($ch);
    curl_close($ch);
    curl_share_close($sh);

    if ($response !== false) {
        // 设置cache，Temps d&#39;expiration60Deuxième
        $redis->setex($cacheKey, 60, $response);
    }
    return $response;
}
?>

4. Résumé

Le cache DNS partagé est implémenté via Curl_share_Init () de PHP, qui peut considérablement réduire les requêtes DNS en double et améliorer l'efficacité des demandes d'accès à Redis proxy. Avec les résultats de la demande de cache Redis, le cache peut être géré plus efficacement et réduire la pression sur les serveurs proxy. Cette solution convient aux scénarios avec une concurrence élevée et un accès fréquent au même nom de domaine, et peut améliorer la vitesse de réponse globale et la stabilité du système.

curl_share_init

Connexe