How to Install LAMP Stack on Amazon Linux (EC2)

By Ravindra Bagale, trainer · LinkedIn · Last updated: 18 October 2026

1. Why: static sites vs dynamic sites

Why. So far every site sent the same files to everyone. Apps like Instagram build a different page for each visitor, and that needs more software on the server.

Until now we hosted static websites on Apache and Nginx, connected a domain, kept the IP fixed with an Elastic IP and backed the server up with an AMI. The next step is a dynamic website.

What is static? A static site is made only of files the browser understands: HTML, CSS, JavaScript and images. The server just sends the files, and every visitor gets the same page. A web server such as Apache or Nginx is all you need.

What is dynamic? A dynamic site runs server-side code (PHP, Python, Java, Node.js) and reads a database, so it can build a different page for each visitor.

Example 1, step by step. Suppose we are Instagram.

1. You log in. The server checks your user name and password against the database.
2. The server-side code looks up who you follow and what you like.
3. It builds your feed: cricket and food posts for you, travel and music posts for your friend.
4. Both of you open the same address, but each gets a page that was made just now, just for you.

None of that is possible with fixed HTML files. You need a language that runs on the server, plus a database.

2. What: LAMP and LEMP

Why. Job posts and tutorials say LAMP and LEMP without explaining them. Knowing the four letters tells you exactly what to install.

A stack is a set of software that works together to run a website. Two classic stacks for PHP websites:

1. LAMP = Linux + Apache + MySQL or MariaDB + PHP.
2. LEMP = Linux + Nginx (said "Engine-x", hence the E) + MySQL or MariaDB + PHP.

The only difference is the web server. In this chapter we build LAMP on Amazon Linux; Ubuntu and LEMP come next.

Why MariaDB? MariaDB is a community fork of MySQL, started by MySQL's original developers. It works as a drop-in replacement: the same commands and the same SQL, so a PHP app written for MySQL runs on it. Amazon Linux offers MariaDB in its own repositories, so that's what we install.

Why PHP? It's open source and runs a large share of the web, including WordPress sites. The same idea works with Python, Java or Node.js; only the "P" changes.

3. Why the browser can't run PHP

Why. A browser understands only HTML, CSS and JavaScript. If a web server sends a .php file as it is, the browser doesn't know what to do with it: it shows the code as text or simply downloads the file. Your PHP never runs.

What fixes it: php-fpm. php-fpm (PHP FastCGI Process Manager) is a service that runs PHP code for the web server. Apache doesn't run PHP itself; it passes .php requests to php-fpm and sends back what php-fpm returns.

Example 2, step by step: opening http://PUBLIC_IP/index.php

1. The browser sends a request to the server on port 80.
2. Apache receives it and sees the file ends in .php.
3. Apache hands the request to php-fpm.
4. php-fpm runs the PHP code. If the code needs data (a login, a feed), it asks MariaDB.
5. The output of the code is plain HTML. php-fpm gives it back to Apache.
6. Apache sends that HTML to the browser. The browser never sees a line of PHP.

For index.html the path is shorter: Apache sends the file itself, and php-fpm isn't involved.

4. How: install Apache, MariaDB and PHP

Why. A dynamic site needs all three pieces: a web server, a database and a language runtime. Missing one gives a blank page or a downloaded .php file.

Launch an Amazon Linux EC2 server with a security group that allows SSH (22) from your IP and HTTP (80). Connect with SSH, then install the three packages one by one.

Step 1. Apache. On Amazon Linux the Apache package is called httpd.

sudo yum install httpd -y

Step 2. MariaDB.

sudo yum install mariadb105-server -y

Why -server? The package mariadb105 alone gives you only the client, the mysql command that connects to a database somewhere else. The -server package installs the database server itself, the service that stores the data. A website needs the server. (105 is the MariaDB version, 10.5.)

Step 3. PHP.

sudo yum install php -y

This installs the PHP version Amazon Linux currently offers, together with php-fpm.

How do I find a package name? You don't have to remember them.

1. Guess first. The package usually has the same name as the software, for example php.
2. Tab completion. Type sudo yum install mariadb and press Tab twice. The shell lists the matching packages, such as mariadb105 and mariadb105-server.
3. Search. Run sudo yum search php (or sudo yum search mariadb) to list every package with that word.

5. Start the services, then restart once everything is installed

Why. Installed software does nothing until it runs. The restart at the end makes Apache pick up PHP, which was installed after Apache started.

Step 1. Start each service.

sudo service httpd start
sudo service mariadb start
sudo service php-fpm start

On Amazon Linux, service passes the job to systemctl; you'll see a line like Redirecting to /bin/systemctl start httpd.service.

Step 2. Restart after everything is installed.

sudo service php-fpm restart
sudo service mariadb restart
sudo service httpd restart

Why restart? If you installed and started Apache before PHP, Apache read its configuration at a time when PHP's settings file (/etc/httpd/conf.d/php.conf, the rule that sends .php to php-fpm) didn't exist yet. Apache reads that folder only when it starts. A restart makes it load the PHP rule. Restart php-fpm first, then Apache last.

6. Test pages: index.html and a phpinfo() page

Why. Two tiny pages separate the problems: if index.html works and index.php doesn't, Apache is fine and PHP is the issue.

Apache's web root on Amazon Linux is /var/www/html. Create one HTML page and one PHP page there.

Step 1. Go to the web root:

cd /var/www/html

Step 2. Create an HTML test page (the folder belongs to root, so use sudo):

sudo nano index.html

Type html page, save with Ctrl+O, Enter, and exit with Ctrl+X.

Step 3. Create a PHP test page:

sudo nano index.php

Type exactly this line, with a space after <?php:

<?php phpinfo(); ?>

Step 4. In the browser, open http://PUBLIC_IP/index.html. You see html page. Apache works.

Step 5. Open http://PUBLIC_IP/index.php. You see the PHP information page: the PHP version, and Server API: FPM/FastCGI, which proves Apache is handing PHP to php-fpm.

Why phpinfo first? It's the baseline test. If phpinfo() works, Linux, Apache, php-fpm and PHP are all fine. When a real application fails after that, the problem is in the application (for example, it was written for an older PHP version), not in the server. Without this test, everyone blames the server.

7. Install everything in one line

Why. Fewer commands means fewer chances to forget one, and it is the first step towards the script in the next section.

yum install takes several package names at once, so steps 1 to 3 of section 4 become one command:

sudo yum install httpd mariadb105-server php -y

The start commands can share a line too, separated by ;:

sudo service mariadb start; sudo service php-fpm start; sudo service httpd start

8. Automate it: the lamp.sh script

Why. You will build this stack again and again: for practice, for every new project, for every new server. Typing ten commands each time is slow and easy to get wrong. Put them in a shell script and run one file.

8.1 A script can't use nano: write files with sudo tee

In section 6 we typed the test pages in nano. A script can't type into nano; it needs commands that write files by themselves. The first idea is a redirect:

sudo echo "html page" > index.html

This fails with Permission denied. Why? sudo runs only echo as root. The > redirect is done by your own shell, as ec2-user, before sudo even starts, and ec2-user can't write in /var/www/html.

The fix is tee. tee reads text from a pipe and writes it to a file, and it can run as root:

echo "html page" | sudo tee index.html

1. echo prints the text.
2. The pipe | hands it to tee.
3. sudo tee index.html runs as root and writes the file. (It also prints the text on screen; add > /dev/null at the end if you want it quiet.)

tee overwrites the file. To add a line at the end instead, use tee -a:

echo "second line" | sudo tee -a index.html

8.2 Write the script

Step 1. Go to your home folder and open a new file:

cd ~
nano lamp.sh

Step 2. Type the script:

#!/bin/bash
sudo yum update -y
sudo yum install httpd mariadb105-server php -y
sudo service mariadb start
sudo service php-fpm start
sudo service httpd restart
cd /var/www/html
sudo touch index.html index.php
echo "html page" | sudo tee index.html
echo "<?php phpinfo(); ?>" | sudo tee index.php

Save and exit (Ctrl+O, Enter, Ctrl+X).

What each part does:

1. #!/bin/bash says which program runs the script.
2. sudo yum update -y updates all installed packages first. Start every automation script this way, so you build on current software. (On Ubuntu the pair is sudo apt-get update, which refreshes the package list, then sudo apt-get upgrade -y.)
3. The one-line install from section 7.
4. MariaDB and php-fpm start first, and Apache is restarted last, so it always loads PHP's config. restart also starts a service that isn't running, so the script is safe to run again.
5. cd /var/www/html moves into the web root.
6. sudo touch creates two empty files (tee would create them anyway).
7. The two tee lines write the test pages as root, with the correct <?php phpinfo(); ?>.

Why -y everywhere? Without -y, yum stops and asks Is this ok [y/N]:. Nobody is there to answer, so the script waits forever.

Why the home folder, not /var/www/html? Everything in the web root can be opened from a browser. If lamp.sh sat there, anyone could type http://PUBLIC_IP/lamp.sh and read your script. Keep scripts in ~ (here /home/ec2-user).

8.3 Make it executable and run it

Step 1. Give the file execute permission:

chmod +x lamp.sh

Step 2. Run it from the home folder:

./lamp.sh

(bash lamp.sh also works, even without chmod +x.)

Step 3. Watch the output. The packages install, the services start, and the two tee lines echo your page contents. If it stops with an error, the usual causes are a missing sudo, a typo in a package name, or running it from the wrong folder.

Example 3: the whole thing on a fresh server.

1. Launch a new Amazon Linux server (HTTP and SSH allowed) and connect.
2. nano lamp.sh, paste the script, save.
3. chmod +x lamp.sh, then ./lamp.sh.
4. Open http://PUBLIC_IP/index.php. The phpinfo page appears. A full LAMP server in a few minutes, with no typing mistakes.

9. Test from the server itself: curl and status

Why. You can't always open a browser, for example inside a script or when the security group isn't ready. curl and status check the stack from inside.

You don't always need a browser. From the SSH session:

Step 1. Ask Apache for the HTML page:

curl http://localhost/index.html

It prints html page.

Step 2. Ask for the PHP page:

curl http://localhost/index.php

It prints a long HTML page that contains PHP Version. If you see the raw <?php phpinfo(); ?> line instead, PHP isn't running (section 10.3).

Step 3. Check each service:

sudo service httpd status
sudo service mariadb status
sudo service php-fpm status

Look for active (running) in green. Press q to leave the status screen.

localhost tests the server from the inside. If curl localhost works but the browser doesn't, check the security group allows HTTP (80) and that you used http://, not https://.

10. Troubleshooting: three problems you will meet

10.1 Apache won't start: port 80 is already taken

Symptom. sudo service httpd start prints in red: Job for httpd.service failed because the control process exited with error code.

Cause. Only one program can listen on port 80. On this server, Nginx from an earlier lab was still running and held the port.

Fix, step by step:

1. Read the details: sudo systemctl status httpd. Look for Address already in use.
2. See who holds port 80: sudo ss -tlnp | grep :80. It shows nginx.
3. Stop the other web server: sudo service nginx stop.
4. Start Apache again: sudo service httpd start.
5. To keep Nginx from taking the port at the next boot: sudo systemctl disable nginx.

10.2 index.php shows a blank page

Symptom. index.html works, but index.php shows an empty white page.

Fix, step by step:

1. Right-click the page, View Page Source.
2. The source shows the PHP line itself, for example <?phpphpinfo(); ?>. PHP code reached the browser, so it was never run.
3. Spot the typo: there is no space after <?php. PHP only recognises its opening tag <?php when a space or a new line follows it, so it treated the whole line as plain text, and the browser hid it as an unknown tag.
4. Fix the file: echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/index.php
5. Refresh. The phpinfo page appears.

Lesson: when a page is blank, View Source first. It shows what the server really sent.

10.3 The PHP code is shown as text (or downloads)

Symptom. http://PUBLIC_IP/index.php shows <?php phpinfo(); ?> on the screen, or the browser downloads the file. curl localhost/index.php prints the same raw line.

Cause. Apache is sending the .php file as it is, instead of handing it to php-fpm. Usually php-fpm isn't running, or Apache was started before PHP was installed and never loaded PHP's config.

Fix on Amazon Linux:

1. Check php-fpm: sudo service php-fpm status. If it isn't installed, sudo yum install php -y.

2. Restart php-fpm, then Apache, in that order:

   sudo service php-fpm restart
   sudo service httpd restart
   

3. Refresh with Ctrl+F5 (the browser may have cached the old answer).

sudo a2enmod proxy_fcgi setenvif
sudo a2enconf php8.x-fpm
sudo service apache2 restart

Tip: if you are stuck, describe the exact symptom ("index.html works, index.php shows the code") and paste your script into a search engine or an AI assistant. A precise symptom gets a precise answer.

11. Clean up: stop what you don't use

Why. A LAMP server runs a database and three services all day. Stopping it when you finish saves free-tier hours.

A running instance costs money every hour, even if nobody visits it.

1. In the EC2 console, check the region selector at the top. A server you launched in another region doesn't show in this list; switch regions to find it.
2. Select every test server you no longer need, Instance state > Stop instance.
3. Terminate servers you'll never use again (after making an AMI if you want to keep the set-up).

12. The whole flow on one page

1. Static = same files for everyone; dynamic = server-side code + database, a page per visitor.
2. LAMP = Linux, Apache, MySQL/MariaDB, PHP. LEMP swaps Apache for Nginx.
3. The browser can't run PHP: Apache hands .php to php-fpm, which returns HTML.
4. sudo yum install httpd mariadb105-server php -y (-server = the database server itself).
5. Start httpd, mariadb, php-fpm; restart after installing everything (php-fpm first, Apache last).
6. Test with index.html and <?php phpinfo(); ?> in /var/www/html.
7. Automate in ~/lamp.sh: update first, -y everywhere, write files with echo ... | sudo tee.
8. chmod +x lamp.sh, ./lamp.sh, then curl localhost and service ... status.
9. Port 80 taken: stop Nginx. Blank page: View Source, fix the typo. PHP as text: restart php-fpm, then httpd.
10. Stop servers you don't use.

13. Hands-on lab: build and test a LAMP server

Why this lab. A dynamic site breaks in more places than a static one. This lab installs the stack, starts each service, and tests HTML and PHP separately, so you know which piece to blame when something fails.

1. Install all three in one line
   • Command: sudo yum install httpd mariadb105-server php -y
   • You should see: Download lines, then Complete!.
   • Check: httpd -v, mysql --version and php -v each print a version.
   • Why: yum takes several packages at once. mariadb105-server is the MariaDB server package on Amazon Linux 2023; php brings php-fpm with it.
2. Start the services
   • Command: sudo service mariadb start; sudo service php-fpm start; sudo service httpd restart
   • You should see: Three Redirecting to /bin/systemctl ... lines.
   • Check: sudo service httpd status shows active (running); the same for mariadb and php-fpm.
   • Why: Database and PHP first, Apache last, so Apache connects to a PHP that is already running.
3. Make them start at boot
   • Command: sudo systemctl enable httpd mariadb php-fpm
   • You should see: Three Created symlink ... lines.
   • Check: systemctl is-enabled httpd mariadb php-fpm prints enabled three times.
   • Why: start lasts until the next reboot. Without enable, the site is down after every stop and start.
4. Write an HTML test page
   • Command: echo "<h1>HTML works</h1>" | sudo tee /var/www/html/index.html
   • You should see: <h1>HTML works</h1>
   • Check: curl http://localhost → <h1>HTML works</h1>
   • Why: sudo echo ... > file fails, because the redirect runs as ec2-user. Piping into sudo tee writes as root.
5. Write a PHP test page
   • Command: echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/index.php
   • You should see: <?php phpinfo(); ?>
   • Check: curl -s http://localhost/index.php | grep -m1 "PHP Version" prints a line with the PHP version.
   • Why: If you get the raw <?php text back instead, PHP isn't running: start php-fpm and restart Apache.
6. Open both pages in the browser
   • Do: Allow HTTP (80) in the security group, then open http://PUBLIC_IP/ and http://PUBLIC_IP/index.php.
   • You should see: HTML works, then the purple-and-grey PHP information page.
   • Check: The PHP page lists Server API: FPM/FastCGI.
   • Why: The browser test proves the outside path works too. FPM/FastCGI shows Apache hands PHP to php-fpm, as in the diagram above.
7. Remove phpinfo and stop
   • Command: sudo rm /var/www/html/index.php
   • You should see: Nothing.
   • Check: http://PUBLIC_IP/index.php now gives 404. Stop the instance.
   • Why: phpinfo() shows your server's versions and paths to anyone, which helps attackers. Delete it once the test passes.

14. Try at home

Recap

Quick revision cards

Revise this lesson in two minutes. Save the cards on your phone or download them as PNG files. The QR code on each card opens its lesson.

More cards: Ravi Sir's Cards.