Memached is an open-source distributed memory caching system commonly used to speed up dynamic websites by, as the name suggests, caching data objects in RAM. By caching the data in RAM, Memcached is able to reduce the number of times that the database or API must be read when performing operations on the website. Memcached is free to use and runs on Linux, OS X, and Microsoft Windows. Available under the Revised BSD license, it is possible to install the Memcached host-client infrastructure on your own Ubuntu 16 servers.<\/p>\n
This tutorial will cover the process of PHP session saving and replication for Ubuntu 16 on multiple Memcached servers.<\/p>\n
For completing this tutorial, you will need the following setup for a landscape with three servers running Ubuntu 16: Kindly note that before proceeding, you are able to act as the root user on all three servers. All commands in this tutorial, unless otherwise specified, must be executed as the root user or using the command sudo (when possessing superuser privileges) to act as root.<\/p>\n Throughout the tutorial, we will refer to the servers in our landscape using the following information in the table below. This information includes the hostname for each server, its Public IP, LAN IP, and the services that should be running on it. Make sure to refer back to this table whenever you may need to confirm which server an instruction should be executed on for a quick overview of the landscape.<\/p>\n We will begin the process with the preparation steps that must be executed on all three servers. During this preparation, you will have to ensure that the system is up to date, the firewall is disabled, and the servers are running with the latest kernel.<\/p>\n As root, on each node execute the following command using the native Ubuntu package manager apt to update the local package index with the latest information concerning available packages and package versions:<\/p>\n After fetching the new package information, apt must then be used again in order to upgrade the installed packages with available updates:<\/p>\n Your Ubuntu server comes equipped with a firewall known as the Uncomplicated Firewall, or ufw. While it is disabled by default, likely you have enabled it as some prior point. For this tutorial, we will need to disable the firewall. This is done easily with the ufw command:<\/p>\n To know whether the kernel version will need to be updated, check the current version of the kernel using the uname command:<\/p>\n The output of this command will look somewhat like the following (depending on which version is installed):<\/p>\n The latest version at this time of writing is 4.7. If you have any other version, you can update your kernel by downloading the required packages from the Ubuntu website. First, make sure you have the web utility wget, which will allow you to download files. Install wget if you do not have it using apt:<\/p>\n Finally, reboot the server for the changes to take into effect.<\/p>\n Verify that you are now running the new kernel version using uname a second time:<\/p>\n Don’t forget to run all the steps in this section on all three servers before proceeding to the next section.<\/p>\n This section will concern itself with the configuration of the node that you will use for your HAProxy load-balancer. HAProxy is a free open-source software that provides load-balancing, high-availability, and proxying services for both TCP and HTTP applications. For the purposes of this guide, we will provide a basic HAProxy configuration that should be suitable out of the box for the majority of applications.<\/p>\n On your dedicated HAProxy server, begin by installing the HAProxy package as root:<\/p>\n After the package finishes installing, you will need to enable HAProxy with the following command as it is disabled by default:<\/p>\n You can start the HAProxy service after enabling it by executing:<\/p>\n However, you must complete some further configuration steps for HAProxy before you can use it. Open up the configuration file haproxy.cfg in the text editor vi:<\/p>\n Remove all the contents from the open configuration file. Next, insert the following code to create the new configuration file. This will add a listener on port 80 on localhost for HTTP and port 443 for HTTPS:<\/p>\n Save and close the configuration file once you are done editing it. Restart HAProxy for your changes to take into effect:<\/p>\n To enable the HAProxy service to start on boot (recommended), use the update-rc.de command as shown:<\/p>\n You can check the status of HAProxy at any time to verify it is working by checking the output of the following:<\/p>\n Once you have set up your dedicated HAProxy node, you will now have to configure your two remaining web servers. The steps in this section will need to be executed twice, once on each server.<\/p>\n Begin by installing the packages for the Apache web server, PHP, and Memcached using apt. We will also install some PHP extensions as well the PHP-Memcache extension. This package provides integration functions for Memcached into your applications as well as activating Memcached support in other existing applications. Be careful when typing the name of the PHP-Memcache extension. There is another library that is not suitable for the purposes of this guide that is named php-memcached. Double check that you are instead typing the name of the extension we need, which is php-memcache (without the letter “d”). This package is lighter and has less dependencies than php-memcached.<\/p>\n When the installation of the packages completes, you will need to configure the Apache web server, particularly the ServerName directive. You can do this by opening the following file using the text editor vi:<\/p>\n Modify this file to include the following line with the a server name of your choice, which can represent the site or infrastructure. This will be used in order to easily and quickly identify the server.<\/p>\n Save and close the file to proceed. Next, you will need to verify that PHP has been properly installed and that the Memcached library is present. You can do this by checking the output of the following command, which will call PHP with the -m option to show compiled modules, before passing the output to grep using a pipe (“|”). grep will search the output it receives for the term “memcache” and return successfully if it is found.<\/p>\n After verifying that PHP and PHP-Memcache have been installed, the Memcached module will need to be configured in order to allow distributed PHP sessions. Open the memcache.ini file in the text editor vi:<\/p>\n You will need to again remove everything that is already in this file by default. Replace the contents with the following:<\/p>\n Be careful that the memcache.session_redundancy parameter has a value that corresponds to one plus the sum of your configured Memcached instances. This means that if you have two Memcached servers, you will need to enter 3 as the value. Interestingly enough, this PHP bug has never been fixed despite being widely known.<\/p>\n With the Memcached configuration complete for now, we will move on to configuring PHP to store its user sessions. Open the php.ini file for editing with vi:<\/p>\n Search this file for the line session.save_handler = files. When you find this line, delete it. In the same space as the deleted line was previously, insert the following two lines:<\/p>\n You will also need to repeat this process for the CLI-related php.ini file. Open the file for editing, delete the session.save_handler = files line, and replace it with the two lines specified above. This will be useful if you have cron (a task scheduler) jobs running PHP scripts that require session access.<\/p>\n Please ensure that you have repeated the above steps for the two servers before proceeding to the following section.<\/p>\n Both of the Memcached servers will need to be configured in order to allow Memcached to listed on their private LAN IPs. You will also need to modify the amount of memory that is allocated to each instance in this section.<\/p>\n The goal of this guide will be to set both the servers to accept 1024 connections coming from Apache processes with a cache size of 256MB per server. Such a cache size is large enough in order to store thousands of PHP sessions in RAM and works for most applications. Note that for a heavy usage scenario, it will be necessary to increase the size.<\/p>\n To begin, open the Memcached configuration file with vi:<\/p>\n You will need to modify the file contents so that they match the following. Note that the IP listed must be the respective machine’s LAN IP that you are currently working on. Remember to change it when you repeat these steps for the second server.<\/p>\n Restart Memcached and Apache to accept the new changes:<\/p>\n To enable these two services to run on boot, which is recommended, execute additionally the following lines:<\/p>\n Remember again that all of the above steps must be executed on both servers in order for Memcached to run before proceeding.<\/p>\n To ensure that our landscape has been successfully configured to the correct state, we will place a script on both the web servers that will help test the sessions and load balancing. More particularly, we will need to ensure that sessions are being created in the first place, and then that the sessions are being balanced between the two web servers. All the steps in this section must be executed on both the servers.<\/p>\n First, navigate to the default Apache webroot located in \/var\/www\/html. This repository is the source of what is being hosted on the server, and where we will create the test script. Use the following commands to change directories using cd and create the script file:<\/p>\n With the file open for editing in the text editor vi, insert the following code to form the session PHP script:<\/p>\n After saving and closing the file, we now need to visit this script using the load balancer IP address. By using the load balancer IP address (the HAProxy server), some visits will end up on the WEB1 server, while others will access the WEB2 server instead. Open the script at the following URL in your browser:<\/p>\n When the page is open, the output should look as follows:<\/p>\n Check the session ID that is output to ensure that is remains the same for each load, and that the total amount of visits increases by one upon refresh as it should. Keep refreshing until you end up on the other web server, at which point the visitor counter should still be increasing and the PHPSESSID should be the same. The output should look like the following sample:<\/p>\n If all looks correct, we can now confirm that the session is persisting across different web servers. With a second browser open to the same page, refresh a couple of times so that a session ID is created.<\/p>\n Switch to the load balancer node. To test the Memcached servers, you will need to install the additional netcat utility that will allow you to query the servers for their statistics. Install it with:<\/p>\n Use netcat to see the statistics of any given server by executing:<\/p>\n This will check the statistics of the first web server. The output should look as follows:<\/p>\n Next, you can execute the same command as above in order to check the statistics of the second server:<\/p>\n This will also provide output like the following:<\/p>\n These statistics for the servers show that activity has occurred on this instance, as expected. Both Memcached servers should have had activity and stored content. Still, it is important to note that while Memcached does utilize replication, it is not 100% fail proof. This means that if one of the two Memcached servers were to shut down, for any reason, we would not be able to guarantee that both servers did in fact contain the same exact sessions. However, if such a case were to occur, it is no cause for worry as the affected users would only need to login again to their accounts.<\/p>\n To test the failover, shutdown Memcached on any of the two web servers (but not both!) with the command:<\/p>\n Refresh the browser page you have open and observe the behavior. Does the visit counter continue to increase when you refresh the page? If so, then the failover setup is working as it should.<\/p>\n If the counter did not increase, but rather stayed the same, we will need to make an additional test to confirm that replication is working correctly. Restart Memcached on the instance you stopped it on:<\/p>\n Now, you will have to go onto the other server and kill the Memcached instance there instead. On the second server (web1 for example), kill Memcached using:<\/p>\n Go to your webpage again. If the counter increases upon refresh, then you can safely confirm that your Memcached PHP session setup works correctly with both failover and replication.<\/p>\n Congratulations! While setting up PHP session replication on multiple Memcached Ubuntu 16 servers is a lengthy process, it pays off in terms of the speed boost it gives to dynamic web applications you may be running such as WordPress or Moodle. Share this tutorial with your friends if you found it useful!<\/p>\n","protected":false},"excerpt":{"rendered":" How to distribute PHP sessions on multiple memcached instances on Ubuntu 16 Memached is an open-source distributed memory caching system commonly used to speed up dynamic websites by, as the name suggests, caching data objects in RAM. By caching the data in RAM, Memcached is able to reduce the number of times that the database<\/p>\n","protected":false},"author":3,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[75],"tags":[],"class_list":["post-2777","post","type-post","status-publish","format-standard","hentry","category-ha-clustering"],"yoast_head":"\n
\n\u2022 1 Small Server<\/b><\/a>\/Cloud Instance<\/b><\/a> (to be used for HAProxy)
\n\u2022 2 Web Servers\/Cloud Instances (to run Apache, PHP and Memcached)<\/p>\nTutorial<\/h2>\n
Server Hostname Public IP LAN IP Services Running
\nLB1 173.209.44.220 10.0.0.96 Haproxy
\nWEB1 173.209.44.221 10.0.0.97 Apache, PHP, Memcached
\nWEB2 173.209.44.230 10.0.0.98 Apache, PHP, Memcached<\/code><\/p>\nInitial Setup for All Three Servers<\/h2>\n
apt-get update<\/code><\/p>\napt-get upgrade<\/code><\/p>\nufw disable<\/code><\/p>\nuname -r<\/code><\/p>\n4.4.0-22-generic<\/code><\/p>\napt-get install
\napt-get upgrade<\/code><\/p>\nreboot<\/code><\/p>\nuname -r<\/code><\/p>\nProxy Server Configuration for the HAProxy Node<\/h2>\n
apt-get install haproxy<\/code><\/p>\nsed -i \"s\/ENABLED=0\/ENABLED=1\/g\" \/etc\/default\/haproxy<\/code><\/p>\n\/etc\/init.d\/haproxy start<\/code><\/p>\nvi \/etc\/haproxy\/haproxy.cfg<\/code><\/p>\nglobal
\nlog 127.0.0.1 local2
\nchroot \/var\/lib\/haproxy
\npidfile \/var\/run\/haproxy.pid
\nmaxconn 4096
\nuser haproxy
\ngroup haproxy
\ndaemon
\nstats socket \/var\/run\/haproxy.cmd
\ndefaults
\nmode http
\nlog global
\noption httplog
\noption dontlognull
\noption httpclose
\noption forwardfor except 127.0.0.0\/8
\noption redispatch
\nretries 3
\ntimeout http-request 10s
\ntimeout queue 1m
\ntimeout connect 10s
\ntimeout client 45s
\ntimeout server 45s
\ntimeout check 10s
\nmaxconn 4096
\nlisten http :80
\nmode http
\nbalance roundrobin
\noption forwardfor
\noption httpclose
\noption http-server-close
\ntimeout http-keep-alive 3000
\nhttp-request del-header Proxy
\nserver web1 10.0.0.94:80 weight 1 check inter 3000 rise 2 fall 1
\nserver web2 10.0.0.95:80 weight 1 check inter 3000 rise 2 fall 1<\/code><\/p>\n\/etc\/init.d\/haproxy restart<\/code><\/p>\nupdate-rc.d haproxy defaults<\/code><\/p>\nservice haproxy status<\/code><\/p>\nConfigure the Web Servers for Apache, PHP, and Memcached<\/h2>\n
apt-get -y install apache2 php libapache2-mod-php php-mcrypt memcached php-memcache libmemcached-devel php-pecl-memcache httpd <\/code><\/p>\nvi \/etc\/httpd\/conf\/httpd.conf<\/code><\/p>\nServerName mysite.com<\/code><\/p>\nphp -m | grep memcache<\/code><\/p>\nvi \/etc\/php\/7.0\/mods-available\/memcache.ini<\/code><\/p>\nextension=memcache.so
\nmemcache.maxreclevel=0
\nmemcache.maxfiles=0
\nmemcache.archivememlim=0
\nmemcache.maxfilesize=0
\nmemcache.maxratio=0
\nmemcache.hash_strategy = consistent
\nmemcache.allow_failover = 1
\nmemcache.session_redundancy = 3<\/code><\/p>\nvi \/etc\/php.ini<\/code><\/p>\nsession.save_handler = memcache
\nsession.save_path = \"tcp:\/\/10.0.0.94:11211, tcp:\/\/10.0.0.95:11211\"<\/code><\/p>\nConfiguration for the Two Memcached Servers<\/h2>\n
vi \/etc\/sysconfig\/memcached<\/code><\/p>\nPORT=\"11211\"
\nUSER=\"memcached\"
\nMAXCONN=\"1024\"
\nCACHESIZE=\"256\"
\nOPTIONS=\"-l 10.0.0.95\"<\/code><\/p>\nsystemctl restart httpd.service
\nsystemctl restart memcached.service<\/code><\/p>\nsystemctl enable httpd.service
\nsystemctl enable memcached.service<\/code><\/p>\nTesting PHP Sessions Creation and Balancing<\/h2>\n
cd \/var\/www\/html
\nvi session.php<\/code><\/p>\n<?php
\nheader('Content-Type: text\/plain');
\nsession_start();
\nif(!isset($_SESSION['visit']))
\n{
\necho \"Welcome from GloboTech! Thank you for visiting this server.\\n\";
\n$_SESSION['visit'] = 0;
\n}
\nelse
\necho \"You have visited this server \".$_SESSION['visit'] . \" times. \\n\";
\n$_SESSION['visit']++;
\necho \"Server IP: \".$_SERVER['SERVER_ADDR'] . \"\\n\";
\necho \"Client IP: \".$_SERVER['REMOTE_ADDR'] . \"\\n\";
\nprint_r($_COOKIE);
\n?><\/code><\/p>\nhttp:\/\/173.209.44.220\/session.php<\/code><\/p>\nWelcome from GloboTech! Thank you for visiting this server.
\nThis server has seen you 30 times.
\nServer IP: 10.0.0.95
\nClient IP: 10.0.0.93
\nArray
\n(
\n[PHPSESSID] => aeoj7s47i7ke2l0fr7b534v684
\n)<\/code><\/p>\nWelcome from GloboTech! Thank you for visiting this server.
\nThis server has seen you 31 times.
\nServer IP: 10.0.0.94
\nClient IP: 10.0.0.93
\nArray
\n(
\n[PHPSESSID] => aeoj7s47i7ke2l0fr7b534v684
\n)<\/code><\/p>\nTesting Failover Memcached Servers<\/h2>\n
apt-get install netcat<\/code><\/p>\necho 'stats' | nc 10.0.0.94 11211<\/code><\/p>\nSTAT pid 28882
\nSTAT uptime 39
\nSTAT time 1471052900
\nSTAT version 1.4.15
\nSTAT libevent 2.0.21-stable
\nSTAT pointer_size 64
\nSTAT rusage_user 0.016870
\nSTAT rusage_system 0.020244
\nSTAT curr_connections 5
\nSTAT total_connections 104
\nSTAT connection_structures 6
\nSTAT reserved_fds 20
\nSTAT cmd_get 1
\nSTAT cmd_set 195
\nSTAT cmd_flush 0
\nSTAT cmd_touch 0
\nSTAT get_hits 0
\nSTAT get_misses 1
\nSTAT delete_misses 0
\nSTAT delete_hits 0
\nSTAT incr_misses 1
\nSTAT incr_hits 0
\nSTAT decr_misses 0
\nSTAT decr_hits 0
\nSTAT cas_misses 0
\nSTAT cas_hits 0
\nSTAT cas_badval 0
\nSTAT touch_hits 0
\nSTAT touch_misses 0
\nSTAT auth_cmds 0
\nSTAT auth_errors 0
\nSTAT bytes_read 10212
\nSTAT bytes_written 2598
\nSTAT limit_maxbytes 268435456
\nSTAT accepting_conns 1
\nSTAT listen_disabled_num 0
\nSTAT threads 4
\nSTAT conn_yields 0
\nSTAT hash_power_level 16
\nSTAT hash_bytes 524288
\nSTAT hash_is_expanding 0
\nSTAT bytes 202
\nSTAT curr_items 2
\nSTAT total_items 195
\nSTAT expired_unfetched 0
\nSTAT evicted_unfetched 0
\nSTAT evictions 0
\nSTAT reclaimed 0
\nEND<\/code><\/p>\necho 'stats' | nc 10.0.0.95 11211<\/code><\/p>\nSTAT pid 28117
\nSTAT uptime 50
\nSTAT time 1471052915
\nSTAT version 1.4.15
\nSTAT libevent 2.0.21-stable
\nSTAT pointer_size 64
\nSTAT rusage_user 0.013569
\nSTAT rusage_system 0.039201
\nSTAT curr_connections 5
\nSTAT total_connections 103
\nSTAT connection_structures 6
\nSTAT reserved_fds 20
\nSTAT cmd_get 97
\nSTAT cmd_set 291
\nSTAT cmd_flush 0
\nSTAT cmd_touch 0
\nSTAT get_hits 96
\nSTAT get_misses 1
\nSTAT delete_misses 0
\nSTAT delete_hits 0
\nSTAT incr_misses 1
\nSTAT incr_hits 96
\nSTAT decr_misses 0
\nSTAT decr_hits 0
\nSTAT cas_misses 0
\nSTAT cas_hits 0
\nSTAT cas_badval 0
\nSTAT touch_hits 0
\nSTAT touch_misses 0
\nSTAT auth_cmds 0
\nSTAT auth_errors 0
\nSTAT bytes_read 21822
\nSTAT bytes_written 8479
\nSTAT limit_maxbytes 268435456
\nSTAT accepting_conns 1
\nSTAT listen_disabled_num 0
\nSTAT threads 4
\nSTAT conn_yields 0
\nSTAT hash_power_level 16
\nSTAT hash_bytes 524288
\nSTAT hash_is_expanding 0
\nSTAT bytes 202
\nSTAT curr_items 2
\nSTAT total_items 291
\nSTAT expired_unfetched 0
\nSTAT evicted_unfetched 0
\nSTAT evictions 0
\nSTAT reclaimed 0
\nEND<\/code><\/p>\nsystemctl stop memcached.service<\/code><\/p>\nsystemctl restart memcached.service<\/code><\/p>\nsystemctl stop memcached.service<\/code><\/p>\nConclusion<\/h2>\n