Hur man installerar Linux, Nginx, MySQL, PHP (LEMP-stack) på Ubuntu

Introduktion

LEMP-programvarustacken levererar dynamiska webbsidor och webbapplikationer skrivna i PHP. Detta är en förkortning som beskriver ett Linux-operativsystem med en Nginx (uttalas som “Engine-X”) webserver. Backend-data lagras i MySQL-databasen och den dynamiska bearbetningen hanteras av PHP.

Denna guide visar hur man installerar en LEMP-stack på en Ubuntu-server. Ubuntu-operativsystemet tar hand om Linux-delen av stacken. Vi kommer att beskriva hur man får de övriga komponenterna att fungera.

Observera: Denna handledning riktar sig främst till Ubuntu 22.04 LTS med PHP 8.1. För användare av Ubuntu 24.04 LTS, justera PHP-versionreferenser från php8.1-fpm till php8.3-fpm i alla kommandon. Se också till att uppdatera alla PHP-FPM-socketvägar i din Nginx-konfiguration (t.ex. använd /run/php/php8.3-fpm.sock för Ubuntu 24.04).

Hur man installerar Linux, Nginx, MySQL, PHP (LEMP-stack) på Ubuntu

1. Installera Nginx-webbservern
2. Installera MySQL
3. Installera PHP
4. Konfigurera Nginx för att använda PHP-processorn
5. Testa PHP med Nginx
6. Testa databasanslutning från PHP

Förutsättningar

Använd en icke-root sudo-användare på Ubuntu med UFW-brandväggen aktiverad. Följ vår guide för initial serverkonfiguration för Ubuntu för att ställa in detta.

Steg 1 – Installera Nginx-webbservern

För att visa webbsidor för webbplatsbesökare ska du använda Nginx, en högpresterande webbserver. Du kommer att använda APT-pakethanteraren för att hämta denna programvara.

Uppdatera serverns paketindex och installera sedan Nginx:

sudo apt update

Därefter kör apt install för att installera Nginx:

sudo apt install nginx

När du uppmanas, tryck på Y och ENTER för att bekräfta att du vill installera Nginx. När installationen är klar kommer Nginx-webbservern att vara aktiv och igång på din Ubuntu-server.

Verifiera att Nginx körs:

sudo systemctl status nginx

Du bör se ett resultat som visar att Nginx är aktiv:

● nginx.service - A high performance web server and a reverse proxy server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset: enabled)
     Active: active (running) since...

På Ubuntu är Nginx konfigurerat att starta automatiskt vid installationen.

Tillåt HTTP-trafik genom ufw-brandväggen. Nginx registrerar flera UFW-applikationsprofiler vid installation. Kontrollera tillgängliga profiler:

sudo ufw app list

Available applications:
  Nginx Full
  Nginx HTTP
  Nginx HTTPS
  OpenSSH

Aktivera den mest restriktiva profilen som tillåter nödvändig trafik. Eftersom SSL ännu inte är konfigurerat, tillåt endast HTTP-trafik på port 80:

Aktivera detta genom att köra följande:

sudo ufw allow 'Nginx HTTP'

Verifiera brandväggsändringen:

sudo ufw status

Detta resultat visar att HTTP-trafik nu är tillåten:

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Nginx HTTP                 ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Nginx HTTP (v6)            ALLOW       Anywhere (v6)

För att testa Nginx-serverns domänfunktionalitet, navigera till http://your_domain med din föredragna webbläsare.

Om du inte har ett domännamn som pekar på din server och inte vet din servers offentliga IP-adress, kan du hitta den genom att köra någon av följande kommandon:

ip addr show

hostname -I

Detta kommer att skriva ut några IP-adresser. Du kan prova var och en av dem i din webbläsare i tur och ordning.

Som ett alternativ kan du kontrollera vilken IP-adress som är åtkomlig, sett från andra platser på internet:

curl -4 icanhazip.com

Skriv in adressen som du får i din webbläsare så kommer den att ta dig till Nginx standardstartsida:

http://<server_domain_or_IP>

Om du får den här sidan betyder det att du har installerat Nginx och aktiverat HTTP-trafik för din webbserver.

Steg 2 — Installera MySQL

Installera MySQL för att lagra och hantera webbplatsdata. MySQL är den standardiserade databashanteraren för PHP-miljöer.

Använd igen apt för att hämta och installera denna mjukvara:

sudo apt install mysql-server

När du uppmanas, bekräfta installationen genom att trycka på Y och sedan ENTER.

Efter installation, kör säkerhetsskriptet för att ta bort osäkra standardinställningar och låsa databastillgången:

sudo mysql_secure_installation

Du kommer att få en fråga om du vill konfigurera VALIDATE PASSWORD PLUGIN.

Svara Y för ja, eller något annat för att fortsätta utan att aktivera:

VALIDATE PASSWORD COMPONENT 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 component?

Press y|Y for Yes, any other key for No: 

Om du svarar ”ja” kommer du att bli ombedd att välja en nivå för lösenordsvalidering. Tänk på att om du anger 2 för den högsta nivån kommer du att få felmeddelanden när du försöker ställa in ett lösenord som inte innehåller siffror, stora och små bokstäver samt specialtecken:

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

Oavsett om du väljer att ställa in VALIDATE PASSWORD PLUGIN eller inte, kommer din server att be dig att välja och bekräfta ett lösenord för MySQL-root-användaren. Detta ska inte förväxlas med systemroot. Databasroot-användaren är en administrativ användare med fullständiga behörigheter över databassystemet. Även om standardautentiseringsmetoden för MySQL-root-användaren inte kräver användning av lösenord, även när ett är inställt, bör du definiera ett starkt lösenord här som en extra säkerhetsåtgärd. Vi kommer att prata om detta om ett ögonblick.

Om du har aktiverat lösenordsvalidering kommer styrkan på det root-lösenord du angav att visas och din server kommer att fråga om du vill fortsätta med det lösenordet. Om du är nöjd med ditt nuvarande lösenord, tryck Y för "ja" vid prompten:

Estimated strength of the password: 100 
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : y

För resten av frågorna, tryck på Y och tryck på ENTER vid varje prompt. Detta kommer att ta bort vissa anonyma användare och testdatabasen, inaktivera fjärrinloggningar som root, och ladda dessa nya regler så att MySQL omedelbart respekterar de ändringar du har gjort.

När du är klar, testa om du kan logga in på MySQL-konsolen:

sudo mysql

Detta kommer att ansluta till MySQL-servern som den administrativa databasanvändaren root, vilket antyds av användningen av sudo när detta kommando körs. Du bör få följande utskrift:

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 10
Server version: 8.0.28-0ubuntu4 (Ubuntu)

Copyright (c) 2000, 2022, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

För att avsluta MySQL-konsolen, skriv följande:

exit

Observera att du inte behövde ange något lösenord för att ansluta som root-användare, även om du har definierat ett när du körde mysql_secure_installation-skriptet. Detta beror på att standardautentiseringsmetoden för den administrativa MySQL-användaren när MySQL är installerat på Ubuntu är auth_socket, istället för en metod som använder ett lösenord. Detta kan initialt verka som en säkerhetsrisk, men det gör databasservern mer säker eftersom de enda användarna som tillåts logga in som MySQL-root är systemanvändare med sudo-behörigheter som ansluter från konsolen eller genom en applikation som körs med samma behörigheter. I praktiken betyder det att du inte kommer kunna använda den administrativa databasens root-användare för att ansluta från din PHP-applikation.

För ökad säkerhet är det bäst att ha dedikerade användarkonton med begränsade behörigheter för varje databas, särskilt om du planerar att ha flera databaser värd på din server.

Din MySQL-server är nu installerad och säkrad. Nästa steg är att installera PHP, den sista komponenten i LEMP-stacken.

Steg 3 – Installera PHP

Installera PHP för att bearbeta kod och generera dynamiskt innehåll. Nginx kräver ett externt program för PHP-bearbetning.

PHP-FPM ("fastCGI-processhanterare") hanterar PHP-bearbetning effektivt med ytterligare säkerhetsfunktioner och levererar bättre prestanda för PHP-baserade webbplatser. Installera php-fpm för att dirigera PHP-förfrågningar från Nginx, och php-mysql för att möjliggöra PHP-MySQL-kommunikation. Kärn-PHP-paket installeras automatiskt som beroenden.

För att installera paketen php8.1-fpm och php-mysql, kör:

sudo apt install php8.1-fpm php-mysql

När du uppmanas, tryck på Y och ENTER för att bekräfta installationen.

Verifiera att PHP-FPM körs:

sudo systemctl status php8.1-fpm

Du bör se en utskrift som visar att PHP-FPM är aktivt:

● php8.1-fpm.service - The PHP 8.1 FastCGI Process Manager
     Loaded: loaded
     Active: active (running)

Du kan också kontrollera PHP-versionen:

php -v

PHP 8.1.x (cli) (built: ...)
Copyright (c) The PHP Group
Zend Engine v4.1.x

Konfigurera Nginx för att använda dessa PHP-komponenter.

Steg 4 — Konfigurera Nginx för att använda PHP-processorn

Skapa Nginx serverblock (liknande Apache-virtuella värdar) för att kapsla in konfiguration och vara värd för flera domäner på en server. Denna guide använder din_domän som exempel på domännamn.

På Ubuntu 22.04 aktiverar Nginx ett standardserverblock som serverar dokument från /var/www/html. För flera webbplatser, skapa en katalogstruktur inom /var/www för your_domain, och lämna /var/www/html som standard fallback-katalog.

Skapa rotwebbkatalogen för your_domain enligt följande:

sudo mkdir /var/www/your_domain

Nästa steg är att tilldela ägarskap av katalogen med miljövariabeln $USER, som kommer att referera till din nuvarande systemanvändare:

sudo chown -R $USER:$USER /var/www/your_domain

Öppna sedan en ny konfigurationsfil i Nginx:s sites-available-katalog med din föredragna kommandoradsredigerare. Här kommer vi att använda nano:

sudo nano /etc/nginx/sites-available/your_domain

Detta kommer att skapa en ny tom fil. Infoga följande grundläggande konfiguration:

server {
    listen 80;
    server_name your_domain www.your_domain;
    root /var/www/your_domain;

    index index.html index.htm index.php;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php8.1-fpm.sock;
     }

    location ~ /\.ht {
        deny all;
    }

}

Här är vad var och en av dessa direktiv och platsblock gör:

• listen — Definierar vilken port Nginx kommer att lyssna på. I det här fallet kommer den att lyssna på port 80, standardporten för HTTP.
• root — Definierar dokumentroten där filerna som serveras av denna webbplats lagras.
• index — Definierar i vilken ordning Nginx kommer att prioritera indexfiler för denna webbplats. Det är en vanlig praxis att lista index.html-filer med högre prioritet än index.php-filer för att snabbt kunna sätta upp en underhållssida i PHP-applikationer. Du kan justera dessa inställningar för att bättre passa dina applikationsbehov.
• server_name — Definierar vilka domännamn och/eller IP-adresser denna serverblock ska svara på. Pekar denna direktiv till din servers domännamn eller offentliga IP-adress.
• location / — Den första location-blocket innehåller en try_files-direktiv, som kontrollerar om filer eller kataloger som matchar en URL-förfrågan finns. Om Nginx inte kan hitta resurserna kommer det att returnera ett 404-fel.
• location ~ \.php$ — Denna platsblock hanterar den faktiska PHP-bearbetningen genom att peka Nginx till fastcgi-php.conf-konfigurationsfilen och filen php8.1-fpm.sock, som anger vilken socket som är kopplad till php8.1-fpm.
• location ~ /\.ht — Den sista location-blocket hanterar .htaccess-filer, som Nginx inte bearbetar. Genom att lägga till direktivet deny all, om några .htaccess-filer skulle råka hamna i dokumentroten, kommer de inte att serveras till besökare.

När du är klar med redigeringen, spara och stäng filen. Om du använder nano kan du göra detta genom att trycka CTRL+X och sedan Y och ENTER för att bekräfta.

Aktivera din konfiguration genom att länka till konfigurationsfilen från Nginx:s sites-enabled-katalog:

sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/

Därefter, koppla loss standardkonfigurationsfilen från /sites-enabled/-mappen:

sudo unlink /etc/nginx/sites-enabled/default

sudo ln -s /etc/nginx/sites-available/default /etc/nginx/sites-enabled/

Detta kommer att tala om för Nginx att använda konfigurationen nästa gång den laddas om. Du kan testa din konfiguration för syntaxfel genom att köra följande:

sudo nginx -t

Om några fel rapporteras, gå tillbaka till din konfigurationsfil för att granska dess innehåll innan du fortsätter.

När du är redo, ladda om Nginx för att tillämpa ändringarna:

sudo systemctl reload nginx

Din nya webbplats är nu aktiv, men webbrot /var/www/your_domain är fortfarande tom. Skapa en index.html-fil på den platsen så att du kan testa att din nya serverblock fungerar som förväntat:

nano /var/www/your_domain/index.html

Inkludera följande innehåll i den här filen:

<html>
  <head>
    <title>your_domain website</title>
  </head>
  <body>
    <h1>Hello World!</h1>

    <p>This is the landing page of <strong>your_domain</strong>.</p>
  </body>
</html>

Gå nu till din webbläsare och öppna din servers domännamn eller IP-adress, som anges i server_name-direktivet i din serverblockskonfigurationsfil:

http://server_domain_or_IP

Du kommer att få en sida som liknar följande:

Om du får denna sida betyder det att din Nginx-serverblock fungerar som förväntat.

Du kan lämna denna fil som den är som en temporär startsida för din applikation tills du skapar en index.php-fil för att ersätta den.

Din LEMP-stack är nu helt konfigurerad. I nästa steg kommer du att skapa ett PHP-skript för att testa att Nginx faktiskt kan hantera .php-filer på din nyskapade webbplats.

Steg 5 – Testa PHP med Nginx

Din LEMP-stack bör nu vara helt uppsatt. Du kan testa den för att verifiera att Nginx korrekt kan överlämna .php-filer till din PHP-processor.

Du kan göra detta genom att skapa en test-PHP-fil i din dokumentrot. Öppna en ny fil kallad info.php i din dokumentrot i din föredragna textredigerare:

nano /var/www/your_domain/info.php

Lägg till följande rader i den nya filen. Detta är giltig PHP-kod som kommer att returnera information om din server:

<?php
phpinfo();

När du är klar, spara och stäng filen.

Du kan nu komma åt den här sidan i din webbläsare genom att besöka domännamnet eller den offentliga IP-adressen som du har ställt in i din Nginx-konfigurationsfil, följt av /info.php:

http://server_domain_or_IP/info.php

Du kommer att få en webbsida med detaljerad information om din server:

Efter att ha kontrollerat relevant information om din PHP-server via den sidan är det bäst att ta bort filen du skapade eftersom den innehåller känslig information om din PHP-miljö och din Ubuntu-server. Du kan använda rm för att ta bort filen:

sudo rm /var/www/your_domain/info.php

Du kan alltid återskapa den här filen om du behöver den senare.

Steg 6 — Testa databasanslutning från PHP (Valfritt)

Om du vill testa om PHP kan ansluta till MySQL och utföra databasfrågor kan du skapa en testtabell med exempeldata och fråga efter dess innehåll från ett PHP-skript. Innan du gör det måste du skapa en testdatabas och en ny MySQL-användare som är korrekt konfigurerad för att få åtkomst till den.

Vi kommer att skapa en databas som heter example_database och en användare som heter example_user, men du kan ersätta dessa namn med andra värden.

Först, anslut till MySQL-konsolen med root-kontot:

sudo mysql

För att skapa en ny databas, kör följande kommando från din MySQL-konsol:

CREATE DATABASE example_database;

Nu kan du skapa en ny användare och ge dem fullständiga privilegier på den anpassade databasen du har skapat.

Följande kommando skapar en ny användare med namnet example_user, med mysql_native_password som standard autentiseringsmetod. Vi anger detta användarlösenord som password, men du bör ersätta detta värde med ett säkert lösenord som du själv väljer.

CREATE USER 'example_user'@'%' IDENTIFIED WITH mysql_native_password BY 'password';

Nu behöver vi ge den här användaren behörighet över databasen example_database:

GRANT ALL ON example_database.* TO 'example_user'@'%';

Detta kommer att ge användaren example_user fulla behörigheter över databasen example_database samtidigt som det förhindrar att denna användare skapar eller ändrar andra databaser på din server.

Avsluta nu MySQL-skalet med följande kommando:

exit

Du kan testa om den nya användaren har rätt behörigheter genom att logga in på MySQL-konsolen igen, den här gången med de anpassade användaruppgifterna. Observera -p-flaggan i detta kommando, som kommer att be dig om lösenordet som användes när example_user-användaren skapades:

mysql -u example_user -p

Efter att du loggat in på MySQL-konsolen, bekräfta att du har åtkomst till databasen example_database:

SHOW DATABASES;

Detta kommer att ge följande resultat:

+--------------------+
| Database           |
+--------------------+
| example_database   |
| information_schema |
+--------------------+
2 rows in set (0.000 sec)

Nästa steg är att skapa en testtabell som heter todo_list. Från MySQL-konsolen, kör följande kommando:

CREATE TABLE example_database.todo_list (

 item_id INT AUTO_INCREMENT,

 content VARCHAR(255),

 PRIMARY KEY(item_id)

);

Infoga några rader med innehåll i testtabellen. Du kanske vill upprepa nästa kommando några gånger och använda olika värden:

INSERT INTO example_database.todo_list (content) VALUES ("My first important item");

För att bekräfta att uppgifterna sparades korrekt i din tabell, kör:

SELECT * FROM example_database.todo_list;

Din utmatning ska visas som följer:

+---------+--------------------------+
| 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)

Efter att ha bekräftat att du har giltiga data i din testtabell kan du avsluta MySQL-konsolen:

exit

Nu kan du skapa PHP-skriptet som kommer att ansluta till MySQL och söka efter ditt innehåll. Skapa en ny PHP-fil i din anpassade webbrotkatalog med din föredragna redigerare. Vi kommer att använda nano för det:

nano /var/www/your_domain/todo_list.php

Följande PHP-skript ansluter till MySQL-databasen och frågar efter innehållet i tabellen todo_list, och visar resultaten i en lista. Om det uppstår ett problem med databasanslutningen kommer det att kasta ett undantag.

Lägg till följande innehåll i ditt todo_list.php-skript:

<?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();
}

Spara och stäng filen när du är klar med redigeringen.

Du kan nu få åtkomst till den här sidan i din webbläsare genom att besöka domännamnet eller den offentliga IP-adressen som är konfigurerad för din webbplats, följt av /todo_list.php:

http://server_domain_or_IP/todo_list.php

Du bör få en sida som liknar följande, som visar innehållet du har lagt in i din testtabell:

Det betyder att din PHP-miljö är redo att ansluta till och interagera med din MySQL-server.

Vanliga frågor

Vad används LEMP-stacken till?

LEMP-stacken hostar dynamiska PHP-baserade webbplatser och applikationer inklusive WordPress, Laravel, Magento, Drupal och egna PHP-projekt. Den är särskilt effektiv för webbplatser med hög trafik som kräver effektiv hantering av samtidiga anslutningar.

Vad är skillnaden mellan LEMP- och LAMP-staplar?

LEMP använder Nginx, som hanterar anslutningar asynkront med en händelsestyrd arkitektur—effektivt för samtidiga användare. LAMP använder Apache, som traditionellt skapar en tråd per förfrågan (även om modern Apache stödjer händelsestyrda lägen). LEMP ger generellt bättre prestanda för statiskt innehåll och scenarier med hög samtidig belastning, medan LAMP erbjuder enklare .htaccess-konfiguration och bredare modulsupport.

Vilken Ubuntu-version bör jag använda för LEMP?

Ubuntu 22.04 LTS är huvudmålet för denna guide och har PHP 8.1, MySQL 8.0 och Nginx med långtidsstöd. Ubuntu 24.04 LTS (senaste versionen) inkluderar PHP 8.3 som standard och fungerar med denna guide genom att justera PHP-FPM-sockelvägar och versionsnummer därefter.

Hur installerar jag LEMP-stacken på Ubuntu 24.04?

Följ dessa grundläggande steg:

1. Installera Nginx: sudo apt install nginx
2. Installera MySQL: sudo apt install mysql-server
3. Kör MySQL-säkerhetsskript: sudo mysql_secure_installation
4. Installera PHP-FPM: sudo apt install php-fpm php-mysql
5. Konfigurera Nginx-serverblock med PHP-FPM-integration
6. Testa med info.php och databasanslutning

Se hela genomgången i steg 1–6 ovan.

Vilken version av PHP bör jag installera med Nginx och MySQL?

Använd din Ubuntus standard-PHP för bästa kompatibilitet:

• Ubuntu 22.04: PHP 8.1 (installerat via php8.1-fpm)
• Ubuntu 24.04: PHP 8.3 (justera kommandon till php8.3-fpm för denna version)

Båda versionerna fungerar utmärkt med Nginx och MySQL 8.0, stödjer moderna ramverk och får aktiva säkerhetsuppdateringar.

Hur konfigurerar jag Nginx för att hantera PHP-filer?

Lägg till ett location ~ \.php$-block i din Nginx-serverkonfiguration som dirigerar PHP-förfrågningar till PHP-FPM via Unix-socket:

location ~ \.php$ {
    include snippets/fastcgi-php.conf;
    fastcgi_pass unix:/run/php/php8.1-fpm.sock;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    include fastcgi_params;
}

Justera sockelvägen baserat på din PHP-version, testa med sudo nginx -t, och ladda om med sudo systemctl reload nginx.

Varför får jag ett "502 Bad Gateway"-fel efter att ha installerat PHP-FPM?

502-fel indikerar att Nginx inte kan kommunicera med PHP-FPM. Vanliga orsaker:

1. PHP-FPM körs inte: Kontrollera med sudo systemctl status php8.1-fpm och starta om det vid behov
2. Fel på sockelväg: Kontrollera att /run/php/php8.1-fpm.sock finns och stämmer överens med din Nginx-konfiguration
3. Behörighetsproblem: Se till att Nginx-användaren (www-data) kan komma åt sockeln
4. PHP-FPM konfigurationsfel: Kontrollera loggar på /var/log/php8.1-fpm.log

Lösning: Starta om båda tjänsterna:

sudo systemctl restart php8.1-fpm nginx

Hur säkrar jag MySQL efter installationen?

Kör det inbyggda säkerhetsskriptet:

sudo mysql_secure_installation

Följ anvisningarna för att:

• Aktivera lösenordsvalideringsplugin
• Sätt ett starkt root-lösenord
• Ta bort anonyma användare
• Inaktivera fjärrinloggning som root
• Ta bort testdatabasen
• Ladda om privilegier

För applikationsdatabaser, skapa dedikerade användare med begränsade rättigheter istället för att använda root-kontot.

Kan jag köra flera webbplatser på en LEMP-server?

Ja, skapa separata Nginx-serverblock för varje domän:

1. Skapa katalog: sudo mkdir -p /var/www/second_domain
2. Skapa serverblock: sudo nano /etc/nginx/sites-available/second_domain
3. Konfigurera med unika server_name och root-direktiv
4. Aktivera: sudo ln -s /etc/nginx/sites-available/second_domain /etc/nginx/sites-enabled/
5. Testa och ladda om: sudo nginx -t && sudo systemctl reload nginx

Varje webbplats kan ha separata PHP-inställningar och databasanvändare.

Hur uppgraderar jag PHP till en nyare version?

Ubuntu-paketuppgraderingar hanterar mindre versioner automatiskt. För uppgraderingar av större versioner:

1. Lägg till Ondřejs PHP PPA (pålitligt tredjepartsförråd):

   sudo add-apt-repository ppa:ondrej/php
   sudo apt update

2. Installera ny PHP-FPM-version:

   sudo apt install php8.3-fpm php8.3-mysql -y

3. Uppdatera Nginx-konfigurationens socketväg till /run/php/php8.3-fpm.sock

4. Testa och ladda om Nginx

5. Ta bort eventuellt gammal version: sudo apt purge php8.1-fpm

Testa alltid i staging innan du uppgraderar produktionssystemen.

Felsökning av vanliga problem

502 Fel på gateway

Det vanligaste problemet med LEMP-stacken uppstår när Nginx inte kan kommunicera med PHP-FPM:

Kontrollera PHP-FPM-status:

sudo systemctl status php8.1-fpm

Verifiera sokelväg:

ls -la /run/php/

Den förväntade utmatningen bör visa filen php8.1-fpm.sock.

Vanliga åtgärder:

1. Starta om PHP-FPM: sudo systemctl restart php8.1-fpm
2. Kontrollera att Nginx serverblockets socket-väg stämmer överens med den faktiska PHP-FPM-socketen
3. Verifiera filbehörigheter: sudo chown www-data:www-data /run/php/php8.1-fpm.sock

Tillstånd nekade-fel

Fixa webbkatalogens behörigheter:

sudo chown -R www-data:www-data /var/www/your_domain
sudo chmod -R 755 /var/www/your_domain

MySQL-anslutningsproblem

Återställ MySQL root-lösenord:

sudo mysql
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'new_password';
FLUSH PRIVILEGES;
EXIT;

Kontrollera MySQL-tjänsten:

sudo systemctl status mysql

PHP bearbetas inte

Verifiera PHP-moduler:

php -m | grep -E 'mysql|fpm'

Kontrollera PHP-FPM-konfiguration:

sudo nginx -t
sudo php-fpm8.1 -t

Felsök 404-fel:

• Verifiera att index.php finns med i Nginx index-direktiv
• Kontrollera om filen finns: ls -la /var/www/your_domain/
• Granska Nginx-felloggar: sudo tail -f /var/log/nginx/error.log

Slutsats

I den här guiden byggde du en flexibel grund för att leverera PHP-webbplatser och applikationer till dina besökare, med Nginx som webbserver och MySQL som databassystem. Du kan även göra detta med en Apache-webbserver, kolla in vår handledning om hur man installerar Linux, Apache, MySQL, PHP (LAMP) på Ubuntu. Du kan också säkra din webbplats med Let’s Encrypt, som erbjuder gratis, betrodda certifikat. Lär dig hur du gör detta med vår guide om Let’s Encrypt för Apache.

Tack för att du lär dig tillsammans med Linux-Console.net-communityn.