Eine ausführliche Diskussion der verteilten PHP-Bereitstellung

In diesem Artikel werden wir die verteilte PHP-Bereitstellung mit Ihnen teilen, in der Hoffnung, dass jeder eine klarere Vorstellung von der verteilten PHP-Bereitstellung hat.

Bei der normalen Webentwicklung besteht der übliche Modus darin, dass nach der Anmeldung des Benutzers die Anmeldestatusinformationen in der Sitzung gespeichert werden und einige der häufig verwendeten Hot-Daten des Benutzers im Dateicache und im Anhang gespeichert werden Vom Benutzer hochgeladene Informationen werden an einem bestimmten Ort des Webservers in einem Verzeichnis gespeichert. Diese Methode ist sehr komfortabel zu verwenden und für allgemeine Webanwendungen voll geeignet. Bei Websites auf Unternehmensebene mit hoher Parallelität ist dies jedoch nicht möglich. Um einen Lastausgleich zu erreichen, müssen Webcluster verwendet werden.

Nach der Bereitstellung mit der Web-Cluster-Methode müssen zunächst die Benutzerstatusinformationen und Anhangsinformationen angepasst werden. Der Benutzerstatus kann nicht mehr in der Sitzung gespeichert werden, der Cache kann nicht den Dateicache des lokalen Webservers verwenden und die Anhänge können nicht auf dem Webserver gespeichert werden. Denn es muss sichergestellt werden, dass der Status jedes Webservers im Cluster vollständig konsistent ist. Daher müssen Benutzerstatus, Cache usw. auf einem dedizierten Cache-Server wie Memcache gespeichert werden. Anhänge müssen im Cloud-Speicher gespeichert werden, z. B. Qiniu Cloud Storage, Alibaba Cloud Storage, Tencent Cloud Storage usw.

In diesem Artikel wird am Beispiel des ThinkPHP-Entwicklungsframeworks erläutert, wie Sitzung, Cache usw. eingerichtet und auf dem Memcache-Cache-Server gespeichert werden.

Laden Sie die zwischengespeicherte Memcache-Verarbeitungsklasse herunter und platzieren Sie sie im ThinkphpExtendDriverCache-Verzeichnis. Laden Sie die Session Memcache-Verarbeitungsklasse herunter und platzieren Sie sie im ThinkphpExtendDriverSession-Verzeichnis, wie unten gezeigt:

Ändern Sie die Konfigurationsdatei, passen Sie die Sitzung und den Cache an und zeichnen Sie sie auf dem Memcache-Server auf. Öffnen Sie ThinkPHPConfconvention.PHP und fügen Sie Konfigurationselemente hinzu:

[php] ansehen einfache Kopie

1. /* Memcache-Cache-Einstellungen */

2. 'MEMCACHE_HOST' => '192.168.202.20',

3. 'MEMCACHE_PORT'     => 11211, 

Ändern Sie den Datencache in Memcache:

[php] Ansicht einfache Kopie

1. 'DATA_CACHE_TYPE' => 'Memcache' ,

Sitzung in Memcache ändern:

[php] Ansicht einfache Kopie

1. 'SESSION_TYPE' => ,

Wie unten gezeigt:

Da es viele Arten von Cloud-Speicher gibt, werden Anhänge im Cloud-Speicher gespeichert, daher werde ich nicht auf Details eingehen. Parametrisieren Sie einfach das von jedem Cloud-Speicher bereitgestellte SDK. Nach den oben genannten Änderungen kann der Webserver verteilt bereitgestellt werden.

Anhang 1: CacheMemcache.class.php

[php]

Ansicht einfache Kopie

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

3. // | ThinkPHP [ WIR KÖNNEN ES NUR DENKEN ES ]  

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

5. // | Copyright (c) 2006-2012 http://thinkphp.cn Alle Rechte vorbehalten.  

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

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

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

9. // | Autor: liu21st   

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

11.   

12. definiert('THINK_PATH') oder Beenden ();

13. Klasse CacheMemcache erweitert

Cache { 

15. /**

16. * Architekturfunktion

17. * @param array $options Cache Parameter

18. * @access public

20.      */  

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

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

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

24.         }  

25.   

26.         $options = array_merge(array (  

27.             '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.             'persistent'  =>  false,  

31.         ),$options);  

32.   

33.         $this ->options      =   $options;  

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

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

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

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

38.         $this->handler      =   neu Memcache;  

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

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

41.                                             🎜>$func($options['host'], $options['port '], $options[' timeout']

    } >

42. Cache lesen
🎜>
43. * @param string $name Cache Variablenname

44.      * @return mixed 

45.      */  

46.     öffentlich Funktion get( $name) {  

47.         N('cache_read',1 );  

48.         return $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äfix'].$name;  

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

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

67.                  // 记录缓存队列  

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

69.             }  

70.             zurück WAHR;  

71.         }  

72.         return false;  

73.     }  

74.   

75.     /**

76. * Cache löschen

77. * @access public

78. * @param string $name Cache-Variablenname

79. * @return boolen

80. */  

81.     öffentlich  Funktion rm($name, $ttl = falsch) {  

82.         $name   =   $this->options['prefix'].$name;  

83.         return $ttl === false ?  

84.             $this->handler->löschen($name) :  

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

86.     }  

87.   

88.     /**

89. * Cache leeren

90. * @access public

91. * @return boolen

92. */  

93.     öffentlich  Funktion clear() {  

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

95.     }  

96. }  

　　附件2：SessionMemcache.class.php

[php] Ansicht einfache Kopie

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

3. // |   

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

5. // | Copyright (c) 2013-   

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

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

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

9. // |. Autor: richievoe

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

11.  /**

12. * Memcache anpassen, um Sitzung zu speichern

13. */ 

14. Class SessionMemcache{

15. //memcache-Objekt 🎜> privat

16. $mem;  //SESSION gültige Zeit

17. privat

18. $expire; 🎜>

19.     öffentlich Funktion execute(){  

20.         session_set_save_handler(  

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

22.             Array(&$this,'close'),   

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

24.             array(&$this,'schreiben'),   

25.  array(&$this,'destroy'), 

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

27. );

28. } 

29.  //Memcached verbinden und einige Daten initialisieren 

30. öffentlich Funktionoffen($ Pfad,$name){

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

32.  $this->mem = new Memcache; 🎜>

 
33. return

    $this->mem->connect(C('MEMCACHE_HOST'), C('MEMCACHE_PORT'));

34. public
    function
35. close(){
    return

36. $this->mem->close(); } 

37.  //Daten lesen 

38. öffentlich
    Funktion
39. read(

    $id){

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

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

42.         Zurück $data ? $data :'';  

43.     }  

44.     //存入数据  

45.     öffentlich Funktion write( $id,$data){  

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

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

48.         return $this->mem->set($id,$data,0,$this->expire);  

49.     }  

50.     //销毁数据   

51.     öffentlich Funktion zerstören($id){  

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

53.  zurück $this->mem->löschen ($id); >

 
54. //Müllvernichtung

     

55.  public

    function
56. gc(){

    🎜> wahr >

?>

58. Verwandte Empfehlungen:

59. Erfahrungsaustausch mit verteilter PHP-Ablaufverfolgung

Probleme im Zusammenhang mit der verteilten PHP- und umfangreichen Datenverarbeitung

60. verteilte PHP-Architektur

Das obige ist der detaillierte Inhalt vonEine ausführliche Diskussion der verteilten PHP-Bereitstellung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!