Dexter D

Harrison R

twitter

Maciej K

Linux Tutorials

Your privacy is important to us. We promise to not send you spam!

Every week we share the most relevant news in tech, culture and entertainment.

Get the most talked about articles directly in your inbox


In this tutorial, we will provide you with a detailed guide on how to install the LAMP stack on an CentOS 8 server.
The LAMP stack consists of four components: **L**inux, **A**pache, **M**ySQL, and **P**HP. These tools are used together
to host web applications written in PHP, making it a powerful and flexible solution for web development.

Installing the LAMP stack on an CentOS server is a relatively straightforward process, but it does require some technical
knowledge and experience with the command line. We will walk you through each step of the process to ensure that you are
able to set up your LAMP stack successfully.

## Requirements

To run a LAMP web server, we're going to need a server with CentOS 8 installed as its operating
system. You can [grab yourself $200 free credit from Digital Ocean](https://m.do.co/c/e708d0850a94) to get a virtual
machine if you haven't got a server already!

Although it isn't required, we highly recommend you set up some basic firewall rules along with a non-root user. Take a
look at our [basic CentOS 8 server setup guide](/tutorials/linux/connecting-to-a-linux-server-via-ssh) on how to do
that.

During this guide, we will mention `my_domain` which you'll need to replace with your actual domain name.

Installing LAMP (Linux, Apache, MySQL, PHP) on CentOS 8 is a multi-step process that involves installing and configuring each component individually. Here is a detailed guide on how to set up LAMP on CentOS 8:

###Install Apache Web Server:

Open a terminal and run the following command to install Apache:\
`sudo dnf install httpd`

Once the installation is complete, start the Apache service by running:\
`sudo systemctl start httpd`

To make sure Apache starts automatically on boot, run:\
`sudo systemctl enable httpd`

## Install MySQL Server:

Run the following command to install MySQL:\
`sudo dnf install mariadb-server mariadb`

Once the installation is complete, start the MySQL service by running:\
`sudo systemctl start mariadb`

To make sure MySQL starts automatically on boot, run:\
`sudo systemctl enable mariadb`

Now, run the following command to secure MySQL installation:\
`sudo mysql_secure_installation`

Follow the prompts to set the root password and answer the questions.

## Install PHP:

Run the following command to install PHP and the necessary modules for running PHP with Apache:\
`sudo dnf install php php-mysqlnd php-opcache`
Once the installation is complete, you will need to configure Apache to use PHP. To do this, open the file
`/etc/httpd/conf.d/php.conf` and add the following line at the end of the file:\
`AddType application/x-httpd-php .php`

Restart Apache for the changes to take effect:\
`sudo systemctl restart httpd`

## Verify the installation:

To verify that LAMP is working properly, create a new file named "info.php" in the /var/www/html/ directory:\
`sudo nano /var/www/html/info.php`

Add the following line to the file:\

```php
<?php phpinfo(); ?>
```

Save the file and exit.

Open a web browser and navigate to the following URL:\
**http://your_server_ip/info.php**

If everything is working correctly, you should see a page displaying information about your PHP installation.
That's it, you have successfully installed LAMP stack on your CentOS 8 server.

## Conclusions

Congratulation, you should now have a functioning LAMP stack web server with Linux, Apache, MySQL and PHP set up and running.
You can now begin building your website and show it off to the world!

You should now go ahead and protect your website with an SSL certificate using Let's Encrypt, [we have a guide](someguide.com)
outlining exactly how to do this!


Learn how to install the LAMP stack (Linux, Apache, MySQL, and PHP) on a CentOS 8server in this tutorial. Follow the step-by-step guide to set up a powerful and flexible web development environment on your server.

How to install LAMP stack on CentOS 8


Apache and Nginx are two of the most popular web servers in use today. Both servers are open-source software that can
be used to host websites and serve web content to clients. In this article, we will compare Apache and Nginx in terms of
their architecture, performance, and use cases.

## Architecture:

Apache uses a process-based architecture, which means that it creates a new process for each incoming request. This
allows Apache to handle a large number of requests concurrently, but it can also be resource-intensive, especially on
systems with limited memory.

Nginx, on the other hand, uses an event-based architecture, which means that it uses a small number of worker processes
to handle a large number of incoming connections. This allows Nginx to handle a larger number of requests with less
memory and CPU usage than Apache.

## Performance:

In terms of performance, Nginx is generally considered to be faster and more efficient than Apache. This is due in part
to its event-based architecture, which allows it to handle a larger number of connections with fewer resources. Nginx is
also known for its ability to efficiently serve static content, such as images and CSS files, which can help to reduce
the load on the server and improve overall performance.

Apache, on the other hand, can be more resource-intensive due to its process-based architecture. However, it does offer
a number of features and modules that can be used to optimize performance, such as mod_deflate for compressing content
and mod_cache for caching frequently-accessed content.

## Use cases:

Both Apache and Nginx are widely used in a variety of applications, but they do have some differences in terms of their
preferred use cases. Apache is often used for traditional LAMP (Linux, Apache, MySQL, PHP) stack environments and is
known for its support for a wide range of programming languages and modules. It is also the most widely-used web server,
which means that it has a large community of developers and users who can provide support and assistance.

Nginx, on the other hand, is often used in high-traffic environments where performance is a key concern. It is commonly
used as a reverse proxy server in front of Apache or other web servers, and it is also used as a load balancer to
distribute traffic across multiple servers. Nginx is known for its ability to handle a large number of connections
concurrently and is often used to serve static content, such as images and CSS files.

## Conclusion

In conclusion, Apache and Nginx are both powerful and widely-used web servers with their own unique strengths and
capabilities. Apache is known for its versatility and support for a wide range of programming languages and modules,
while Nginx is known for its performance and efficiency in high-traffic environments. Both servers are suitable for a
variety of use cases, and the choice between them will depend on the specific requirements of your project.


When it comes to hosting websites, it's important to choose the right web server. In this article, we  compare Apache and Nginx in terms of architecture, performance, and use cases to help you determine the best option for  your needs.

Apache vs Nginx: Which is the best web server for you?


A reverse proxy is a server that sits in front of one or more web servers and directs client requests to the appropriate
server. Reverse proxies can be used to load balance traffic, cache content, and provide SSL termination, among other
things. In this guide, we will show you how to set up a reverse proxy using Nginx on Ubuntu.

First, make sure that you have Nginx installed on your server. If you don't have Nginx installed, you can install it by
running the following commands:\
`sudo apt-get update`\
`sudo apt-get install nginx`

Once Nginx is installed, you will need to create a new configuration file for your reverse proxy. You can do this by
creating a new file in the `/etc/nginx/sites-available` directory. For example, you might create a file called
`reverse-proxy.conf`.

In your configuration file, you will need to specify the upstream servers that you want to proxy traffic to. This is
done using the upstream block. For example:

```shell
upstream app_server {
  server app1.example.com;
  server app2.example.com;
}
```

Next, you will need to create a server block for your reverse proxy. In this block, you will need to specify the domain
name that you want to use for your reverse proxy, as well as the location of the SSL certificate and key if you want to
serve traffic over HTTPS. You will also need to specify the `proxy_pass` directive, which tells Nginx where to forward
traffic. For example:

```shell
upstream app_server {
  server app1.example.com;
  server app2.example.com;
}

server {
listen 80;
listen [::]:80;
server_name example.com;

    location / {
        proxy_pass http://app_server;
    }
}
```

Once you have created your configuration file, you will need to enable it by creating a symbolic link from the
`sites-available` directory to the `sites-enabled` directory. You can do this by running the following command:\
`sudo ln -s /etc/nginx/sites-available/reverse-proxy.conf /etc/nginx/sites-enabled/`

Finally, you will need to test your configuration and restart Nginx to apply the changes. You can test your
configuration by running the following command:\
`sudo nginx -t`

If the test is successful, you can restart Nginx by running the following command:\
`sudo service nginx restart`

## Conclusion

That's it! You should now have a working reverse proxy set up using Nginx. If you want to learn more about Nginx and how
to configure it, you can check out the Nginx documentation at <https://nginx.org/en/docs>.


In this article, we will show you how to set up an Nginx reverse proxy on Ubuntu. We will cover everything  you need to know, from installation to debugging. This article is suitable for developers looking to host multiple  websites on a single server or business owners looking to improve the performance and security of their online presence.

How to setup an Nginx reverse proxy (Ubuntu)


The root password on a Linux server is the most important password for the system, as it gives you full access to the
server and allows you to perform any action on the machine. It is important to periodically change the root password to
ensure the security of your system. In this guide, we will walk you through the steps to change the root password on a
Linux server using the command line interface (CLI).

## Step 1 - Login to the server

Log in to the server as the root user. We have a [guide](/posts/connecting-to-a-linux-server-via-ssh) on how to do this.

## Step 2 - Run the `passwd` command

At the command prompt, type the following command to change the root password:\
`passwd`

## Step 3 - Set your new password

You will be prompted to enter the current root password. Type in the current password and press **Enter**.

You will then be prompted to enter the new root password. Type in the new password and press **Enter**.

You will be prompted to confirm the new password by typing it in again. Type the new password again and press **Enter**.

The root password has now been changed.

## Conclusion

That's it! You have successfully changed the root password on your Linux server.


This guide will show you how to change the root password on a Linux server using the command line interface  (CLI). It is important to regularly change this password to ensure the security of your system.

Changing the root password on a Linux Server (CLI)


Installing a MariaDB Galera cluster on Ubuntu 22.02 is a straightforward process that allows you to set up a highly
available and scalable database cluster. In this blog post, we will guide you through the steps to install and configure
a MariaDB Galera cluster on three Ubuntu 22.02 machines. You will learn how to install the MariaDB Server and Galera
Cluster packages, as well as how to configure the cluster and start the MariaDB service on each machine. By the end of
this tutorial, you will have a fully functioning MariaDB Galera cluster that is ready to handle your database workload.

## Step 1 - Installing MariaDB Server

First, you need to install the MariaDB Server on each of the three machines. To do this, open a terminal on each machine
and enter the following commands:

`sudo apt update`\
`sudo apt install mariadb-server`

This will install the latest version of the MariaDB Server on your machine.

## Step 2- Installing MariaDB Galera Cluster

Next, you need to install the MariaDB Galera Cluster on each of the three machines. To do this, enter the following
command in the terminal on each machine:

`sudo apt install galera-3`

This will install the necessary packages for the Galera Cluster on your machine.

Once the MariaDB Server and Galera Cluster have been installed, you need to configure the cluster. To do this, you will
need to edit two configuration files:

`/etc/mysql/mariadb.conf.d/50-server.cnf`\
`/etc/mysql/conf.d/cluster.cnf`

In the `/etc/mysql/mariadb.conf.d/50-server.cnf` file, you need to add the following lines under the `[mysqld]` section:

```shell
binlog_format=ROW
default-storage-engine=innodb
innodb_autoinc_lock_mode=2
bind-address=0.0.0.0
```

These lines configure the MariaDB Server to use the ROW-based binary log format, the InnoDB storage engine, and to listen
for connections from other hosts.

In the `/etc/mysql/conf.d/cluster.cnf` file, you need to add the following lines:

```shell
[mysqld]
wsrep_on=ON
wsrep_provider=/usr/lib/galera/libgalera_smm.so
wsrep_cluster_name="my_cluster"
wsrep_cluster_address="gcomm://IP1,IP2,IP3"
wsrep_node_name="node1"
wsrep_node_address="IP1"
wsrep_sst_method=rsync
```

These lines configure the Galera Cluster with a name, address, and node name. Replace **IP1**, **IP2**, and **IP3** with
the respective IP addresses of the three Ubuntu 22.02 machines. Replace node1 with a unique name for the current machine.

Once the configuration files have been edited, you can start the MariaDB service on the first machine by running the
following command:

`sudo systemctl start mariadb`

This will start the MariaDB Server on the first machine and initiate the Galera Cluster.

To start the MariaDB service on the remaining machines, run the following command on each machine:

`sudo systemctl start mariadb --wsrep-new-cluster`

This will start the MariaDB Server on the remaining machines and add them to the cluster.

## Conclusion

That's it! You have successfully installed and configured a MariaDB Galera Cluster on three Ubuntu 22.02 machines.


This guide will show you how to install a MariaDB Galera cluster on Ubuntu 22.02, providing high  availability and scalability for your database workloads.

Installing a MariaDB Galera cluster on Ubuntu 22.02


In this guide, you’ll learn how to establish an SSH connection to a remote server in less than 60 seconds.

SSH, or secure shell is a type of connection protocol which is encrypted. It is the quickest and easiest way to connect
to the command line of, say, your VPS or any remote server, and can be done from all major operating systems.

SSH utilizes a port on a server to listen for connections. Think of it as a letterbox – a letter is sent to a specific
letterbox which has the house number on it, and then the tenant can find their mail in that box. In the same way, SSH
uses the port (like a house number) to identify all the mail coming towards it – the remote connections.

## Getting started

Connecting to a server using SSH is very simple. You’ll usually only need a single command, and if you choose to use an
app for it, the details are exactly the same. Here’s what you’ll need:

-   username – the username of the account you want to connect with
-   host name – the host name, usually an IP address, of the target server
-   port – the port of the target server (if it’s not the default)
-   keyfile - the SSH key file, only if an SSH key is to be used instead of a password

## Establishing the new SSH connection

Your basic command will look like this:

`writer@HostingForFree ~ % ssh [username]@[hostname]`

In simple terms, you’re connecting to the account username which is located at the address hostname. This assumes that
SSH is running on port 22 which is the default, but this isn’t always the case.

## Connecting to alternative ports via SSH

If your port is different, you can specify this in one of two ways:

`writer@HostingForFree ~ % ssh [username]@[hostname]:[port]`
`writer@HostingForFree ~ % ssh -p [port] [username]@[hostname]`

## Login to SSH with SSH key

If you use an SSH key to connect instead of a password, we can adjust for this in the command too:

`writer@HostingForFree ~ % ssh -i [keyfile] [username]@[hostname]`

Whilst there is a terminal option available for Windows, Mac and Linux, there are also GUI options available. The most
popular SSH client is currently PuTTY. All SSH clients, however, will require the same details to log in.

## Conclusion

Good job – you’re now connected to the server in record time!


Learn how to connect to a Linux server via SSH in this tutorial. This guide will show you how to establish  a secure connection to your server using the Secure Shell (SSH) protocol.

Connecting to a Linux server via SSH


In this tutorial, we will provide you with a detailed guide on how to install the LAMP stack on an Ubuntu 20.04 server.
The LAMP stack consists of four components: **L**inux, **A**pache, **M**ySQL, and **P**HP. These tools are used together
to host web applications written in PHP, making it a powerful and flexible solution for web development.

Installing the LAMP stack on an Ubuntu server is a relatively straightforward process, but it does require some technical
knowledge and experience with the command line. We will walk you through each step of the process to ensure that you are
able to set up your LAMP stack successfully.

## Requirements

To run a LAMP web server, we're going to need a server with Ubuntu 20.04 installed as its operating
system. You can [grab yourself $200 free credit from Digital Ocean](https://m.do.co/c/e708d0850a94) to get a virtual
machine if you haven't got a server already!

Although it isn't required, we highly recommend you set up some basic firewall rules along with a non-root user. Take a
look at our [basic Ubuntu 20.04 server setup guide](/tutorials/linux/connecting-to-a-linux-server-via-ssh) on how to do
that.

During this guide, we will mention `my_domain` which you'll need to replace with your actual domain name.

## Step 1 - Getting your server ready

Once you have your Ubuntu 20.04 server, you'll need to connect to it via SSH
([check out this guide if you don't know how](/tutorials/linux/connecting-to-a-linux-server-via-ssh)). There are two
things we'll need to do first which are opening the required firewall ports and ensuring our server is fully up-to-date.

Before we do anything, ensuring the server is up-to-date and our package manager cache is updated is important to prevent
any errors when installing packages later on. This is achieved by running the below commands:

`sudo apt update -y`\
`sudo apt upgrade -y`

We are going to need two ports open, 80 and 443 which are for the web server. To open these, simply run the following
two commands:

`sudo ufw allow 80`\
`sudo ufw allow 443`

## Step 2 - Installing Apache & creating your virtual host

Now we can install our first package of the LAMP stack, Apache, which is going to be used as our web server. To do this,
we'll need to run the following command:

`sudo apt install apache2 -y`

Once this has been installed, we can then create our virtual host which is the web server configuration for our website.
We'll need to create a directory where our website files are going to be stored:

`sudo mkdir /var/www/my_domain`

Then we can change the ownership of the directory we just created:

`sudo chown -R $USER:$USER /var/www/my_domain`

After that, we can create our domain's configuration file. You can use any text editor for this but we'll be using nano:

`sudo nano /etc/apache2/sites-available/my_domain.conf`

Once your file is open, we need to add the following code and save it:

```
<VirtualHost *:80>
	ServerName my_domain
	ServerAlias www.my_domain
	ServerAdmin webmaster@my_domain
	DocumentRoot /var/www/my_domain
	ErrorLog ${APACHE_LOG_DIR}/error.log
	CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
```

Finally, we need to enable the configuration we've just created and disable the default one that ships with Apache:

`sudo a2ensite my_domain`\
`sudo a2dissite 000-default`

We can then reload Apache to make our changes live on the web server:

`sudo systemctl reload apache2`

If you have followed each step carefully, your website will now be live. To test this you can create an `index.html` file and save the following code to it:

`nano /var/www/my_domain/index.html`

```html
<html>
    <head>
        <title>My website</title>
    </head>

    <body>
        <h1>Hello world</h1>
    </body>
</html>
```

You should now be able to access your site by visiting `http://my_domain` in your browser, it should look like this:
![Your website](https://i.hcloud.uk/ow71nmnoz6.png)

## Step 3 - Installing MySQL

Now we have our web server running, we need to install MySQL to serve as our database system. MySQL is an excellent
database system and is the most used for web applications.

To do this, we'll need to run the following command:

`sudo apt install mysql-server -y`

We can then run the pre-installed configuration script to start the setup of MySQL. This will allow us to set important
security settings. These settings should be set depending on your use case so please read each step carefully before
giving an answer. You can enter `Y` for yes and `N` for no.

`sudo mysql_secure_installation`

## Step 4 - Installing PHP

We will need to install the final part of our LAMP stack, PHP, which is used to process our code and display it to the
end-user.

Along with our `php` package, we'll also need the `php-mysql` package which is used to talk to our MySQL databases, and
`libapache2-mod-php` to allow Apache to handle our PHP files. Any required/core packages will be automatically installed
when we install PHP.

To install these packages, simply run the following command:

`sudo apt install php libapache2-mod-php php-mysql -y`

We can then verify PHP has been installed using this command:

`php -v`

By default, a file named `index.html` will always be used over an `index.php` file. If you want to change
this setting, you’ll need to edit the `/etc/apache2/mods-enabled/dir.conf` file and adjust the order ensuring
`index.php` comes first.

`sudo nano /etc/apache2/mods-enabled/dir.conf`

```
<IfModule mod_dir.c>
        DirectoryIndex index.php index.html index.cgi index.pl index.xhtml index.htm
</IfModule>
```

If you edit this file, you'll need to reload Apache with the following command:

`sudo systemctl reload apache2`

## Step 5 - Testing PHP can process files

Now we have all of our LAMP stack installed and configured, we need to test PHP can process our PHP files and display
these on your website.

The easiest way to do this is to create a file called `info.php` and use the `phpinfo()` function to view our PHP
configuration. This can be done with the following command and save the below content in the file:

`sudo nano /var/www/my_domain/info.php`

```
<?php phpinfo(); ?>
```

You should now be able to view this file by visiting `http://my_domain/info.php` in your browser, it should look like this:
![info.php](https://i.hcloud.uk/mdqmfc8sdb.png)

If your website is displaying a page similar to the above screenshot, PHP is successfully processing code to the web server!

## Conclusions

Congratulation, you should now have a functioning LAMP stack web server with Linux, Apache, MySQL and PHP set up and running.
You can now begin building your website and show it off to the world!

You should now go ahead and protect your website with an SSL certificate using Let's Encrypt, [we have a guide](someguide.com)
outlining exactly how to do this!


Learn how to install the LAMP stack (Linux, Apache, MySQL, and PHP) on an Ubuntu 20.04 server in this  tutorial. Follow the step-by-step guide to set up a powerful and flexible web development environment on your server.