The LEMP (Linux, Nginx, MySQL, and PHP) software stack is a group of software that can be used to serve dynamic web pages and web applications. In this tutorial you’ll install a LEMP stack on your server using the packages provided by the operating system. Choose your operating system below to get started.


Ubuntu

16.04

### Introduction

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications.  This is an acronym that describes a Linux operating system, with an Nginx web server.  The backend data is stored in the MySQL database and the dynamic processing is handled by PHP.

In this guide, we will demonstrate how to install a LEMP stack on an Ubuntu 16.04 server.  The Ubuntu operating system takes care of the first requirement.  We will describe how to get the rest of the components up and running.

## Prerequisites

Before you complete this tutorial, you should have a regular, non-root user account on your server with `sudo` privileges.  You can learn how to set up this type of account by completing our [Ubuntu 16.04 initial server setup](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-16-04).

Once you have your user available, sign into your server with that username.  You are now ready to begin the steps outlined in this guide.

## Step 1: Install the Nginx Web Server

In order to display web pages to our site visitors, we are going to employ Nginx, a modern, efficient web server.

All of the software we will be using for this procedure will come directly from Ubuntu's default package repositories.  This means we can use the `apt` package management suite to complete the installation.

Since this is our first time using `apt` for this session, we should start off by updating our local package index.  We can then install the server:

```command
sudo apt-get update
sudo apt-get install nginx
```

On Ubuntu 16.04, Nginx is configured to start running upon installation.

If you have the `ufw` firewall running, as outlined in our initial setup guide, you will need to allow connections to Nginx.  Nginx registers itself with `ufw` upon installation, so the procedure is rather straight forward.

It is recommended that you enable the most restrictive profile that will still allow the traffic you want.  Since we haven't configured SSL for our server yet, in this guide, we will only need to allow traffic on port 80.

You can enable this by typing:

```command
sudo ufw allow 'Nginx HTTP'
```

You can verify the change by typing:

```command
sudo ufw status
```

You should see HTTP traffic allowed in the displayed output:

```
[secondary_label Output]
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
Nginx HTTP                 ALLOW       Anywhere                  
OpenSSH (v6)               ALLOW       Anywhere (v6)             
Nginx HTTP (v6)            ALLOW       Anywhere (v6)
```

With the new firewall rule added, you can test if the server is up and running by accessing your server's domain name or public IP address in your web browser.

If you do not have a domain name pointed at your server and you do not know your server's public IP address, you can find it by typing one of the following into your terminal:

```command
ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'
```

This will print out a few IP addresses.  You can try each of them in turn in your web browser.

As an alternative, you can check which IP address is accessible as viewed from other locations on the internet:

```command
curl -4 icanhazip.com
```

Type one of the addresses that you receive in your web browser.  It should take you to Nginx's default landing page:

```
http://<^>server_domain_or_IP<^>
```

![Nginx default page](https://assets.digitalocean.com/articles/lemp_ubuntu_1604/nginx_default.png)

If you see the above page, you have successfully installed Nginx.

## Step 2: Install MySQL to Manage Site Data

Now that we have a web server, we need to install MySQL, a database management system, to store and manage the data for our site.

You can install this easily by typing:

```command
sudo apt-get install mysql-server
```

You will be asked to supply a root (administrative) password for use within the MySQL system.

The MySQL database software is now installed, but its configuration is not exactly complete yet. 

To secure the installation, we can run a simple security script that will ask whether we want to modify some insecure defaults.  Begin the script by typing:

```command
mysql_secure_installation
```

You will be asked to enter the password you set for the MySQL root account.  Next, you will be asked if you want to configure the `VALIDATE PASSWORD PLUGIN`.

<$>[warning]
**Warning:** Enabling this feature is something of a judgment call.  If enabled, passwords which don't match the specified criteria will be rejected by MySQL with an error.  This will cause issues if you use a weak password in conjunction with software which automatically configures MySQL user credentials, such as the Ubuntu packages for phpMyAdmin.  It is safe to leave validation disabled, but you should always use strong, unique passwords for database credentials.
<$>

Answer **y** for yes, or anything else to continue without enabling.

```
VALIDATE PASSWORD PLUGIN can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD plugin?

Press y|Y for Yes, any other key for No:
```

If you've enabled validation, you'll be asked to select a level of password validation.  Keep in mind that if you enter **2**, for the strongest level, you will receive errors when attempting to set any password which does not contain numbers, upper and lowercase letters, and special characters, or which is based on common dictionary words.

```
There are three levels of password validation policy:

LOW    Length >= 8
MEDIUM Length >= 8, numeric, mixed case, and special characters
STRONG Length >= 8, numeric, mixed case, special characters and dictionary                  file

Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: <^>1<^>
```

If you enabled password validation, you'll be shown a password strength for the existing root password, and asked you if you want to change that password.  If you are happy with your current password, enter **n** for "no" at the prompt:

```
Using existing password for root.

Estimated strength of the password: <^>100<^>
Change the password for root ? ((Press y|Y for Yes, any other key for No) : <^>n<^>
```

For the rest of the questions, you should press **Y** and hit the **Enter** key at each prompt.  This will remove some anonymous users and the test database, disable remote root logins, and load these new rules so that MySQL immediately respects the changes we have made.

At this point, your database system is now set up and we can move on.

## Step 3: Install PHP for Processing

We now have Nginx installed to serve our pages and MySQL installed to store and manage our data.  However, we still don't have anything that can generate dynamic content.  We can use PHP for this.

Since Nginx does not contain native PHP processing like some other web servers, we will need to install `php-fpm`, which stands for "fastCGI process manager".  We will tell Nginx to pass PHP requests to this software for processing.

We can install this module and will also grab an additional helper package that will allow PHP to communicate with our database backend.  The installation will pull in the necessary PHP core files.  Do this by typing:

```command
sudo apt-get install php-fpm php-mysql
```

### Configure the PHP Processor

We now have our PHP components installed, but we need to make a slight configuration change to make our setup more secure.

Open the main `php-fpm` configuration file with root privileges:

```command
sudo nano /etc/php/7.0/fpm/php.ini
```

What we are looking for in this file is the parameter that sets `cgi.fix_pathinfo`.  This will be commented out with a semi-colon (;) and set to "1" by default.

This is an extremely insecure setting because it tells PHP to attempt to execute the closest file it can find if the requested PHP file cannot be found.  This basically would allow users to craft PHP requests in a way that would allow them to execute scripts that they shouldn't be allowed to execute.

We will change both of these conditions by uncommenting the line and setting it to "0" like this:

```
[label /etc/php/7.0/fpm/php.ini]
cgi.fix_pathinfo=0
```

Save and close the file when you are finished.

Now, we just need to restart our PHP processor by typing:

```command
sudo systemctl restart php7.0-fpm
```

This will implement the change that we made.

## Step 4: Configure Nginx to Use the PHP Processor

Now, we have all of the required components installed.  The only configuration change we still need is to tell Nginx to use our PHP processor for dynamic content.

We do this on the server block level (server blocks are similar to Apache's virtual hosts).  Open the default Nginx server block configuration file by typing:

```command
sudo nano /etc/nginx/sites-available/default
```

Currently, with the comments removed, the Nginx default server block file looks like this:

```
[label /etc/nginx/sites-available/default]
server {
    listen 80 default_server;
    listen [::]:80 default_server;

    root /var/www/html;
    index index.html index.htm index.nginx-debian.html;

    server_name _;

    location / {
        try_files $uri $uri/ =404;
    }
}
```

We need to make some changes to this file for our site.

* First, we need to add `index.php` as the first value of our `index` directive so that files named `index.php` are served, if available, when a directory is requested.
* We can modify the `server_name` directive to point to our server's domain name or public IP address.
* For the actual PHP processing, we just need to uncomment a segment of the file that handles PHP requests by removing the pound symbols (#) from in front of each line.  This will be the `location ~\.php$` location block, the included `fastcgi-php.conf` snippet, and the socket associated with `php-fpm`.
* We will also uncomment the location block dealing with `.htaccess` files using the same method.  Nginx doesn't process these files.  If any of these files happen to find their way into the document root, they should not be served to visitors.

The changes that you need to make are in red in the text below:

```
[label /etc/nginx/sites-available/default]
server {
    listen 80 default_server;
    listen [::]:80 default_server;

    root /var/www/html;
    index <^>index.php<^> index.html index.htm index.nginx-debian.html;

    server_name <^>server_domain_or_IP<^>;

    location / {
        try_files $uri $uri/ =404;
    }

    <^>location ~ \.php$ {<^>
        <^>include snippets/fastcgi-php.conf;<^>
        <^>fastcgi_pass unix:/run/php/php7.0-fpm.sock;<^>
    <^>}<^>

    <^>location ~ /\.ht {<^>
        <^>deny all;<^>
    <^>}<^>
}
```

When you've made the above changes, you can save and close the file.

Test your configuration file for syntax errors by typing:

```command
sudo nginx -t
```

If any errors are reported, go back and recheck your file before continuing.

When you are ready, reload Nginx to make the necessary changes:

```command
sudo systemctl reload nginx
```

## Step 5: Create a PHP File to Test Configuration

Your LEMP stack should now be completely set up.  We can test it to validate that Nginx can correctly hand `.php` files off to our PHP processor.

We can do this by creating a test PHP file in our document root.  Open a new file called `info.php` within your document root in your text editor:

```command
sudo nano /var/www/html/info.php
```

Type or paste the following lines into the new file.  This is valid PHP code that will return information about our server:

```
[label /var/www/html/info.php]
<?php
phpinfo();
```

When you are finished, save and close the file.

Now, you can visit this page in your web browser by visiting your server's domain name or public IP address followed by `/info.php`:

```
http://<^>server_domain_or_IP<^>/info.php
```

You should see a web page that has been generated by PHP with information about your server:

![PHP page info](https://assets.digitalocean.com/articles/lemp_ubuntu_1604/php_info.png)

If you see a page that looks like this, you've set up PHP processing with Nginx successfully.

After verifying that Nginx renders the page correctly, it's best to remove the file you created as it can actually give unauthorized users some hints about your configuration that may help them try to break in.  You can always regenerate this file if you need it later.

For now, remove the file by typing:

```command
sudo rm /var/www/html/info.php
```

## Conclusion

You should now have a LEMP stack configured on your Ubuntu 16.04 server.  This gives you a very flexible foundation for serving web content to your visitors.

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications. This is an acronym that describes a Linux operating system, with an Nginx web server. The backend data is stored in the MySQL database and the dynamic processing...

How To Install Linux, Nginx, MySQL, PHP (LEMP stack) in Ubuntu 16.04

How to install LEMP 

18.04

### Introduction

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications. This is an acronym that describes a **L**inux operating system, with an Nginx (pronounced like “**E**ngine-X”) web server. The backend data is stored in the **M**ySQL database and the dynamic processing is handled by **P**HP.

This guide demonstrates how to install a LEMP stack on an Ubuntu 18.04 server. The Ubuntu operating system takes care of the first requirement. We will describe how to get the rest of the components up and running.


## Prerequisites

Before you complete this tutorial, you should have a regular, non-root user account on your server with `sudo` privileges. Set up this account by completing our [initial server setup guide for Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-04).

Once you have your user available, you are ready to begin the steps outlined in this guide.


## Step 1 – Installing the Nginx Web Server

In order to display web pages for your site visitors, you’re going to employ Nginx, a modern, efficient web server.

All of the software used in this procedure will come from Ubuntu's default package repositories. This means you’ll use the `apt` package management suite to complete the necessary installations.

Since this is your first time using `apt` for this session, start off by updating your server’s package index: 

```command
sudo apt update
```
Next, install the server:

```command
sudo apt install nginx
```

On Ubuntu 18.04, Nginx is configured to start running upon installation.

If you have the `ufw` firewall running, as outlined in the initial setup guide, you will need to allow connections to Nginx. Nginx registers itself with `ufw` upon installation, so the procedure is rather straightforward.

It is recommended that you enable the most restrictive profile that will still allow the traffic you want. Since you haven't configured SSL for your server in this guide, you will only need to allow traffic on port `80`.

Enable this by typing the following:

```command
sudo ufw allow 'Nginx HTTP'
```

You can verify the change by checking the status:

```command
sudo ufw status
```

This command’s output will show that HTTP traffic is allowed:

```
[secondary_label Output]
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Nginx HTTP                 ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Nginx HTTP (v6)            ALLOW       Anywhere (v6)
```

With the new firewall rule added, you can test if the server is up and running by accessing your server's domain name or public IP address in your web browser.

If you do not have a domain name pointed at your server and you do not know your server's public IP address, you can find it by running the following command:

```command
ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'
```

This will print out a few IP addresses. You can try each of them in your web browser.

As an alternative, you can check which IP address is accessible, as viewed from other locations on the internet:

```command
curl -4 icanhazip.com
```

Type the address that you receive in your web browser and it will take you to Nginx's default landing page:

```
http://<^>server_domain_or_IP<^>
```

![Nginx default page](https://assets.digitalocean.com/articles/lemp_ubuntu_1604/nginx_default.png)

If you received a web page that states **”Welcome to nginx”** then you have successfully installed Nginx.


## Step 2 – Installing MySQL to Manage Site Data

Now that you have a web server, you need to install MySQL (a database management system) to store and manage the data for your site.

Install MySQL by typing the following command:

```command
sudo apt install mysql-server
```

The MySQL database software is now installed, but its configuration is not yet complete.

To secure the installation, MySQL comes with a script that will ask whether you want to modify some insecure defaults. Initiate the script by typing the following:

```command
sudo mysql_secure_installation
```

This script will ask if you want to configure the `VALIDATE PASSWORD PLUGIN`.

<$>[warning]
**Warning:** Enabling this feature is a judgment call. If enabled, passwords that don't match the specified criteria will be rejected by MySQL with an error. This will cause issues if you use a weak password in conjunction with software that automatically configures MySQL user credentials, such as the Ubuntu packages for phpMyAdmin. It is safe to leave validation disabled, but you should always use strong, unique passwords for database credentials.
<$>

Answer `Y` for yes, or anything else to continue without enabling.

```
VALIDATE PASSWORD PLUGIN can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD plugin?

Press y|Y for Yes, any other key for No:
```

If you've enabled validation, the script will also ask you to select a level of password validation. Keep in mind that if you enter **2** – for the strongest level – you will receive errors when attempting to set any password which does not contain numbers, upper and lowercase letters, and special characters, or which is based on common dictionary words.

```
There are three levels of password validation policy:

LOW    Length >= 8
MEDIUM Length >= 8, numeric, mixed case, and special characters
STRONG Length >= 8, numeric, mixed case, special characters and dictionary file

Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: <^>1<^>
```

Next, you'll be asked to submit and confirm a root password:

```
Please set the password for root here.

New password:

Re-enter new password:
```

For the rest of the questions, you should press `Y` and hit the `ENTER` key at each prompt. This will remove some anonymous users and the test database, disable remote root logins, and load these new rules so that MySQL immediately respects the changes we have made.

Note that in Ubuntu systems running MySQL 5.7 (and later versions), the **root** MySQL user is set to authenticate using the `auth_socket` plugin by default rather than with a password. This allows for some greater security and usability in many cases, but it can also complicate things when you need to allow an external program (e.g., phpMyAdmin) to access the user.

If using the `auth_socket` plugin to access MySQL fits with your workflow, you can proceed to Step 3. If, however, you prefer to use a password when connecting to MySQL as **root**, you will need to switch its authentication method from `auth_socket` to `mysql_native_password`. To do this, open up the MySQL prompt from your terminal:

```command
sudo mysql
```

Next, check which authentication method each of your MySQL user accounts uses with the following command:

```custom_prefix(mysql>)
SELECT user,authentication_string,plugin,host FROM mysql.user;
```
```
[secondary_label Output]
+------------------+-------------------------------------------+-----------------------+-----------+
| user             | authentication_string                     | plugin                | host      |
+------------------+-------------------------------------------+-----------------------+-----------+
| root             |                                           | auth_socket           | localhost |
| mysql.session    | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost |
| mysql.sys        | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost |
| debian-sys-maint | *CC744277A401A7D25BE1CA89AFF17BF607F876FF | mysql_native_password | localhost |
+------------------+-------------------------------------------+-----------------------+-----------+
4 rows in set (0.00 sec)
```

This example demonstrates that the **root** user does in fact authenticate using the `auth_socket` plugin. To configure the **root** account to authenticate with a password, run the following `ALTER USER` command. Be sure to change `<^>password<^>` to a strong password of your choosing:

```custom_prefix(mysql>)
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '<^>password<^>';
```

Then, run `FLUSH PRIVILEGES` to tell the server to reload the grant tables and put your new changes into effect:

```custom_prefix(mysql>)
FLUSH PRIVILEGES;
```

Check the authentication methods employed by each of your users again to confirm that **root** no longer authenticates using the `auth_socket` plugin:

```custom_prefix(mysql>)
SELECT user,authentication_string,plugin,host FROM mysql.user;
```
```
[secondary_label Output]
+------------------+-------------------------------------------+-----------------------+-----------+
| user             | authentication_string                     | plugin                | host      |
+------------------+-------------------------------------------+-----------------------+-----------+
| root             | *3636DACC8616D997782ADD0839F92C1571D6D78F | <^>mysql_native_password<^> | localhost |
| mysql.session    | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost |
| mysql.sys        | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | mysql_native_password | localhost |
| debian-sys-maint | *CC744277A401A7D25BE1CA89AFF17BF607F876FF | mysql_native_password | localhost |
+------------------+-------------------------------------------+-----------------------+-----------+
4 rows in set (0.00 sec)
```

This example output shows that the **root** MySQL user now authenticates using a password. Once you confirm this on your own server, you can exit the MySQL shell:

```custom_prefix(mysql>)
exit
```

<$>[note]
**Note**: After configuring your **root** MySQL user to authenticate with a password, you'll no longer be able to access MySQL with the `sudo mysql` command used previously. Instead, you must run the following:

```command
mysql -u root -p
```

After entering the password you set, you will receive the MySQL prompt.
<$>

At this point, your database system is now set up and you can move on to installing PHP.


## Step 3 – Installing PHP and Configuring Nginx to Use the PHP Processor

Nginx is now installed to serve your pages and MySQL is installed to store and manage your data. However, you still don't have anything that can generate dynamic content. This is where PHP comes into play.

Since Nginx does not contain native PHP processing like some other web servers, you will need to install `php-fpm`, which stands for "fastCGI process manager". After, you’ll tell Nginx to pass PHP requests to this software for processing.

<$>[note]
**Note**: Depending on your cloud provider, you may need to add Ubuntu's `universe` repository, which includes free and open-source software maintained by the Ubuntu community, before installing the `php-fpm` package. You can do this by typing the following command:

```command
sudo add-apt-repository universe
```
<$>

Install the `php-fpm` module along with an additional helper package, `php-mysql`, which will allow PHP to communicate with your database backend. The installation will pull in the necessary PHP core files. Do this by typing the following:

```command
sudo apt install php-fpm php-mysql
```

Even with all of the required LEMP stack components installed, you still need to make a few configuration changes in order to tell Nginx to use the PHP processor for dynamic content.

This is done on the server block level (server blocks are similar to Apache's virtual hosts). To do this, create a new server block configuration file using your preferred text editor within the `/etc/nginx/sites-available/` directory. In this example, we will be using `nano` and the new server block configuration file will say `your_domain`, so you can replace it with your own information:

```command
sudo nano /etc/nginx/sites-available/<^>your_domain<^>
```

By creating a new server block configuration file, rather than editing the default one, you’ll be able to restore the default configuration if you ever need to.

Add the following content, which was taken and slightly modified from the default server block configuration file, to your new server block configuration file:

```
[label /etc/nginx/sites-available/your_domain]
server {
        listen 80;
        root /var/www/html;
        index index.php index.html index.htm index.nginx-debian.html;
        server_name <^>your_domain<^>;

        location / {
                try_files $uri $uri/ =404;
        }

        location ~ \.php$ {
                include snippets/fastcgi-php.conf;
                fastcgi_pass unix:/var/run/php/php7.2-fpm.sock;
        }

        location ~ /\.ht {
                deny all;
        }
}
```

Here’s what each directives and location blocks does:

* `listen` — Defines what port Nginx will listen on. In this case, it will listen on port `80`, the default port for HTTP.
* `root` — Defines the document root where the files served by the website are stored.
* `index` — Configures Nginx to prioritize serving files named `index.php` when an index file is requested if they’re available.
* `server_name` — Defines which server block should be used for a given request to your server. **Point this directive to your server's domain name or public IP address.**
* `location /` — The first location block includes a `try_files` directive, which checks for the existence of files matching a URI request. If Nginx cannot find the appropriate file, it will return a 404 error.
* `location ~ \.php$` — This location block handles the actual PHP processing by pointing Nginx to the `fastcgi-php.conf` configuration file and the `php7.2-fpm.sock` file, which declares what socket is associated with `php-fpm`.
* `location ~ /\.ht` — The last location block deals with `.htaccess` files, which Nginx does not process. By adding the `deny all` directive, if any `.htaccess` files happen to find their way into the document root they will not be served to visitors.

After adding this content, save and close the file. If you’re using `nano`, you can do this by pressing `CTRL + X` then `Y` and `ENTER`. Enable your new server block by creating a symbolic link from your new server block configuration file (in the `/etc/nginx/sites-available/` directory) to the `/etc/nginx/sites-enabled/` directory:

```command
sudo ln -s /etc/nginx/sites-available/<^>your_domain<^> /etc/nginx/sites-enabled/
```

Then, unlink the default configuration file from the `/sites-enabled/` directory:

```command
sudo unlink /etc/nginx/sites-enabled/default
```

<$>[note]
**Note**: If you ever need to restore the default configuration, you can do so by recreating the symbolic link using a command like the following:

```command
sudo ln -s /etc/nginx/sites-available/default /etc/nginx/sites-enabled/
```
<$>

Test your new configuration file for syntax errors:

```command
sudo nginx -t
```

If any errors are reported, go back and recheck your file before continuing.

When you are ready, reload Nginx to make the necessary changes:

```command
sudo systemctl reload nginx
```

This concludes the installation and configuration of your LEMP stack. However, it’s prudent to confirm that all of the components can communicate with one another.


## Step 4 – Creating a PHP File to Test Configuration

Your LEMP stack should now be completely set up. You can test it to validate that Nginx can correctly hand `.php` files off to the PHP processor.

To do this, use your preferred text editor to create a test PHP file called `info.php` in your document root:

```command
sudo nano /var/www/html/info.php
```

Enter the following lines into the new file. This is valid PHP code that will return information about your server:

```
[label /var/www/html/info.php]
<?php
phpinfo();
```

When you are finished, save and close the file. 

Now, you can visit this page in your web browser by visiting your server's domain name or public IP address followed by `/info.php`:

```
http://<^>your_server_domain_or_IP<^>/info.php
```

Your browser will load a web page like the following that has been generated by PHP with information about your server:

![PHP page info](https://assets.digitalocean.com/lemp_ubuntu_1804/php_info_1804.png)

If your page is as described, you've set up PHP processing with Nginx successfully.

After verifying that Nginx renders the page correctly, it's best to remove the file you created as it can actually give unauthorized users some hints about your configuration that may help them try to break in. You can always regenerate this file if you need it later.

For now, remove the file:

```command
sudo rm /var/www/html/info.php
```

With that, you have a fully configured and functioning LEMP stack on your Ubuntu 18.04 server.


## Conclusion

A LEMP stack is a powerful platform that will allow you to set up and serve nearly any website or application from your server.

There are a number of next steps you could take from here. For example, you should ensure that connections to your server are secured. To this end, you could [secure your Nginx installation with Let’s Encrypt](https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu-18-04). By following this guide, you will acquire a free TLS/SSL certificate for your server, allowing it to serve content over HTTPS.

This tutorial details the process for installing and configuring the components that constitute a LEMP stack on an Ubuntu 18.04 server, including Nginx, MySQL, and PHP. It also includes instructions for testing that these components can communicate effectively and serve your content correctly.

How To Install Linux, Nginx, MySQL, PHP (LEMP stack) on Ubuntu 18.04

14.04

### Introduction

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications.  This is an acronym that describes a Linux operating system, with an Nginx web server.  The backend data is stored in MySQL and the dynamic processing is handled by PHP.

In this guide, we will demonstrate how to install a LEMP stack on an Ubuntu 14.04 server.  The Ubuntu operating system takes care of the first requirement.  We will describe how to get the rest of the components up and running.

<$>[note]
**Note:** The LEMP Stack can be installed automatically on your Droplet by adding [this script](http://do.co/1LGk9EC) to its User Data when launching it. Check out [this tutorial](https://www.digitalocean.com/community/tutorials/an-introduction-to-droplet-metadata) to learn more about Droplet User Data.
<$>

## Prerequisites

Before you complete this tutorial, you should have a regular, non-root user account on your server with `sudo` privileges.  You can learn how to set up this type of account by completing steps 1-4 in our [Ubuntu 14.04 initial server setup](https://www.digitalocean.com/community/articles/initial-server-setup-with-ubuntu-14-04).

Once you have your account available, sign into your server with that username.  You are now ready to begin the steps outlined in this guide.

## 1. Install the Nginx Web Server

In order to display web pages to our site visitors, we are going to employ Nginx, a modern, efficient web server.

All of the software we will be getting for this procedure will come directly from Ubuntu's default package repositories.  This means we can use the `apt` package management suite to complete the installation.

Since this is our first time using `apt` for this session, we should start off by updating our local package index.  We can then install the server:

    sudo apt-get update
    sudo apt-get install nginx

In Ubuntu 14.04, Nginx is configured to start running upon installation.

You can test if the server is up and running by accessing your server's domain name or public IP address in your web browser.

If you do not have a domain name pointed at your server and you do not know your server's public IP address, you can find it by typing one of the following into your terminal:

<pre>
ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'
</pre>
<pre>
<span class="highlight">111.111.111.111</span>
<span class="highlight">fe80::601:17ff:fe61:9801</span>
</pre>

Or you could try using:

<pre>
curl http://icanhazip.com
</pre>
<pre>
<span class="highlight">111.111.111.111</span>
</pre>

Try one of the lines that you receive in your web browser.  It should take you to Nginx's default landing page:

<pre>
http://<span class="highlight">server_domain_name_or_IP</span>
</pre>

![Nginx default page](https://assets.digitalocean.com/articles/lemp_1404/nginx_default.png)

If you see the above page, you have successfully installed Nginx.

## 2. Install MySQL to Manage Site Data

Now that we have a web server, we need to install MySQL, a database management system, to store and manage the data for our site.

You can install this easily by typing:

    sudo apt-get install mysql-server

You will be asked to supply a root (administrative) password for use within the MySQL system.

The MySQL database software is now installed, but its configuration is not exactly complete yet. 

First, we need to tell MySQL to generate the directory structure it needs to store its databases and information.  We can do this by typing:

    sudo mysql_install_db

Next, you'll want to run a simple security script that will prompt you to modify some insecure defaults.  Begin the script by typing:

    sudo mysql_secure_installation

You will need to enter the MySQL root password that you selected during installation.

Next, it will ask if you want to change that password.  If you are happy with your MySQL root password, type "N" for no and hit "ENTER".  Afterwards, you will be prompted to remove some test users and databases.  You should just hit "ENTER" through these prompts to remove the unsafe default settings.

Once the script has been run, MySQL is ready to go.

## 3. Install PHP for Processing

Now we have Nginx installed to serve our pages and MySQL installed to store and manage our data, but we still need something to connect these two pieces and to generate dynamic content.  We can use PHP for this.

Since Nginx does not contain native PHP processing like some other web servers, we will need to install `php5-fpm`, which stands for "fastCGI process manager".  We will tell Nginx to pass PHP requests to this software for processing.

We can install this module and will also grab an additional helper package that will allow PHP to communicate with our database backend.  The installation will pull in the necessary PHP core files.  Do this by typing:

    sudo apt-get install php5-fpm php5-mysql

### Configure the PHP Processor

We now have our PHP components installed, but we need to make a slight configuration change to make our setup more secure.

Open the main `php5-fpm` configuration file with root privileges:

    sudo nano /etc/php5/fpm/php.ini

What we are looking for in this file is the parameter that sets `cgi.fix_pathinfo`.  This will be commented out with a semi-colon (;) and set to "1" by default.

This is an extremely insecure setting because it tells PHP to attempt to execute the closest file it can find if a PHP file does not match exactly.  This basically would allow users to craft PHP requests in a way that would allow them to execute scripts that they shouldn't be allowed to execute.

We will change both of these conditions by uncommenting the line and setting it to "0" like this:

    cgi.fix_pathinfo=0

Save and close the file when you are finished.

Now, we just need to restart our PHP processor by typing:

    sudo service php5-fpm restart

This will implement the change that we made.

## 4. Configure Nginx to Use our PHP Processor

Now, we have all of the required components installed.  The only configuration change we still need to do is tell Nginx to use our PHP processor for dynamic content.

We do this on the server block level (server blocks are similar to Apache's virtual hosts).  Open the default Nginx server block configuration file by typing:

    sudo nano /etc/nginx/sites-available/default

Currently, with the comments removed, the Nginx default server block file looks like this:

<pre>
server {
    listen 80 default_server;
    listen [::]:80 default_server ipv6only=on;

    root /usr/share/nginx/html;
    index index.html index.htm;

    server_name localhost;

    location / {
        try_files $uri $uri/ =404;
    }
}
</pre>

We need to make some changes to this file for our site.

* First, we need to add an `index.php` option as the first value of our `index` directive to allow PHP index files to be served when a directory is requested.
* We also need to modify the `server_name` directive to point to our server's domain name or public IP address.
* The actual configuration file includes some commented out lines that define error processing routines.  We will uncomment those to include that functionality.
* For the actual PHP processing, we will need to uncomment a portion of another section.  We will also need to add a `try_files` directive to make sure Nginx doesn't pass bad requests to our PHP processor.

The changes that you need to make are in red in the text below:

<pre>
server {
    listen 80 default_server;
    listen [::]:80 default_server ipv6only=on;

    root /usr/share/nginx/html;
    index <span class="highlight">index.php</span> index.html index.htm;

    server_name <span class="highlight">server_domain_name_or_IP</span>;

    location / {
        try_files $uri $uri/ =404;
    }

    <span class="highlight">error_page 404 /404.html;</span>
    <span class="highlight">error_page 500 502 503 504 /50x.html;</span>
    <span class="highlight">location = /50x.html {</span>
        <span class="highlight">root /usr/share/nginx/html;</span>
    <span class="highlight">}</span>

    <span class="highlight">location ~ \.php$ {</span>
        <span class="highlight">try_files $uri =404;</span>
        <span class="highlight">fastcgi_split_path_info ^(.+\.php)(/.+)$;</span>
        <span class="highlight">fastcgi_pass unix:/var/run/php5-fpm.sock;</span>
        <span class="highlight">fastcgi_index index.php;</span>
        <span class="highlight">fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;</span>
        <span class="highlight">include fastcgi_params;</span>
    <span class="highlight">}</span>
}
</pre>

When you've made the above changes, you can save and close the file.

Restart Nginx to make the necessary changes:

    sudo service nginx restart

## 5. Create a PHP File to Test Configuration

Your LEMP stack should now be completely set up.  We still should test to make sure that Nginx can correctly hand `.php` files off to our PHP processor.

We can do this by creating a test PHP file in our document root.  Open a new file called `info.php` within your document root in your text editor:

    sudo nano /usr/share/nginx/html/info.php

We can type this into the new file.  This is valid PHP code that will return formatted information about our server:

    <?php
    phpinfo();
    ?>

When you are finished, save and close the file.

Now, you can visit this page in your web browser by visiting your server's domain name or public IP address followed by `/info.php`:

<pre>
http://<span class="highlight">server_domain_name_or_IP</span>/info.php
</pre>

You should see a web page that has been generated by PHP with information about your server:

![PHP page info](https://assets.digitalocean.com/articles/lemp_1404/php_info.png)

If you see a page that looks like this, you've set up PHP processing with Nginx successfully.

After you test this, it's probably best to remove the file you created as it can actually give unauthorized users some hints about your configuration that may help them try to break in.  You can always regenerate this file if you need it later.

For now, remove the file by typing:

    sudo rm /usr/share/nginx/html/info.php

## Conclusion

You should now have a LEMP stack configured on your Ubuntu 14.04 server.  This gives you a very flexible foundation for serving web content to your visitors.

<div class="author">By Justin Ellingwood</div>


A LEMP stack (Linux, Nginx, MySQL, and PHP) is a powerful set of software that can be configured to serve dynamic sites and web apps from your server.  In this guide, we will discuss how to install a LEMP stack on an Ubuntu 14.04 server.

How To Install Linux, Nginx, MySQL, PHP (LEMP) stack on Ubuntu 14.04

Debian

### Introduction

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications.  This is an acronym that describes a Linux operating system, with an Nginx web server.  The backend data is stored in the MySQL database and the dynamic processing is handled by PHP.

In this guide, you'll install a LEMP stack on a Debian server using the packages provided by the operating system.

## Prerequisites

To complete this guide, you will need:

* A Debian 8 server with a non-root user with `sudo` privileges. You can set up a user with these privileges in our [Initial Server Setup with Debian 8](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-8) guide.

## Step 1 — Install the Nginx Web Server

In order to display web pages to our site visitors, we are going to employ Nginx, a modern, efficient web server.

All of the software we will be using for this procedure will come directly from Debian's default package repositories.  This means we can use the `apt` package management suite to complete the installation.

Since this is our first time using `apt` for this session, we should start off by updating our local package index.  We can then install the server:

```command
sudo apt-get update
sudo apt-get install nginx
```

On Debian 8, Nginx is configured to start running upon installation.

If you have the `ufw` firewall running, you will need to allow connections to Nginx. You should enable the most restrictive profile that will still allow the traffic you want.  Since we haven't configured SSL for our server yet, in this guide, we will only need to allow traffic on port `80`.

You can enable this by typing:

```command
sudo ufw allow 'Nginx HTTP'
```

You can verify the change by typing:

```command
sudo ufw status
```

You should see HTTP traffic allowed in the displayed output:

```
[secondary_label Output]
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
Nginx HTTP                 ALLOW       Anywhere                  
OpenSSH (v6)               ALLOW       Anywhere (v6)             
Nginx HTTP (v6)            ALLOW       Anywhere (v6)
```

Now, test if the server is up and running by accessing your server's domain name or public IP address in your web browser. If you do not have a domain name pointed at your server and you do not know your server's public IP address, you can find it by typing one of the following into your terminal:

```command
ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'
```

This will print out a few IP addresses.  You can try each of them in turn in your web browser.

As an alternative, you can check which IP address is accessible as viewed from other locations on the internet:

```command
curl -4 icanhazip.com
```

Type one of the addresses that you receive in your web browser.  It should take you to Nginx's default landing page:

```
http://<^>server_domain_or_IP<^>
```

![Nginx default page](https://assets.digitalocean.com/articles/lemp_debian8/THcJfIl.png)

If you see the above page, you have successfully installed Nginx.

## Step 2 — Install MySQL to Manage Site Data

Now that we have a web server, we need to install MySQL, a database management system, to store and manage the data for our site.

You can install this easily by typing:

```command
sudo apt-get install mysql-server
```

You will be asked to supply a root (administrative) password for use within the MySQL system, and you'll need to confirm that password.

The MySQL database software is now installed, but its configuration is not exactly complete yet. 

To secure the installation, we can run a simple security script that will ask whether we want to modify some insecure defaults.  Begin the script by typing:

```command
sudo mysql_secure_installation
```

You will be asked to enter the password you set for the MySQL **root** account.  Then you'll be asked you if you want to change that password.  If you are happy with your current password, enter `N` for "no" at the prompt:

```
Using existing password for root.

Setting the root password ensures that nobody can log into the MySQL
root user without the proper authorisation.

You already have a root password set, so you can safely answer 'n'.

Change the root password? [Y/n] <^>n<^>
 ... skipping.
```

For the rest of the questions the script asks, you should press `Y`, followed by the `ENTER` key at each prompt.  This will remove some anonymous users and the test database, disable remote root logins, and load these new rules so that MySQL immediately respects the changes you have made.

At this point, your database system is now set up and secured. Let's set up PHP.

## Step 3 — Install PHP for Processing

We now have Nginx installed to serve our pages and MySQL installed to store and manage our data.  However, we still don't have anything that can generate dynamic content. That's where PHP comes in.

Since Nginx does not contain native PHP processing like some other web servers, we will need to install `fpm`, which stands for "fastCGI process manager".  We will tell Nginx to pass PHP requests to this software for processing. We'll also install an additional helper package that will allow PHP to communicate with our MySQL  database backend.  The installation will pull in the necessary PHP core files to make that work. 

These packages aren't available in the default repositories due to licensing issues, so we'll have to modify the repository sources to pull them in.

Open `/etc/apt/sources.list` in your text editor:

```command
sudo nano /etc/apt/sources.list
```

Then, for each source, append the `contrib` and `non-free` repositories to each source. Your file should look like the following after you've made those changes:

```
[label /etc/apt/sources.list]
...
deb http://mirrors.digitalocean.com/debian jessie main <^>contrib non-free<^>
deb-src http://mirrors.digitalocean.com/debian jessie main <^>contrib non-free<^>

deb http://security.debian.org/ jessie/updates main <^>contrib non-free<^>
deb-src http://security.debian.org/ jessie/updates main <^>contrib non-free<^>

# jessie-updates, previously known as 'volatile'
deb http://mirrors.digitalocean.com/debian jessie-updates main <^>contrib non-free<^>
deb-src http://mirrors.digitalocean.com/debian jessie-updates main <^>contrib non-free<^>
```

Save and exit the file. Then update your sources:

```command
sudo apt-get update
```

Then install the `php5-fpm` and `php5-mysql` modules:

```command
sudo apt-get install php5-fpm php5-mysql
```

We now have our PHP components installed, but we need to make a slight configuration change to make our setup more secure.

Open the main `php-fpm` configuration file with root privileges:

```command
sudo nano /etc/php5/fpm/php.ini
```

Look in the file for the parameter that sets `cgi.fix_pathinfo`.  This will be commented out with a semi-colon (;) and set to "1" by default.

This is an extremely insecure setting because it tells PHP to attempt to execute the closest file it can find if the requested PHP file cannot be found.  This basically would allow users to craft PHP requests in a way that would allow them to execute scripts that they shouldn't be allowed to execute.

We will change both of these conditions by uncommenting the line and setting it to "0" like this:

```
[label /etc/php5/fpm/php.ini]
cgi.fix_pathinfo=0
```

Save and close the file when you are finished.

Now, we just need to restart our PHP processor by typing:

```command
sudo systemctl restart php5-fpm
```

This will implement the change that we made.

## Step 4 — Configure Nginx to Use the PHP Processor

Now, we have all of the required components installed.  The only configuration change we still need is to tell Nginx to use our PHP processor for dynamic content.

We do this on the server block level (server blocks are similar to Apache's virtual hosts).  Open the default Nginx server block configuration file by typing:

```command
sudo nano /etc/nginx/sites-available/default
```

Currently, with the comments removed, the Nginx default server block file looks like this:

```
[label /etc/nginx/sites-available/default]
server {
    listen 80 default_server;
    listen [::]:80 default_server;

    root /var/www/html;
    index index.html index.htm index.nginx-debian.html;

    server_name _;

    location / {
        try_files $uri $uri/ =404;
    }
}
```

We need to make some changes to this file for our site.

* First, we need to add `index.php` as the first value of our `index` directive so that files named `index.php` are served, if available, when a directory is requested.
* We can modify the `server_name` directive to point to our server's domain name or public IP address.
* For the actual PHP processing, we just need to uncomment a segment of the file that handles PHP requests.  This will be the `location ~\.php$` location block, the included `fastcgi-php.conf` snippet, and the socket associated with `php-fpm`.
* We will also uncomment the location block dealing with `.htaccess` files.  Nginx doesn't process these files.  If any of these files happen to find their way into the document root, they should not be served to visitors.

The changes that you need to make are in red in the text below:

```
[label /etc/nginx/sites-available/default]
server {
    listen 80 default_server;
    listen [::]:80 default_server;

    root /var/www/html;
    index <^>index.php<^> index.html index.htm index.nginx-debian.html;

    server_name <^>your_server_ip<^>;

    location / {
        try_files $uri $uri/ =404;
    }

    <^>location ~ \.php$ {<^>
        <^>include snippets/fastcgi-php.conf;<^>
        <^>fastcgi_pass unix:/var/run/php5-fpm.sock;<^>
    <^>}<^>

    <^>location ~ /\.ht {<^>
        <^>deny all;<^>
    <^>}<^>
}
```

When you've made the above changes, you can save and close the file.

Test your configuration file for syntax errors by typing:

```command
sudo nginx -t
```

If any errors are reported, go back and recheck your file before continuing.

When you are ready, reload Nginx to make the necessary changes:

```command
sudo systemctl reload nginx
```

## Step 5 — Create a PHP File to Test Configuration

Your LEMP stack should now be completely set up.  We can test it to validate that Nginx can correctly hand `.php` files off to our PHP processor.

We can do this by creating a test PHP file in our document root.  Open a new file called `info.php` within your document root in your text editor:

```command
sudo nano /var/www/html/info.php
```

Type or paste the following lines into the new file.  This is valid PHP code that will return information about our server:

```
[label /var/www/html/info.php]
<?php
  phpinfo();
?>
```

When you are finished, save and close the file.

Now, you can visit this page in your web browser by visiting your server's domain name or public IP address followed by `/info.php`:

```
http://<^>server_domain_or_IP<^>/info.php
```

You should see a web page that has been generated by PHP with information about your server:

![PHP page info](https://assets.digitalocean.com/articles/lemp_debian8/ZP3DpyX.png)

If you see a page that looks like this, you've set up PHP processing with Nginx successfully.

After verifying that Nginx renders the page correctly, it's best to remove the file you created as it can actually give unauthorized users some hints about your configuration that may help them try to break in.

For now, remove the file by typing:

```command
sudo rm /var/www/html/info.php
```

You can always regenerate this file if you need it later.

## Conclusion

You should now have a LEMP stack configured on your Debian server.  This gives you a very flexible foundation for serving web content to your visitors.


How To Install Linux, Nginx, MySQL, PHP (LEMP Stack) on Debian 8

CentOS

### Introduction

A LEMP software stack is a group of open source software that is typically installed together to enable a server to host dynamic websites and web apps.  This term is actually an acronym which represents the **L**inux operating system, with the **E**Nginx web server (which replaces the Apache component of a LAMP stack).  The site data is stored in a **M**ySQL-based database, and dynamic content is processed by **P**HP.

In this guide, we'll get a LEMP stack with PHP 7.4 installed on a CentOS 7 server, using MariaDB as the database management system. MariaDB works as a drop-in replacement for the original MySQL server, which in practice means you can switch to MariaDB without having to make any configuration or code changes in your application.

## Prerequisites

Before you begin with this guide, you should have a separate, non-root user account set up on your server.  You can learn how to do this by completing steps 1-4 in the [initial server setup for CentOS 7](https://www.digitalocean.com/community/articles/initial-server-setup-with-centos-7).

## Step 1 — Installing Nginx

In order to display web pages to our site visitors, we are going to employ Nginx, a high-performance web server. To get the latest Nginx version, we'll first install the EPEL repository, which contains additional software for the CentOS 7 operating system.

To add the CentOS 7 EPEL repository, run the following command:

```command
sudo yum install epel-release
```

Since we are using a `sudo` command, these operations get executed with root privileges.  It will ask you for your regular user's password to verify that you have permission to run commands with root privileges. You'll also be prompted to confirm installation, so press `Y` to proceed.

Now that the EPEL repository is installed on your server, install Nginx using the following `yum` command:

```command
sudo yum install nginx
```

Once the installation is finished, start the Nginx service with:

```command
sudo systemctl start nginx
```

You can do a spot check right away to verify that everything went as planned by visiting your server's public IP address in your web browser (see the note under the next heading to find out what your public IP address is if you do not have this information already):

```
[secondary_label Open in a web browser:]
http://<^>server_domain_name_or_IP<^>/
```

You will see the default CentOS 7 Nginx web page, which is there for informational and testing purposes.  It should look something like this:

![CentOS 7 Nginx Default](https://assets.digitalocean.com/articles/lemp_centos7/nginx_centos7.png)

If you see this page, then your web server is now correctly installed.

To enable Nginx to start on boot, run the following command:

```command
sudo systemctl enable nginx
```

### How To Find Your Server's Public IP Address

If you do not know what your server's public IP address is, there are a number of ways you can find it.  Usually, this is the address you use to connect to your server through SSH.

From the command line, you can find this a few ways.  First, you can use the `iproute2` tools to get your address by typing this:

```command
ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'
```

This will give you one or two lines back.  They are both correct addresses, but your computer may only be able to use one of them, so feel free to try each one.

An alternative method is to use an outside party to tell you how *it* sees your server.  You can do this by asking a specific server what your IP address is:

```command
curl http://icanhazip.com
```

Regardless of the method you use to get your IP address, you can type it into your web browser's address bar to get to your server.

## Step 2 — Installing MariaDB

Now that we have our web server up and running, it is time to install MariaDB, a MySQL drop-in replacement.  MariaDB is a community-developed fork of the MySQL relational database management system.

Again, we can use `yum` to acquire and install our software.  This time, we'll also install some other helper packages that will assist us in getting our components to communicate with each other:

```command
sudo yum install mariadb-server mariadb
```

When the installation is complete, we need to start MariaDB with the following command:

```command
sudo systemctl start mariadb
```

Now that our MariaDB database is running, we want to run a security script that will remove some dangerous defaults and lock down access to our database. Start the interactive script by running:

```command
sudo mysql_secure_installation
```

The prompt will ask you for your current `root` MariaDB password. Since you just installed MariaDB, you most likely won’t have one, so leave it blank by pressing enter. Then the prompt will ask you if you want to set a `root` password. Go ahead and enter `Y`, and follow the instructions:

```
[secondary_label mysql_secure_installation prompts:]
Enter current password for root (enter for none): 
OK, successfully used password, moving on...

Setting the root password ensures that nobody can log into the MariaDB
root user without the proper authorisation.

Set root password? [Y/n] y
New password: 
Re-enter new password: 
Password updated successfully!
Reloading privilege tables..
 ... Success!
```

For the rest of the questions, you should hit the "ENTER" key through each prompt to accept the default values.  This will remove some sample users and databases, disable remote root logins, and load these new rules so that MySQL immediately respects the changes we have made.

The last thing you will want to do is enable MariaDB to start on boot. Use the following command to do so:

```command
sudo systemctl enable mariadb
```

At this point, your database system is now set up and we can move on.

## Step 3 — Installing PHP

PHP is the component of our setup that will process code to display dynamic content.  It can run scripts, connect to our MySQL databases to get information, and hand the processed content over to our web server to display.

The PHP version available by default within CentOS 7 servers is outdated, and for that reason, we'll need to install a third-party package repository in order to obtain PHP 7+ and get it installed on your CentOS 7 server. [Remi](https://rpms.remirepo.net/) is a popular package repository providing the most up-to-date PHP releases for CentOS servers.

To install the Remi repository for CentOS 7, run:

```command
sudo yum install http://rpms.remirepo.net/enterprise/remi-release-7.rpm
``` 

After the installation is done, you'll need to run a command to enable the repository containing your preferred version of PHP. To check which PHP 7+ releases are available in the Remi repository, run:

```command
yum --disablerepo="*" --enablerepo="remi-safe" list php[7-9][0-9].x86_64
```

You'll see output like this:

```
[secondary_label Output]
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
 * remi-safe: mirrors.ukfast.co.uk
Available Packages
php70.x86_64                                              2.0-1.el7.remi                                       remi-safe
php71.x86_64                                              2.0-1.el7.remi                                       remi-safe
php72.x86_64                                              2.0-1.el7.remi                                       remi-safe
php73.x86_64                                              2.0-1.el7.remi                                       remi-safe
php74.x86_64                                              1.0-3.el7.remi                                       remi-safe
php80.x86_64                                              1.0-3.el7.remi                                       remi-safe
```

In this guide, we'll install PHP 7.4, which is currently the most updated stable version of PHP. To enable the correct Remi package to get PHP 7.4 installed, run:

```command
sudo yum-config-manager --enable remi-php<^>74<^>
```

Now we can proceed to use `yum` for installing PHP as usual. The following command will install all the required packages to get PHP 7.4 set up within Nginx and allow it to connect to MySQL-based databases:

```command
sudo yum install php php-mysqlnd php-fpm
``` 

To confirm that PHP is available as your chosen version, run:

```command
php --version
```

You'll see output like this:

```
[secondary_label Output]
PHP 7.4.5 (cli) (built: Apr 14 2020 12:54:33) ( NTS )
Copyright (c) The PHP Group
Zend Engine v3.4.0, Copyright (c) Zend Technologies
```

PHP is now successfully installed on your system. Next, we need to make a few adjustments to the default configuration. To facilitate editing files on CentOS, we'll first install `nano`, a more user-friendly text editor than `vi`:

```command
sudo yum install nano
```

Open the `/etc/php-fpm.d/www.conf` configuration file using `nano` or your editor of choice:

```command
sudo nano /etc/php-fpm.d/www.conf
```

Now look for the `user` and `group` directives. If you are using `nano`, you can hit `CTRL`+`W` to search for these terms inside the open file.

```
[label /etc/php-fpm.d/www.conf]
…
; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
;       will be used.
; RPM: apache user chosen to provide access to the same directories as httpd
user = <^>apache<^>
; RPM: Keep a group allowed to write in log dir.
group = <^>apache<^>
…
```

You'll notice that both the `user` and `group` variables are set to `apache`. We need to change these to `nginx`:

```
[label /etc/php-fpm.d/www.conf]
…
; RPM: apache user chosen to provide access to the same directories as httpd
user = <^>nginx<^>
; RPM: Keep a group allowed to write in log dir.
group = <^>nginx<^>
…
```

Next, locate the `listen` directive. By default, `php-fpm` will listen on a specific host and port  over TCP. We want to change this setting so it listens on a local socket file, since this improves the overall performance of the server.
Change the line containing the `listen` directive to the following:

```
[label /etc/php-fpm.d/www.conf]
listen = <^>/var/run/php-fpm/php-fpm.sock<^>;
```

Finally, we'll need to change the owner and group settings for the socket file we just defined within the `listen` directive. Locate the `listen.owner`, `listen.group` and `listen.mode` directives. These lines are commented out by default. Uncomment them by removing the preceding `;` sign at the beginning of the line. Then, change the owner and group to `nginx`:

```
[label /etc/php-fpm.d/www.conf]
<^>listen.owner = nginx<^>
<^>listen.group = nginx<^>
<^>listen.mode = 0660<^>
``` 

Save and close the file when you're done editing. If you are using `nano`, do so by pressing `CTRL + X`, then `Y` and `ENTER`.

To enable and start the `php-fpm` service, run:

```command
sudo systemctl start php-fpm
```
Your PHP environment is now ready. Next, we'll configure Nginx so that it sends all requests for PHP scripts to be processed by `php-fpm`.

## Step 4 — Configuring Nginx to Process PHP Pages

Now, we have all of the required components installed. The only configuration change we still need to do is tell Nginx to use our PHP processor for dynamic content.

Nginx has a dedicated directory where we can define each hosted website as a separate configuration file, using a server block. This is similar to Apache's virtual hosts. 

With the default installation, however, this directory is empty. We'll create a new file to serve as the default PHP website on this server, which will override the default server block defined in the `/etc/nginx/nginx.conf` file.

First, open a new file in the `/etc/nginx/conf.d` directory:

```command
sudo nano /etc/nginx/conf.d/default.conf
```

Copy the following PHP server definition block to your configuration file, and don't forget to replace the `server_name` directive so that it points to your server's domain name or IP address:

```
[label /etc/nginx/conf.d/default.conf]
server {
    listen       80;
    server_name  <^>server_domain_or_IP<^>;

    root   /usr/share/nginx/html;
    index index.php index.html index.htm;

    location / {
        try_files $uri $uri/ =404;
    }
    error_page 404 /404.html;
    error_page 500 502 503 504 /50x.html;
    
    location = /50x.html {
        root /usr/share/nginx/html;
    }

    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_pass unix:<^>/var/run/php-fpm/php-fpm.sock<^>;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}
```

Save and close the file when you're done.

Next, restart Nginx to apply the changes:

```command
sudo systemctl restart nginx
```

Your web server is now fully set up. In the next step, we'll test the PHP integration to Nginx.

## Step 5 — Testing PHP Processing on your Web Server

Now that your web server is set up, we can create a test PHP script to make sure Nginx is correctly handling `.php` scripts with the help of `php-fpm`.

Before creating our script, we'll make a change to the default ownership settings on Nginx's document root, so that our regular sudo user is able to create files in that location.

The following command will change the ownership of the default Nginx document root to a user and group called <^>sammy<^>, so be sure to replace the highlighted username and group in this command to reflect your system's username and group.

```command
sudo chown -R <^>sammy<^>.<^>sammy<^> /usr/share/nginx/html/
```

We'll now create a test PHP page to make sure the web server works as expected.

Create a new PHP file called `info.php` at the `/usr/share/nginx/html` directory:

```command
nano /usr/share/nginx/html/<^>info.php<^>
```

The following PHP code will display information about the current PHP environment running on the server:

```php
[label /usr/share/nginx/html/info.php]
<?php

phpinfo();
```

When you are finished, save and close the file.

Now we can test whether our web server can correctly display content generated by a PHP script.  Go to your browser and access your server hostname or IP address, followed by `/info.php`:

```
http://<^>server_host_or_IP<^>/info.php
```

You'll see a page similar to this:

![CentOS 7 PHP 7.4 info](https://assets.digitalocean.com/articles/lemp_centos7/phpinfo_74.png)

After checking the relevant information about your PHP server through that page, it’s best to remove the file you created as it contains sensitive information about your PHP environment and your CentOS server. You can use `rm` to remove that file:

```command
rm /usr/share/nginx/html/<^>info.php<^>
```

You can always regenerate this file if you need it later.

## Conclusion

In this guide, you've built a flexible foundation for serving PHP websites and applications to your visitors, using Nginx as web server and the latest PHP release version. You've set up Nginx to handle PHP requests through `php-fpm`, and you also set up a MariaDB database to store your website's data. 


In this guide, we'll get a LEMP stack installed on an CentOS 7 server. A LEMP software stack is a group of open source software that is typically installed together to enable a server to host dynamic websites and web apps.  This term is actually an acronym which represents the Linux operating system, with the ENginx web server (which replaces the Apache component of a LAMP stack).  The site data is stored in a MySQL database (using MariaDB), and dynamic content is processed by PHP.

How To Install Linux, Nginx, MySQL, PHP (LEMP) stack On CentOS 7

<span class="warning"><p></p>

<h2><strong>Status:</strong> Deprecated</h2>

<p>This article covers a version of CentOS that is no longer supported. If you are currently operating a server running CentOS 6, we highly recommend upgrading or migrating to a supported version of CentOS.</p>

<p><strong>Reason:</strong>
<a href="https://wiki.centos.org/About/Product">CentOS 6 reached end of life (EOL) on November 30th, 2020</a> and no longer receives security patches or updates. For this reason, this guide is no longer maintained.</p>

<p><strong>See Instead:</strong><br>
This guide might still be useful as a reference, but may not work on other CentOS releases. If available, we strongly recommend using a guide written for the version of CentOS you are using.</p>
<p>The following DigitalOcean tutorial may be of interest, as it outlines installing a LEMP stack on a CentOS 7 server:
<br>
<ul>
<li><a href="https://www.digitalocean.com/community/tutorials/how-to-install-linux-nginx-mysql-php-lemp-stack-on-centos-7">How To Install Linux, Nginx, MySQL, PHP (LEMP) stack On CentOS 7</a></li>
</ul><br></p></span>


<h3>About Lemp</h3>

<p>LEMP stack is a group of open source software to get web servers up and running. The acronym stands for Linux, nginx (pronounced Engine x), MySQL, and PHP. Since the server is already running CentOS, the linux part is taken care of. Here is how to install the rest.</p> 

<h2>Step One—Install the Required Repositories</h2>

<p>We will be installing all of the required software with Yum. However, because nginx is not available straight from CentOS, we'll need to install the epel repository.</p>

<pre>sudo yum install epel-release</pre>

<h2>Step Two—Install MySQL</h2>

<p>The next step is to begin installing the server software on the virtual private server, starting with MySQL and dependancies.</p>

<pre> sudo yum install mysql-server</pre>

<p>Once the download is complete, restart MySQL:</p>

<pre>sudo /etc/init.d/mysqld restart</pre>

<p>You can do some configuration of MySQL with this command:</p>

<pre>sudo /usr/bin/mysql_secure_installation</pre>

<p>The prompt will ask you for your current root password.</p>  

<p>Since you just installed MySQL, you most likely won’t have one, so leave it blank by pressing enter.</p>

<pre>Enter current password for root (enter for none): 
OK, successfully used password, moving on...</pre>  

<p>Then the prompt will ask you if you want to set a root password. Go ahead and choose Y and follow the instructions.</p>  

<p>CentOS automates the process of setting up MySQL, asking you a series of yes or no questions.</p>
  
<p>It’s easiest just to say Yes to all the options. At the end, MySQL will reload and implement the changes.</p>

<pre>By default, a MySQL installation has an anonymous user, allowing anyone
to log into MySQL without having to have a user account created for
them.  This is intended only for testing, and to make the installation
go a bit smoother.  You should remove them before moving into a
production environment.

Remove anonymous users? [Y/n] y                                            
 ... Success!

Normally, root should only be allowed to connect from 'localhost'.  This
ensures that someone cannot guess at the root password from the network.

Disallow root login remotely? [Y/n] y
... Success!

By default, MySQL comes with a database named 'test' that anyone can
access.  This is also intended only for testing, and should be removed
before moving into a production environment.

Remove test database and access to it? [Y/n] y
 - Dropping test database...
 ... Success!
 - Removing privileges on test database...
 ... Success!

Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.

Reload privilege tables now? [Y/n] y
 ... Success!

Cleaning up...

All done!  If you've completed all of the above steps, your MySQL
installation should now be secure.

Thanks for using MySQL!</pre>

<h2> Step Three—Install nginx</h2>

<p>As with MySQL, we will install nginx on our virtual private server using yum:</p>

<pre>sudo yum install nginx</pre>

<p>nginx does not start on its own. To get nginx running, type:</p>

<pre>sudo /etc/init.d/nginx start</pre>

<p>You can confirm that nginx has installed on your virtual private server by directing your browser to your IP address.</p> 

<p>You can run the following command to reveal your server’s IP address.</p>

<pre>ifconfig eth0 | grep inet | awk '{ print $2 }'</pre>


<h2>Step Four—Install PHP</h2>

<p>The php-fpm package is located within the REMI repository, which, at this point, is disabled. The first thing we need to do is enable the REMI repository and install php and php-fpm:</p>

<pre>sudo yum install php-fpm php-mysql</pre>

<h2>Step Five—Configure php</h2>

<p>We need to make one small change in the php configuration. Open up php.ini:</p>

<pre> sudo vi /etc/php.ini</pre>

<p>Find the line, cgi.fix_pathinfo=1, and change the 1 to 0.</p> 

<pre>cgi.fix_pathinfo=0</pre>

<p>If this number is kept as a 1, the php interpreter will do its best to process the file that is as near to the requested file as possible. This is a possible security risk. If this number is set to 0, conversely, the interpreter will only process the exact file path—a much safer alternative. Save and Exit.</p>



<h2>Step Six—Configure nginx</h2>

<p>Open up the default nginx config file:</p>

<pre>sudo vi /etc/nginx/nginx.conf</pre>

<p>Raise the number of worker processes to 4 then save and exit that file.</p> 

<p>Now we should configure the nginx virtual hosts.</p>

<p>In order to make the default nginx file more concise, the virtual host details are in a different location.</p> 

<pre>sudo vi /etc/nginx/conf.d/default.conf</pre>

<p>The configuration should include the changes below (the details of the changes are under the config information):</p>

<pre>#
# The default server
#
server {
    listen       80;
    server_name example.com;

   
    location / {
        root   /usr/share/nginx/html;
        index index.php  index.html index.htm;
    }

    error_page  404              /404.html;
    location = /404.html {
        root   /usr/share/nginx/html;
    }

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }

    # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
    #
    location ~ \.php$ {
        root           /usr/share/nginx/html;
        fastcgi_pass   127.0.0.1:9000;
        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME   $document_root$fastcgi_script_name;
        include        fastcgi_params;
    }
}

</pre>

<p>Here are the details of the changes:</p>

<ul><li>Add index.php within the index line.</li>
<li>Change the server_name to your domain name or IP address (replace the example.com in the configuration)</li>
<li>Change the root to  /usr/share/nginx/html;</li>
<li>Uncomment the section beginning with "location ~ \.php$ {", </li>
<li>Change the root to access the actual document root, /usr/share/nginx/html;</li> 
<li>Change the fastcgi_param line to help the PHP interpreter find the PHP script that we stored in the document root home.</li></ul>

<p>Save and Exit</p>

<p>Open up the php-fpm configuration:</p>

<pre>sudo vi /etc/php-fpm.d/www.conf</pre>

 <p>Replace the apache in the user and group with nginx:</p>

<pre>[...]
; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
;	will be used.
; RPM: apache Choosed to be able to access some dir as httpd
user = nginx
; RPM: Keep a group allowed to write in log dir.
group = nginx
[...]</pre>


<p>Finish by restarting php-fpm.</p> 

<pre>sudo service php-fpm restart</pre>

<h2>Step Seven—RESULTS: Create a php info page</h2>

<p>Although LEMP is installed, we can still take a look and see the components online by creating a quick php info page</p>

<p>To set this up, first create a new file:</p>

<pre>sudo vi /usr/share/nginx/html/info.php</pre>

<p>Add in the following line:</p>

<pre>&lt;?php
phpinfo();
?></pre>

<p>Then Save and Exit.</p> 

<p>Restart nginx so that all of the changes take effect:</p>

<pre>sudo service nginx restart</pre>

<p>Finish up by visiting your php info page (make sure you replace the example ip address with your correct one): http://12.34.56.789/info.php</p>

<p>It should look similar to <a href="https://assets.digitalocean.com/tutorial_images/hu4uM.png">this</a>.</p>


<h2>Step Eight—Set Up Autostart</h2>

<p>You are almost done. The last step is to set all of the newly installed programs to automatically begin when the VPS boots.</p>

<pre>sudo chkconfig --levels 235 mysqld on
sudo chkconfig --levels 235 nginx on
sudo chkconfig --levels 235 php-fpm on</pre>


<div class="author">By Etel Sverdlov</div>

LEMP stack is a group of open source software to get web servers up and running. The acronym stands for Linux, nginx (pronounced Engine x), MySQL, and PHP. This tutorial explains how to install the required repos to download nginx and php-fpm, how to install MySQL, how to install nginx,  how to install php-fpm, how to configure php and nginx, and how to create a php info page. This tutorial is written for CentOS.

How To Install Linux, nginx, MySQL, PHP (LEMP) stack on CentOS 6

12.04

<span class="warning"><p></p>

<div name="status-deprecated" data-unique="status-deprecated"></div><h2 id="status-deprecated"><strong>Status:</strong> Deprecated</h2>

<p>This article covers a version of Ubuntu that is no longer supported.  If you are currently operate a server running Ubuntu 12.04, we highly recommend upgrading or migrating to a supported version of Ubuntu:</p>

<ul>
<li><a href="https://www.digitalocean.com/community/tutorials/how-to-upgrade-ubuntu-12-04-lts-to-ubuntu-14-04-lts">Upgrade to Ubuntu 14.04</a>.</li>
<li><a href="https://www.digitalocean.com/community/tutorials/how-to-upgrade-to-ubuntu-16-04-lts">Upgrade from Ubuntu 14.04 to Ubuntu 16.04</a></li>
<li><a href="https://www.digitalocean.com/community/tutorials/how-to-migrate-linux-servers-part-1-system-preparation">Migrate the server data to a supported version</a></li>
</ul>

<p><strong>Reason:</strong>
<a href="https://lists.ubuntu.com/archives/ubuntu-announce/2017-March/000218.html">Ubuntu 12.04 reached end of life (EOL) on April 28, 2017</a> and no longer receives security patches or updates.  This guide is no longer maintained.</p>

<p><strong>See Instead:</strong><br>
This guide might still be useful as a reference, but may not work on other Ubuntu releases.  If available, we strongly recommend using a guide written for the version of Ubuntu you are using.   You can use the search functionality at the top of the page to find a more recent version.<br></p></span><h3>About Lemp</h3>

<p>LEMP stack is a group of open source software to get web servers up and running. The acronym stands for Linux, nginx (pronounced Engine x), MySQL, and PHP. Since the server is already running Ubuntu, the linux part is taken care of. Here is how to install the rest.</p> 

<h2>Setup</h2>

<p>The steps in this tutorial require the user to have root privileges. You can see how to set that up in the <a href="https://www.DigitalOcean.com/community/articles/initial-server-setup-with-ubuntu-12-04">Initial Server Setup Tutorial</a> in steps 3 and 4.</p> 

<h2>Step One—Update Apt-Get</h2>

<p>Throughout this tutorial we will be using apt-get as an installer for all the server programs. On May 8th, 2012, a serious php vulnerability was discovered, and it is important that we download all of the latest patched software to protect the virtual private server.</p> 

<p>Let's do a thorough update.</p> 

<pre>sudo apt-get update</pre>

<h2>Step Two—Install MySQL</h2>

<p>MySQL is a powerful database management system used for organizing and retrieving data</p>

<p>To install MySQL, open terminal and type in these commands:</p>

<pre>sudo apt-get install mysql-server php5-mysql</pre>

<p>During the installation, MySQL will ask you to set a root password. If you miss the chance to set the password while the program is installing, it is very easy to set the password later from within the MySQL shell.</p>

<p>Once you have installed MySQL, we should activate it with this command:</p>

<pre>sudo mysql_install_db</pre>

<p>Finish up by running the MySQL set up script:</p>

<pre>sudo /usr/bin/mysql_secure_installation</pre>

<p>The prompt will ask you for your current root password.</p>

<p>Type it in.</p> 

<pre>Enter current password for root (enter for none): 
OK, successfully used password, moving on...</pre>

<p>Then the prompt will ask you if you want to change the root password. Go ahead and choose N and move on to the next steps.</p> 


<p>It’s easiest just to say Yes to all the options. At the end, MySQL will reload and implement the new changes.</p>
 
<pre>By default, a MySQL installation has an anonymous user, allowing anyone
to log into MySQL without having to have a user account created for
them.  This is intended only for testing, and to make the installation
go a bit smoother.  You should remove them before moving into a
production environment.

Remove anonymous users? [Y/n] y                                            
 ... Success!

Normally, root should only be allowed to connect from 'localhost'.  This
ensures that someone cannot guess at the root password from the network.

Disallow root login remotely? [Y/n] y
... Success!

By default, MySQL comes with a database named 'test' that anyone can
access.  This is also intended only for testing, and should be removed
before moving into a production environment.

Remove test database and access to it? [Y/n] y
 - Dropping test database...
 ... Success!
 - Removing privileges on test database...
 ... Success!

Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.

Reload privilege tables now? [Y/n] y
 ... Success!

Cleaning up...</pre>

<p>Once you're done with that you can finish up by installing PHP.</p>

<h2>Step Three—Install nginx</h2>

<p>Once MySQL is all set up, we can move on to installing nginx on the VPS.</p>

<pre>echo "deb http://ppa.launchpad.net/nginx/stable/ubuntu $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/nginx-stable.list
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys C300EE8C
sudo apt-get update
sudo apt-get install nginx</pre>

<p>nginx does not start on its own. To get nginx running, type:</p>

<pre>sudo service nginx start</pre>

<p>You can confirm that nginx has installed an your web server by directing your browser to your IP address.</p> 

<p>You can run the following command to reveal your VPS's IP address.</p>

<pre>ifconfig eth0 | grep inet | awk '{ print $2 }'</pre>

<h2>Step Four—Install PHP</h2>

<p>To install PHP-FPM, open terminal and type in these commands. We will configure the details of nginx and php details in the next step:</p>

<pre>sudo apt-get install php5-fpm</pre>

<h2>Step Five—Configure php</h2>
We need to make one small change in the php configuration.Open up php.ini:
<pre> sudo nano /etc/php5/fpm/php.ini</pre>

Find the line, cgi.fix_pathinfo=1, and change the 1 to 0. 

<pre>cgi.fix_pathinfo=0</pre>

If this number is kept as 1, the php interpreter will do its best to process the file that is as near to the requested file as possible. This is a possible security risk. If this number is set to 0, conversely, the interpreter will only process the exact file path—a much safer alternative. Save and Exit. 

We need to make another small change in the php5-fpm configuration.Open up www.conf:
<pre> sudo nano /etc/php5/fpm/pool.d/www.conf</pre>

Find the line, listen = 127.0.0.1:9000, and change the 127.0.0.1:9000 to /var/run/php5-fpm.sock. 

<pre>listen = /var/run/php5-fpm.sock</pre>

<p>Save and Exit.</p> 

<p>Restart php-fpm:</p>

<pre>sudo service php5-fpm restart</pre>

<h2>Step Six—Configure nginx</h2>

<p>Open up the default virtual host file.</p>

<pre>sudo nano /etc/nginx/sites-available/default</pre>

<p>The configuration should include the changes below (the details of the changes are under the config information):</p>

<p><strong>UPDATE:</strong> Newer Ubuntu versions create a directory called 'html' instead of 'www' by default. If /usr/share/nginx/www does not exist, it's probably called html. Make sure you update your configuration appropriately.</p>

<pre> [...]
server {
        listen   80;
     

        root /usr/share/nginx/www;
        index index.php index.html index.htm;

        server_name example.com;

        location / {
                try_files $uri $uri/ /index.html;
        }

        error_page 404 /404.html;

        error_page 500 502 503 504 /50x.html;
        location = /50x.html {
              root /usr/share/nginx/www;
        }

        # pass the PHP scripts to FastCGI server listening on the php-fpm socket
        location ~ \.php$ {
                try_files $uri =404;
                fastcgi_pass unix:/var/run/php5-fpm.sock;
                fastcgi_index index.php;
                fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
                include fastcgi_params;
                
        }

}
[...]</pre>


<p>Here are the details of the changes:</p>

<ul><li>Add index.php to the index line. </li>
<li>Change the server_name from local host to your domain name or IP address (replace the example.com in the configuration) </li>
<li>Change the  correct lines in “location ~ \.php$ {“ section</li></ul>

<p>Save and Exit</p>

<h2>Step Seven—Create a php Info Page</h2>

<p>We can quickly see all of the details of the new php configuration.</p> 

<p>To set this up, first create a new file:</p>

<pre>sudo nano /usr/share/nginx/www/info.php</pre>

Add in the following line:

<pre>&lt;?php
phpinfo();
?></pre>

<p>Then Save and Exit.</p> 

<p>Restart nginx</p>

<pre>sudo service nginx restart</pre>

<p>You can see the nginx and php-fpm configuration details by visiting http://youripaddress/info.php</p>

<p>Your LEMP stack is now set up and configured on your virtual private server.</p>


<h2>See More</h2>

<p>After installing LEMP, you can <a href="https://www.digitalocean.com/community/articles/how-to-install-wordpress-with-nginx-on-ubuntu-12-04">Install WordPress</a>, go on to do more with MySQL (<a href="https://www.digitalocean.com/community/articles/a-basic-mysql-tutorial">A Basic MySQL Tutorial</a>) or <a href="https://www.digitalocean.com/community/articles/how-to-install-phpmyadmin-on-a-lemp-server/">Install phpMyAdmin</a>, <a href="https://www.digitalocean.com/community/articles/how-to-create-a-ssl-certificate-on-nginx-for-ubuntu-12-04">Create an SSL Certificate</a>, or <a href="https://www.digitalocean.com/community/articles/how-to-set-up-vsftpd-on-ubuntu-12-04">Install an FTP Server</a>.</p> 

<div class="author">By Etel Sverdlov</div>

LEMP stack is a group of open source software to get web servers up and running. The acronym stands for Linux, nginx (pronounced Engine x), MySQL, and PHP. This tutorial explains how to install the required repos to download nginx and php-fpm, how to install MySQL, how to install nginx,  how to install php-fpm, how to configure php and nginx, and how to create a php info page. This tutorial is written for Ubuntu 12.04.

How To Install Linux, nginx, MySQL, PHP (LEMP) stack on Ubuntu 12.04

### Introduction

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications. This is an acronym that describes a Linux operating system, with an Nginx web server. The backend data is stored in the MySQL database and the dynamic processing is handled by PHP.

In this guide, you'll install a LEMP stack on a Debian server using the packages provided by the operating system.

## Prerequisites

To complete this guide, you will need a Debian 9 server with a non-root user with `sudo` privileges. You can set up a user with these privileges in our [Initial Server Setup with Debian 9](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-9) guide.

## Step 1 — Installing the Nginx Web Server

In order to display web pages to our site visitors, we are going to employ Nginx, a modern, efficient web server.

All of the software we will be using for this procedure will come directly from Debian's default package repositories. This means we can use the `apt` package management suite to complete the installation.

Since this is our first time using `apt` for this session, we should start off by updating our local package index. We can then install the server:

```command
sudo apt update
sudo apt install nginx
```

On Debian 9, Nginx is configured to start running upon installation.

If you have the `ufw` firewall running, you will need to allow connections to Nginx. You should enable the most restrictive profile that will still allow the traffic you want. Since we haven't configured SSL for our server yet, in this guide, we will only need to allow traffic on port `80`.

You can enable this by typing:

```command
sudo ufw allow 'Nginx HTTP'
```

You can verify the change by typing:

```command
sudo ufw status
```

You should see HTTP traffic allowed in the displayed output:

```
[secondary_label Output]
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Nginx HTTP                 ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Nginx HTTP (v6)            ALLOW       Anywhere (v6)
```

Now, test if the server is up and running by accessing your server's domain name or public IP address in your web browser. If you do not have a domain name pointed at your server and you do not know your server's public IP address, you can find it by typing one of the following into your terminal:

```command
ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'
```

This will print out a few IP addresses. You can try each of them in turn in your web browser.

Type one of the addresses that you receive in your web browser. It should take you to Nginx's default landing page:

```
http://<^>your_domain_or_IP<^>
```

![Nginx default page](https://assets.digitalocean.com/articles/lemp_debian8/THcJfIl.png)

If you see the above page, you have successfully installed Nginx.

## Step 2 — Installing MySQL to Manage Site Data

Now that we have a web server, we need to install MySQL, a database management system, to store and manage the data for our site.

You can install this easily by typing:

```command
sudo apt install mysql-server
```

<$>[note]
**Note:** In Debian 9 a community fork of the MySQL project – MariaDB – is packaged as the default MySQL variant. While, MariaDB works well in most cases, if you need features found only in Oracle's MySQL, you can install and use packages from a repository maintained by the MySQL developers. To install the official MySQL server, use our tutorial [_How To Install the Latest MySQL on Debian 9_](https://www.digitalocean.com/community/tutorials/how-to-install-the-latest-mysql-on-debian-9).
<$>

The MySQL database software is now installed, but its configuration is not complete.

To secure the installation, we can run a security script that will ask whether we want to modify some insecure defaults. Begin the script by typing:

```command
sudo mysql_secure_installation
```

You will be asked to enter the password for the MySQL **root** account. We haven't set this yet, so just hit `ENTER`. Then you'll be asked you if you want to set that password. You should type `y` then set a **root** password.

For the rest of the questions the script asks, you should press `y`, followed by the `ENTER` key at each prompt. This will remove some anonymous users and the test database, disable remote root logins, and load these new rules so that MySQL immediately respects the changes you have made.

At this point, your database system is now set up and secured. Let's set up PHP.

## Step 3 — Installing PHP for Processing

We now have Nginx installed to serve our pages and MySQL installed to store and manage our data. However, we still don't have anything that can generate dynamic content. That's where PHP comes in.

Since Nginx does not contain native PHP processing like some other web servers, we will need to install `fpm`, which stands for "fastCGI process manager". We will tell Nginx to pass PHP requests to this software for processing. We'll also install an additional helper package that will allow PHP to communicate with our MySQL database backend. The installation will pull in the necessary PHP core files to make that work.

Then install the `php-fpm` and `php-mysql` packages:

```command
sudo apt install php-fpm php-mysql
```

We now have our PHP components installed. Next we'll configure Nginx to use them.

## Step 4 — Configuring Nginx to Use the PHP Processor

Now we have all of the required components installed. The only configuration change we still need is to tell Nginx to use our PHP processor for dynamic content.

We do this on the server block level (server blocks are similar to Apache's virtual hosts). We're going to leave the default Nginx configuration alone and instead create a new configuration file and new web root directory to hold our PHP files. We'll name the configuration file and the directory after the domain name or hostname that the server should respond to.

First, create a new directory in `/var/www` to hold the PHP site:

```command
sudo mkdir /var/www/<^>your_domain<^>
```

Then, open a new configuration file in Nginx's `sites-available` directory:

```command
sudo nano /etc/nginx/sites-available/<^>your_domain<^>
```

This will create a new blank file. Paste in the following bare-bones configuration:

```
[label /etc/nginx/sites-available/your_domain]
server {
    listen 80;
    listen [::]:80;

    root /var/www/<^>your_domain<^>;
    index index.php index.html index.htm;

    server_name <^>your_domain<^>;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php7.0-fpm.sock;
    }
}
```

This is a very basic configuration that listens on port 80 and serves files from the web root we just created. It will only respond to requests to the name provided after `server_name`, and any files ending in `.php` will be processed by the `php-fpm` process before Nginx sends the results to the user.

Save and close the file when you're done customizing it.

Activate your configuration by linking to the config file from Nginx's `sites-enabled` directory:

```command
sudo ln -s /etc/nginx/sites-available/<^>your_domain<^>.conf /etc/nginx/sites-enabled/
```

This will tell Nginx to use the configuration next time it is reloaded. First, test your configuration for syntax errors by typing:

```command
sudo nginx -t
```

If any errors are reported, go back and recheck your file before continuing.

When you are ready, reload Nginx to make the changes:

```command
sudo systemctl reload nginx
```

Next we'll create a file in our new web root directory to test out PHP processing.

## Step 5 — Create a PHP File to Test Configuration

Your LEMP stack should now be completely set up. We can test it to validate that Nginx can correctly hand `.php` files off to our PHP processor.

We can do this by creating a test PHP file in our document root. Open a new file called `info.php` within your document root in your text editor:

```command
sudo nano /var/www/<^>your_domain<^>/info.php
```

Type or paste the following lines into the new file. This is valid PHP code that will return information about our server:

```
[label /var/www/your_domain/info.php]
<?php
  phpinfo();
?>
```

When you are finished, save and close the file.

Now, you can visit this page in your web browser by visiting your server's domain name or public IP address followed by `/info.php`:

```
http://<^>your_domain<^>/info.php
```

You should see a web page that has been generated by PHP with information about your server:

![PHP page info](https://assets.digitalocean.com/articles/lemp_debian8/ZP3DpyX.png)

If you see a page that looks like this, you've set up PHP processing with Nginx successfully.

After verifying that Nginx renders the page correctly, it's best to remove the file you created as it can actually give unauthorized users some hints about your configuration that may help them try to break in.

For now, remove the file by typing:

```command
sudo rm /var/www/html/info.php
```

You can always regenerate this file if you need it later.

## Conclusion

You should now have a LEMP stack configured on your Debian server. This gives you a very flexible foundation for serving web content to your visitors.


The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications. This is an acronym that describes a Linux operating system, with an Nginx web server. The backend data is stored in the MySQL database and the dynamic processing is...

How To Install Linux, Nginx, MySQL, PHP (LEMP stack) on Debian 9

### Introduction

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications. The name "LEMP" is an acronym that describes a **L**inux operating system, with an (**E**)Nginx web server. The backend data is stored in a **M**ariaDB database and the dynamic processing is handled by **P**HP. 

Although this software stack typically includes **MySQL** as the database management system, some Linux distributions — including Debian — use [MariaDB](https://mariadb.org) as a drop-in replacement for MySQL.

In this guide, you'll install a LEMP stack on a Debian 10 server using MariaDB as the database management system.

## Prerequisites

To complete this guide, you will need access to a Debian 10 server. This server should have a regular user configured with `sudo` privileges and a firewall enabled with `ufw`. To set this up, you can follow our  [Initial Server Setup with Debian 10](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-10) guide.

## Step 1 — Installing the Nginx Web Server

In order to serve web pages to your site visitors, we are going to employ [Nginx](https://www.nginx.com/), a popular web server which is well known for its overall performance and stability.

All of the software you will be using for this procedure will come directly from Debian's default package repositories. This means you can use the `apt` package management suite to complete the installation.

Since this is the first time you'll be using `apt` for this session, you should start off by updating your local package index. You can then install the server:

```command
sudo apt update
sudo apt install nginx
```

On Debian 10, Nginx is configured to start running upon installation.

If you have the `ufw` firewall running, you will need to allow connections to Nginx. You should enable the most restrictive profile that will still allow the traffic you want. Since you haven't configured SSL for your server yet, for now you only need to allow HTTP traffic on port `80`.

You can enable this by typing:

```command
sudo ufw allow 'Nginx HTTP'
```

You can verify the change by typing:

```command
sudo ufw status
```

You should see HTTP traffic allowed in the displayed output:

```
[secondary_label Output]
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Nginx HTTP                 ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Nginx HTTP (v6)            ALLOW       Anywhere (v6)
```

Now, test if the server is up and running by accessing your server's domain name or public IP address in your web browser. If you do not have a domain name pointed at your server and you do not know your server's public IP address, you can find it by typing one of the following into your terminal:

```command
ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'
```

This will print out a few IP addresses. You can try each of them in turn in your web browser.

Type one of the addresses that you receive in your web browser. It should take you to Nginx's default landing page:

```
http://<^>your_domain_or_IP<^>
```

![Nginx default page](https://assets.digitalocean.com/articles/lemp_debian8/THcJfIl.png)

If you see the above page, you have successfully installed Nginx.

## Step 2 — Installing MariaDB

Now that you have a web server up and running, you need to install the database system to be able to store and manage data for your site. 

In Debian 10, the metapackage `mysql-server`, which was traditionally used to install the MySQL server, was replaced by `default-mysql-server`. This metapackage references [MariaDB](https://mariadb.org/), a community fork of the original MySQL server by Oracle, and it's currently the default MySQL-compatible database server available on debian-based package manager repositories. 

For longer term compatibility, however, it’s recommended that instead of using the metapackage you install MariaDB using the program’s actual package, `mariadb-server`. 

To install this software, run:

```command
sudo apt install mariadb-server
```

When the installation is finished, it's recommended that you run a security script that comes pre-installed with MariaDB. This script will remove some insecure default settings and lock down access to your database system. Start the interactive script by running:

```command
sudo mysql_secure_installation
```

This script will take you through a series of prompts where you can make some changes to your MariaDB setup. The first prompt will ask you to enter the current **database root** password. This is not to be confused with the **system root**. The **database root** user is an administrative user with full privileges over the database system. Because you just installed MariaDB and haven’t made any configuration changes yet, this password will be blank, so just press `ENTER` at the prompt. 

The next prompt asks you whether you'd like to set up a **database root** password. Because MariaDB uses a special authentication method for the **root** user that is typically safer than using a password, you don't need to set this now. Type `N` and then press `ENTER`. 

From there, you can press `Y` and then `ENTER` to accept the defaults for all the subsequent questions. This will remove anonymous users and the test database, disable remote **root** login, and load these new rules so that MariaDB immediately respects the changes you have made.
When you're finished, log in to the MariaDB console by typing:

```command
sudo mariadb
```

This will connect to the MariaDB server as the administrative database user **root**, which is inferred by the use of `sudo` when running this command. You should see output like this:

```
[secondary_label Output]
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 74
Server version: 10.3.15-MariaDB-1 Debian 10

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]> 
```

Notice that you didn't need to provide a password to connect as the **root** user. That works because the default authentication method for the administrative MariaDB user is `unix_socket` instead of `password`. Even though this might look like a security concern at first, it makes the database server more secure because the only users allowed to log in as the **root** MariaDB user are the system users with sudo privileges connecting from the console or through an application running with the same privileges. In practical terms, that means you won't be able to use the administrative database **root** user to connect from your PHP application.

For increased security, it's best to have dedicated user accounts with less expansive privileges set up for every database, especially if you plan on having multiple databases hosted on your server. To demonstrate such a setup, we'll create a database named **example\_database** and a user named **example\_user**, but you can replace these names with different values.
To create a new database, run the following command from your MariaDB console:

```custom_prefix(MariaDB\s[(none)]>)
CREATE DATABASE <^>example_database<^>;
```

Now you can create a new user and grant them full privileges on the custom database you've just created. The following command defines this user's password as `<^>password<^>`, but you should replace this value with a secure password of your own choosing.

```custom_prefix(MariaDB\s[(none)]>)
GRANT ALL ON <^>example_database<^>.* TO '<^>example_user<^>'@'localhost' IDENTIFIED BY '<^>password<^>' WITH GRANT OPTION;
```

This will give the **example\_user** user full privileges over the **example\_database** database, while preventing this user from creating or modifying other databases on your server.

Flush the privileges to ensure that they are saved and available in the current session:

```custom_prefix(MariaDB\s[(none)]>)
FLUSH PRIVILEGES;
```

Following this, exit the MariaDB shell:

```custom_prefix(MariaDB\s[(none)]>)
exit
```

You can test if the new user has the proper permissions by logging in to the MariaDB console again, this time using the custom user credentials:

```command
mariadb -u <^>example_user<^> -p
```

Note the `-p` flag in this command, which will prompt you for the password used when creating the **example\_user** user. After logging in to the MariaDB console, confirm that you have access to the **example\_database** database:

```custom_prefix(MariaDB\s[(none)]>)
SHOW DATABASES;
```

This will give you the following output:


```
[secondary_label Output]
+--------------------+
| Database           |
+--------------------+
| <^>example_database<^>   |
| information_schema |
+--------------------+
2 rows in set (0.000 sec)
```

To exit the MariaDB shell, type:

```custom_prefix(MariaDB\s[(none)]>)
exit
```

At this point, your database system is set up and you can move on to installing PHP, the final component of the LEMP stack.

## Step 3 — Installing PHP for Processing

You have Nginx installed to serve your content and MySQL installed to store and manage your data. Now you can install PHP to process code and generate dynamic content for the web server.

While Apache embeds the PHP interpreter in each request, Nginx requires an external program to handle PHP processing and act as _bridge_ between the PHP interpreter itself and the web server. This allows for a better overall performance in most PHP-based websites, but it requires additional configuration. You'll need to install `php-fpm`, which stands for "PHP fastCGI process manager", and tell Nginx to pass PHP requests to this software for processing. Additionally, you'll need `php-mysql`, a PHP module that allows PHP to communicate with MySQL-based databases. Core PHP packages will automatically be installed as dependencies.

To install the `php-fpm` and `php-mysql` packages, run:

```command
sudo apt install php-fpm php-mysql
```

You now have your PHP components installed. Next, you'll configure Nginx to use them.

## Step 4 — Configuring Nginx to Use the PHP Processor

When using the Nginx web server, _server blocks_ (similar to virtual hosts in Apache) can be used to encapsulate configuration details and host more than one domain on a single server. In this guide, we'll use **your_domain** as example domain name. To learn more about setting up a domain name with DigitalOcean, see our [introduction to DigitalOcean DNS](https://www.digitalocean.com/docs/networking/dns/). 

On Debian 10, Nginx has one server block enabled by default and is configured to serve documents out of a directory at `/var/www/html`. While this works well for a single site, it can become difficult to manage if you are hosting multiple sites. Instead of modifying `/var/www/html`, let's create a directory structure within `/var/www` for the **your_domain** website, leaving `/var/www/html` in place as the default directory to be served if a client request doesn't match any other sites.

Create the root web directory for **your_domain** as follows:

```command
sudo mkdir /var/www/<^>your_domain<^>
```

Next, assign ownership of the directory with the $USER environment variable, which should reference your current system user:

```command
sudo chown -R $USER:$USER /var/www/<^>your_domain<^>
```

Then, open a new configuration file in Nginx's `sites-available` directory using your preferred command-line editor. Here, we'll use `nano`:

```command
sudo nano /etc/nginx/sites-available/<^>your_domain<^>
```

This will create a new blank file. Paste in the following bare-bones configuration:

```
[label /etc/nginx/sites-available/your_domain]
server {
    listen 80;
    listen [::]:80;

    root /var/www/<^>your_domain<^>;
    index index.php index.html index.htm;

    server_name <^>your_domain<^>;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php<^>7.3<^>-fpm.sock;
    }
}
```

This is a basic configuration that listens on port `80` and serves files from the web root you just created. It will only respond to requests to the host or IP address provided after `server_name`, and any files ending in `.php` will be processed by `php-fpm` before Nginx sends the results to the user.

> Note: If you are running a PHP version different from PHP 7.3, you would need to adjust the `fastcgi_pass` to match the PHP version that you are using.

When you're done editing, save and close the file. If you used `nano` to create the file, do so by typing `CTRL`+`X` and then `y` and `ENTER` to confirm.

Activate your configuration by linking to the config file from Nginx's `sites-enabled` directory:

```command
sudo ln -s /etc/nginx/sites-available/<^>your_domain<^> /etc/nginx/sites-enabled/
```

This will tell Nginx to use the configuration next time it is reloaded. You can test your configuration for syntax errors by typing:

```command
sudo nginx -t
```

If any errors are reported, go back to your configuration file to review its contents before continuing.

When you are ready, reload Nginx to make the changes:

```command
sudo systemctl reload nginx
```

Next, you'll create a file in your new web root directory to test out PHP processing.

## Step 5 — Creating a PHP File to Test Configuration

Your LEMP stack should now be completely set up. You can test it to validate that Nginx can correctly hand `.php` files off to your PHP processor.

You can do this by creating a test PHP file in your document root. Open a new file called `info.php` within your document root in your text editor:

```command
nano /var/www/<^>your_domain<^>/info.php
```

Type or paste the following lines into the new file. This is valid PHP code that will return information about your server:

```
[label /var/www/your_domain/info.php]
<?php
phpinfo();
?>
```

When you are finished, save and close the file by typing `CTRL`+`X` and then `y` and `ENTER` to confirm.

You can now access this page in your web browser by visiting the domain name or public IP address you've set up in your Nginx configuration file, followed by `/info.php`:

```
http://<^>your_domain<^>/info.php
```

You will see a web page containing detailed information about your server:

![PHP page info](https://assets.digitalocean.com/articles/lemp_debian10/phpinfo.png)

After checking the relevant information about your PHP server through that page, it's best to remove the file you created as it contains sensitive information about your PHP environment and your Debian server. You can use `rm` to remove that file:

```command
rm /var/www/<^>your_domain<^>/info.php
```

You can always regenerate this file if you need it later. Next, we'll test the database connection from the PHP side.

## Step 6 — Testing Database Connection from PHP (Optional)

If you want to test if PHP is able to connect to MariaDB and execute database queries, you can create a test table with dummy data and query for its contents from a PHP script.

First, connect to the MariaDB console with the database user you created in [Step 2](#step-2-—-installing-mariadb) of this guide:

```command
mariadb -u <^>example_user<^> -p
```

Create a table named **todo_list**. From the MariaDB console, run the following statement:

```
CREATE TABLE <^>example_database<^>.<^>todo_list<^> (
	item_id INT AUTO_INCREMENT,
	content VARCHAR(255),
	PRIMARY KEY(item_id)
);
```

Now, insert a few rows of content in the test table. You might want to repeat the next command a few times, using different values:

```custom_prefix(MariaDB\s[(none)]>)
INSERT INTO <^>example_database<^>.<^>todo_list<^> (content) VALUES ("<^>My first important item<^>");
```

To confirm that the data was successfully saved to your table, run:

```custom_prefix(MariaDB\s[(none)]>)
SELECT * FROM <^>example_database<^>.<^>todo_list<^>;
```

You will see the following output:

```
[secondary_label Output]
+---------+--------------------------+
| item_id | content                  |
+---------+--------------------------+
|       1 | My first important item  |
|       2 | My second important item |
|       3 | My third important item  |
|       4 | and this one more thing  |
+---------+--------------------------+
4 rows in set (0.000 sec)

```

After confirming that you have valid data in your test table, you can exit the MariaDB console:

```custom_prefix(MariaDB\s[(none)]>)
exit
```

Now you can create the PHP script that will connect to MariaDB and query for your content. Create a new PHP file in your custom web root directory using your preferred editor. We'll use `nano` for that:

```command
nano /var/www/<^>your_domain<^>/<^>todo_list.php<^>
```

Add the following content to your PHP script:

```php
<?php
$user = "<^>example_user<^>";
$password = "<^>password<^>";
$database = "<^>example_database<^>";
$table = "<^>todo_list<^>";

try {
  $db = new PDO("mysql:host=localhost;dbname=$database", $user, $password);
  echo "<h2>TODO</h2><ol>"; 
  foreach($db->query("SELECT content FROM $table") as $row) {
    echo "<li>" . $row['content'] . "</li>";
  }
  echo "</ol>";
} catch (PDOException $e) {
    print "Error!: " . $e->getMessage() . "<br/>";
    die();
}
```

Save and close the file when you're done editing. 

You can now access this page in your web browser by visiting the domain name or public IP address you've set up in your Nginx configuration file, followed by `/todo_list.php`:

```
http://<^>your_domain<^>/todo_list.php
```

You should see a page like this, showing the content you've inserted in your test table:

![Example PHP todo list](https://assets.digitalocean.com/articles/lemp_debian10/todo_list.png)

That means your PHP environment is ready to connect and interact with your MariaDB server.

## Conclusion

In this guide, you've built a flexible foundation for serving PHP websites and applications to your visitors, using Nginx as web server. You've set up Nginx to handle PHP requests through `php-fpm`, and you also set up a MariaDB database to store your website's data. 

To further improve your current setup, you can [install Composer](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-composer-on-debian-10) for dependency and package management in PHP, and you can also [install an OpenSSL certificate](https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-debian-10) for your website using [Let's Encrypt](https://www.digitalocean.com/community/tutorials/an-introduction-to-let-s-encrypt).

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications. This is an acronym that describes a Linux operating system, with an Nginx web server. The backend data is stored in the MariaDB/MySQL database and the dynamic processing is handled by PHP.

In this guide, you'll install a LEMP stack on a Debian 10 server using MariaDB as database.

How To Install Linux, Nginx, MariaDB, PHP (LEMP stack) on Debian 10

Tutorials in this section guide the user through running software or scripts to automate setting up different environments across one or more servers.

Automated

Ansible

### Introduction

Server automation now plays an essential role in systems administration, due to the disposable nature of modern application environments. [Configuration management](https://www.digitalocean.com/community/tutorial_series/getting-started-with-configuration-management) tools such as [Ansible](https://ansible.com) are typically used to streamline the process of automating server setup by establishing standard procedures for new servers while also reducing human error associated with manual setups.

Ansible offers a simple architecture that doesn't require special software to be installed on nodes. It also provides a robust set of features and built-in modules which facilitate writing automation scripts.
 
This guide explains how to use Ansible to automate the steps contained in our guide on [How To Install Linux, Nginx, MySQL and PHP (LEMP) on Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/how-to-install-linux-nginx-mysql-php-lemp-stack-ubuntu-18-04). The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications. This is an acronym that describes a **L**inux operating system, with an Nginx (pronounced like “**E**ngine-X”) web server. The backend data is stored in the **M**ySQL database and the dynamic processing is handled by **P**HP.

## Prerequisites

In order to execute the automated setup provided by the playbook we're discussing in this guide, you'll need:

- **One Ansible control node**: an Ubuntu 18.04 machine with Ansible installed and configured to connect to your Ansible hosts using SSH keys. Make sure the control node has a regular user with sudo permissions and a firewall enabled, as explained in our [Initial Server Setup](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-04) guide. To set up Ansible, please follow our guide on [How to Install and Configure Ansible on Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-ansible-on-ubuntu-18-04).
- **One or more Ansible Hosts**: one or more remote Ubuntu 18.04 servers previously set up following the guide on [How to Use Ansible to Automate Initial Server Setup on Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/how-to-use-ansible-to-automate-initial-server-setup-on-ubuntu-18-04).

<$>[note]
Before proceeding, you first need to make sure your Ansible control node is able to connect and execute commands on your Ansible host(s). For a connection test, please check step 3 of [How to Install and Configure Ansible on Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-ansible-on-ubuntu-18-04#step-3-%E2%80%94-testing-connection).
<$>

## What Does this Playbook Do?

This Ansible playbook provides an alternative to manually running through the procedure outlined in our guide on [How To Install Linux, Nginx, MySQL, PHP (LEMP stack) on Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/how-to-install-linux-nginx-mysql-php-lemp-stack-ubuntu-18-04).

Running this playbook will perform the following actions on your Ansible hosts:

1. Install `aptitude`, which is preferred by Ansible as an alternative to the `apt` package manager.
2. Install the required LEMP packages.
3. Set up the Nginx configuration file using the provided template.
4. Enable the new Nginx configuration and disable the default one.
5. Set the password for the MySQL **root** user.
6. Remove anonymous MySQL accounts and the test database.
7. Set up UFW to allow HTTP traffic on the configured port (`80` by default).
8. Set up a PHP test script using the provided template.

Once the playbook has finished running, you will have a web PHP environment running on top of Nginx, based on the options you defined within your configuration variables.

## How to Use this Playbook

The first thing we need to do is obtain the LEMP playbook and its dependencies from the [do-community/ansible-playbooks](https://github.com/do-community/ansible-playbooks) repository. We need to clone this repository to a local folder inside the Ansible Control Node.

In case you have cloned this repository before while following a different guide, access your existing `ansible-playbooks` copy and run a `git pull` command to make sure you have updated contents:

```command
[environment local]
cd ~/ansible-playbooks
git pull
```
If this is your first time using the `do-community/ansible-playbooks` repository, you should start by cloning the repository to your home folder with:

```command
[environment local]
cd ~
git clone https://github.com/do-community/ansible-playbooks.git
cd ansible-playbooks
```

The files we're interested in are located inside the `lemp_ubuntu1804` folder, which has the following structure:

```
lemp_ubuntu1804
├── files
│   ├── info.php.j2
│   └── nginx.conf.j2
├── vars
│   └── default.yml
├── playbook.yml
└── readme.md
```

Here is what each of these files are:

- `files/info.php.j2`: Template file for setting up a PHP test page on the web server's root 
- `files/nginx.conf.j2`: Template file for setting up the Nginx server.
directory.
- `vars/default.yml`: Variable file for customizing playbook settings.
- `playbook.yml`: The playbook file, containing the tasks to be executed on the remote server(s).
- `readme.md`: A text file containing information about this playbook.

We'll edit the playbook's variable file to customize the configurations of both MySQL and Nginx. Access the `lemp_ubuntu1804` directory and open the `vars/default.yml` file using your command line editor of choice:

```command
[environment local]
cd lemp_ubuntu1804
nano vars/default.yml
```

This file contains a few variables that require your attention:

```yaml
[label vars/default.yml]
[environment local]
---
mysql_root_password: "<^>mysql_root_password<^>"
http_host: "<^>your_domain<^>"
http_conf: "<^>your_domain<^>.conf"
http_port: "<^>80<^>"
```
The following list contains a brief explanation of each of these variables and how you might want to change them:
    
- `mysql_root_password`: The desired password for the **root** MySQL account.
- `http_host`: The host name or IP address for this web server.
- `http_conf`: The name of the configuration file to be created inside `/etc/nginx/sites-available`, typically set to the host or application name for easier identification.
- `http_port`: The port Nginx will use to serve this site. This is port `80` by default, but if you want to serve your site or application on a different port, enter it here.

Once you're done updating the variables inside `vars/default.yml`, save and close this file. If you used `nano`, do so by pressing `CTRL + X`, `Y`, then `ENTER`.

You're now ready to run this playbook on one or more servers. Most playbooks are configured to be executed on every` server in your inventory, by default. We can use the `-l` flag to make sure that only a subset of servers, or a single server, is affected by the playbook. We can also use the `-u` flag to specify which user on the remote server we're using to connect and execute the playbook commands on the remote hosts.

To execute the playbook only on `<^>server1<^>`, connecting as `<^>sammy<^>`, you can use the following command:

```command
[environment local]
ansible-playbook playbook.yml -l <^>server1<^> -u <^>sammy<^>
``` 

You will get output similar to this:

```
[secondary_label Output]

PLAY [all] *****************************************************************************************************************************

TASK [Gathering Facts] *****************************************************************************************************************
ok: [server1]

TASK [Install Prerequisites] ***********************************************************************************************************
changed: [server1] => (item=aptitude)

...

TASK [UFW - Allow HTTP on port 80] *****************************************************************************************************
changed: [server1]

TASK [Sets Up PHP Info Page] ***********************************************************************************************************
changed: [server1]

RUNNING HANDLER [Reload Nginx] *********************************************************************************************************
changed: [server1]

PLAY RECAP *****************************************************************************************************************************
server1         : ok=12   changed=9    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   

```

<$>[note]
**Note**: For more information on how to run Ansible playbooks, check our [Ansible Cheat Sheet Guide](https://www.digitalocean.com/community/tutorials/how-to-use-ansible-cheat-sheet-guide).
<$>

When the playbook is finished running, go to your web browser and access the host or IP address of the server, as configured in the playbook variables, followed by `/info.php`:

```
http://<^>server_host_or_IP<^>/info.php
```

You will see a page like this:

![phpinfo page](https://assets.digitalocean.com/articles/automated_ansible/phpinfo.png)

Because this page contains sensitive information about your PHP environment, it is recommended that you remove it from the server by running an `rm -f /var/www/info.php` command once you have finished setting it up. 

## The Playbook Contents

You can find the LEMP server setup featured in this tutorial in the [`lemp_ubuntu1804`](https://github.com/do-community/ansible-playbooks/tree/master/lemp_ubuntu1804) folder inside the [DigitalOcean Community Playbooks](https://github.com/do-community/ansible-playbooks) repository. To copy or download the script contents directly, click the **Raw** button towards the top of each script.


The full contents of the playbook as well as its associated files are also included here for your convenience.

### vars/default.yml

The `default.yml` variable file contains values that will be used within the playbook tasks, such as the password for the MySQL **root** account and the domain name to configure within Nginx.

```yaml
[label vars/default.yml]
[environment local]
---
mysql_root_password: "<^>mysql_root_password<^>"
http_host: "<^>your_domain<^>"
http_conf: "<^>your_domain<^>.conf"
http_port: "<^>80<^>"
```

### files/nginx.conf.j2

The `nginx.conf.j2` file is a [Jinja 2](https://jinja.palletsprojects.com/en/2.10.x/) template file that configures the Nginx web server. The variables used within this template are defined in the `vars/default.yml` variable file.

```
[environment local]
[label files/nginx.conf.j2]
server {
       listen {{ http_port }};
       root /var/www/html;
       index index.php index.html index.htm index.nginx-debian.html;
       server_name {{ http_host }};

       location / {
               try_files $uri $uri/ =404;
       }

       location ~ \.php$ {
               include snippets/fastcgi-php.conf;
               fastcgi_pass unix:/var/run/php/php7.2-fpm.sock;
       }

       location ~ /\.ht {
               deny all;
       }
}

```

### files/info.php.j2

The `info.php.j2` file is another Jinja template, used to set up a test PHP script in the document root of the newly configured LEMP server.

```
[environment local]
[label files/info.php.j2]
<?php
phpinfo();

```

### playbook.yml

The `playbook.yml` file is where all tasks from this setup are defined. It starts by defining the group of servers that should be the target of this setup (`all`), after which it uses `become: true` to define that tasks should be executed with privilege escalation (`sudo`) by default. Then, it includes the `vars/default.yml` variable file to load configuration options.


```yaml
[label playbook.yml]
[environment local]
---
- hosts: all
  become: true
  vars_files:
   - vars/default.yml

 tasks:
   - name: Install Prerequisites
     apt: name={{ item }} update_cache=yes state=latest force_apt_get=yes
     loop: [ 'aptitude' ]

   - name: Install LEMP Packages
     apt: name={{ item }} update_cache=yes state=latest
     loop: [ 'nginx', 'mysql-server', 'python3-pymysql', 'php-fpm', 'php-mysql' ]
  
# Nginx Configuration
  
   - name: Sets Nginx conf file
     template:
       src: "files/nginx.conf.j2"
       dest: "/etc/nginx/sites-available/{{ http_conf }}"

   - name: Enables new site
     file:
       src: "/etc/nginx/sites-available/{{ http_conf }}"
       dest: "/etc/nginx/sites-enabled/{{ http_conf }}"
       state: link
     notify: Reload Nginx
  
   - name: Removes "default" site
     file:
       path: "/etc/nginx/sites-enabled/default"
       state: absent
     notify: Reload Nginx

# MySQL Configuration

   - name: Sets the root password
     mysql_user:
       name: root
       password: "{{ mysql_root_password }}"
       login_unix_socket: /var/run/mysqld/mysqld.sock

   - name: Removes all anonymous user accounts
     mysql_user:
       name: ''
       host_all: yes
       state: absent
       login_user: root
       login_password: "{{ mysql_root_password }}"

   - name: Removes the MySQL test database
     mysql_db:
       name: test
       state: absent
       login_user: root
       login_password: "{{ mysql_root_password }}"

# UFW Configuration

   - name: "UFW - Allow HTTP on port {{ http_port }}"
     ufw:
       rule: allow
       port: "{{ http_port }}"
       proto: tcp

# Sets Up PHP Info Page

   - name: Sets Up PHP Info Page
     template:
       src: "files/info.php.j2"
       dest: "/var/www/html/info.php"

# Handlers

 handlers:
   - name: Reload Nginx
     service:
       name: nginx
       state: reloaded

   - name: Restart Nginx
     service:
       name: nginx
       state: restarted

```


Feel free to modify these files to best suit your individual needs within your own workflow. 

## Conclusion

In this guide, we used Ansible to automate the process of installing and setting up a LEMP environment on a remote server. Because each individual typically has different needs when working with MySQL databases and users, we encourage you to check out the [official Ansible documentation](https://docs.ansible.com/ansible/latest/modules/mysql_user_module.html#mysql-user-module) for more information and use cases of the `mysql_user` Ansible module.

If you'd like to include other tasks in this playbook to further customize your server setup, please refer to our introductory Ansible guide [Configuration Management 101: Writing Ansible Playbooks](https://www.digitalocean.com/community/tutorials/configuration-management-101-writing-ansible-playbooks). 


This guide explains how to use Ansible to automate the steps contained in our guide on How To Install Linux, Nginx, MySQL and PHP (LEMP) on Ubuntu 18.04. The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications. This is an acronym that describes a Linux operating system, with an Nginx (pronounced like “Engine-X”) web server. The backend data is stored in the MySQL database and the dynamic processing is handled by PHP.

How to Use Ansible to Install and Set Up LEMP on Ubuntu 18.04

### Introduction

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications written in PHP. The name "LEMP" is an acronym that describes a **L**inux operating system with an Nginx (pronounced like "**E**ngine-X") web server. The backend data is stored in a **M**ariaDB database and the dynamic processing is handled by **P**HP. 

The database layer in a LEMP stack is typically a MySQL database server, but prior to the release of CentOS 8, MySQL wasn't available from the default CentOS repositories. Because of this, [MariaDB](https://mariadb.org/), a community fork of MySQL, became a widely accepted alternative to MySQL as the default database system for LEMP stacks on CentOS machines. MariaDB works as a drop-in replacement for the original MySQL server, which in practice means you can switch to MariaDB without having to make any configuration or code changes in your application.

In this guide, you'll install a LEMP stack on a CentOS 8 server. Although MySQL is available from the default repositories in CentOS 8, this guide will walk through the process of setting up a LEMP stack with MariaDB as the database management system.

## Prerequisites

To follow this guide, you'll need access to a CentOS 8 server as a non-root user with sudo privileges, and an active firewall installed on your server. To set this up, you can follow our [Initial Server Setup Guide for CentOS 8](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-centos-8).


## Step 1 — Installing the Nginx Web Server

In order to display web pages to our site visitors, we are going to employ Nginx, a high-performance web server. We'll use the `dnf` package manager, which is the new default package manager on CentOS 8, to install this software.

Install the `nginx` package with:

```command
sudo dnf install nginx
```
When prompted, enter `y` to confirm that you want to install nginx. 

After the installation is finished, run the following command to enable and start the server:

```command
sudo systemctl start nginx
```

In case you have enabled the `firewalld` firewall as per our initial server setup guide, you will need to allow connections to Nginx. The following command will permanently enable HTTP connections, which run on port `80` by default:

```command
sudo firewall-cmd --permanent --add-service=<^>http<^>
```

To verify that the change was applied, you can run:

```command
sudo firewall-cmd --permanent --list-all
```

You'll see output like this:
```
[secondary_label Output]
public
  target: default
  icmp-block-inversion: no
  interfaces: 
  sources: 
  services: cockpit dhcpv6-client <^>http<^> ssh
  ports: 
  protocols: 
  masquerade: no
  forward-ports: 
  source-ports: 
  icmp-blocks: 
  rich rules: 
```

You'll need to reload the firewall configuration so the changes take effect:

```command
sudo firewall-cmd --reload
```

With the new firewall rule added, you can test if the server is up and running by accessing your server’s public IP address or domain name from your web browser.

<$>[note]
**Note**: In case you are using DigitalOcean as DNS hosting provider, you can check our [product docs](https://www.digitalocean.com/docs/networking/dns/how-to/manage-records/#a-records) for detailed instructions on how to set up a new domain name and point it to your server.
<$>

If you do not have a domain name pointed at your server and you do not know your server’s public IP address, you can find it by running the following command:

```command
ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'
```

This will print out a few IP addresses. You can try each of them in turn in your web browser.

As an alternative, you can check which IP address is accessible, as viewed from other locations on the internet:

```command
curl -4 icanhazip.com
```

Type the address that you receive in your web browser and it will take you to Nginx’s default landing page:

![Default Nginx Page CentOS 8](https://assets.digitalocean.com/articles/lemp_centos8/nginx_default_page.png)

If you see this page, then your web server is now correctly installed.


## Step 2 — Installing MariaDB

Now that you have a web server up and running, you need to install a database system to be able to store and manage data for your site. We'll install [MariaDB](https://mariadb.org/), a community-developed fork of the original MySQL server by Oracle. 

To install this software, run:

```command
sudo dnf install mariadb-server
```
When the installation is finished, you can enable and start the MariaDB server with:

```command
sudo systemctl start mariadb
```

To improve the security of your database server, it's recommended that you run a security script that comes pre-installed with MariaDB. This script will remove some insecure default settings and lock down access to your database system. Start the interactive script by running:

```command
sudo mysql_secure_installation
```

This script will take you through a series of prompts where you can make some changes to your MariaDB setup. The first prompt will ask you to enter the current **database root** password. This is not to be confused with the **system root** user. The **database root** user is an administrative user with full privileges over the database system. Because you just installed MariaDB and haven’t made any configuration changes yet, this password will be blank, so just press `ENTER` at the prompt. 

The next prompt asks you whether you'd like to set up a **database root** password. Because MariaDB uses a special authentication method for the **root** user that is typically safer than using a password, you don't need to set this now. Type `N` and then press `ENTER`. 

From there, you can press `Y` and then `ENTER` to accept the defaults for all the subsequent questions. This will remove anonymous users and the test database, disable remote **root** login, and load these new rules so that the server immediately respects the changes you have made.

When you're finished, log in to the MariaDB console by typing:

```command
sudo mysql
```

This will connect to the MariaDB server as the administrative database user **root**, which is inferred by the use of `sudo` when running this command. You should see output like this:

```
[secondary_label Output]
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 9
Server version: 10.3.17-MariaDB MariaDB Server

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]> 
```

Notice that you didn't need to provide a password to connect as the **root** user. That works because the default authentication method for the administrative MariaDB user is `unix_socket` instead of `password`. Even though this might look like a security concern at first, it makes the database server more secure because the only users allowed to log in as the **root** MariaDB user are the system users with sudo privileges connecting from the console or through an application running with the same privileges. In practical terms, that means you won't be able to use the administrative database **root** user to connect from your PHP application.

For increased security, it's best to have dedicated user accounts with less expansive privileges set up for every database, especially if you plan on having multiple databases hosted on your server. To demonstrate such a setup, we'll create a database named **example\_database** and a user named **example\_user**, but you can replace these names with different values.

To create a new database, run the following command from your MariaDB console:

```custom_prefix(MariaDB\s[(none)]>)
CREATE DATABASE <^>example_database<^>;
```

Now you can create a new user and grant them full privileges on the custom database you've just created. The following command defines this user's password as `<^>password<^>`, but you should replace this value with a secure password of your own choosing:

```custom_prefix(MariaDB\s[(none)]>)
GRANT ALL ON <^>example_database<^>.* TO '<^>example_user<^>'@'localhost' IDENTIFIED BY '<^>password<^>' WITH GRANT OPTION;
```

This will give the **example\_user** user full privileges over the `example\_database` database, while preventing this user from creating or modifying other databases on your server.

Flush the privileges to ensure that they are saved and available in the current session:

```custom_prefix(MariaDB\s[(none)]>)
FLUSH PRIVILEGES;
```

Following this, exit the MariaDB shell:

```custom_prefix(MariaDB\s[(none)]>)
exit
```

You can test if the new user has the proper permissions by logging in to the MariaDB console again, this time using the custom user credentials:

```command
mysql -u <^>example_user<^> -p
```

Note the `-p` flag in this command, which will prompt you for the password you chose when creating the **example\_user** user. After logging in to the MariaDB console, confirm that you have access to the `example\_database` database:

```custom_prefix(MariaDB\s[(none)]>)
SHOW DATABASES;
```

This will give you the following output:


```
[secondary_label Output]
+--------------------+
| Database           |
+--------------------+
| <^>example_database<^>   |
| information_schema |
+--------------------+
2 rows in set (0.000 sec)
```

To exit the MariaDB shell, type:

```custom_prefix(MariaDB\s[(none)]>)
exit
```

At this point, your database system is set up and you can move on to installing PHP, the final component of the LEMP stack.

## Step 3 — Installing PHP-FPM 

You have Nginx installed to serve your content and MariaDB installed to store and manage your data. Now you can install PHP to process code and generate dynamic content for the web server.

While Apache embeds the PHP interpreter in each request, Nginx requires an external program to handle PHP processing and act as bridge between the PHP interpreter itself and the web server. This allows for a better overall performance in most PHP-based websites, but it requires additional configuration. You’ll need to install `php-fpm`, which stands for “PHP fastCGI process manager”, and tell Nginx to pass PHP requests to this software for processing. Additionally, you’ll need `php-mysqlnd`, a PHP module that allows PHP to communicate with MySQL-based databases. Core PHP packages will automatically be installed as dependencies.

To install the `php-fpm` and `php-mysql` packages, run:

```command
sudo dnf install php-fpm php-mysqlnd
```

When the installation is finished, you'll need to edit the `/etc/php-fpm.d/www.conf` file in order to adjust a couple settings.

The default text editor that comes with CentOS 8 is `vi`. `vi` is an extremely powerful text editor, but it can be somewhat obtuse for users who lack experience with it. You might want to install a more user-friendly editor such as `nano` to facilitate editing configuration files on your CentOS 8 server:

```command
sudo dnf install nano
```

Now open the `/etc/php-fpm.d/www.conf` configuration file using `nano` or your editor of choice:

```command
sudo nano /etc/php-fpm.d/www.conf
```

Now look for the `user` and `group` directives. If you are using `nano`, you can hit `CTRL`+`W` to search for these terms inside the open file.

```
[label /etc/php-fpm.d/www.conf]
…
; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
;       will be used.
; RPM: apache user chosen to provide access to the same directories as httpd
user = <^>apache<^>
; RPM: Keep a group allowed to write in log dir.
group = <^>apache<^>
…
```

You'll notice that both the `user` and `group` variables are set to `apache`. We need to change these to `nginx`:

```
[label /etc/php-fpm.d/www.conf]
…
; RPM: apache user chosen to provide access to the same directories as httpd
user = <^>nginx<^>
; RPM: Keep a group allowed to write in log dir.
group = <^>nginx<^>
…
```

Save and close the file when you're done editing. If you are using `nano`, do so by pressing `CTRL + X`, then `Y` and `ENTER`.

To enable and start the `php-fpm` service, run:

```command
sudo systemctl start php-fpm
```

Finally, restart the Nginx web server so that it loads the configuration files created by the `php-fpm` installation:

```command
sudo systemctl restart nginx
```

Your web server is now fully set up. In the next step, we'll create a PHP testing script to make sure everything works as expected.

## Step 4 — Testing PHP with Nginx

On CentOS 8,  the default `php-fpm` installation automatically creates configuration files that will allow your Nginx web server to handle `.php` files in the default document root located at `/usr/share/nginx/html`. You won't need to make any changes to Nginx's configuration in order for PHP to work correctly within your web server.

The only adjustment we'll make is to change the default permission settings on your Nginx document root folder. This way, you'll be able to create and modify files in that directory with your regular system user, without the need to prefix each command with `sudo`.

The following command will change the ownership of the default Nginx document root to a user and group called <^>sammy<^>, so be sure to replace the highlighted username and group in this command to reflect your system's username and group.

```command
sudo chown -R <^>sammy<^>.<^>sammy<^> /usr/share/nginx/html/
```

We'll now create a test PHP page to make sure the web server works as expected.

Create a new PHP file called `info.php` at the `/usr/share/nginx/html` directory:

```command
nano /usr/share/nginx/html/<^>info.php<^>
```

The following PHP code will display information about the current PHP environment running on the server:

```php
[label /usr/share/nginx/html/info.php]
<?php

phpinfo();
```

When you are finished, save and close the file.

Now we can test whether our web server can correctly display content generated by a PHP script.  Go to your browser and access your server hostname or IP address, followed by `/info.php`:

```
http://<^>server_host_or_IP<^>/info.php
```

You'll see a page similar to this:

![CentOS 8 default PHP info](https://assets.digitalocean.com/articles/lemp_centos8/phpinfo.png)

After checking the relevant information about your PHP server through that page, it’s best to remove the file you created as it contains sensitive information about your PHP environment and your CentOS server. You can use `rm` to remove that file:

```command
rm /usr/share/nginx/html/<^>info.php<^>
```

You can always regenerate this file if you need it later. Next, we’ll test the database connection from the PHP side.


## Step 5 — Testing Database Connection from PHP (Optional)

If you want to test if PHP is able to connect to MariaDB and execute database queries, you can create a test table with dummy data and query for its contents from a PHP script.

First, connect to the MariaDB console with the database user you created in [Step 2](#step-2-—-installing-mariadb) of this guide:

```command
mysql -u <^>example_user<^> -p
```

Create a table named `todo_list`. From the MariaDB console, run the following statement:

```
CREATE TABLE <^>example_database<^>.<^>todo_list<^> (
	item_id INT AUTO_INCREMENT,
	content VARCHAR(255),
	PRIMARY KEY(item_id)
);
```

Now, insert a few rows of content in the test table. You might want to repeat the next command a few times, using different values:

```custom_prefix(MariaDB\s[(none)]>)
INSERT INTO <^>example_database<^>.<^>todo_list<^> (content) VALUES ("<^>My first important item<^>");
```

To confirm that the data was successfully saved to your table, run:

```custom_prefix(MariaDB\s[(none)]>)
SELECT * FROM <^>example_database<^>.<^>todo_list<^>;
```

You will see the following output:

```
[secondary_label Output]
+---------+--------------------------+
| item_id | content                  |
+---------+--------------------------+
|       1 | My first important item  |
|       2 | My second important item |
|       3 | My third important item  |
|       4 | and this one more thing  |
+---------+--------------------------+
4 rows in set (0.000 sec)

```

After confirming that you have valid data in your test table, you can exit the MariaDB console:

```custom_prefix(MariaDB\s[(none)]>)
exit
```

Now you can create the PHP script that will connect to MariaDB and query for your content. Create a new PHP file in your custom web root directory using your preferred editor. We'll use `nano` for that:

```command
nano /usr/share/nginx/html/<^>todo_list.php<^>
```

Add the following content to your PHP script:

```php
[label /usr/share/nginx/html/todo_list.php]
<?php
$user = "<^>example_user<^>";
$password = "<^>password<^>";
$database = "<^>example_database<^>";
$table = "<^>todo_list<^>";

try {
  $db = new PDO("mysql:host=localhost;dbname=$database", $user, $password);
  echo "<h2>TODO</h2><ol>"; 
  foreach($db->query("SELECT content FROM $table") as $row) {
    echo "<li>" . $row['content'] . "</li>";
  }
  echo "</ol>";
} catch (PDOException $e) {
    print "Error!: " . $e->getMessage() . "<br/>";
    die();
}
```

Save and close the file when you're done editing. 

You can now access this page in your web browser by visiting your server's host name or public IP address, followed by `/todo_list.php`:

```
http://<^>server_host_or_IP<^>/todo_list.php
```

You should see a page like this, showing the content you've inserted in your test table:

![Example PHP todo list](https://assets.digitalocean.com/articles/lemp_debian10/todo_list.png)

That means your PHP environment is ready to connect and interact with your MariaDB server.

## Conclusion

In this guide, you've built a flexible foundation for serving PHP websites and applications to your visitors, using Nginx as web server. You've set up Nginx to handle PHP requests through `php-fpm`, and you also set up a MariaDB database to store your website's data. 

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications written in PHP. The name "LEMP" is an acronym that describes a Linux operating system, with an (E)Nginx web server. The backend data is stored in a MariaDB database and the dynamic processing is handled by PHP. In this guide, you'll install a LEMP stack on a CentOS 8 server using MariaDB as the database management system.

How To Install Linux, Nginx, MySQL, PHP (LEMP) Stack on CentOS 8

20.04

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications written in PHP. This is an acronym that describes a Linux operating system, with an Nginx (pronounced like “Engine-X”) web server. The backend data is stored in a MySQL database, and dynamic processing is handled by PHP.
In this guide, we'll set up a LEMP stack on an Ubuntu 20.04 server.

How To Install Linux, Nginx, MySQL, PHP (LEMP stack) on Ubuntu 20.04

22.04

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications written in PHP. This is an acronym that describes a Linux operating system, with an Nginx (pronounced like “Engine-X”) web server. The backend data is stored in a MySQL database, and dynamic processing is handled by PHP.
In this guide, we'll set up a LEMP stack on an Ubuntu 22.04 server.

How To Install Linux, Nginx, MySQL, PHP (LEMP stack) on Ubuntu 22.04

Initial Server Setup with Ubuntu 14.04

This tutorial series helps sysadmins set up a new web server using the LEMP stack, focusing on Nginx setup with virtual blocks. This will let you serve multiple websites from one Droplet.

You'll start by setting up your Ubuntu 14.04 server and end with multiple virtual blocks set up for your websites. An Nginx configuration guide is included at the end for reference.

Introduction to Nginx and LEMP on Ubuntu 14.04

How To Set Up Nginx Server Blocks (Virtual Hosts) on Ubuntu 14.04 LTS

Understanding the Nginx Configuration File Structure and Configuration Contexts

Developer Advocate

Manager, Developer Education

Associate Developer Educator

Sign up for Infrastructure as a Newsletter.

Working on improving health and education, reducing inequality, and spurring economic growth? DigitalOcean would like to help.

Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.

Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

You get paid; we donate to tech nonprofits.

DigitalOcean makes it simple to launch in the cloud and scale up as you grow – whether you’re running one virtual machine or ten thousand.