Brève analyse des solutions de résolution du dépassement du délai d'attente d'accès aux interfaces backend et API en PHP

[Accès HTTP]

Nous avons de nombreuses méthodes pour accéder à HTTP, principalement : curl, socket, file_get_contents() et d'autres méthodes.

Si le serveur de l'autre côté ne répond pas toujours, nous sommes dans une situation désastreuse, il est facile de tuer tout le serveur, donc il faut aussi envisager le problème de délai d'attente lors de l'accès à HTTP.

[Accès HTTP avec CURL]

CURL est une bibliothèque de librairies couramment utilisée pour accéder aux interfaces des protocoles HTTP, relativement fiable, avec des performances élevées et des fonctionnalités de support concurrentiel.

CURL:

curl_setopt($ch, opt) peut configurer divers paramètres de délai d'expiration, principalement :

*(Important) CURLOPT_TIMEOUT configure le temps maximum autorisé pour l'exécution de cURL en secondes.

*(Important) CURLOPT_TIMEOUT_MS configure le temps maximum autorisé pour l'exécution de cURL en millisecondes. (Dans cURL 7.16.2was added. From PHP 5.2.3disponible maintenant. )

CURLOPT_CONNECTTIMEOUT est le temps d'attente avant l'établissement de la connexion, si configuré à 0, l'attente est illimitée.

CURLOPT_CONNECTTIMEOUT_MS est le temps d'attente pour la tentative de connexion, en millisecondes. Si configuré à 0, l'attente est illimitée. Dans cURL 7.16.2was added. From PHP 5.2.3disponible à partir de maintenant.

CURLOPT_DNS_CACHE_TIMEOUT configure la durée de conservation des informations DNS en mémoire, la valeur par défaut est120 secondes.

Expiration en secondes pour curl :

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL,$url);

curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

curl_setopt($ch, CURLOPT_TIMEOUT, 60);　　 //Il suffit de définir un nombre de secondes pour configurer

curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

curl_setopt($ch, CURLOPT_USERAGENT, $defined_vars['HTTP_USER_AGENT']);

Utilisation de l'expiration en secondes pour curl :

curl_setopt($ch, CURLOPT_TIMEOUT, 60);

Pour que curl puisse effectuer une expiration en millisecondes, il est nécessaire d'ajouter :

curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);

ou :

curl_setopt ($ch, CURLOPT_NOSIGNAL, true); est compatible avec la configuration de l'expiration en millisecondes

Exemple d'une expiration en millisecondes pour curl :

<?php
if (!isset($_GET['foo'])) {
// Client
    $ch = curl_init('http://example.com/');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_NOSIGNAL, 1);  
//Attention, il est impératif de configurer cette valeur pour le délai d'expiration en millisecondes
    curl_setopt($ch, CURLOPT_TIMEOUT_MS, 200); 
//timeout in milliseconds, cURL 7.16.2was added. From PHP 5.2.3can be used
    $data = curl_exec($ch);
    $curl_errno = curl_errno($ch);
    $curl_error = curl_error($ch);
    curl_close($ch);
    if ($curl_errno > 0) {
        echo "cURL Error ($curl_errno): $curl_error\n";
    } else {
        echo "Data received: $data\n";
    }
} else {
// Server
    sleep(10);
    echo "Done.";
}
?>

Other tips:

1. Based on experience, it is summarized as: cURL version >= libcurl/7.21.0 version, millisecond timeouts are definitely effective, please note.

2. curl_multi's millisecond timeout also has issues... While single access supports ms-level timeouts, curl_multi parallel calls are not accurate

[Stream processing method to access HTTP]

In addition to curl, we often use fsockopen or file operation functions ourselves for HTTP protocol processing, so timeout handling in this area is also necessary.

Generally, connection timeouts can be set directly, but stream read timeouts require separate handling.

write your own code to handle:

$intUSGone = ($tmCurrent['sec'] - $tmStart['sec']) * 10
+ ($tmCurrent['usec'] - $tmStart['usec']);
if ($intUSGone > $this->_intReadTimeoutUS) {
return false;
}

or use built-in stream handling functions stream_set_timeout() and stream_get_meta_data() for processing:

<?php 
// Timeout in seconds 
$timeout = 5; 
$fp = fsockopen("example.com", 80, $errno, $errstr, $timeout); 
if ($fp) { 
    fwrite($fp, "GET"); / HTTP/1.0\r\n"); 
    fwrite($fp, "Host: example.com\r\n"); 
    fwrite($fp, "Connection: Close\r\n\r\n"); 
    stream_set_blocking($fp, true);  
//Important, définir le mode non bloquant
    stream_set_timeout($fp,$timeout);  
//Définir le délai d'attente
    $info = stream_get_meta_data($fp); 
    while ((!feof($fp)) && (!$info['timed_out'])) { 
        $data .= fgets($fp, 4096); 
        $info = stream_get_meta_data($fp); 
        ob_flush; 
        flush(); 
    } 
    if ($info['timed_out']) { 
        echo "Connection Timed Out!"; 
    } else { 
        echo $data; 
    } 
}

file_get_contents timeout :

<?php
$timeout = array(
  'http' => array(
    'timeout' => 5 
//Définir un délai d'attente, en secondes
  )
);
$ctx = stream_context_create($timeout);
$text = file_get_contents("http://example.com/", 0, $ctx);
?>

fopen timeout :

<?php
$timeout = array(
  'http' => array(
    'timeout' => 5 
//Définir un délai d'attente, en secondes
  )
);
$ctx = stream_context_create($timeout);
if ($fp = fopen("http://example.com/", "r", false, $ctx)) {
 while( $c = fread($fp, 8192)) {
  echo $c;
 }
 fclose($fp);
}
?>

Voici la totalité des solutions de résolution des problèmes de timeout après le traitement backend et l'accès aux interfaces PHP que l'éditeur vous présente. J'espère que vous soutiendrez fortement le tutoriel ~