Installation and use of memcache in PHP environment, phpmemcache_php tutorial

Installation and use of memcache in the PHP environment, Phpmemcache

Memcache is a danga.com project, the first to serve LiveJournal, many people around the world use this cache project to build their own heavy load of the site, to share the pressure of the database. It can handle any number of connections, using non-blocking network IO. Because it works by opening up a space in memory, it then builds a hashtable,memcached self-managing these hashtable. Memcache Official website: http://www.danga.com/memcached, more detailed information can come here to understand.

Why are there two names of Memcache and memcached? In fact Memcache is the name of this project, and memcached is its server side of the main program file name, know what I mean to put ~ ~ ~ ~ ~. One is the project name, one is the main program file name, on the internet to see a lot of people do not understand, so mixed.

Installation of Memcache

It is divided into two processes: Memcache server-side installation and memcached client installation.
The so-called server-side installation is to install Memcache on the server (generally Linux system) to implement data storage.
The so-called client installation refers to PHP (or other programs, memcache and other good API interface) to use the server-side memcache provided functions, PHP needs to add extensions.

PHP's Memcache

<?php  //connection  $mem = new Memcache;  $mem->connect ("db.nowamagic.net",);  Save Data  $mem->set (' key ', ' This is first value ',,);  $val = $mem->get (' key ');  echo "Get key value:". $val. "
";  Replace data  $mem->replace (' key ', ' This is replace value ',,);  $val = $mem->get (' key ');  echo "Get key value:". $val. "
";  Save array  $arr = Array (' AAA ', ' BBB ', ' CCC ', ' ddd ');  $mem->set (' key ', $arr,,);  $val = $mem->get (' key ');  echo "Get key value:";  Print_r ($val);  echo "
";  Delete Data  $mem->delete (' key ');  $val = $mem->get (' key ');  echo "Get key value:". $val. "
";  Clear all data  $mem->flush ();  $val = $mem->get (' key ');  echo "Get key value:";  Print_r ($val);  echo "
";  Close connection  $mem->close ();? >

If normal, the browser will output:

Get key Value:this is first value
Get key Value:this is replace value
Get key Value:array ([] = AAA [] = bbb [] = = CCC [] = DDD)
Get Key value:
Get Key value:

Program Code Analysis

Initializes an Memcache object: $mem = new Memcache;
Connect to our Memcache server side, the first parameter is the server's IP address, it can be the hostname, the second parameter is the open port of Memcache: $mem->connect ("192.168.0.200", 12000);

Save a data to the Memcache server, the first parameter is the data key, used to locate a data, the second parameter is to save the data content, here is a string, the third parameter is a marker, generally set to 0 or memcache_compressed on the line, The fourth parameter is the validity period of the data, that is, the data in this time is valid, if the past this time, then the memcache server side will be purged of this data, the unit is seconds, if set to 0, it is always valid, we set up here 60, is a minute effective time: $mem Set (' Key1 ', ' This is first value ', 0, 60);

Get a piece of data from the Memcache server, it has only one parameter, is the key that needs to get the data, we here is the key1 that the previous step sets, now obtains this data after output:

$val = $mem->get (' key′); echo "Get Key value:". $val;

Instead of replacing the value of the above key1 with the Replace method, the Replace method parameter is the same as set, but the first parameter, Key1, must be the key to replace the data content, and the final output is:

$mem->replace (' key ', ' This is replace value ',,); $val = $mem->get (' key '); echo "Get Key value:". $val;

Similarly, memcache can also save an array, the following is an array saved on memcache, and then get back and output:

$arr = Array (' AAA ', ' BBB ', ' CCC ', ' DDD '), $mem->set (' key ', $arr,,); $val = $mem->get (' key ');p Rint_r ($val);

Now delete a data, using the Delte interface, the parameter is a key, and then can be the Memcache server This key data delete, the final output when there is no result:

$mem->delete (' key '); $val = $mem->get (' key '); echo "Get Key value:". $val. "
";

Finally, we put all the data stored on the Memcache server erased, we will find that the data is not, the final output key2 data is empty, and finally close the connection:

$mem->flush (); $val = $mem->get (' key '); echo "Get key value:";p rint_r ($val); echo "
";

Use of Memcache

The use of Memcache website general traffic is relatively large, in order to alleviate the pressure of the database, let Memcache as a cache area, the part of the information stored in memory, in the front-end can be quickly accessed. Then the general focus is to focus on how to share the database pressure and distributed, after all, the memory capacity of a single memcache limited. Here I briefly put forward my personal views, without practice, right when reference.

Distributed applications

Memcache originally support distributed, our client a little transformation, better support. Our key can be appropriately in a regular package, such as the user-oriented site, each users have a customer ID, you can follow a fixed ID to extract and access, such as 1, the beginning of the user is saved on the first memcache server, Data for users starting with 2 are saved on the second Mecache server, and access data is converted and accessed according to the user ID first.

However, this has the disadvantage that the user ID needs to be judged, if the business is inconsistent, or other types of applications may not be appropriate, then according to their actual business to consider, or to think of a more appropriate method.

Reduce database pressure

This is more important, all the data is basically stored in the database, every time the database is frequently accessed, resulting in a very slow database performance, can not serve more users at the same time, such as MySQL, especially frequent lock table, then let memcache to share the pressure of the database. We need to change the current architecture in a way that is small and does not change the front-end on a large scale.

An easy way for me to consider:

Back end of the database operation module, all the select operation is extracted (Update/delete/insert no matter), and then the corresponding SQL for the corresponding hash algorithm to calculate a hash data key (such as MD5 or SHA), Then the key to Memcache to find the data, if the data does not exist, the description has not been written to the cache, then extract the data from the database, an array class format, and then the data in set to Memcache, key is the SQL hash value, Then the corresponding setting of a failure time, such as one hours, then one hours of data are extracted from the cache, effectively reduce the pressure of the database. The disadvantage is that the data is not real-time, when the data has been modified, can not be real-time to the front-end display, and there may be a large memory footprint, after all, the number of select out of the data may be relatively large, this is a factor to consider.

Memcache's Safety

Our above Memcache server is directly through the client connection after direct operation, there is no verification process, so if the server is directly exposed to the Internet is more dangerous, light data leakage by other unrelated personnel view, heavy server was compromised, Because the Mecache is run as root, and there may be some of our unknown bugs or buffer overflow situation, these are unknown to us, so the danger is predictable. For the sake of safety, I do two suggestions, can be a little to prevent hacking or data leakage.

Intranet access

It is best to put the access between the two servers in the intranet form, usually between the Web server and the Memcache server. Universal servers are two network card, a point to the Internet, a point to the intranet, then let the Web server through the intranet network card to access the Memcache server, we memcache on the server when the boot on the network to listen to the IP address and port, Access between the intranet can effectively block other illegal access.

# memcached-d-M 1024-u root-l 192.168.0.200-p 11211-c 1024-p/tmp/memcached.pid

The Memcache server-side setting listens on the 11211 port of the 192.168.0.200 IP over the intranet, consumes 1024MB of memory, and allows a maximum of 1024 concurrent connections.

Set up a firewall

Firewall is a simple and effective way, if the two servers are hanging in the network, and need to access the Memcache through the extranet IP, then you can consider using a firewall or agent to filter illegal access. Generally we can use iptables or FreeBSD under the Linux under the IPFW to specify some rules to prevent some illegal access, such as we can set only allow our Web server to access our Memcache server, while blocking other access.

# iptables-f
# iptables-p INPUT DROP
# iptables-a input-p tcp-s ... –dport-j ACCEPT
# iptables-a input-p udp-s ... –dport-j ACCEPT

The iptables rule above is to allow only 192.168.0.2 this Web server to the Memcache server access, can effectively prevent some illegal access, the corresponding can also add some other rules to enhance security, which can be done according to their own needs.

http://www.bkjia.com/PHPjc/1068828.html www.bkjia.com true http://www.bkjia.com/PHPjc/1068828.html techarticle PHP Environment in the installation and use of Memcache, Phpmemcache Memcache is a danga.com project, the earliest for the LiveJournal service, currently many people around the world use this cache project to construct ...

