[Hématémèse] 28 questions d'entretien sur la technologie de base PHP pour vous aider à changer d'emploi !

Cet article compile et partage avec vous 28 questions d'entretien sur la technologie de base PHP, vous donnant une compréhension approfondie de la technologie de base PHP. Vous pouvez rapidement éviter les pièges lors des entretiens et sont essentielles pour changer d'emploi. J'espère que cela sera utile à tout le monde !

Recommandations associées : "Résumé des questions d'entretien PHP 2022 (collection)"

1 Qu'est-ce que oop ?

Réponse : oop est une programmation orientée objet, et la programmation orientée objet est un ordinateur Architecture de programmation : un principe de base de la POO est qu'un programme informatique est composé d'une seule unité ou d'un objet pouvant fonctionner comme un sous-programme.

OOP a trois caractéristiques majeures

1. Encapsulation : également connue sous le nom de masquage d'informations, ce qui signifie séparer l'utilisation et l'implémentation d'une classe, et ne conserver que certaines interfaces et méthodes pour les contacts externes, ou n'en exposer que certaines pour le développement. méthodes utilisées par le personnel. Par conséquent, les développeurs doivent uniquement prêter attention à la façon d'utiliser cette classe, plutôt que de se soucier de son processus de mise en œuvre spécifique. Cela peut permettre une division du travail et une coopération MVC, et peut également éviter efficacement l'interdépendance entre les programmes et obtenir un couplage lâche entre les modules de code.

2. Héritage : les sous-classes héritent automatiquement des attributs et des méthodes de leur classe parent, et peuvent ajouter de nouveaux attributs et méthodes ou réécrire certains attributs et méthodes. L'héritage augmente la réutilisabilité du code. PHP ne prend en charge que l'héritage unique, ce qui signifie qu'une sous-classe ne peut avoir qu'une seule classe parent.

3. Polymorphisme : La sous-classe hérite des attributs et des méthodes de la classe parent et réécrit certaines des méthodes. Par conséquent, bien que plusieurs sous-classes aient la même méthode, les objets instanciés par ces sous-classes peuvent obtenir des résultats complètement différents après avoir appelé ces mêmes méthodes. Cette technologie est le polymorphisme.

Le polymorphisme améliore la flexibilité des logiciels.

1. Facile à maintenir

La structure est conçue avec une pensée orientée objet et est très lisible. En raison de l'existence de l'héritage, même si les exigences changent, la maintenance se fait uniquement dans les modules locaux, elle est donc très pratique. et peu coûteux à entretenir.

2. Haute qualité

Lors de la conception, les classes existantes qui ont été testées dans le domaine de projets précédents peuvent être réutilisées pour que le système réponde aux besoins de l'entreprise et soit de haute qualité.

3. Haute efficacité

Pendant le développement de logiciels, les éléments du monde réel sont abstraits et les classes sont générées en fonction des besoins de conception. Utiliser cette méthode pour résoudre des problèmes est proche de la vie quotidienne et d'une façon naturelle de penser, ce qui améliorera inévitablement l'efficacité et la qualité du développement logiciel.

4. Facile à étendre

En raison des caractéristiques d'héritage, d'encapsulation et de polymorphisme, une structure de système avec une cohésion élevée et un faible couplage est naturellement conçue, rendant le système plus flexible, plus facile à étendre et moins coûteux.

2 Il existe plusieurs façons de fusionner deux tableaux, essayez de comparer leurs similitudes et leurs différences

Méthodes :

1, array_merge()

2, '+'

3, array_merge_recursive

Similarités et différences :

array_merge fusionne simplement les tableaux

array_merge_recursive Fusionne deux tableaux s'il y a exactement les mêmes données dans le tableau, fusionnez-les de manière récursive

array_combine et '+' : fusionnez deux tableaux, la valeur du premier est utilisée. comme clé du nouveau tableau

3 Il y a un bug dans la fonction is_writeable() de PHP. Elle ne peut pas déterminer avec précision si un répertoire/fichier est accessible en écriture. Veuillez écrire une fonction pour déterminer si le répertoire/fichier est absolument accessible en écriture.

Réponse : Le bug existe sous deux aspects,

1. Sous Windows, lorsque le fichier n'a qu'un attribut en lecture seule, la fonction is_writeable() renvoie false. Lorsqu'elle renvoie true, le fichier n'est pas nécessairement accessible en écriture.

S'il s'agit d'un répertoire, créez un nouveau fichier dans le répertoire et vérifiez en ouvrant le fichier ;

S'il s'agit d'un fichier, vous pouvez tester si le fichier est accessible en écriture en ouvrant le fichier (fopen).

2. Sous Unix, lorsque safe_mode est activé dans le fichier de configuration php (safe_mode=on), is_writeable() est également indisponible.

Lisez le fichier de configuration pour voir si safe_mode est activé.

/**
* Tests for file writability
*
* is_writable() returns TRUE on Windows servers when you really can't write to
* the file, based on the read-only attribute. is_writable() is also unreliable
* on Unix servers if safe_mode is on.
*
* @access   private
* @return   void
*/
if ( ! function_exists('is_really_writable'))
{
    function is_really_writable($file){
    // If we're on a Unix server with safe_mode off we call is_writable
    if (DIRECTORY_SEPARATOR == '/' AND @ini_get("safe_mode") == FALSE){
        return is_writable($file);
    }
    // For windows servers and safe_mode "on" installations we'll actually
    // write a file then read it. Bah...
    if (is_dir($file)){
        $file = rtrim($file, '/').'/'.md5(mt_rand(1,100).mt_rand(1,100));
        if (($fp = @fopen($file, FOPEN_WRITE_CREATE)) === FALSE){
            return FALSE;
        }
        fclose($fp);
        @chmod($file, DIR_WRITE_MODE);
        @unlink($file);
        return TRUE;
    } elseif ( ! is_file($file) OR ($fp = @fopen($file, FOPEN_WRITE_CREATE)) === FALSE) {
        return FALSE;
    }
    fclose($fp);
    return TRUE;
    }
}

4 Quel est le mécanisme de récupération de place de PHP ?

PHP peut gérer automatiquement la mémoire et effacer les objets qui ne sont plus nécessaires. PHP utilise un mécanisme simple de récupération de place appelé comptage de références.

Chaque objet contient un compteur de référence. Chaque référence est connectée à l'objet et le compteur est incrémenté de 1. Lorsque la référence quitte l'espace de vie ou est définie sur NULL, le compteur est décrémenté de 1. Lorsque le compteur de références d'un objet atteint zéro, PHP sait que vous n'avez plus besoin d'utiliser l'objet et libère l'espace mémoire qu'il occupe.

5 Écrivez une fonction pour récupérer l'extension de fichier à partir d'une URL standard le plus efficacement possible,

Par exemple : http://www.startphp.cn/abc/de/fg.php?id=1 Besoin de extraire php ou .php

<?php
    // 方案一
    function getExt1($url){
        $arr = parse_url($url);
        //Array ( [scheme] => http [host] => www.startphp.cn [path] => /abc/de/fg.php [query] => id=1 )
        $file = basename($arr[&#39;path&#39;]);
        $ext = explode(&#39;.&#39;, $file);
        return $ext[count($ext)-1];
    }
    // 方案二
    function getExt2($url){
        $url = basename($url);
        $pos1 = strpos($url,&#39;.&#39;);
        $pos2 = strpos($url,&#39;?&#39;);
        if (strstr($url,&#39;?&#39;)) {
            return substr($url,$pos1+1,$pos2-$pos1-1);
        } else {
            return substr($url,$pos1);
        }
    }
    $path = "http://www.startphp.cn/abc/de/fg.php?id=1";
    echo getExt1($path);
    echo "<br />";
    echo getExt2($path);
?>

6 Utilisez des expressions régulières pour extraire un morceau de langage de balisage (html ou xml)

La valeur d'attribut spécifiée de la balise spécifiée dans le segment de code (il faut tenir compte de l'irrégularité de l'attribut valeur, telle que la taille (il n'est pas sensible à l'écriture, il y a un espace entre la valeur du nom d'attribut et le signe égal, etc.). On suppose ici que la valeur de l'attribut attr de la balise de test doit être extraite. Veuillez construire vous-même une chaîne contenant la balise (Tencent)

comme suit :

<?php
    header("content-type:text/html;charset=utf-8");
    function getAttrValue($str,$tagName,$attrName){
        $pattern1="/<".$tagName."(s+w+s*=s*([&#39;"]?)([^&#39;"]*)())*s+".$attrName."s*=s*([&#39;"]?)([^&#39;"]*)()(s+w+s*=s*([&#39;"]?)([^&#39;"]*)(9))*s*>/i";
        $arr=array();
        $re=preg_match($pattern1,$str,$arr);
        if($re){
            echo"<br/>$arr[6]={$arr[6]}";
        }else{
            echo"<br/>没找到。";
        }
    }
    // 示例
    $str1="<test attr=&#39;ddd&#39;>";
    getAttrValue($str1,"test","attr");//找test标签中attr属性的值,结果为ddd
    $str2="<test2 attr=&#39;ddd&#39;attr2=&#39;ddd2&#39;t1="t1 value"t2=&#39;t2 value&#39;>";
    getAttrValue($str2,"test2","t1");//找test2标签中t1属性的值，结果为t1 value
?>

7 php中WEB上传文件的原理是什么，如何限制上传文件的大小？

上传文件的表单使用post方式，并且要在form中添加enctype='multipart/form-data'。

一般可以加上隐藏域：a477cd11f888a00d3a5c1a04e2bd042a，位置在file域前面。

value的值是上传文件的客户端字节限制。可以避免用户在花时间等待上传大文件之后才发现文件过大上传失败的麻烦。

使用file文件域来选择要上传的文件，当点击提交按钮之后，文件会被上传到服务器中的临时目录，在脚本运行结束时会被销毁，所以应该在脚本结束之前，将其移动到服务器上的某个目录下，可以通过函数move_uploaded_file()来移动临时文件，要获取临时文件的信息，使用$_FILES。

限制上传文件大小的因素有：

客户端的隐藏域MAX_FILE_SIZE的数值（可以被绕开）。

服务器端的upload_max_filesize，post_max_size和memory_limit。这几项不能够用脚本来设置。

自定义文件大小限制逻辑。即使服务器的限制是能自己决定，也会有需要个别考虑的情况。所以这个限制方式经常是必要的。

8 请说明 PHP 中传值与传引用的区别，什么时候传值什么时候传引用?

按值传递：函数范围内对值的任何改变在函数外部都会被忽略

按引用传递：函数范围内对值的任何改变在函数外部也能反映出这些修改

优缺点：按值传递时，php必须复制值。特别是对于大型的字符串和对象来说，这将会是一个代价很大的操作。按引用传递则不需要复制值，对于性能提高很有好处。

9 MySQL数据库中的字段类型varchar和char的主要区别是什么?

Varchar是变长，节省存储空间，char是固定长度。查找效率要char型快，因为varchar是非定长，必须先查找长度，然后进行数据的提取，比char定长类型多了一个步骤，所以效率低一些。

10 静态化如何实现的？伪静态如何实现？

1、 静态化指的是页面静态化，也即生成实实在在的静态文件，也即不需要查询数据库就可以直接从文件中获取数据，指的是真静态。

实现方式主要有两种：一种是我们在添加信息入库的时候就生成的静态文件，也称为模板替换技术。一种是用户在访问我们的页面时先判断是否有对应的缓存文件存在，如果存在就读缓存，不存在就读数据库，同时生成缓存文件。

2、伪静态不是真正意义上的静态化，之所以使用伪静态，主要是为了SEO推广，搜索引擎对动态的文件获取难度大，不利于网站的推广。

实习原理是基于Apache或Nginx的rewrite

主要有两种方式：

一种是直接在配置虚拟机的位置配置伪静态，这个每次修改完成后需要重启web服务器。

另一种采用分布式的，可以在网站的根目录上创建.htaccess的文件，在里面配置相应的重写规则来实现伪静态，这种每次重写时不需要重启web服务器，且结构上比较清晰。

11 如何处理负载，高并发？

1、HTML静态化

效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的 网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。

2、图片服务器分离

把图片单独存储，尽量减少图片等大流量的开销，可以放在一些相关的平台上，如七牛等

3、数据库集群和库表散列及缓存

数据库的并发连接为100，一台数据库远远不够，可以从读写分离、主从复制，数据库集群方面来着手。另外尽量减少数据库的访问，可以使用缓存数据库如memcache、redis。

4、镜像：

尽量减少下载，可以把不同的请求分发到多个镜像端。

5、负载均衡：

Apache的最大并发连接为1500，只能增加服务器，可以从硬件上着手，如F5服务器。当然硬件的成本比较高，我们往往从软件方面着手。

12 PHP7的新特性？

标量类型声明：PHP 7 中的函数的形参类型声明可以是标量了。在 PHP 5 中只能是类名、接口、array 或者 callable (PHP 5.4，即可以是函数，包括匿名函数)，现在也可以使用 string、int、float和 bool 了。 

Déclaration du type de valeur de retour : ajout de la prise en charge de la déclaration du type de retour. Semblable à la déclaration de type de paramètre, la déclaration de type de retour spécifie le type de valeur de retour de la fonction. Les types disponibles sont les mêmes que ceux disponibles dans la déclaration des paramètres.

Opérateur de fusion NULL : Comme il existe de nombreuses situations où les expressions ternaires et isset() sont utilisées simultanément dans l'utilisation quotidienne, l'opérateur de fusion NULL renverra sa propre valeur si la variable existe et que la valeur n'est pas NULL, sinon elle renvoie c'est le deuxième opérande.

Amélioration de l'utilisation : les classes, fonctions et constantes importées du même espace de noms peuvent désormais être importées en même temps via une instruction à usage unique. Classes anonymes : prise en charge désormais de l'instanciation d'une classe anonyme via une nouvelle classe

13 Attaques de sécurité PHP courantes Injection SQL :

Les utilisateurs utilisent des instructions SQL pour saisir des champs de formulaire afin d'affecter l'exécution normale de SQL.

Prévention : utilisez mysql_real_escape_string() pour filtrer les données. Vérifiez manuellement si chaque donnée est du bon type de données. Utilisez des instructions préparées et des variables SQL paramétrées : fait référence à la nécessité de remplir des valeurs lors de la conception pour se connecter. la base de données et accéder aux données ou aux données, utilisez des paramètres (Paramètre) pour donner des valeurs, utilisez @ ou ? pour représenter les paramètres.

Attaque XSS : attaque de script intersite, dans laquelle l'utilisateur saisit certaines données dans votre site Web, qui incluent un script côté client (généralement JavaScript). Si vous exportez des données vers une autre page Web sans filtrage, ce script sera exécuté.

Prévention : afin de prévenir les attaques XSS, utilisez la fonction htmlentities() de PHP pour filtrer et afficher dans le navigateur.

CSRF : Contrefaçon de demande intersite, lorsqu'une page fait une demande qui semble être celle d'un utilisateur de confiance du site, mais qui est fausse.

Prévention : En général, assurez-vous que l'utilisateur provient de votre formulaire et qu'il correspond à tous les Le formulaire que vous avez envoyé. Deux choses à retenir : utilisez des mesures de sécurité appropriées pour les sessions utilisateur, telles que la mise à jour des identifiants pour chaque session et l'utilisation de SSL pour les utilisateurs. Générez un autre jeton unique et intégrez-le dans le formulaire, enregistrez-le dans la session (une variable de session), vérifiez-le lors de la soumission. Tel que _token dans laravel

Injection de code : l'injection de code est provoquée par l'exploitation de vulnérabilités informatiques en traitant des données invalides. Le problème survient lorsque vous exécutez accidentellement du code arbitraire, généralement via l'inclusion de fichiers. Un code mal écrit peut permettre à un fichier distant d'être inclus et exécuté. Comme de nombreuses fonctions PHP, require peut contenir une URL ou un nom de fichier.

Empêchez l'injection de code et filtrez les entrées de l'utilisateur. Désactivez Allow_url_fopen et Allow_url_include dans php.ini. Cela désactivera les fichiers distants require/include/fopen

14 Quelles sont les fonctionnalités orientées objet ?

Inclut principalement l'encapsulation, l'héritage et le polymorphisme. S'il s'agit de 4 aspects, ajoutez : abstraction.

Encapsulation :

L'encapsulation est la base pour garantir que les composants logiciels ont une excellente modularité. L'objectif de l'encapsulation est d'obtenir une cohésion élevée et un faible couplage des composants logiciels et d'éviter l'impact des changements causés par l'interdépendance des programmes.

Héritage :

Lors de la définition et de l'implémentation d'une classe, vous pouvez le faire sur la base d'une classe existante. Vous pouvez utiliser le contenu défini par cette classe existante comme votre propre contenu, et vous pouvez en ajouter plusieurs nouveaux. modifier la méthode d'origine pour la rendre plus adaptée à des besoins particuliers. Il s'agit d'un héritage. L'héritage est un mécanisme permettant aux sous-classes de partager automatiquement les données et les méthodes de la classe parent. Il s'agit d'une relation entre les classes qui améliore la réutilisabilité et l'évolutivité du logiciel.

Polymorphisme :

Le polymorphisme signifie que le type spécifique pointé par la variable de référence définie dans le programme et l'appel de méthode émis via la variable de référence ne sont pas déterminés lors de la programmation, mais sont déterminés lors de l'exécution du programme, c'est-à-dire is L'objet d'instance de classe vers lequel pointe une variable de référence et la classe qui implémente l'appel de méthode émis par la variable de référence doivent être déterminés lors de l'exécution du programme.

Abstraction :

L'abstraction consiste à découvrir les similitudes et les points communs de certaines choses, puis à classer ces choses dans une classe. Ce cours ne considère que les similitudes et les points communs de ces choses, et ignore le sujet actuel et ces aspects. qui ne sont pas pertinents par rapport à l’objectif, concentrez-vous sur les aspects qui sont pertinents par rapport à l’objectif actuel. Par exemple, si vous voyez une fourmi et un éléphant et que vous pouvez imaginer à quel point ils se ressemblent, c’est de l’abstraction.

15 ​​​​Quelles sont les méthodes pour optimiser les instructions SQL ? (Choisissez-en quelques-uns)

(1) Dans la clause Where : la connexion entre les tables Where doit être écrite avant les autres conditions Where et les conditions qui peuvent filtrer le nombre maximum d'enregistrements doivent être écrites à la fin de la clause Where. La clause HAVING est la dernière.

(2) Remplacez IN par EXISTS et NOT IN par NOT EXISTS.

(3) Évitez d'utiliser des calculs sur les colonnes d'index

(4) Évitez d'utiliser IS NULL et IS NOT NULL sur les colonnes d'index

(5) Pour optimiser les requêtes, les analyses de table complètes doivent être évitées autant que possible. Créez des index sur les colonnes impliquées dans Where et triez par.

(6) Essayez d'éviter de porter des jugements de valeur nulle sur les champs de la clause Where, sinon le moteur abandonnera l'utilisation de l'index et effectuera une analyse complète de la table

(7) Essayez d'éviter de faire des expressions sur les champs de la clause Where opération, cela amènera le moteur à abandonner l'utilisation de l'index et à effectuer une analyse complète de la table

16 La base de données MySQL est utilisée comme stockage du système de publication, avec un incrément de plus de 50 000 entrées par jour. L'exploitation et la maintenance devraient durer trois ans. Comment l'optimiser ?

(1) Concevez une structure de base de données bien conçue, autorisez une redondance partielle des données et essayez d'éviter les requêtes de jointure pour améliorer l'efficacité.

(2) Sélectionnez le type de données de champ de table et le moteur de stockage appropriés, et ajoutez les index de manière appropriée.

(3) Effectuez la séparation lecture-écriture de la réplication maître-esclave MySQL.

(4) Divisez la table de données en tables pour réduire la quantité de données dans une seule table et améliorer la vitesse des requêtes.

(5) Ajoutez un mécanisme de mise en cache, tel que redis, memcached, etc.

(6) Générez des pages statiques pour les pages qui ne changent pas fréquemment (comme la mise en cache ob).

(7) Écrivez du SQL efficace. Par exemple, SELECT * FROM TABEL est remplacé par SELECT field_1, field_2, field_3 FROM TABLE.

17 Pour les sites Web à fort trafic, quelle méthode utilisez-vous pour résoudre le problème des statistiques de visites de pages ?

(1) Confirmez si le serveur peut prendre en charge le trafic actuel.

(2) Optimiser l'accès à la base de données.

(3) Interdire l'accès externe aux liens (hotlinking), comme le hotlinking d'images.

(4) Téléchargement du fichier de contrôle.

(5) Effectuez un équilibrage de charge et utilisez différents hôtes pour décharger.

(6) Utiliser un logiciel de statistiques de navigation pour comprendre le nombre de visites et effectuer une optimisation ciblée.

18 Parlez-moi de votre compréhension de la différence entre MyISAM et InnoDB dans le moteur MySQL ?

InnoDB et MyISAM sont les deux types de tables les plus couramment utilisés par de nombreuses personnes lors de l'utilisation de MySQL. Les deux types de tables ont leurs propres avantages et inconvénients, selon l'application spécifique. La différence fondamentale est la suivante : le type MyISAM ne prend pas en charge le traitement avancé tel que le traitement des transactions, contrairement au type InnoDB. La table de type MyISAM met l'accent sur les performances et ses temps d'exécution sont plus rapides que le type InnoDB, mais elle ne fournit pas de prise en charge des transactions, tandis qu'InnoDB fournit une prise en charge des transactions et des fonctions de base de données avancées telles que les clés étrangères.

Voici quelques détails et différences spécifiques d'implémentation :

Quelle est la différence entre MyISAM et InnoDB ?

1. Structure de stockage

MyISAM : Chaque MyISAM est stocké sous forme de trois fichiers sur le disque. Le nom du premier fichier commence par le nom de la table et l'extension indique le type de fichier. Les fichiers .frm stockent les définitions de table. L'extension du fichier de données est .MYD (MYData). L'extension du fichier d'index est .MYI (MYIndex).

InnoDB : Toutes les tables sont stockées dans le même fichier de données (ou dans plusieurs fichiers, ou dans des fichiers d'espace table indépendants). La taille de la table InnoDB n'est limitée que par la taille du fichier du système d'exploitation, qui est généralement de 2 Go.

2. Espace de stockage

MyISAM : Il peut être compressé et dispose d'un espace de stockage plus petit. Prend en charge trois formats de stockage différents : table statique (par défaut, mais veuillez noter qu'il ne doit y avoir aucun espace à la fin des données, elles seront supprimées), table dynamique et table compressée.

InnoDB : nécessite plus de mémoire et de stockage, il établira son propre pool de tampons dédié dans la mémoire principale pour la mise en cache des données et des index.

3. Portabilité, sauvegarde et récupération

MyISAM : Les données sont stockées sous forme de fichiers, elles sont donc très pratiques pour le transfert de données multiplateforme. Vous pouvez effectuer des opérations sur une table individuellement pendant la sauvegarde et la restauration.

InnoDB : les solutions gratuites incluent la copie de fichiers de données, la sauvegarde du binlog ou l'utilisation de mysqldump, ce qui est relativement pénible lorsque le volume de données atteint des dizaines de gigaoctets.

4. Prise en charge des transactions

MyISAM : L'accent est mis sur les performances. Chaque requête est atomique et ses temps d'exécution sont plus rapides que le type InnoDB, mais elle ne fournit pas de prise en charge des transactions.

InnoDB : fournit une prise en charge des transactions, des clés étrangères et d'autres fonctions de base de données avancées. Tables sécurisées pour les transactions (conformes à l'ACID) avec capacités de transaction (validation), de restauration (rollback) et de récupération après incident.

5. AUTO_INCREMENT

MyISAM : Peut créer un index conjoint avec d'autres champs. La colonne de croissance automatique du moteur doit être un index. S'il s'agit d'un index combiné, la colonne de croissance automatique n'a pas besoin d'être la première colonne. Elle peut être triée selon les colonnes précédentes puis incrémentée.

InnoDB : InnoDB doit contenir un index avec uniquement ce champ. La colonne à croissance automatique du moteur doit être un index, et s'il s'agit d'un index composite, elle doit également être la première colonne de l'index composite.

6. Différences de verrouillage de table

MyISAM : prend uniquement en charge les verrous au niveau de la table. Lorsque les utilisateurs utilisent des tables myisam, les instructions select, update, delete et insert verrouillent automatiquement la table si la table verrouillée répond à la situation de concurrence d'insertion. peut insérer de nouvelles données à la fin du tableau.

InnoDB : la prise en charge des transactions et des verrous au niveau des lignes est la fonctionnalité la plus importante d'InnoDB. Les verrous de ligne améliorent considérablement les performances des opérations simultanées multi-utilisateurs. Cependant, le verrouillage de ligne d'InnoDB n'est valable que sur la clé primaire de WHERE. Toute clé non primaire WHERE verrouillera la table entière.

7. Index de texte intégral

MyISAM : prend en charge l'index de texte intégral de type FULLTEXT

InnoDB : ne prend pas en charge l'index de texte intégral de type FULLTEXT, mais innodb peut utiliser le plug-in sphinx pour prendre en charge l'index de texte intégral, et l'effet est meilleur.

8. Clé primaire de table

MyISAM : permet aux tables sans index ni clés primaires d'exister. Les index sont les adresses où les lignes sont enregistrées.

InnoDB : Si aucune clé primaire ou index unique non vide n'est défini, une clé primaire de 6 octets (invisible pour l'utilisateur) sera automatiquement générée. Les données font partie de l'index primaire, et l'index supplémentaire enregistre la valeur. de l’indice primaire.

9. Le nombre spécifique de lignes dans le tableau

MyISAM : enregistre le nombre total de lignes dans le tableau. Si count(*) from table est sélectionné, la valeur sera extraite directement.

InnoDB : le nombre total de lignes dans la table n'est pas enregistré. Si vous utilisez select count(*) from table ; il parcourra toute la table, ce qui consomme beaucoup d'argent. Cependant, après avoir ajouté la condition wehre, myisam et. innodb le gère de la même manière.

10. Opération CURD

MyISAM : Si vous effectuez un grand nombre de SELECT, MyISAM est un meilleur choix.

InnoDB : Si vos données effectuent beaucoup d'INSERT ou de UPDATE, vous devez utiliser une table InnoDB pour des raisons de performances. DELETE a de meilleures performances qu'InnoDB, mais lors de DELETE FROM table, InnoDB ne recréera pas la table, mais la supprimera ligne par ligne. Si vous souhaitez effacer une table avec une grande quantité de données sur InnoDB, il est préférable. pour utiliser la commande tronquer la table.

11. Clés étrangères

MyISAM : non pris en charge

InnoDB : pris en charge

Grâce à l'analyse ci-dessus, vous pouvez essentiellement envisager d'utiliser InnoDB pour remplacer le moteur MyISAM. La raison en est qu'InnoDB lui-même possède de nombreuses fonctionnalités intéressantes, telles que les transactions. prise en charge, procédures de stockage, vues, verrouillage au niveau des lignes, etc., dans le cas de beaucoup de concurrence, je pense que les performances d'InnoDB seront certainement bien meilleures que celles de MyISAM. De plus, aucune table n'est omnipotente. Ce n'est qu'en sélectionnant le type de table approprié en fonction du type d'entreprise que les avantages en termes de performances de MySQL peuvent être maximisés. S'il ne s'agit pas d'une application web très complexe ou d'une application non critique, vous pouvez toujours envisager MyISAM. Vous pouvez envisager vous-même cette situation spécifique.

19 La différence entre Redis et Memache Cache

Résumé 1 :

1 Type de données

Redis a des types de données riches et prend en charge la liste définie et d'autres types

memcache prend en charge les types de données simples. et nécessite que les clients La fin gère les objets complexes par elle-même

2 Persistance

redis prend en charge le stockage persistant d'atterrissage des données

memcache ne prend pas en charge le stockage persistant des données

3. mode

memcache peut utiliser un hachage cohérent pour la distribution

les tailles des valeurs sont différentes

memcache est un cache mémoire, la longueur de la clé est inférieure à 250 caractères et le stockage d'un seul élément est inférieur à 1 Mo, ce qui n'est pas le cas adapté aux machines virtuelles

4. La cohérence des données est différente

redis utilise un modèle monothread pour garantir que les données sont soumises dans l'ordre.

memcache doit utiliser cas pour garantir la cohérence des données. CAS (Check and Set) est un mécanisme permettant d'assurer la cohérence de la concurrence et appartient à la catégorie des « verrouillages optimistes » le principe est très simple : prendre le numéro de version, opérer, comparer le numéro de version, s'il est cohérent, opérer, si ; c'est incohérent, abandonnez toute opération

5 Utilisation du processeur

Le modèle Redis monothread ne peut utiliser qu'un seul processeur et peut ouvrir plusieurs processus Redis

Résumé 2 :

1. , toutes les données ne sont pas toujours stockées en mémoire, c'est la plus grande différence par rapport à Memcached.

2.Redis prend non seulement en charge les données simples de type k/v, mais fournit également le stockage de structures de données telles que la liste, l'ensemble et le hachage.

3.Redis prend en charge la sauvegarde des données, c'est-à-dire la sauvegarde des données en mode maître-esclave.

4.Redis prend en charge la persistance des données, qui peut conserver les données en mémoire sur le disque et peut être rechargée pour être utilisée lors du redémarrage.

Personnellement, je pense que la différence la plus essentielle est que Redis a les caractéristiques d'une base de données à bien des égards, ou est un système de base de données, tandis que Memcached n'est qu'un simple cache K/V

Résumé 3 :

Redis et memecache La différence est :

1. Méthode de stockage :

memecache stocke toutes les données dans la mémoire. Il raccrochera après une panne de courant. Les données ne peuvent pas dépasser la taille de la mémoire. sont stockées sur le disque dur, ce qui assure la persistance des données.

2. Type de support de données :

redis a beaucoup plus de support de données que memecache.

3. Le modèle sous-jacent est différent :

La nouvelle version de redis construit directement le mécanisme de la VM par elle-même, car si le système général appelle les fonctions système, il perdra un certain temps à se déplacer et à demander.

4. Différents environnements d'exploitation :

redis ne prend actuellement officiellement en charge que Linux, éliminant ainsi le besoin de prise en charge d'autres systèmes. De cette manière, l'énergie peut être mieux dépensée pour optimiser l'environnement système, bien que plus tard, une équipe de Microsoft. a écrit un patch pour cela. Mais il n'est pas placé sur le tronc

memcache ne peut être utilisé que comme cache. Le contenu du cache

redis peut être implémenté, ce qui est quelque peu similaire à MongoDB. Ensuite, redis peut également être utilisé comme cache, et master-. l'esclave peut être configuré

20 redis À quoi devons-nous faire attention lors de l'utilisation du premier entré, premier sorti dans les files d'attente de messages

Réponse : Habituellement, une liste est utilisée pour implémenter les opérations de file d'attente. Cela a une petite limitation. Toutes les tâches sont uniformément premier entré, premier sorti. Ce n'est pas bien si vous souhaitez prioriser une certaine tâche traitée, cela nécessite que la file d'attente ait le concept de priorité, afin que nous puissions prioriser les tâches de haut niveau. plusieurs façons d'y parvenir :

1）单一列表实现：队列正常的操作是 左进右出（lpush,rpop）为了先处理高优先级任务，在遇到高级别任务时，可以直接插队，直接放入队列头部（rpush），这样，从队列头部（右侧）获取任务时，取到的就是高优先级的任务（rpop）

2）使用两个队列，一个普通队列，一个高级队列，针对任务的级别放入不同的队列，获取任务时也很简单，redis的BRPOP命令可以按顺序从多个队列中取值，BRPOP会按照给出的 key 顺序查看，并在找到的第一个非空 list 的尾部弹出一个元素，redis> BRPOP list1 list2 0

list1 做为高优先级任务队列
list2 做为普通任务队列

这样就实现了先处理高优先级任务，当没有高优先级任务时，就去获取普通任务
方式1  最简单，但实际应用比较局限，方式3可以实现复杂优先级，但实现比较复杂，不利于维护
方式2  是推荐用法，实际应用最为合适

21 Redis如何防止高并发?

答：其实redis是不会存在并发问题的，因为他是单进程的，再多的命令都是一个接一个地执行的。我们使用的时候，可能会出现并发问题，比如获得和设定这一对。Redis的为什么 有高并发问题？Redis的出身决定等

Redis是一种单线程机制的nosql数据库，基于key-value，数据可持久化落盘。由于单线程所以redis本身并没有锁的概念，多个客户端连接并不存在竞争关系，但是利用jedis等客户端对redis进行并发访问时会出现问题。发生连接超时、数据转换错误、阻塞、客户端关闭连接等问题，这些问题均是由于客户端连接混乱造成。

同时，单线程的天性决定，高并发对同一个键的操作会排队处理，如果并发量很大，可能造成后来的请求超时。

在远程访问redis的时候，因为网络等原因造成高并发访问延迟返回的问题。

解决办法

在客户端将连接进行池化，同时对客户端读写Redis操作采用内部锁synchronized。

服务器角度，利用setnx变向实现锁机制。

22 做秒杀用什么数据库，怎么实现的?

答:因为秒杀的一瞬间，并发非常大，如果同时请求数据库，会导致数据库的压力非常大，导致数据库的性能急剧下降，更严重的可能会导致数据库服务器宕机。

这时候一般采用内存高速缓存数据库redis来实现的,redis是非关系型数据库，redis是单线程的，通过redis的队列可以完成秒杀过程。

23 什么情况下使用缓存?

答:当用户第一次访问应用系统的时候，因为还没有登录，会被引导到认证系统中进行登录；根据用户提供的登录信息，认证系统进行身份校验，如果通过校验，应该返回给用户一个认证的凭据－－ticket；

用户再访问别的应用的时候，就会将这个ticket带上，作为自己认证的凭据，应用系统接受到请求之后会把 ticket送到认证系统进行校验，检查ticket的合法性。如果通过校验，用户就可以在不用再次登录的情况下访问应用系统2和应用系统3了。

实现主要技术点：

1、两个站点共用一个数据验证系统

2、主要通过跨域请求的方式来实现验证及session处理。

24 如何解决异常处理?

答: 抛出异常:使用try…catch，异常的代码放在try代码块内，如果没有触发异常，则代码继续执行，如果异常被触发，就会 抛出一个异常。Catch代码块捕获异常，并创建一个包含异常信息的对象。$e->getMessage()，输出异常的错误信息。

解决异常:使用set_error_handler函数获取异常(也可以使用try()和catch()函数),然后使用set_exception_handler()函数设置默认的异常处理程序,register_shutdown_function()函数来执行,执行机制是,php要把调入的函数调入到内存,当页面所有的php语句都执行完成时,再调用此函数

25 权限管理(RBAC)的实现?

1.首先创建一张用户表:id name auto(保存格式为:控制器-方法)

2.然后在后台中创建一个基类控制器,控制器里封装一个构造方法,当用户登陆成功后,使用TP框架中封装好的session函数获取保存在服务器中的session id,然后实例化模型,通过用户id获取保存在数据表中的auth数据,使用explode函数分割获取到的数据,并使用一个数组保存起来,然后使用TP框架中封装好的常量获取当前控制器和方法,然后把他们组装成字符串,使用in_array函数进行判断该数组中是否含有当前获取到的控制器和方法,如果没有,就提示该用户没有权限,如果有就进行下一步操作

26 Comment s'assurer que les produits promotionnels ne seront pas survendus ?

Réponse : Ce problème était une difficulté que nous avons rencontrée lors du développement à l'époque. La principale raison de la survente est que le nombre de commandes passées n'est pas cohérent avec le nombre de commandes. produits que nous souhaitons promouvoir. De ce fait, le nombre de commandes à chaque fois était toujours supérieur au nombre de nos produits promotionnels. A cette époque, notre équipe a longuement discuté et a proposé plusieurs plans pour y parvenir :

. Le premier plan : avant chaque commande. Nous avons jugé si la quantité de produits promotionnels était suffisante, et nous n'étions pas autorisés à passer une commande si elle n'était pas suffisante. Nous avons ajouté une condition lors de la modification de l'inventaire, et avons uniquement modifié l'inventaire de. produits avec un inventaire supérieur à 0. À cette époque, nous utilisions ab pour les tests de résistance. Lorsque la concurrence dépassait 500, le nombre de visites lorsqu'il dépasse 2000, des conditions de survente se produiront toujours. Nous l'avons donc nié.

Deuxième solution : utilisez des transactions MySQL et des verrous exclusifs pour résoudre le problème. Tout d'abord, nous choisissons le moteur de stockage de la base de données comme innoDB, qui est implémenté à l'aide de verrous exclusifs. Au début, nous avons testé le verrou partagé et avons constaté qu'il était toujours le cas. Un phénomène de survente se produit. Un problème est que lorsque nous effectuons des tests à haute concurrence, cela a un impact important sur les performances de la base de données, provoquant une forte pression sur la base de données, et a finalement été rejeté par nous.

La troisième option : utiliser l'implémentation du verrouillage de fichiers. Lorsqu'un utilisateur récupère un article promotionnel, le verrouillage du fichier est d'abord déclenché pour empêcher les autres utilisateurs d'entrer. Une fois que l'utilisateur a saisi l'article promotionnel, le verrouillage du fichier est déverrouillé et les autres utilisateurs sont autorisés à opérer. Cela peut résoudre le problème de survente, mais cela entraînera une surcharge d'E/S importante pour le fichier.

Enfin, nous avons utilisé la file d'attente Redis pour l'implémenter. Le nombre de produits à promouvoir est stocké dans Redis dans une file d'attente. Chaque fois qu'un utilisateur récupère un produit promotionnel, une donnée est supprimée de la file d'attente pour garantir que le produit ne sera pas survendu. C'est très pratique à utiliser et extrêmement efficace. Au final, nous avons adopté cette méthode pour réaliser

27 Mise en œuvre de ventes flash dans le centre commercial ?

Réponse : Les achats précipités et les ventes flash sont un scénario d'application très courant aujourd'hui, et les principaux problèmes doivent être résolus. Il y en a deux :

• La pression provoquée par une forte concurrence sur la base de données

• Comment résoudre la réduction correcte des stocks (problème de "survente") dans un état concurrentiel

Pour la première question, il est facile de penser à utiliser Caching pour gérer les achats urgents et éviter d'exploiter directement la base de données, comme en utilisant Redis.

Pour la deuxième question, nous pouvons utiliser la file d'attente redis pour la compléter et mettre instantanément les produits à vendre dans la file d'attente. Car l'opération pop est atomique, même si de nombreux utilisateurs arrivent en même temps, ils seront exécutés en même temps. Les verrouillages de fichiers et les transactions sont à un niveau élevé. Les performances chutent rapidement en cas de concurrence. Bien sûr, d'autres aspects doivent être pris en compte, comme rendre la page de capture statique et appeler l'interface via ajax. un utilisateur saisit plusieurs fois. À ce stade, une file d'attente doit être ajoutée, des files d'attente de résultats urgents et des files d'attente d'inventaire.

En cas de concurrence élevée, entrez l'utilisateur dans la file d'attente, utilisez une boucle de thread pour supprimer un utilisateur de la file d'attente et déterminez si l'utilisateur est déjà dans la file d'attente des résultats d'achat urgent. Si c'est le cas, c'est le cas. a été récupéré, sinon il n'est pas récupéré et l'inventaire est réduit de 1. Écrivez la base de données, placez l'utilisateur dans la file d'attente des résultats.

28 Comment gérer la charge et la simultanéité élevée ?

Réponse : Du point de vue du faible coût, des performances élevées et de la grande évolutivité, il existe les solutions suivantes :

1. Staticisation HTML

En fait, tout le monde sait que la méthode la plus efficace et la moins consommatrice est la staticisation pure. Pages HTML, nous faisons donc de notre mieux pour utiliser des pages statiques pour les pages de notre site Web. Cette méthode la plus simple est en fait la méthode la plus efficace.

2. Séparation des serveurs d'images

Stockez les images séparément pour minimiser la surcharge du trafic important tel que les images. Elles peuvent être placées sur certaines plates-formes associées, telles que monter un taureau, etc.

3. et hachage de table de bibliothèque Et cache

La connexion simultanée de la base de données est de 100. Une base de données est loin d'être suffisante. Vous pouvez commencer par la séparation en lecture-écriture, la réplication maître-esclave et le clustering de bases de données. De plus, pour minimiser l'accès aux bases de données, vous pouvez utiliser des bases de données en cache telles que Memcache et Redis.

4. Mirroring :

Réduisez autant que possible les téléchargements et distribuez différentes requêtes à plusieurs miroirs.

5. Équilibrage de charge :

Le nombre maximum de connexions simultanées d'Apache est de 1 500. Vous ne pouvez ajouter que des serveurs. Vous pouvez commencer avec du matériel, tel que le serveur F5. Bien entendu, le coût du matériel est relativement élevé, nous partons donc souvent du côté logiciel.

Load Balancing est construit sur la structure du réseau existante. Il fournit une méthode peu coûteuse, efficace et transparente pour étendre la bande passante des périphériques et des serveurs réseau, augmenter le débit, améliorer les capacités de traitement des données du réseau et en même temps améliorer les performances du réseau. Flexibilité et disponibilité. Actuellement, les logiciels d'équilibrage de charge les plus utilisés sont Nginx, LVS et HAProxy.

Parlons respectivement des avantages et des inconvénients des trois types suivants :

Les avantages de Nginx sont :

En travaillant au-dessus de la 7ème couche du réseau, vous pouvez élaborer des stratégies de détournement pour les applications http , tels que les noms de domaine et la structure du répertoire, ses règles habituelles sont plus puissantes et flexibles que HAProxy, ce qui est l'une des principales raisons pour lesquelles Nginx est actuellement très populaire et peut être exploité dans bien plus de situations que LVS sur cette seule base.

Nginx dépend très peu de la stabilité du réseau. En théorie, il peut effectuer des fonctions de chargement tant qu'il peut être pingé. C'est aussi l'un de ses avantages, au contraire, LVS dépend davantage de la stabilité du réseau, ce que je suis. profondément conscient de ;

Nginx est relativement simple à installer et à configurer, et il est plus pratique à tester. Il peut essentiellement imprimer les erreurs dans les journaux. La configuration et les tests de LVS prennent relativement longtemps et LVS s'appuie fortement sur le réseau.

Il peut résister à une pression de charge élevée et est stable. Si le matériel n'est pas mauvais, il peut généralement prendre en charge des dizaines de milliers de concurrence et le degré de charge est relativement inférieur à celui du LVS.

Nginx peut détecter les pannes internes du serveur via les ports, telles que les codes d'état, les délais d'attente, etc. renvoyés par le serveur lors du traitement des pages Web, et soumettra à nouveau les requêtes qui renvoient des erreurs à un autre nœud. Cependant, l'inconvénient est qu'il ne prend pas en charge. Détection d'URL. Par exemple, si l'utilisateur télécharge un fichier et que le nœud traitant le téléchargement échoue pendant le processus de téléchargement, Nginx basculera le téléchargement vers un autre serveur pour le retraitement, et LVS sera directement déconnecté si un fichier volumineux est téléchargé, ou très. fichiers importants, les utilisateurs peuvent être insatisfaits.

Nginx n'est pas seulement un excellent logiciel d'équilibrage de charge/proxy inverse, c'est également un puissant serveur d'applications Web. LNMP est également une architecture web très populaire ces dernières années, et sa stabilité est également très bonne dans les environnements à fort trafic.

Nginx devient désormais de plus en plus mature en tant que cache d'accélération inverse Web et est plus rapide que le serveur Squid traditionnel. Vous pouvez envisager de l'utiliser comme accélérateur de proxy inverse.

Nginx peut être utilisé comme proxy inverse de niveau intermédiaire. À ce niveau, Nginx n'a fondamentalement aucun rival. Le seul qui peut se comparer à Nginx est lighttpd. Cependant, lighttpd n'a pas encore toutes les fonctions de Nginx, et le. la configuration n'est pas aussi claire et facile à lire. Les informations de la communauté sont également beaucoup moins actives que Nginx.

Nginx peut également être utilisé comme page Web statique et serveur d'images, et ses performances dans ce domaine sont inégalées. La communauté Nginx est également très active et il existe de nombreux modules tiers.

Les inconvénients de Nginx sont :

Nginx ne peut prendre en charge que les protocoles http, https et Email, le champ d'application est donc plus petit.

Le bilan de santé du serveur back-end prend uniquement en charge la détection via les ports et ne prend pas en charge la détection via les URL. La conservation directe de la session n'est pas prise en charge, mais elle peut être résolue via ip_hash.

LVS : utilisez le cluster de noyau Linux pour implémenter un serveur d'équilibrage de charge hautes performances et haute disponibilité, doté d'une bonne évolutivité (Scalability), fiabilité (Reliability) et gérabilité (Manageability).

Les avantages de LVS sont :

Forte résistance à la charge, il fonctionne au-dessus de la 4ème couche du réseau uniquement pour la distribution, et aucun trafic n'est généré. Cette fonctionnalité détermine également ses plus fortes performances dans le logiciel d'équilibrage de charge, la mémoire et. La consommation des ressources CPU est relativement faible.

La configurabilité est relativement faible, ce qui constitue un inconvénient et un avantage. Parce qu'il n'y a rien qui puisse être trop configuré, cela ne nécessite pas trop de contacts, ce qui réduit considérablement le risque d'erreur humaine.

Il fonctionne de manière stable car il a une forte résistance à la charge et dispose d'une solution complète de sauvegarde à chaud sur deux machines, telle que LVS+Keepalived. Cependant, celle que nous utilisons le plus dans la mise en œuvre du projet est LVS/DR+Keepalived.

Pas de trafic, LVS distribue uniquement les requêtes et le trafic ne sort pas de lui-même. Cela garantit que les performances de l'équilibreur IO ne seront pas affectées par un trafic important.

Il dispose d'un large éventail d'applications. Étant donné que LVS fonctionne sur la couche 4, il peut équilibrer la charge de presque toutes les applications, y compris http, les bases de données, les salons de discussion en ligne, etc.

Les inconvénients de LVS sont :

Le logiciel lui-même ne prend pas en charge le traitement des expressions régulières et ne peut pas séparer les données dynamiques et statiques ; et de nombreux sites Web ont désormais de fortes exigences à cet égard. C'est l'avantage de Nginx/HAProxy+Keepalived. .

Si l'application du site Web est relativement volumineuse, LVS/DR+Keepalived sera plus compliqué à mettre en œuvre. Surtout s'il y a une machine Windows Server derrière, le processus de mise en œuvre, de configuration et de maintenance sera relativement plus compliqué, Nginx/. HAProxy+Keepalived est beaucoup plus simple.

Les fonctionnalités de HAProxy sont :

HAProxy prend également en charge les hôtes virtuels.

Les avantages de HAProxy peuvent compléter certaines des lacunes de Nginx, telles que la prise en charge de la conservation des sessions et du guidage des cookies ; il prend également en charge la détection de l'état du serveur principal en obtenant l'URL spécifiée.

HAProxy est similaire à LVS, c'est juste un logiciel d'équilibrage de charge uniquement en termes d'efficacité, HAProxy aura une meilleure vitesse d'équilibrage de charge que Nginx, et il est également meilleur que Nginx en termes de traitement simultané.

HAProxy prend en charge le transfert d'équilibrage de charge du protocole TCP. Il peut équilibrer la charge des lectures MySQL et détecter et équilibrer la charge des nœuds MySQL back-end. Vous pouvez utiliser LVS + Keepalived pour équilibrer la charge du maître et de l'esclave MySQL.

HAProxy a de nombreuses stratégies d'équilibrage de charge. Les algorithmes d'équilibrage de charge de HAProxy ont actuellement les 8 types suivants :

① roundrobin, ce qui signifie une interrogation simple, c'est essentiellement ce qu'a l'équilibrage de charge ; ce qui signifie qu'en fonction du poids, il est recommandé de faire attention ;

③ les moins connectés, ce qui signifie que les moins connectés sont traités en premier, il est recommandé de faire attention

④ source, ce qui signifie en fonction de l'IP source de la demande, ceci ; est similaire au mécanisme IP_hash de Nginx, nous l'utilisons comme solution de session. Une façon de résoudre le problème, il est recommandé d'y prêter attention ;

⑤ ri, représente l'URI demandé ;

⑥ rl_param, représente le paramètre d'URl demandé 'balance url_param' nécessite un nom de paramètre d'URL ;

⑦ hdr(name), représente le verrouillage de chaque requête HTTP en fonction de l'en-tête de la requête HTTP ;

⑧ rdp-cookie(name), signifie verrouiller et hacher chaque requête TCP en fonction du cookie(name).

Résumé de la comparaison entre Nginx et LVS :

Nginx fonctionne sur la 7ème couche du réseau, il peut donc implémenter des stratégies de détournement pour l'application http elle-même, comme les noms de domaine, les structures de répertoires, etc. LVS n'a pas ces fonctions, donc Nginx peut être utilisé dans bien plus de situations que LVS sur cette seule base ; mais ces fonctions utiles de Nginx le rendent plus ajustable que LVS, vous devez donc souvent toucher, toucher et trop toucher. La probabilité de problèmes d’origine humaine sera également plus grande.

Nginx dépend moins de la stabilité du réseau. Théoriquement, tant que le ping est réussi et que l'accès aux pages Web est normal, Nginx peut se connecter. C'est un avantage majeur de Nginx ! Nginx peut également faire la distinction entre les réseaux internes et externes. S'il s'agit d'un nœud avec des réseaux internes et externes, cela équivaut à une seule machine disposant d'une ligne de sauvegarde ; même segment de réseau et LVS utilise le mode direct pour décharger. L'effet est plus garanti.

Notez également que LVS doit demander au moins une adresse IP supplémentaire auprès du fournisseur d'hébergement pour être utilisée comme adresse IP visuelle. Il semble qu'il ne puisse pas utiliser sa propre adresse IP en tant que VIP. Pour être un bon administrateur LVS, il faut vraiment suivre et acquérir beaucoup de connaissances sur la communication réseau, qui n'est plus aussi simple que HTTP.

Nginx est relativement simple à installer et à configurer, et il est également très pratique à tester, car il peut essentiellement imprimer les erreurs dans les journaux. L'installation, la configuration et les tests de LVS prennent un temps relativement long ; LVS dépend fortement du réseau. Dans de nombreux cas, l'échec de la configuration est dû à des problèmes de réseau plutôt qu'à des problèmes de configuration. plus difficile à résoudre.

Nginx peut également supporter des charges élevées et est stable, mais la charge et la stabilité sont médiocres. LVS a plusieurs niveaux : Nginx gère tout le trafic, il est donc limité par les E/S de la machine et ses propres bugs sont toujours inévitables.

Nginx peut détecter les pannes internes du serveur, telles que les codes d'état, les délais d'attente, etc. renvoyés par le serveur traitant les pages Web, et soumettra à nouveau les requêtes qui renvoient des erreurs à un autre nœud. Actuellement, ldirectd dans LVS peut également prendre en charge la surveillance des conditions internes du serveur, mais le principe de LVS l'empêche de renvoyer des requêtes. Par exemple, si l'utilisateur télécharge un fichier et que le nœud traitant le téléchargement échoue pendant le processus de téléchargement, Nginx basculera le téléchargement vers un autre serveur pour le retraitement, et LVS sera directement déconnecté si un fichier volumineux est téléchargé, ou très. fichiers importants, les utilisateurs peuvent être ennuyés par cela.

Le traitement asynchrone des requêtes par Nginx peut aider le serveur de nœud à réduire la charge. Si Apache est utilisé pour servir directement des parties externes, alors lorsqu'il existe de nombreux liens à bande étroite, le serveur Apache occupera une grande quantité de mémoire et ne pourra pas être libéré. un autre Nginx est utilisé comme proxy Apache, ceux-ci Le lien à bande étroite sera bloqué par Nginx, il n'y aura donc pas trop de requêtes empilées sur Apache, réduisant ainsi considérablement l'utilisation des ressources. L'utilisation de Squid a le même effet à cet égard. Même si Squid lui-même est configuré pour ne pas mettre en cache, il reste d'une grande aide pour Apache.

Nginx peut prendre en charge http, https et email (la fonction email est moins couramment utilisée), et LVS prend en charge plus d'applications que Nginx à cet égard. En termes d'utilisation, la stratégie adoptée par le front-end doit généralement être LVS, c'est-à-dire que le DNS doit être dirigé vers l'égaliseur LVS. Les avantages de LVS le rendent très adapté à cette tâche.

Les adresses IP importantes sont mieux hébergées par LVS, telles que les adresses IP des bases de données, les adresses IP des serveurs de services Web, etc. Ces adresses IP deviendront de plus en plus largement utilisées au fil du temps. Si les adresses IP sont modifiées, des défauts s'ensuivront. Par conséquent, il est plus sûr de confier ces adresses IP importantes à LVS pour l'hébergement. Le seul inconvénient est que le nombre de VIP requis sera plus important.

Nginx peut être utilisé comme machine à nœuds LVS. Premièrement, il peut profiter des fonctions de Nginx. Deuxièmement, il peut profiter des performances de Nginx. Bien sûr, vous pouvez également utiliser Squid directement à ce niveau. Les fonctions de Squid sont beaucoup plus faibles que celles de Nginx et ses performances sont également inférieures à celles de Nginx.

Nginx peut également être utilisé comme proxy de niveau intermédiaire. À ce niveau, Nginx n'a fondamentalement aucun rival. Le seul qui peut ébranler Nginx est lighttpd. Cependant, lighttpd n'est pas encore capable d'atteindre toutes les fonctions de Nginx. la configuration n'est pas si claire et facile à lire. De plus, l'adresse IP de l'agent de niveau intermédiaire est également importante, c'est donc la solution la plus parfaite pour l'agent de niveau intermédiaire d'avoir également un VIP et un LVS.

L'application spécifique doit être analysée en détail. S'il s'agit d'un site Web relativement petit (le PV quotidien est inférieur à 10 millions), il est parfaitement possible d'utiliser Nginx. S'il y a de nombreuses machines, vous pouvez utiliser le sondage DNS. consomme plus de machines. Pour les grands sites Web ou les services importants, lorsque la machine n'est pas inquiète, vous devriez envisager d'utiliser LVS.

Apprentissage recommandé : "Tutoriel vidéo PHP"

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!