Préface
Il est bien connu que Linux ne prend pas bien en charge la haute concurrence avec les paramètres par défaut, qui sont principalement limités par le nombre maximum de fichiers ouverts dans un seul processus, les paramètres TCP du noyau et le mécanisme d'allocation d'événements IO. Les ajustements suivants seront effectués à partir de plusieurs aspects pour permettre au système Linux de prendre en charge un environnement à haute concurrence.
1. Iptables liés
Si cela n'est pas nécessaire, désactivez ou désinstallez le pare-feu iptables et empêchez le noyau de charger le module iptables. Ces modules affecteront les performances simultanées.
2. Nombre maximum de fichiers ouverts en un seul processus
La version générale limite le nombre maximal de 1 024 fichiers pouvant être ouverts par un seul processus, ce qui est loin de répondre aux exigences élevées de concurrence. Le processus d'ajustement est le suivant:
Tapez l'invite #:
# ulimit–n 65535
Définissez le nombre maximum de fichiers pouvant être ouverts pour un seul processus démarré par root sur 65535. Si le système fait écho à quelque chose comme "Operationnotpermitted", cela signifie que la modification de restriction ci-dessus a échoué, en fait, c'est parce que la valeur spécifiée dans dépasse la limite souple ou stricte du nombre de fichiers ouverts par le système Linux pour l'utilisateur. Par conséquent, il est nécessaire de modifier les limites souples et strictes du système Linux sur le nombre de fichiers ouverts.
La première étape consiste à modifier le fichier limits.conf et à ajouter:
# vim /etc/security/limits.conf
* softnofile 65536
* hard nofile65536
Parmi eux, le signe '*' signifie modifier la limite de tous les utilisateurs; soft ou hard spécifie s'il faut modifier la limite souple ou la limite dure; 65536 spécifie la nouvelle valeur limite que vous souhaitez modifier, c'est-à-dire le nombre maximum des fichiers ouverts (veuillez noter que la valeur de la limite souple doit être inférieure à Ou égale à la limite stricte). Enregistrez le fichier après modification.
La deuxième étape consiste à modifier le fichier /etc/pam.d/login et à ajouter la ligne suivante au fichier:
vim /etc/pam.d/login
sessionrequired /lib/security/pam_limits.so
Cela indique à Linux qu'une fois que l'utilisateur a terminé la connexion au système, le module pam_limits.so doit être appelé pour définir la limite maximale du système sur le nombre de ressources que l'utilisateur peut utiliser (y compris le nombre maximum de fichiers que l'utilisateur peut ouvrir), et le module pam_limits.so Il lira la configuration depuis le fichier /etc/security/limits.conf pour définir ces limites. Enregistrez ce fichier après modification.
La troisième étape consiste à vérifier le nombre maximum de fichiers ouverts au niveau du système Linux et à utiliser la commande suivante:
cat/proc/sys/fs/file-max
32568
Cela montre que ce système Linux permet d'ouvrir jusqu'à 32568 fichiers en même temps (c'est-à-dire, y compris le nombre total de fichiers ouverts par tous les utilisateurs), qui est une limite stricte au niveau du système Linux, et la limite du nombre des fichiers ouverts à tous les niveaux utilisateur ne doivent pas dépasser cette valeur. Habituellement, cette limite stricte au niveau du système est le nombre maximal optimal de fichiers ouverts en même temps calculé en fonction de l'état des ressources matérielles du système au démarrage du système Linux. S'il n'y a pas de besoin particulier, cette limite ne doit pas être modifiée sauf si vous le souhaitez pour limiter le nombre de fichiers ouverts pour le niveau utilisateur. Définissez une valeur qui dépasse cette limite. La façon de modifier cette limite stricte est de modifier fs.file-max = 131072 dans le fichier /etc/sysctl.conf
Cela permet à Linux de définir de force la limite stricte au niveau du système sur le nombre de fichiers ouverts à 131072 une fois le démarrage terminé. Enregistrez ce fichier après modification.
Après avoir effectué les étapes ci-dessus, redémarrez le système. Dans des circonstances normales, vous pouvez définir le nombre maximum de fichiers que le système Linux autorise pour un seul processus d'un utilisateur spécifié à ouvrir en même temps à la valeur spécifiée. Si vous utilisez la commande ulimit-n pour afficher la limite du nombre de fichiers qui peuvent être ouverts par l'utilisateur après le redémarrage, elle est toujours inférieure à la valeur maximale définie dans les étapes ci-dessus, cela peut être dû au fait que la commande ulimit-n dans le script de connexion de l'utilisateur / etc / profile a déjà ouvert l'utilisateur en même temps Le nombre de fichiers est limité. Parce que lorsque le système limite le nombre maximum de fichiers que les utilisateurs peuvent ouvrir en même temps via ulimit-n, la valeur nouvellement modifiée ne peut être inférieure ou égale à la valeur définie par ulimit-n la dernière fois, il est donc impossible de augmentez cette valeur limite avec cette commande de. Par conséquent, si les problèmes ci-dessus existent, vous ne pouvez ouvrir que le fichier de script / etc / profile, recherchez dans le fichier si ulimit-n est utilisé pour limiter le nombre maximum de fichiers que l'utilisateur peut ouvrir en même temps, s'il est trouvé, supprimez cette commande, ou modifiez sa valeur définie par une valeur appropriée, puis enregistrez le fichier et l'utilisateur peut se déconnecter et se reconnecter au système.
Grâce aux étapes ci-dessus, la limite du système sur le nombre de fichiers ouverts est levée pour le programme de traitement de communication qui prend en charge le traitement de connexion TCP simultanée élevé.
3. Paramètres TCP du noyau
Sous Linux, une fois la connexion TCP déconnectée, elle restera dans l'état TIME_WAIT pendant un certain temps avant de libérer le port. Lorsqu'il y a trop de demandes simultanées, un grand nombre de connexions dans l'état TIME_WAIT sera généré. Si elles ne peuvent pas être déconnectées à temps, une grande quantité de ressources de port et de ressources serveur sera occupée. À ce stade, nous pouvons optimiser les paramètres du noyau TCP pour effacer les ports dans l'état TIME_WAIT dans le temps.
La méthode décrite ci-dessous n'est efficace que pour la consommation de ressources système causée par des connexions avec un grand nombre d'états TIME_WAIT. Si ce n'est pas le cas, l'effet peut ne pas être évident. Vous pouvez utiliser la commande netstat pour vérifier l'état de connexion de l'état TIME_WAIT, entrez la commande combinée suivante,
Affichez l'état de la connexion TCP actuelle et le nombre de connexions correspondant:
# netstat-n | awk ‘/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}’
#这个命令会输出类似下面的结果：
LAST_ACK16
SYN_RECV348
ESTABLISHED70
FIN_WAIT1229
FIN_WAIT230
CLOSING33
TIME_WAIT18098
Nous devons seulement nous soucier du nombre de TIME_WAIT, comme vous pouvez le voir ici, il y a plus de 18 000 TIME_WAIT, donc plus de 18 000 ports sont occupés. Il est important de savoir que le nombre de ports n'est que de 65 535, occupant un de moins d'un, cela affectera sérieusement les nouvelles connexions ultérieures. Dans ce cas, il est nécessaire d'ajuster les paramètres du noyau TCP de Linux pour permettre au système de libérer la connexion TIME_WAIT plus rapidement.
Editez le fichier de configuration: /etc/sysctl.conf, dans ce fichier, ajoutez les lignes suivantes:
vim /etc/sysctl.conf
net.ipv4.tcp_syncookies= 1#表示开启SYNCookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；
net.ipv4.tcp_tw_reuse= 1#表示开启重用。允许将TIME-WAITsockets重新用于新的TCP连接，默认为0，表示关闭；
net.ipv4.tcp_tw_recycle= 1#表示开启TCP连接中TIME-WAITsockets的快速回收，默认为0，表示关闭；
net.ipv4.tcp_fin_timeout= 30#修改系統默认的TIMEOUT 时间。
#输入下面的命令，让内核参数生效：
sysctl-p
Après de tels ajustements, en plus d'augmenter encore la capacité de charge du serveur, il peut également se défendre contre les attaques DoS, CC et SYN avec de faibles niveaux de trafic.
De plus, si vous avez beaucoup de connexions, nous pouvons optimiser la plage de ports TCP pour améliorer encore la concurrence du serveur. Ajoutez toujours la configuration suivante au fichier de paramètres ci-dessus:
net.ipv4.tcp_keepalive_time= 1200#表示当keepalive起用的时候，TCP发送keepalive消息的频度。缺省是2小时，改为20分钟。
net.ipv4.ip_local_port_range= 1024 65535#表示用于向外连接的端口范围。缺省情况下很小，改为1024到65535。
net.ipv4.tcp_max_syn_backlog= 8192#表示SYN队列的长度，默认为1024，加大队列长度为8192，可以容纳更多等待连接的网络连接数。
net.ipv4.tcp_max_tw_buckets= 5000#表示系统同时保持TIME_WAIT的最大数量，如果超过这个数字，TIME_WAIT将立刻被清除并打印警告信息。默认为180000，改为5000。此项参数可以控制TIME_WAIT的最大数量，只要超出了。
Il est recommandé d'activer ces paramètres uniquement sur les serveurs avec un trafic très important, ce qui aura des effets significatifs. En règle générale, il n'est pas nécessaire de définir ces paramètres sur les serveurs à faible trafic.
4. Description des autres paramètres TCP du noyau
net.ipv4.tcp_max_syn_backlog= 65536#记录的那些尚未收到客户端确认信息的连接请求的最大值。对于有128M内存的系统而言，缺省值是1024，小内存的系统则是128。
net.core.netdev_max_backlog= 32768#每个网络接口接收数据包的速率比内核处理这些包的速率快时，允许送到队列的数据包的最大数目。
net.core.somaxconn= 32768#例如web应用中listen函数的backlog默认会给我们内核参数的net.core.somaxconn限制到128，而nginx定义的NGX_LISTEN_BACKLOG默认为511，所以有必要调整这个值。
net.core.wmem_default= 8388608
net.core.rmem_default= 8388608
net.core.rmem_max= 16777216 #最大socket读buffer,可参考的优化值:873200
net.core.wmem_max= 16777216 #最大socket写buffer,可参考的优化值:873200
net.ipv4.tcp_timestsmps= 0#时间戳可以避免序列号的卷绕。一个1Gbps的链路肯定会遇到以前用过的序列号。时间戳能够让内核接受这种“异常”的数据包。这里需要将其关掉。
net.ipv4.tcp_synack_retries= 2#为了打开对端的连接，内核需要发送一个SYN并附带一个回应前面一个SYN的ACK。也就是所谓三次握手中的第二次握手。这个设置决定了内核放弃连接之前发送SYN+ACK包的数量。
net.ipv4.tcp_syn_retries= 2#在内核放弃建立连接之前发送SYN包的数量。
#net.ipv4.tcp_tw_len= 1
net.ipv4.tcp_tw_reuse= 1#开启重用。允许将TIME-WAITsockets重新用于新的TCP连接。
net.ipv4.tcp_wmem= 8192 436600 873200#TCP写buffer,可参考的优化值:8192 436600 873200
net.ipv4.tcp_rmem = 32768 436600 873200#TCP读buffer,可参考的优化值:32768 436600 873200
net.ipv4.tcp_mem= 94500000 91500000 92700000
#同样有3个值,意思是:
#net.ipv4.tcp_mem[0]:低于此值，TCP没有内存压力。
#net.ipv4.tcp_mem[1]:在此值下，进入内存压力阶段。
#net.ipv4.tcp_mem[2]:高于此值，TCP拒绝分配socket。
#上述内存单位是页，而不是字节。可参考的优化值是:7864321048576 1572864
net.ipv4.tcp_max_orphans= 3276800
#系统中最多有多少个TCP套接字不被关联到任何一个用户文件句柄上,如果超过这个数字，连接将即刻被复位并打印出警告信息,这个限制仅仅是为了防止简单的DoS攻击，不能过分依靠它或者人为地减小这个值，更应该增加这个值(如果增加了内存之后)。
net.ipv4.tcp_fin_timeout= 30
#如果套接字由本端要求关闭，这个参数决定了它保持在FIN-WAIT-2状态的时间。对端可以出错并永远不关闭连接，甚至意外当机。缺省值是60秒。2.2 内核的通常值是180秒，你可以按这个设置，但要记住的是，即使你的机器是一个轻载的WEB服务器，也有因为大量的死套接字而内存溢出的风险，FIN-WAIT-2的危险性比FIN-WAIT-1要小，因为它最多只能吃掉1.5K内存，但是它们的生存期长些。
En même temps, cela implique également un algorithme de congestion TCP. Vous pouvez utiliser la commande suivante pour afficher le module de contrôle de l'algorithme de congestion fourni par cette machine:
$ sysctl net.ipv4.tcp_available_congestion_control
#对于几种算法的分析，详情可以参考下：TCP拥塞控制算法的优缺点、适用环境、性能分析，比如高延时可以试用hybla，中等延时可以试用htcp算法等。
net.ipv4.tcp_congestion_control=hybla#如果想设置TCP 拥塞算法为hybla
net.ipv4.tcp_fastopen= 3#额外的，对于内核版高于于3.7.1的，我们可以开启tcp_fastopen
5. Mécanisme de distribution des événements IO
Pour activer les connexions TCP à haute concurrence sous Linux, vous devez confirmer si l'application utilise la technologie d'E / S réseau et le mécanisme de répartition d'événements d'E / S appropriés. Les technologies d'E / S disponibles sont les E / S synchrones, les E / S synchrones non bloquantes et les E / S asynchrones. Dans le cas d'une concurrence TCP élevée, si des E / S synchrones sont utilisées, cela bloquera sérieusement le fonctionnement du programme à moins qu'un thread ne soit créé pour chaque E / S de connexion TCP. Cependant, trop de threads entraîneront une surcharge énorme en raison de la planification des threads par le système.
Par conséquent, il n'est pas conseillé d'utiliser des E / S synchrones en cas de forte concurrence TCP. À ce stade, vous pouvez envisager d'utiliser des E / S synchrones non bloquantes ou des E / S asynchrones. Les techniques d'E / S synchrones non bloquantes incluent l'utilisation de select (), poll (), epoll et d'autres mécanismes. La technique des E / S asynchrones consiste à utiliser AIO.
Du point de vue du mécanisme de distribution d'événements d'E / S, l'utilisation de select () n'est pas appropriée, car le nombre de connexions simultanées qu'il prend en charge est limité (généralement à moins de 1024). Si vous considérez les performances, poll () est également inapproprié, bien qu'il puisse prendre en charge une plus grande concurrence TCP, mais en raison de son mécanisme de "scrutation", lorsque le nombre de concurrence est élevé, son efficacité de fonctionnement est assez faible et peut exister. la distribution des événements d'E / S entraîne une "famine" d'E / S sur certaines connexions TCP.
Si vous utilisez epoll ou AIO, il n'y a pas de tel problème (l'implémentation précoce de la technologie AIO dans le noyau Linux a été réalisée en créant un thread pour chaque demande d'E / S dans le noyau. Ce mécanisme d'implémentation est dans le cas d'un TCP simultané élevé En fait, il y a de sérieux problèmes de performances. Mais dans le dernier noyau Linux, l'implémentation d'AIO a été améliorée).
En résumé, lors du développement d’applications Linux prenant en charge les connexions TCP à haute concurrence, la technologie epoll ou AIO doit être utilisée autant que possible pour obtenir le contrôle des E / S sur les connexions TCP simultanées. Cela améliorera la prise en charge par le programme des connexions TCP à haute concurrence. Fournit une garantie E / S efficace.
Après une telle configuration optimisée, la capacité de traitement simultané TCP du serveur sera considérablement améliorée. La configuration ci-dessus est pour référence seulement. Pour l'environnement de production, veuillez ajuster, observer et ensuite ajuster en fonction de votre situation réelle.
