Comment utiliser Nginx Keepalive

L'en-tête de requête du protocole http1.1 par défaut consiste à activer keepalive par défaut, comme indiqué dans l'image :

So qu'est-ce que Keepalive ? Quelle est la fonction ?

keepalive est un mécanisme dans TCP qui peut détecter les connexions mortes. Sa fonction est d'empêcher les connexions socket longues d'être déconnectées. C'est une fonction de la couche TCP et n'appartient pas à la couche TCP. couche applicative.

Comment la couche TCP maintient-elle une longue connexion ?

Regardons d'abord l'utilisation de keepalive : il y a trois paramètres, ouverts à la couche application

sk->keepalive_probes：探测次数，重试次数
sk->keepalive_time 探测的心跳间隔，tcp链接在多少秒之后没有数据报文传输启动探测报文
sk->keepalive_intvl 探测间隔，未收到回复时，重试的时间间隔

Vue de configuration par défaut :

[***@*** ~]$ cat /proc/sys/net/ipv4/tcp_keepalive_time
7200
[***@*** ~]$ cat /proc/sys/net/ipv4/tcp_keepalive_intvl
75
[***@*** ~]$ cat /proc/sys/net/ipv4/tcp_keepalive_probes
9

.

Méthode d'utilisation :

int keepalive = 1; // 开启keepalive属性
int keepidle = 60; // 如该连接在60秒内没有任何数据往来,则进行探测
int keepinterval = 5; // 探测时发包的时间间隔为5 秒
int keepcount = 3; // 探测尝试的次数。如果第1次探测包就收到响应了,则后2次的不再发。并且清零该计数
setsockopt(rs, sol_socket, so_keepalive, (void *)&keepalive , sizeof(keepalive ));
setsockopt(rs, sol_tcp, tcp_keepidle, (void*)&keepidle , sizeof(keepidle ));
setsockopt(rs, sol_tcp, tcp_keepintvl, (void *)&keepinterval , sizeof(keepinterval ));
setsockopt(rs, sol_tcp, tcp_keepcnt, (void *)&keepcount , sizeof(keepcount ));

Une fois la couche d'application définie comme ceci, la configuration par défaut sera écrasée et la configuration définie manuellement sera utilisée.

Pour une connexion TCP établie. S'il n'y a pas de transmission de paquets de données entre les deux parties dans le délai keepalive_time, l'extrémité qui active la fonction keepalive enverra un paquet de battements de cœur de données keepalive. Si aucune réponse n'est reçue, le paquet de données sera renvoyé à chaque fois keepalive_intvl et keepalive_probes. . Si aucune réponse n'est reçue, un premier paquet est envoyé pour fermer la connexion. Si une réponse est reçue, le minuteur est effacé.

Capturez le paquet pour vérifier le contenu du paquet TCP Heartbeat

Continuer vers analyser l'envoi keepalive en fonction de la capture du paquet et du contenu du paquet heartbeat envoyé :

Le code source de la structure d'en-tête TCP est :

typedef struct _tcp_header
{
 short m_ssourport;    　　　　　　// 源端口号16bit
 short m_sdestport;    　　　　　　 // 目的端口号16bit
 unsigned int m_uisequnum;    　　// req字段 序列号32bit
 unsigned int m_uiacknowledgenum; //ack字段 确认号32bit
 short m_sheaderlenandflag;   　　// 前4位：tcp头长度；中6位：保留；后6位：标志位
 short m_swindowsize;    　　　　　//win字段 窗口大小16bit
 short m_schecksum;    　　　　　 // 检验和16bit
 short m_surgentpointer;   　　　　 // 紧急数据偏移量16bit
}__attribute__((packed))tcp_header, *ptcp_header;

Regardez le contenu de le paquet de battements de cœur envoyé :

0000 d4 6d 50 f5 02 7f f4 5c  89 cb 35 29 08 00    //mac头 14字节：
                         45 00 // ip头 20字节 ：
0010 00 28 10 f4 00 00 40 06  5b dd ac 19 42 76 0a b3
0020 14 bd
      e4 4a 1f 7c 32 7e  7a cb 4c bc 55 08 50 10  // tcp头 20字节 
0030 10 00 3f 00 00 00
//分析tcp头部内容
e4 4a //源端口号16bit 10进制为：58442 
1f 7c //目的端口号16bit 10进制为 : 8060 
32 7e 7a cb // req字段 序列号32bit 10进制为 : 
4c bc 55 08 // ack字段 确认号32bit 
5 // 前4位：tcp头长度 5*4 =20 字节 没问题 
0 10 /// 中6位：保留；后6位：标志位 10 代表倒数第5位为1， 标识改tcp包为 ack 确认包 
0030 10 00 3f 00 00 00

Continuer à regarder Le contenu du paquet de battements de cœur de réponse :

0000 f4 5c 89 cb 35 29 d4 6d 50 f5 02 7f 08 00 45 00 
0010 00 34 47 28 40 00 36 06 ef 9c 0a b3 14 bd ac 19 
0020 42 76 // 前面数据不解读 
1f 7c
e4 4a
4c bc 55 08
32 7e 7a cc
8// tcp头长度为8 * 4 = 32 除了头部 还有 选项数据 12字节 
0 10  // 中6位：保留；后6位：标志位 10 代表倒数第5位为1， 标识该tcp包为 ack 确认包 
0030 01 3f //win字段 窗口大小16bit
4e 0d // 检验和16bit
00 00 // 紧急数据偏移量16bit
01 01 08 0a 00 59 be 1c 39 13 
0040 cf 12 // 选项数据 12字节

Comme le montre ce qui précède, le paquet de battements de cœur de TCP pour maintenir un long la connexion est que le navigateur envoie d'abord un paquet d'accusé de réception au serveur, puis le serveur répond avec un paquet d'accusé de réception, et avec l'option data

Comment nginx gérera-t-il la requête keepalive et que fera ça fait ?

首先做的是版本判断 ：http协议版本低于1.1时，该链接的keepalive置为0
if (r->http_version < ngx_http_version_11) {
  r->keepalive = 0;
} 
ngx_http_process_connection 函数中 ngx_http_request_t 中带有keep-alive则把改链接标识起来 
if (ngx_strcasestrn(h->value.data, "keep-alive", 10 - 1)) {
  r->headers_in.connection_type = ngx_http_connection_keep_alive;
}
ngx_http_handler函数中对r->headers_in.connection_type 判断，给r->keepalive赋值为1
  switch (r->headers_in.connection_type) {
  case ngx_http_connection_keep_alive:
    r->keepalive = 1;
    break;
  }
ngx_configure_listening_sockets函数中，当keepalive为1时，对该连接开启keepalive，之后tcp底层就会对该连接fd做检测死连接的机制，保持长连接，不断开。
if (ls[i].keepalive) {
  value = (ls[i].keepalive == 1) ? 1 : 0;

  if (setsockopt(ls[i].fd, sol_socket, so_keepalive,//开启keepalive功能
          (const void *) &value, sizeof(int))
    == -1)
  
}

nginx Quand la longue connexion sera-t-elle déconnectée ?

Après que nginx ait activé keepalive via setsockopt(ls[i].fd, sol_socket, so_keepalive,(const void *) &value, sizeof(int)), il restera toujours avec le client Connexion longue, cela entraînera un problème très grave. Le nombre de connexions que chaque travailleur peut maintenir est limité (ep = epoll_create(cycle->connection_n / 2); cycle->connection_n / 2 est ce qu'epoll peut gérer fd limite supérieure), par conséquent, le nombre de connexions sera rapidement épuisé. Comment nginx devrait-il gérer cela ?

Afin de trouver cette réponse, examinons les deux paramètres de configuration de nginx à propos de keeoalive

keepalive_timeout

keepalive_timeout timeout [header_timeout];

Le premier paramètre : Set keep- The valeur du délai d'attente pour que la connexion client active reste ouverte côté serveur (par défaut 75 s) ; une valeur de 0 désactivera la connexion client persistante ;

Le deuxième paramètre : facultatif, dans le champ d'en-tête ; de la réponse Définissez une valeur "keep-alive: timeout=time" ; généralement, vous n'avez pas besoin de la définir

Remarque : keepalive_timeout est par défaut de 75 s

keepalive_requests# ; 🎜🎜#

keepalive_requests La directive est utilisée pour définir le nombre maximum de requêtes pouvant être servies sur une connexion keep-alive. Lorsque le nombre maximum de requêtes est atteint, la connexion est également fermée. désactiver les connexions client persistantes ;. La valeur par défaut est 100.

La réponse est évidente, gérer les connexions longues via keepalive_timeout keepalive_requests,

• Lorsqu'une connexion TCP survit plus longtemps que keepalive_timeout, elle sera fermée, l'implémentation spécifique de nginx, cela se fait via une minuterie

• Lorsque le nombre maximum de lettres d'amour dans une connexion TCP dépasse keepalive_requests, elle sera également fermée

  #🎜🎜 ##🎜 🎜#

  Utilisez ces deux mécanismes pour vous assurer que le nombre de connexions pour chaque travailleur ne dépassera pas le nombre qu'epoll peut gérer.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!