Une discussion détaillée du déploiement distribué php

Dans cet article, nous partagerons avec vous le déploiement distribué PHP, en espérant que tout le monde aura une idée plus claire du déploiement distribué PHP.

Dans le développement Web ordinaire, le mode courant est qu'une fois que l'utilisateur s'est connecté, les informations sur l'état de connexion sont stockées dans la session, certaines des données chaudes couramment utilisées par l'utilisateur sont stockées dans le cache de fichiers et la pièce jointe les informations téléchargées par l'utilisateur sont stockées dans un certain emplacement du répertoire du serveur Web. Cette méthode est très pratique à utiliser et entièrement adaptée aux applications Web générales. Mais pour les sites Web d’entreprise à haute concurrence, il ne peut pas le gérer. Les clusters Web doivent être utilisés pour réaliser l'équilibrage de charge.

Après le déploiement à l'aide de la méthode du cluster Web, la première chose à ajuster est les informations sur l'état de l'utilisateur et les informations sur les pièces jointes. Le statut de l'utilisateur ne peut plus être enregistré dans la session, le cache ne peut pas utiliser le cache de fichiers du serveur Web local et les pièces jointes ne peuvent pas être enregistrées sur le serveur Web. Car il faut s’assurer que l’état de chaque serveur web du cluster est totalement cohérent. Par conséquent, le statut de l'utilisateur, le cache, etc. doivent être enregistrés sur un serveur de cache dédié, tel que Memcache. Les pièces jointes doivent être enregistrées sur le stockage cloud, tel que Qiniu Cloud Storage, Alibaba Cloud Storage, Tencent Cloud Storage, etc.

Cet article prend le framework de développement ThinkPHP comme exemple pour expliquer comment configurer et enregistrer la session, le cache, etc. sur le serveur de cache Memcache.

Téléchargez la classe de traitement Memcache mise en cache et placez-la dans le répertoire ThinkphpExtendDriverCache ; téléchargez la classe de traitement Session Memcache et placez-la dans le répertoire ThinkphpExtendDriverSession, comme indiqué ci-dessous :

Modifiez le fichier de configuration, ajustez la session et le cache, et enregistrez-les sur le serveur Memcache. Ouvrez ThinkPHPConfconvention.PHP et ajoutez des éléments de configuration :

[php] voir copie simple

1. /* Paramètres du cache Memcache */

2. 'MEMCACHE_HOST' => '192.168.202.20',

3. 'MEMCACHE_PORT'     => 11211, 

Modifier le cache de données vers Memcache :

[php] vue copie simple

1. 'DATA_CACHE_TYPE' => ,

Modifier la session vers Memcache :

[php]

voir copie simple

1. 'SESSION_TYPE' => 'Memcache' ,

Comme indiqué ci-dessous :

Comme il existe de nombreux types de stockage cloud, les pièces jointes sont stockées sur le stockage cloud, je n'entrerai donc pas dans les détails. Paramétrez simplement le SDK fourni par chaque stockage cloud. Après les modifications ci-dessus, le serveur Web peut être déployé de manière distribuée.

Pièce jointe 1 : CacheMemcache.class.php

[php]

vue copie simple

2. // +---- -------------------------------------------------- ----------------  

3. // | ThinkPHP [ NOUS POUVONS LE FAIRE JUST PENSEZ-LE ]  

4. // +------- -------------------------------------------------- -------------  

5. // | Copyright (c) 2006-2012 http://thinkphp.cn Tous droits réservés.  

6. // +------------------------------------------------- ---------------------  

7. // | Sous licence ( http://www.apache.org/licenses/LICENSE-2.0 )  

8. // +------------------------------------------------- ---------------------  

9. // | Auteur : liu21st   

10. // +------ -------------------------------------------------- ----------  

11.   

12. défini('THINK_PATH') ou sortie ();

13. class CacheMemcache étend

Cache { 

15. /**

16. * Fonction architecturale

17. * @param array $options Cache paramètres

18. * @access public

20.      */  

21.     fonction __construct($options=array()) {  

22.         if ( !extension_loaded('memcache' ) ) {  

23.             throw_exception(L('_NOT_SUPPERT_').' : memcache');  

24.         }  

25.   

26.         $options = array_merge(array (  

27.             'hôte'        =>   C('MEMCACHE_HOST') ? C('MEMCACHE_HOST') : '127.0.0.1',  

28.             'port'        =>  C('MEMCACHE_PORT') ? C('MEMCACHE_PORT') : 11211,  

29.             'timeout'     =>  C('DATA_CACHE_TIMEOUT') ? C('DATA_CACHE_TIMEOUT') : false,  

30.             'persistant'  =>  faux,  

31.         ),$options);  

32.   

33.         $this -> options      =   $options;  

34.         $this->options['expire'] =  isset( $options['expire']) ?  $options['expire']   :   C('DATA_CACHE_TIME') ;  

35.         $this->options['préfixe'] =  isset($options['prefix']) ?  $options['préfixe']   :   C('DATA_CACHE_PREFIX') ;          

36.         $this->options['longueur'] =  isset( $options['longueur']) ?  $options['longueur']   :   0 ;          

37.         $func               =   $options['persistant'] ? 'pconnect' : 'connect' ;  

38.         $this->handler      =   nouveau Cache mémoire ;  

39.         $options['timeout'] = == faux ?  

40.  $this->handler->$func($options['hôte'], $options['port ']) :

41.                                             🎜>$func ($options['hôte'], $options['port '], $options['timeout']

    } >

42. Lire le cache
🎜>
43. * @param string $name cache nom de la variable

44.      * @retour mixte 

45.      */  

46.     public fonction get( $name) {  

47.         N('cache_read',1 );  

48.         retour $this->handler- >get($this->options['prefix'].$name);  

49.     }  

50.   

51.     /** 

52.      * 写入缓存 

53.      * @access public 

54.      * @param string $name缓存变量名 

55.      * @param mixed $value  存储数据 

56.      * @param integer $expire  有效时间（秒） 

57. * @return boolen 

58.      */  

59.     public function set($name,  $value, $expire = null) {  

60.         N('cache_write',1);  

61.         if(is_null($expire)) {  

62.             $expire  =  $this->options['expire'];  

63.         }  

64.         $name   =   $this->options[' préfixe'].$name;  

65.         if($this->handler ->set($name, $value, 0, $expire)) {  

66.             if($this ->options['longueur']>0) {  

67.                   // 记录缓存队列  

68.                $this->queue($nom);  

69.              }  

70.              retour vrai;  

71.         }  

72.         retour faux ;  

73.     }  

74.   

75.     /**

76. * Supprimer le cache

77. * @access public

78. * @param string $name Nom de la variable cache

79. * @return boolen

80. */  

81.     public  fonction rm($name, $ttl = false) {  

82.         $name   =   $this->options['préfixe'].$name;  

83.         return $ttl === false ?  

84.             $this->handler->supprimer($name) :  

85.             $this->handler->supprimer($name, $ttl);  

86.     }  

87.   

88.     /**

89. * Vider le cache

90. * @access public

91. * @return boolen

92. */  

93.     public  fonction clear() {  

94.         retour $this->handler->flush ();  

95.     }  

96. }  

　　附件2：SessionMemcache.class.php

[php] voir copie simple

2. // +--------------------------------------------- -------------------------------  

3. // |   

4. // +----------------- -------------------------------------------------- ---  

5. // | Copyright (c) 2013-   

6. // +----------- -------------------------------------------------- ---------  

7. // | Sous licence ( http://www.apache.org/licenses/LICENSE-2.0 )  

8. // +-------------------------------- ---------------------------------------------

9. // | Auteur : richievoe

10. // +--------------------------------- -- ----------------------------------

11.  /**

12. * Personnalisez Memcache pour enregistrer la session

13. */ 

14. Session de coursMemcache{

15. //objet memcache 🎜> privé

16. $mem;  //heure de validité de la SESSION

17. privé

18. $expire

19.     public fonction execute(){  

20.         session_set_save_handler(  

21.             array(&$this ,'ouvrir'),   

22.             tableau(&$this,'fermer'),   

23.             array(&$this,'lire'),   

24.             array(&$this,'écrire'),   

25.  tableau(&$this,'détruire'), 

26.  tableau(&$this ,'gc')

27. 🎜>

} 
 
29. //Connectez memcached et initialisez certaines données

     

30. public

    fonction ouvert($ chemin,$name){

31. ->expire = C('SESSION_EXPIRE') ? 🎜>'session.gc_maxlifetime');

32.  $this->mem = nouveau Memcache

33.  return $this->mem->connect(C('MEMCACHE_HOST'), C('MEMCACHE_PORT')); > }

34. //Fermer le serveur Memcache

35. public

36. fonction fermer(){

    retour

37. $this->mem->close( } 

38.  

    //Lire les données
39.  
    public

40. fonction lire( $ identifiant){

41.         $id = C('SESSION_PREFIX').$ identifiant;  

42.         $data = $this-> mem->get($id);  

43.         retour $data ? $data :'';  

44.     }  

45.     //存入数据  

46.     public fonction écrire( $id,$data){  

47.         $id = C('SESSION_PREFIX').$ identifiant;  

48.         //$data = addslashes($data);  

49.         retour $this->mem->set($id,$data,0,$this->expire);  

50.     }  

51.     //销毁数据   

52.     public fonction détruire($id){  

53.         $id = C( 'SESSION_PREFIX').$id;  

54.  retourner $this->mem->supprimer ($id); >

 
55. //Destruction des déchets

     

56.   public

    fonction
57. gc(){

    🎜> vrai >

?>

59. Recommandations associées :

60. Partage d'expérience de traçage distribué PHP

Problèmes liés à la distribution PHP et au traitement des données à grande échelle

61. architecture distribuée 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!