Cómo instalar Nginx con PHP y MySQL (LEMP Stack) en Ubuntu 22.04
La pila de software LEMP es un grupo de software de código abierto que permite a un servidor alojar sitios web dinámicos y aplicaciones escritas en PHP. Es un acrónimo de Linux, Nginx (pronunciado como Engine-X), MySQLy PHP.
Esta guía te enseñará a instalar una Pila LEMP en un servidor Ubuntu 22.04. También aprenderás a instalar aplicaciones como phpMyAdmin.
Requisitos previos
- Un servidor con Ubuntu 22.04.
- Un usuario no root con privilegios sudo.
- Firewall sin complicaciones (UFW) activado y en ejecución.
- Todo está actualizado.
$ sudo apt update && sudo apt upgrade
Paso 1 – Configurar el Cortafuegos
El primer paso antes de instalar ningún paquete es configurar el cortafuegos para permitir conexiones HTTP y HTTPS.
Comprueba el estado del cortafuegos.
$ sudo ufw status
Deberías ver algo como lo siguiente
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6)
Permitir puertos HTTP y HTTPs.
$ sudo ufw allow http $ sudo ufw allow https
Vuelve a comprobar el estado para confirmarlo.
$ sudo ufw status Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80/tcp ALLOW Anywhere 443/tcp ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443/tcp (v6) ALLOW Anywhere (v6)
Paso 2 – Instala PHP
Ubuntu 22.04 incluye PHP 8.1 por defecto. Puedes instalarlo ejecutando el siguiente comando.
$ sudo apt install php-fpm php-cli php-mysqlnd php-mbstring php-xml php-gd
Hemos instalado las extensiones MySQL, CLI, GD, Mbstring y XML de PHP. Puedes instalar cualquier extensión adicional según tus necesidades.
Para estar siempre con la última versión de PHP o si quieres instalar varias versiones de PHP, añade el repositorio PHP de Ondrej.
Añade el repositorio PHP de Ondrej.
$ sudo add-apt-repository ppa:ondrej/php
Ahora puedes instalar cualquier versión de PHP.
$ sudo apt install php8.0-fpm php8.0-cli
Comprueba la versión de PHP instalada.
$ php --version
PHP 8.1.2 (cli) (built: Jun 13 2022 13:52:54) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.1.2, Copyright (c) Zend Technologies
with Zend OPcache v8.1.2, Copyright (c), by Zend Technologies
Paso 3 – Instalar MySQL
Ubuntu 22.04 incluye la última versión de MySQL. Puedes instalarla con un solo comando.
$ sudo apt install mysql-server
Comprueba la versión de MySQL.
$ mysql --version mysql Ver 8.0.29-0ubuntu0.22.04.2 for Linux on x86_64 ((Ubuntu))
Este paso es necesario para las versiones de MySQL 8.0.28 y superiores. Entra en la Shell de MySQL.
$ sudo mysql
Ejecuta el siguiente comando para establecer la contraseña de tu usuario root. Asegúrate de que tiene una mezcla de números, mayúsculas, minúsculas y caracteres especiales.
mysql> ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'YourPassword12!';
Sal del intérprete de comandos.
mysql> exit
Ejecuta el script de instalación segura de MySQL.
$ sudo mysql_secure_installation
Se te pedirá que instales el componente Validar Contraseña. Comprueba la seguridad de las contraseñas utilizadas en MySQL. Pulsa Y para instalarlo.
A continuación, se te pedirá que establezcas el nivel de la política de validación de contraseñas. Elige 2, ya que es el más fuerte.
A continuación, introduce tu contraseña de root. Pulsa N para negarte a cambiarla.
Pulsa Y para eliminar los usuarios anónimos, desautorizar los inicios de sesión remotos de root, eliminar la base de datos de prueba y recargar las tablas de privilegios.
Paso 4 – Configurar MySQL
Accede al shell de MySQL. Introduce tu contraseña de root cuando se te solicite.
$ sudo mysql -u root -p
Crea una base de datos de prueba.
mysql> CREATE DATABASE exampledb;
Crea una cuenta de usuario SQL.
mysql> CREATE USER 'exampleuser'@'localhost' IDENTIFIED BY 'YourPassword2!';
Concede al usuario todos los privilegios sobre la base de datos.
mysql> GRANT ALL PRIVILEGES ON exampledb.* TO 'exampleuser'@'localhost';
Elimina los privilegios del usuario.
mysql> FLUSH PRIVILEGES;
Sal del intérprete de comandos.
mysql> exit
Volvamos a entrar en el intérprete de comandos MySQL utilizando el usuario recién creado.
$ sudo mysql -u exampleuser -p
Crea una tabla de prueba.
mysql> CREATE TABLE exampledb.name_list ( sno INT AUTO_INCREMENT, content VARCHAR(255), PRIMARY KEY(sno) );
Inserta los datos de prueba.
mysql> INSERT INTO exampledb.name_list (content) VALUES ("Navjot");
Repite el comando anterior varias veces para añadir más entradas. Ejecuta el siguiente comando para comprobar el contenido de la tabla.
mysql> SELECT * FROM exampledb.name_list;
Recibirás la siguiente salida.
+-----+---------+ | sno | content | +-----+---------+ | 1 | Navjot | | 2 | Adam | | 3 | Josh | | 4 | Peter | +-----+---------+ 4 rows in set (0.00 sec)
Sal del intérprete de comandos MySQL.
mysql> exit
Paso 5 – Instalar Nginx
Ubuntu 22.04 incluye una versión antigua de Nginx. Para instalar la última versión, necesitas descargar el repositorio oficial de Nginx.
Importa la clave de firma de Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \ | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Añade el repositorio de la versión estable de Nginx.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \ http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \ | sudo tee /etc/apt/sources.list.d/nginx.list
Actualiza los repositorios del sistema.
$ sudo apt update
Instala Nginx.
$ sudo apt install nginx
Verifica la instalación.
$ nginx -v nginx version: nginx/1.22.0
Paso 6 – Configurar PHP-FPM
Abre php.ini para editarlo.
$ sudo nano /etc/php/8.1/fpm/php.ini
Para configurar el tamaño de subida de los archivos, cambia los valores de las variables upload_max_filesize y post_max_size.
upload_max_filesize = 50M ... post_max_size = 50M
Configura el límite de memoria de PHP en función de los recursos y requisitos de tu servidor.
memory_limit = 256M
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Abre el archivo /etc/php/8.0/fpm/pool.d/www.conf.
$ sudo nano /etc/php/8.0/fpm/pool.d/www.conf
Necesitamos establecer el usuario/grupo Unix de los procesos PHP a nginx. Busca las líneas user=www-data y group=www-data en el archivo y cámbialas por nginx.
... ; Unix user/group of processes ; Note: The user is mandatory. If the group is not set, the default user's group ; will be used. user = nginx group = nginx ...
Busca también las líneas listen.owner=www-data y listen.group=www-data en el archivo y cámbialas por nginx.
listen.owner = nginx listen.group = nginx
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Reinicia el proceso PHP-fpm.
$ sudo systemctl restart php8.1-fpm
Paso 7 – Instalar phpMyAdmin
Descarga el archivo de phpMyAdmin para el idioma español.
$ wget https://files.phpmyadmin.net/phpMyAdmin/5.2.0/phpMyAdmin-5.2.0-english.tar.gz
Crea un directorio público para el sitio.
$ sudo mkdir /var/www/html/example.com -p
Extrae el archivo comprimido al directorio público.
$ sudo tar -xzvf phpMyAdmin-5.2.0-english.tar.gz -C /var/www/example.com
Cambia al directorio público.
$ cd /var/www/html/example.com
Cambia el nombre del directorio extraído a algo oscuro para mejorar la seguridad.
$ sudo mv phpMyAdmin-5.2.0-english sm175
Paso 8 – Configurar phpMyAdmin
Copia el archivo de configuración de ejemplo.
$ sudo cp sm175/config.sample.inc.php sm175/config.inc.php
Abre el archivo de configuración para editarlo.
$ sudo nano sm175/config.inc.php
Busca la línea $cfg['blowfish_secret'] = ''; e introduce una cadena aleatoria de 32 caracteres para la autenticación basada en cookies.
Puedes utilizar el generador blowfish online de phpSolved o hacerlo a través de la línea de comandos.
Copia el valor y pégalo como se muestra.
$cfg['blowfish_secret'] = 'Tc/HfLPBOAPxJ-rhQP}HJoZEK69c3j:m';
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Cambia la propiedad del sitio y de phpMyAdmin al servidor Nginx.
$ sudo chown -R nginx:nginx /var/www/html/example.com
Elimina el directorio de configuración de phpMyAdmin.
$ sudo rm -rf /var/www/html/example.com/sm175/setup
Paso 9 – Configurar Opcache
Opcache es el sistema de caché de PHP. Funciona guardando el bytecode del script precompilado en la memoria, de modo que cada vez que un usuario visita una página, ésta se carga más rápido. Opcache está instalado por defecto. Para verificarlo, comprueba la versión de PHP.
$ php --version
PHP 8.1.2 (cli) (built: Jun 13 2022 13:52:54) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.1.2, Copyright (c) Zend Technologies
with Zend OPcache v8.1.2, Copyright (c), by Zend Technologies
Esto nos indica que Opcache está instalado y disponible. En caso de que no aparezca aquí, puedes instalarlo manualmente ejecutando el siguiente comando.
$ sudo apt install php-opcache
Para cambiar la configuración de Opcache, abre el archivo /etc/php/8.1/fpm/conf.d/10-opcache.ini para editarlo.
$ sudo nano /etc/php/8.1/fpm/conf.d/10-opcache.ini
Las siguientes configuraciones deberían servirte para empezar a utilizar Opcache y, en general, se recomiendan para obtener un buen rendimiento. Puedes activar una configuración descomentándola eliminando el punto y coma que la precede.
opcache.enable_cli=1 opcache.memory_consumption=128 opcache.interned_strings_buffer=8 opcache.max_accelerated_files=4000 opcache.revalidate_freq=60
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Paso 10 – Instalar Certbot para SSL
Necesitamos instalar Certbot para generar certificados SSL gratuitos ofrecidos por Let’s Encrypt.
Puedes instalar Certbot utilizando el repositorio de Ubuntu o descargar la última versión utilizando la herramienta Snapd. Nosotros utilizaremos la versión Snapd.
Ubuntu 22.04 viene con Snapd instalado por defecto. Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd está actualizada.
$ sudo snap install core $ sudo snap refresh core
Instala Certbot.
$ sudo snap install --classic certbot
Utiliza el siguiente comando para asegurarte de que se puede ejecutar el comando Certbot creando un enlace simbólico al directorio /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Paso 11 – Probar un sitio de demostración
Crea el sitio
Crea y abre una página de prueba para editarla.
$ sudo nano /var/www/html/example.com/index.php
Pega en ella el siguiente código.
<?php
$user = "exampleuser";
$password = "YourPassword2!";
$database = "exampledb";
$table = "name_list";
try {
$db = new PDO("mysql:host=localhost;dbname=$database", $user, $password);
echo "<h2>Members List</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();
}
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Crea un certificado SSL
Ejecuta el siguiente comando para generar un certificado SSL.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d example.com
El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/example.com de tu servidor.
Genera un certificado de grupo Diffie-Hellman.
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096
Abre el archivo /etc/letsencrypt/renewal/example.com.conf para editarlo.
$ sudo nano /etc/letsencrypt/renewal/example.com.conf
Pega el siguiente código en la parte inferior.
pre_hook = systemctl stop nginx post_hook = systemctl start nginx
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Hemos generado el certificado SSL utilizando la opción autónoma de Certbot. Ejecuta su servidor web para crear el certificado, lo que significa que Nginx debe estar apagado durante la renovación. Los comandos pre_hook y post_hook se ejecutan antes y después de la renovación para apagar y reiniciar automáticamente el servidor Nginx, por lo que no requieren intervención manual.
Para comprobar si la renovación SSL funciona correctamente, realiza una ejecución en seco del proceso.
$ sudo certbot renew --dry-run
Si no ves ningún error, ya está todo listo. Tu certificado se renovará automáticamente.
Configurar Nginx
Crea y abre el archivo /etc/nginx/conf.d/example.conf para editarlo.
$ sudo nano /etc/nginx/conf.d/example.conf
Pega en él el siguiente código.
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name example.com;
access_log /var/log/nginx/example.com.access.log;
error_log /var/log/nginx/example.com.error.log;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers on;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
root /var/www/html/example.com;
index index.php index.html;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
# Pass PHP Scripts To FastCGI Server
location ~ \.php$ {
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass unix:/run/php/php8.1-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
location ~ /\.(?!well-known).* {
deny all;
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name example.com;
return 301 https://$host$request_uri;
}
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.
Abre el archivo /etc/nginx/nginx.conf para editarlo.
$ sudo nano /etc/nginx/nginx.conf
Añade la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Comprueba la configuración de Nginx.
$ sudo nginx -t
Si no ves ningún error, significa que puedes continuar. Inicia el servidor Nginx.
$ sudo systemctl start nginx
Carga tu sitio web visitando https://example.com en tu navegador y verás la siguiente página.
Puedes acceder a tu instalación de phpMyAdmin visitando la URL https://example.com/sm175 en tu navegador. Puedes introducir tu usuario root o el usuario creado anteriormente para acceder.
Conclusión
Con esto concluye nuestro tutorial, en el que has aprendido a configurar una pila LEMP en un servidor Ubuntu 22.04 y a crear un sitio de demostración. Si tienes alguna pregunta, publícala en los comentarios a continuación.