Instalează PHP 8.1 și configurează un mediu de dezvoltare local pe Ubuntu

O versiune anterioară a acestui tutorial a fost scrisă de alenaholligan.

Introducere

PHP este un limbaj de scripting popular, open-source, pe partea de server, conceput pentru dezvoltarea web și care alimentează o parte semnificativă a internetului, de la bloguri și site-uri de comerț electronic până la aplicații la scară largă. Cu fiecare versiune nouă, PHP oferă performanță îmbunătățită, securitate și caracteristici moderne de dezvoltare pentru a ajuta dezvoltatorii să construiască software robust și scalabil.

PHP 8.1 este o versiune stabilă, cu suport pe termen lung, care aduce îmbunătățiri notabile și noi funcționalități ale limbajului, menținând în același timp fiabilitatea. Instalarea PHP 8.1 pe Ubuntu asigură că mediul tău local de dezvoltare este actualizat, sigur și compatibil cu framework-uri și platforme utilizate pe scară largă, cum ar fi WordPress, Laravel și aplicații PHP personalizate.

Acest tutorial te ghidează prin procesul de instalare a PHP 8.1 pe Ubuntu, configurarea acestuia cu Apache sau Nginx, configurarea extensiilor PHP esențiale și instalarea Composer pentru gestionarea dependențelor. De asemenea, vei învăța cum să verifici instalarea și să rezolvi problemele comune.

Aspecte principale

• Instalarea PHP 8.1 pe Ubuntu 22.04: Ubuntu 22.04 LTS include PHP 8.1 în repository-urile sale implicite, permițându-ți să instalezi o versiune stabilă și cu suport pe termen lung a PHP folosind apt fără PPA-uri terțe. Aceasta asigură actualizări previzibile, patch-uri de securitate și compatibilitate cu cadrele moderne PHP.

• Extensii PHP esențiale pentru proiecte reale: Majoritatea aplicațiilor PHP de producție se bazează pe extensii precum mysql, curl, xml, mbstring, zip, gd și bcmath. Instalarea acestora din timp previne erorile la rulare și asigură compatibilitatea cu framework-uri precum Laravel, Symfony și WordPress.

• Alegerea între Apache și Nginx pentru dezvoltarea PHP: Apache poate executa PHP direct folosind mod_php, în timp ce Nginx necesită PHP‑FPM pentru gestionarea cererilor. Ambele abordări funcționează bine pentru dezvoltarea locală, dar PHP‑FPM reflectă mai fidel mediile de producție moderne și se bazează mai bine sub sarcină.

• Composer ca fundament al fluxurilor de lucru moderne PHP: Composer gestionează dependențele proiectului prin composer.json și composer.lock, asigurând construiri consistente pe diferite calculatoare. Este esențial pentru instalarea framework-urilor, generarea autoloader-elor și menținerea unor versiuni de dependență fiabile în proiectele PHP colaborative.

• Configurarea PHP special pentru dezvoltare: Mediile de dezvoltare beneficiază de raportarea detaliată a erorilor, limite de memorie mai mari și timpi de executare mai lungi. Ajustarea acestor setări în php.ini ajută la identificarea rapidă a bug-urilor în timpul dezvoltării, dar acestea trebuie întotdeauna revertite pentru implementările în producție.

• Depanarea și validarea fac parte din configurare: Verificarea PHP cu php -v, verificarea extensiilor încărcate și examinarea jurnalelor Apache, Nginx sau PHP‑FPM sunt pași critici. Majoritatea problemelor de configurare provin din extensii lipsă, permisiuni sau directive ale serverului web configurate greșit.

Cerințe prealabile

Pentru a finaliza acest tutorial, aveți nevoie de:

• O mașină locală sau un server virtual care rulează Ubuntu (compatibil cu Ubuntu 22.04 LTS și versiunile ulterioare)
• Acces administrativ (sudo) la mașină
• O conexiune activă la internet
• Cunoștințe de bază despre linia de comandă

Dacă configurezi un nou server Ubuntu, consultă ghidul nostru despre Configurarea Inițială a Serverului cu Ubuntu.

Pasul 1 — Configurarea PHP 8.1

Veți finaliza instalarea și configurarea folosind linia de comandă, care este un mod nongrafic de a interacționa cu calculatorul. Adică, în loc să faceți clic pe butoane, veți tasta text și veți primi feedback de la calculator tot prin text.

Linia de comandă, cunoscută și sub numele de shell sau terminal, te poate ajuta să modifici și să automatizezi multe dintre sarcinile pe care le faci zilnic pe un calculator și este un instrument esențial pentru dezvoltatorii de software. Există multe comenzi de terminal de învățat care îți permit să faci lucruri mai puternice. Articolul Introducere în terminalul Linux te poate ajuta să te familiarizezi mai bine cu terminalul.

Pe Ubuntu, poți găsi aplicația Terminal făcând clic pe pictograma Ubuntu din colțul din stânga sus al ecranului și tastând terminal în bara de căutare. Fă clic pe pictograma aplicației Terminal pentru a o deschide. Alternativ, poți apăsa simultan tastele CTRL, ALT și T de pe tastatură pentru a deschide automat aplicația Terminal.

Rulați următoarele comenzi pentru a vă actualiza lista de pachete disponibile, apoi instalați PHP 8.1:

sudo apt update

sudo apt install --no-install-recommends php8.1

Flagul --no-install-recommends va asigura că alte pachete, cum ar fi serverul web Apache, nu vor fi instalate.

Verifică informațiile despre versiunea ta de PHP cu următoarea comandă:

php -v

Veți primi un rezultat ca acesta:

PHP 8.1.2-1ubuntu2.22 (cli) (built: Jul 15 2025 12:11:22) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.1.2, Copyright (c) Zend Technologies
    with Zend OPcache v8.1.2-1ubuntu2.22, Copyright (c), by Zend Technologies

Această configurație a fost testată pe Ubuntu 22.04 LTS folosind pachetele PHP 8.1 din depozitele oficiale Ubuntu.

Instalează extensiile PHP esențiale pentru dezvoltarea web:

sudo apt install -y php8.1-cli php8.1-common php8.1-mysql php8.1-zip php8.1-gd php8.1-mbstring php8.1-curl php8.1-xml php8.1-bcmath

Această comandă va instala următoarele module:

• php8.1-cli - interpret de comenzi, util pentru testarea scripturilor PHP dintr-un shell sau pentru realizarea sarcinilor generale de scripting în shell
• php8.1-common - documentație, exemple și module comune pentru PHP
• php8.1-mysql - pentru lucrul cu bazele de date MySQL
• php8.1-zip - pentru lucrul cu fișiere comprimate
• php8.1-gd - pentru lucrul cu imagini
• php8.1-mbstring - folosit pentru a gestiona șiruri de caractere non-ASCII
• php8.1-curl - îți permite să faci cereri HTTP în PHP
• php8.1-xml - pentru lucrul cu date XML
• php8.1-bcmath - folosit atunci când se lucrează cu numere zecimale cu precizie

Fișierele de configurare PHP sunt stocate în /etc/php/8.1/. Fișierul principal de configurare este php.ini, care poate fi localizat în diferite directoare în funcție de configurația ta:

• Configurarea CLI: /etc/php/8.1/cli/php.ini
• Configurarea Apache: /etc/php/8.1/apache2/php.ini (dacă Apache este instalat)
• Configurarea PHP-FPM: /etc/php/8.1/fpm/php.ini (dacă PHP-FPM este instalat)

Verificați extensiile instalate:

php -m

Aceasta listează toate modulele PHP încărcate. Dacă php -v afișează o versiune diferită de cea așteptată, este posibil să ai instalate mai multe versiuni de PHP. Folosește php8.1 -v pentru a verifica în mod specific PHP 8.1.

Ați instalat PHP și ați verificat versiunea pe care o aveți instalată. De asemenea, ați instalat modulele PHP necesare și ați reușit să listați modulele pe care le aveți încărcate.

Pasul 2 — Configurarea PHP cu Apache

Instalați modulul Apache PHP:

sudo apt install libapache2-mod-php8.1

Activează modulul și repornește Apache:

sudo a2enmod php8.1
sudo systemctl restart apache2

Înțelegerea mod_php: Modulul mod_php încorporează PHP direct în procesul Apache. Când Apache primește o cerere pentru un fișier PHP, acesta îl procesează intern folosind interpretatorul PHP încorporat. Acest lucru diferă de Nginx, care necesită un serviciu PHP-FPM separat. Comanda a2enmod creează un link simbolic în /etc/apache2/mods-enabled/ pentru a activa modulul.

Verificați dacă Apache procesează corect PHP creând un fișier de test în rădăcina documentelor Apache (de obicei /var/www/html):

echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/info.php

Vizitează http://localhost/info.php în browserul tău. Ar trebui să vezi pagina cu informațiile de configurare PHP. Șterge acest fișier după testare din motive de securitate:

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

Depanarea problemelor Apache PHP

Dacă Apache nu pornește după instalarea mod_php:

Verificați jurnalul de erori al Apache:

sudo tail -20 /var/log/apache2/error.log

Problemele comune includ:

• Module PHP conflictuale: Dacă aveți mai multe versiuni de PHP, dezactivați mai întâi celelalte module PHP cu sudo a2dismod php7.4 (dacă sunt prezente)
• Erori de sintaxă în configurația Apache: Rulați sudo apache2ctl configtest pentru a verifica

Dacă vizitezi localhost și vezi „Funcționează!„, dar fișierele PHP apar ca text simplu:

Aceasta înseamnă că Apache nu procesează PHP. Verifică:

1. Verificați dacă modulul este activat:

apache2ctl -M | grep php

1. Dacă nu apare nimic, modulul nu este încărcat. Re-activați-l:

sudo a2enmod php8.1
sudo systemctl restart apache2

1. Verifică dacă fișierul tău PHP are extensia corectă (.php) și conține cod PHP

Dacă primești o eroare 403 Interzis:

Verifică permisiunile fișierului:

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

Configurarea gazdei virtuale Apache

Pentru dezvoltare locală cu domenii personalizate, creează un host virtual:

sudo nano /etc/apache2/sites-available/example.local.conf

Adaugă această configurație:

<VirtualHost *:80>
    ServerName example.local
    DocumentRoot /var/www/example.local
    <Directory /var/www/example.local>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

• ServerName: Numele de domeniu pentru acest host virtual
• DocumentRoot: Unde sunt localizate fișierele tale PHP
• AllowOverride All: Permite fișierelor .htaccess să suprascrie setările Apache (necesar pentru framework-uri precum Laravel)
• Require all granted: Permite accesul la director

Creați directorul, activați site-ul și reporniți Apache:

sudo mkdir -p /var/www/example.local
sudo chown -R www-data:www-data /var/www/example.local
sudo a2ensite example.local.conf
sudo systemctl restart apache2

Adaugă domeniul în fișierul tău /etc/hosts pentru acces local:

echo "127.0.0.1 example.local" | sudo tee -a /etc/hosts

Alegerea între Apache și Nginx

Înainte de a configura serverul web, ia în considerare care dintre ele se potrivește nevoilor tale:

Când să alegi Apache:

• Ești familiarizat cu Apache sau ai nevoie de suport pentru .htaccess
• Configurarea unui mediu de dezvoltare simplu
• Lucrul cu framework-uri care se bazează foarte mult pe .htaccess (unele configurații WordPress)
• Preferi o configurație inițială mai simplă

Când să alegi Nginx:

• Ai nevoie de performanțe mai bune sub sarcină mare
• Vrei să reflectezi mediile de producție moderne
• Construiești aplicații care se vor extinde
• Preferi o arhitectură mai modernă

Ambele funcționează la fel de bine pentru dezvoltarea locală. Alegerea depinde adesea de preferința personală sau de infrastructura existentă.

Pasul 3 — Configurarea PHP cu Nginx

Instalează PHP-FPM (Manager de Procese FastCGI):

sudo apt install php8.1-fpm

Porniți și activați PHP-FPM:

sudo systemctl start php8.1-fpm
sudo systemctl enable php8.1-fpm

Înțelegerea PHP-FPM și FastCGI: Spre deosebire de mod_php al Apache, Nginx nu procesează PHP direct. PHP-FPM (FastCGI Process Manager) rulează ca un serviciu separat cu care Nginx comunică utilizând protocolul FastCGI. FastCGI este un protocol binar pentru interfațarea programelor cu serverele web—este mai rapid decât CGI-ul tradițional deoarece menține procesele active între cereri.

Când Nginx primește o cerere pentru un fișier PHP, o redirecționează către PHP-FPM printr-un socket Unix (sau o conexiune TCP). PHP-FPM procesează codul PHP și returnează rezultatul către Nginx, care apoi îl trimite clientului. Această separare permite PHP-FPM să gestioneze propriul său pool de procese, îmbunătățind performanța și gestionarea resurselor.

Configurația blocului de server Nginx

Creează o configurație pentru blocul de server:

sudo nano /etc/nginx/sites-available/example.local

Adaugă această configurație:

server {
    listen 80;
    server_name example.local;
    root /var/www/example.local;
    index index.php index.html index.htm;

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

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

    location ~ /\.ht {
        deny all;
    }
}

Configurarea explicată:

• root: Directorul unde se află fișierele tale PHP
• location ~ \.php$: Potrivește toate cererile care se termină cu .php folosind regex
• include snippets/fastcgi-php.conf: Include configurația FastCGI implicită a Nginx (setează SCRIPT_FILENAME și alte variabile necesare)
• fastcgi_pass unix:/var/run/php/php8.1-fpm.sock: Socket-ul Unix pe care PHP-FPM îl ascultă. Așa comunică Nginx cu PHP-FPM. Calea către socket este definită în /etc/php/8.1/fpm/pool.d/www.conf

Activează site-ul și testează configurația:

sudo mkdir -p /var/www/example.local
sudo chown -R www-data:www-data /var/www/example.local
sudo ln -s /etc/nginx/sites-available/example.local /etc/nginx/sites-enabled/
sudo nginx -t

Dacă testul trece, repornește Nginx:

sudo systemctl restart nginx

Adaugă domeniul în /etc/hosts:

echo "127.0.0.1 example.local" | sudo tee -a /etc/hosts

Creează un fișier PHP de test:

echo "<?php phpinfo(); ?>" | sudo tee /var/www/example.local/info.php

Vizitați http://example.local/info.php. Ar trebui să vedeți pagina de configurare PHP. Îndepărtați fișierul de test după verificare:

sudo rm /var/www/example.local/info.php

Depanarea problemelor Nginx PHP

Dacă primiți eroarea „502 Gateway Bad”:

Aceasta înseamnă că Nginx nu poate comunica cu PHP-FPM. Verifică:

1. Verificați dacă PHP-FPM rulează:

sudo systemctl status php8.1-fpm

1. Verificați dacă calea către socket este corectă. Locația socket-ului este definită în /etc/php/8.1/fpm/pool.d/www.conf:

grep listen /etc/php/8.1/fpm/pool.d/www.conf

Ar trebui să vezi ceva de genul listen=/run/php/php8.1-fpm.sock. Calea din configurația ta Nginx trebuie să se potrivească exact. Reține că /var/run este adesea un link simbolic către /run, astfel încât ambele căi funcționează.

1. Verifică permisiunile fișierului socket:

ls -la /var/run/php/php8.1-fpm.sock

Socket-ul ar trebui să fie deținut de www-data sau de utilizatorul sub care rulează Nginx. Dacă permisiunile sunt greșite:

sudo chown www-data:www-data /var/run/php/php8.1-fpm.sock

1. Verifică jurnalul de erori Nginx:

sudo tail -20 /var/log/nginx/error.log

S-ar putea să vezi erori precum:

connect() to unix:/var/run/php/php8.1-fpm.sock failed (2: No such file or directory)

Aceasta indică faptul că calea către socket este incorectă sau PHP-FPM nu rulează.

Dacă fișierele PHP se descarcă în loc să se execute:

Aceasta înseamnă că Nginx nu transmite fișierele PHP către PHP-FPM. Verificați:

• Blocul location ~ \.php$ există în configurația serverului tău
• Directiva fastcgi_pass indică către socket-ul corect
• Ai repornit Nginx după ce ai făcut modificări

Dacă primiți erori „Fișierul nu a fost găsit”:

Verificați dacă snippets/fastcgi-php.conf există:

ls -la /etc/nginx/snippets/fastcgi-php.conf

Acest fișier setează SCRIPT_FILENAME, care îi spune PHP-FPM ce fișier să execute. Fără acesta, PHP-FPM nu știe ce fișier să proceseze.

Pasul 4 — Configurarea PHP pentru Dezvoltare

Configurează PHP pentru dezvoltare ajustând raportarea erorilor, setările de afișare și limitele de memorie în php.ini. Aceste setări diferă de configurațiile pentru producție.

PHP folosește fișiere de configurare separate pentru utilizarea în linia de comandă (CLI) și pentru serverul web. Editează fișierul corespunzător:

Pentru CLI (când rulezi PHP din terminal):

sudo nano /etc/php/8.1/cli/php.ini

Pentru server web (Apache sau Nginx cu PHP-FPM):

# For Apache
sudo nano /etc/php/8.1/apache2/php.ini

# For PHP-FPM (Nginx)
sudo nano /etc/php/8.1/fpm/php.ini

Setări esențiale de dezvoltare

Găsește și actualizează aceste setări în fișierul tău php.ini:

display_errors = On
display_startup_errors = On
error_reporting = E_ALL
log_errors = On
error_log = /var/log/php_errors.log
memory_limit = 256M
upload_max_filesize = 64M
post_max_size = 64M
max_execution_time = 300
date.timezone = America/New_York

Ce face fiecare setare:

• display_errors=On: Afișează erorile PHP direct în browser (util pentru depanare, periculos în producție)
• display_startup_errors=On: Afișează erorile care apar în timpul pornirii PHP
• error_reporting=E_ALL: Raportează toate tipurile de erori (avertismente, notificări etc.)
• log_errors=On: Scrie erorile într-un fișier jurnal
• error_log: Unde PHP scrie jurnalele de erori
• memory_limit=256M: Memoria maximă pe care un script o poate folosi (măriți dacă primiți erori „memorie epuizată”)
• upload_max_filesize=64M: Dimensiunea maximă pentru fișierele încărcate
• post_max_size=64M: Dimensiunea maximă pentru datele POST (trebuie să fie mai mare decât upload_max_filesize)
• max_execution_time=300: Timpul maxim în care un script poate rula (în secunde)
• date.timezone: Setează fusul orar implicit (folosește fusul tău orar local: Asia/Kolkata, Europe/London, UTC, etc.)

După ce efectuați modificările, reporniți serverul web:

# For Apache
sudo systemctl restart apache2

# For PHP-FPM
sudo systemctl restart php8.1-fpm

Verificarea configurației tale

Verifică dacă modificările tale au avut efect:

# For CLI
php -i | grep display_errors

# For web server (create a test file)
echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/test.php

Accesează fișierul de test în browser și caută display_errors. Ar trebui să afișeze On. Șterge fișierul de test după verificare.

Dacă modificările tale nu apar:

1. Asigură-te că ai editat fișierul corect php.ini (CLI vs server web)
2. Verificați eventualele greșeli de ortografie în numele setărilor (sunt sensibile la majuscule)
3. Reporniți serverul web după ce ați făcut modificările
4. Unele setări pot fi suprascrise de .htaccess (Apache) sau php.ini din directorul proiectului tău

Ai putea începe să folosești PHP chiar acum, dar probabil vei dori să folosești diferite biblioteci pentru a construi aplicații PHP rapid. Înainte să testezi mediul tău PHP, configurează mai întâi un manager de dependențe pentru proiectele tale.

Pasul 5 — Configurarea Composer pentru gestionarea dependențelor (Opțional)

Bibliotecile sunt o colecție de cod care te pot ajuta să rezolvi probleme comune fără a fi nevoie să scrii totul singur. Deoarece există multe biblioteci disponibile, utilizarea unui manager de dependențe te va ajuta să gestionezi mai multe biblioteci pe măsură ce devii mai experimentat în scrierea codului PHP.

Composer este un instrument pentru gestionarea dependențelor în PHP. Îți permite să declari bibliotecile de care proiectul tău depinde și se va ocupa de instalarea și actualizarea acestor pachete.

Deși asemănător, Composer nu este un manager de pachete în același sens ca yum sau apt. El se ocupă de „pachete” sau biblioteci, dar le gestionează pe baza fiecărui proiect, instalându-le într-un director (de exemplu vendor) din interiorul proiectului tău. Implicit, nu instalează nimic la nivel global. Astfel, este un manager de dependențe. Totuși, suportă un proiect global pentru comoditate prin comanda global.

Această idee nu este nouă, iar Composer este puternic inspirat de npm din Node și de bundler din Ruby.

Să presupunem:

• Ai un proiect care depinde de mai multe biblioteci.
• Unele dintre aceste biblioteci depind de alte biblioteci.

Compozitor:

• Îți permite să declari bibliotecile de care depinzi.
• Determină care versiuni ale căror pachete pot și trebuie instalate și le instalează descărcându-le în proiectul tău.
• Îți permite să actualizezi toate dependențele tale cu o singură comandă.
• Îți permite să vezi capitolul Utilizare de bază pentru mai multe detalii despre declararea dependențelor.

Descarcă instalatorul Composer:

curl -sS https://getcomposer.org/installer -o /tmp/composer-setup.php

Verificați integritatea programului de instalare verificând hash-ul său SHA-384. Obțineți cel mai recent hash:

HASH=$(curl -sS https://composer.github.io/installer.sig)

Verifică dacă hash-ul se potrivește:

php -r "if (hash_file('SHA384', '/tmp/composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('/tmp/composer-setup.php'); } echo PHP_EOL;"

Ar trebui să vezi:

Installer verified

Dacă vezi Installer corupt, descărcarea a fost incompletă sau modificată. Descarcă din nou instalatorul și verifică hash-ul. Dacă tot nu reușește, verifică conexiunea la internet sau încearcă să descarci de pe o altă rețea.

Instalează Composer la nivel global:

sudo php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer

Veți primi un rezultat asemănător cu acesta:

All settings correct for using Composer
Downloading...

Composer (version 2.3.5) successfully installed to: /usr/local/bin/composer
Use it: php /usr/local/bin/composer

Testează-ți instalarea:

composer

Veți primi un rezultat asemănător cu următorul:

   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version 2.3.5 2022-04-13 16:43:00

Usage:
  command [options] [arguments]

Options:
  -h, --help                     Display help for the given command. When no command is given display help for the list command
  -q, --quiet                    Do not output any message
  -V, --version                  Display this application version
      --ansi|--no-ansi           Force (or disable --no-ansi) ANSI output
  -n, --no-interaction           Do not ask any interactive question
      --profile                  Display timing and memory usage information
      --no-plugins               Whether to disable plugins.
      --no-scripts               Skips the execution of all scripts defined in composer.json file.
  -d, --working-dir=WORKING-DIR  If specified, use the given directory as working directory.
      --no-cache                 Prevent use of the cache
  -v|vv|vvv, --verbose           Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug
. . .

Acest lucru verifică dacă Composer a fost instalat cu succes pe sistemul tău și este disponibil la nivel de întreg sistemul.

Pasul 6 — Utilizarea Composer într-un proiect PHP

Ca pas final, puteți opțional să inițializați proiectul cu composer init. Aceasta va crea fișierul composer.json care va gestiona dependențele proiectului. Inițializarea proiectului vă va permite, de asemenea, să definiți detalii despre proiect, cum ar fi Autorul și Licența, și să utilizați funcționalitatea de autoload a Composer. Puteți defini dependențele acum sau să le adăugați mai târziu.

Creează un director pentru proiect și inițializează Composer:

cd ~
mkdir example-project
cd example-project
composer init

Rularea acestei comenzi va porni expertul de configurare. Detaliile pe care le introduceți în expert pot fi actualizate ulterior, așa că nu ezitați să lăsați valorile implicite și să apăsați doar ENTER. Dacă nu sunteți pregătit să instalați vreună dependențe, puteți alege nu. Introduceți detaliile dvs. la fiecare solicitare:

                                            
  Welcome to the Composer config generator  
                                            


This command will guide you through creating your composer.json config.

Package name (<vendor>/<name>) [sammy/example-project]:  sammy/project1
Description []:
Author [n to skip]: Sammy <sammy@linux-console.net>
Minimum Stability []: 
Package Type (e.g. library, project, metapackage, composer-plugin) []: project
License []: 

Define your dependencies.

Would you like to define your dependencies (require) interactively [yes]? no
Would you like to define your dev dependencies (require-dev) interactively [yes]? no

Add PSR-4 autoload mapping? Maps namespace "Sammy\Project1" to the entered relative path. [src/, n to skip]: n

{
    "name": "sammy/project1",
    "type": "project",
    "authors": [
        {
            "name": "Sammy",
            "email": "sammy@linux-console.net"
        }
    ],
    "require": {}
}

Do you confirm generation [yes]? yes

Înainte de a confirma generarea, vei vedea un exemplu al fișierului composer.json pe care vrăjitorul îl va crea. Dacă totul arată bine, poți confirma implicitul da. Dacă trebuie să începi de la început, alege nu.

Prima dată când definești o dependență, Composer va crea un folder vendor. Toate dependențele se instalează în acest folder vendor. Composer creează, de asemenea, un fișier composer.lock. Acest fișier specifică versiunea exactă a fiecărei dependențe și subdependențe utilizate în proiectul tău. Acest lucru asigură că orice mașină pe care rulează programul tău va folosi exact aceeași versiune a fiecărui pachet.

Acum că ai PHP instalat și o modalitate de a-ți gestiona dependențele proiectului folosind Composer, ești gata să-ți testezi mediul.

Pasul 7 — Testarea mediului PHP

Creează și rulează un script PHP de bază pentru a-ți testa instalarea:

nano hello.php

Adaugă următorul cod PHP:

<?php
echo 'Hello World!';
?>

Salvează și închide fișierul (apasă CTRL+X, apoi Y, apoi ENTER). Rulează scriptul:

php hello.php

Dacă PHP-ul este procesat corespunzător, vei vedea doar caracterele din interiorul ghilimelelor:

Hello World!

PHP a procesat cu succes scriptul, ceea ce înseamnă că mediul tău PHP este instalat cu succes și ești pregătit să continui călătoria ta în programare.

Pasul 8 — Configurarea proiectelor PHP din lumea reală

Framework-urile moderne PHP precum Laravel, Symfony și WordPress necesită extensii PHP specifice și Composer. Instalează framework-ul folosind Composer sau instalatorul acestuia, apoi configurează serverul web să indice către directorul public al proiectului.

Configurarea Laravel

Instalează Laravel folosind Composer:

composer create-project laravel/laravel my-laravel-app
cd my-laravel-app

Această comandă descarcă Laravel și toate dependențele sale. Procesul poate dura câteva minute.

Laravel necesită aceste extensii PHP (instalate în Pasul 1):

• php8.1-mbstring - Gestionarea șirurilor de caractere cu mai multe octeți
• php8.1-xml - analiză XML
• php8.1-curl - cereri HTTP
• php8.1-zip - Gestionarea arhivelor
• php8.1-bcmath - Matematică cu precizie arbitrară

Dacă Laravel afișează „mbstring lipsă” chiar dacă l-ai instalat:

Acest lucru înseamnă, de obicei, că extensia este instalată, dar nu este încărcată. Verificați:

1. Verificați dacă extensia este instalată:

php -m | grep mbstring

1. Dacă lipsește, instalează-l:

sudo apt install php8.1-mbstring

1. Dacă este instalat, dar nu apare, reporniți serverul web:

# For Apache
sudo systemctl restart apache2

# For PHP-FPM
sudo systemctl restart php8.1-fpm

1. Verificați care fișier php.ini este folosit. Installerul Laravel utilizează PHP din linia de comandă, așa că verificați:

php --ini

Asigurați-vă că extensia este activată în fișierul php.ini din CLI.

Verificarea instalării Laravel:

După ce instalarea se finalizează, porniți serverul de dezvoltare Laravel:

php artisan serve

Ar trebui să vezi:

INFO  Server running on [http://127.0.0.1:8000]

Vizitați http://localhost:8000 în browserul dvs. Ar trebui să vedeți pagina de bun venit a Laravel.

Pentru configurări asemănătoare mediului de producție cu Apache sau Nginx:

Configurează serverul web să indice către directorul public (nu către rădăcina proiectului). public/index.php din Laravel este punctul de intrare pentru toate cererile.

Configurarea WordPress

Descarcă și extrage WordPress:

cd /var/www
sudo wget https://wordpress.org/latest.tar.gz
sudo tar -xzf latest.tar.gz
sudo chown -R www-data:www-data /var/www/wordpress

WordPress necesită o bază de date MySQL sau MariaDB. Instalează MySQL dacă este necesar:

sudo apt install mysql-server
sudo mysql_secure_installation

Scriptul mysql_secure_installation vă va solicita să:

• Setează o parolă pentru utilizatorul root
• Eliminați utilizatorii anonimi
• Interziceți autentificarea root de la distanță
• Șterge baza de date de test
• Reîncarcă tabelele de privilegii

Creează o bază de date și un utilizator pentru WordPress:

sudo mysql -u root -p

În promptul MySQL:

CREATE DATABASE wordpress_db;
CREATE USER 'wpuser'@'localhost' IDENTIFIED BY 'secure_password';
GRANT ALL PRIVILEGES ON wordpress_db.* TO 'wpuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Înlocuiește secure_password cu o parolă puternică. WordPress va folosi aceste date de autentificare pentru a se conecta la baza de date.

Dacă WordPress nu se poate conecta la baza de date:

1. Verificați dacă MySQL rulează:

sudo systemctl status mysql

1. Testați conexiunea la baza de date:

mysql -u wpuser -p wordpress_db

Dacă aceasta eșuează, verifică:

• Numele de utilizator și parola sunt corecte
• Baza de date există: SHOW DATABASES;
• Utilizatorul are permisiuni: SHOW GRANTS FOR 'wpuser'@'localhost';

1. Verifică dacă extensia MySQL a PHP este instalată:

php -m | grep mysql

Dacă lipsește, instalează-l:

sudo apt install php8.1-mysql
sudo systemctl restart apache2  # or php8.1-fpm for Nginx

Finalizarea instalării WordPress:

Configurează serverul web să indice către /var/www/wordpress (vezi Pasul 2 pentru Apache sau Pasul 3 pentru Nginx). Accesează site-ul în browserul tău. WordPress îți va cere să:

1. Selectează-ți limba
2. Introduceți acreditările bazei de date (utilizați baza de date, numele de utilizator și parola pe care le-ați creat)
3. Finalizează instalarea

Configurarea Symfony

Instalează Symfony folosind Composer:

composer create-project symfony/website-skeleton my-symfony-app
cd my-symfony-app

Symfony necesită aceleași extensii ca Laravel. Porniți serverul de dezvoltare:

symfony server:start

Sau folosește serverul încorporat al PHP:

php -S localhost:8000 -t public

Dacă instalarea Symfony eșuează din cauza unor erori ale extensiilor:

Verificați dacă toate extensiile necesare sunt instalate și încărcate:

php -m | grep -E 'mbstring|xml|curl|zip|bcmath'

Dacă lipsește vreunul, instalați-l și reporniți serverul web.

Pasul 9 — Cele mai bune practici pentru dezvoltarea locală

Asigurați-vă mediul local, folosiți controlul versiunilor, configurați permisiunile corespunzătoare ale fișierelor și setați configurații specifice fiecărui mediu. Aceste practici previn problemele de securitate și fac dezvoltarea mai lină.

Considerații de securitate

Chiar și în dezvoltarea locală, urmează cele mai bune practici de securitate:

1. Dezactivați funcțiile PHP periculoase în producție: Funcții precum exec(), system() și shell_exec() ar trebui să fie restricționate în fișierele php.ini din producție.

2. Folosește variabile de mediu: Stochează configurația sensibilă în fișiere .env (nu le adăuga niciodată în controlul versiunilor). Laravel și Symfony suportă acest lucru nativ.

3. Setați permisiunile corecte pentru fișiere: Fișierele serverului web ar trebui să fie lizibile de utilizatorul serverului web, dar să nu poată fi modificate:

sudo chown -R www-data:www-data /var/www/your-project
sudo find /var/www/your-project -type d -exec chmod 755 {} \;
sudo find /var/www/your-project -type f -exec chmod 644 {} \;

De ce sunt importante aceste permisiuni: Directorii au nevoie de 755 (citire, scriere, executare pentru proprietar; citire și executare pentru alții) pentru ca serverul web să poată naviga prin ei. Fișierele au nevoie de 644 (citire și scriere pentru proprietar; doar citire pentru alții) pentru ca serverul web să le poată citi, dar să nu le poată modifica. Acest lucru previne ca scripturile malițioase să suprascrie fișierele tale.

Integrare control versiuni

Folosește întotdeauna controlul versiunilor pentru proiectele tale PHP. Inițializează Git în directorul proiectului tău:

cd /var/www/your-project
git init

Creează un fișier .gitignore pentru a exclude fișierele inutile:

/vendor/
/node_modules/
.env
.DS_Store
*.log

Optimizarea performanței

Pentru o performanță mai bună în dezvoltarea locală:

• Activează OPcache: OPcache este inclus în PHP 8.1 și îmbunătățește performanța prin stocarea în cache a codului PHP compilat.

• Folosește optimizarea autoloader-ului Composer:

composer install --optimize-autoloader --no-dev

• Configurează pool-urile PHP-FPM pentru o mai bună gestionare a resurselor dacă folosești Nginx.

Pasul 10 — Depanarea problemelor comune

Problemele comune de instalare PHP includ extensii lipsă, permisiuni incorecte ale fișierelor, erori în configurarea serverului web și conflicte de versiune. Majoritatea problemelor pot fi rezolvate verificând instalarea extensiilor, confirmând permisiunile fișierelor și analizând jurnalele serverului web.

Extensiile PHP nu se încarcă

Dacă php -m nu afișează o extensie pe care tocmai ați instalat-o:

• Verifică dacă este într-adevăr instalat:

dpkg -l | grep php8.1-extension_name

• Verifică dacă fișierul de extensie există:

ls /usr/lib/php/*/extension_name.so

• Verifică dacă este activat în php.ini. Unele extensii trebuie activate explicit:

grep -i extension_name /etc/php/8.1/*/php.ini

• Reporniți serverul web:

# For Apache
sudo systemctl restart apache2

# For PHP-FPM
sudo systemctl restart php8.1-fpm

• Verifica care php.ini este folosit:

php --ini

Asigură-te că verifici fișierul php.ini corect (CLI vs server web).

Dacă extensia încă nu apare:

• Unele extensii necesită biblioteci suplimentare de sistem. Verificați documentația extensiei.
• Verifică dacă ai instalat versiunea corectă (php8.1-extension, nu php8.0-extension)
• Verifică dacă există versiuni PHP conflictuale care ar putea interfera

Eroare internă a serverului 500

Eroarea 500 înseamnă că serverul a întâmpinat o eroare, dar nu poate afișa detalii. Verificați jurnalele de erori:

# Apache
sudo tail -20 /var/log/apache2/error.log

# Nginx
sudo tail -20 /var/log/nginx/error.log

# PHP-FPM
sudo tail -20 /var/log/php8.1-fpm.log

Cauze comune și soluții:

1. Permisiuni incorecte ale fișierului: fișierele PHP trebuie să fie accesibile pentru citire de către utilizatorul serverului web

sudo chown -R www-data:www-data /var/www/your-project
sudo find /var/www/your-project -type f -exec chmod 644 {} \;
sudo find /var/www/your-project -type d -exec chmod 755 {} \;

1. Extensii PHP lipsă: Verificați jurnalul de erori pentru mesaje de tipul „Apel către funcția nedefinită”. Instalați extensia lipsă și reporniți serverul web.

2. Erori de sintaxă în fișierele PHP: Jurnalul de erori va afișa fișierul și numărul liniei. Probleme comune:

   • Lipsesc punctele și virgulele
   • Paranteze sau ghilimele neînchise
   • Folosirea funcțiilor sau claselor nedefinite

3. Configurare incorectă a serverului web:

   • Apache: Verificați configurația gazdei virtuale, încărcarea modulului
   • Nginx: Verificați calea socket-ului PHP-FPM, configurația FastCGI

4. Limita de memorie PHP depășită: Măriți memory_limit în php.ini dacă vedeți erori de tipul „Dimensiunea memoriei permise a fost depășită”

Conflicte între versiunile PHP

Dacă php -v afișează o versiune diferită de cea așteptată, aveți mai multe versiuni de PHP instalate.

Verificați ce versiuni sunt instalate:

dpkg -l | grep php | grep -E 'php[0-9]'

Folosește versiunea corectă în mod explicit:

php8.1 -v
php8.1 -m

Actualizați serverul dvs. web pentru a folosi PHP 8.1:

Pentru Apache, dezactivați alte module PHP și activați PHP 8.1:

sudo a2dismod php7.4 php8.0  # if they exist
sudo a2enmod php8.1
sudo systemctl restart apache2

Pentru PHP-FPM, oprește celelalte versiuni și pornește PHP 8.1:

sudo systemctl stop php7.4-fpm php8.0-fpm  # if they exist
sudo systemctl start php8.1-fpm
sudo systemctl enable php8.1-fpm

Setați PHP 8.1 ca versiunea implicită pentru CLI:

sudo update-alternatives --set php /usr/bin/php8.1

Probleme de memorie ale Composer

Dacă Composer rămâne fără memorie, vei vedea o eroare de genul:

Fatal error: Allowed memory size of 134217728 bytes exhausted

Reparați-l rulând Composer cu memorie mărită:

php -d memory_limit=512M /usr/local/bin/composer install

Sau mărește limita de memorie a PHP în php.ini:

memory_limit = 512M

Dacă instalarea Composer eșuează din cauza nepotrivirii hash-ului:

Verificarea hash-ului ar putea eșua dacă:

• Programul de instalare a fost actualizat de când l-ai descărcat (descarcă din nou pentru a obține cel mai recent hash)
• Descărcarea ta a fost coruptă (încearcă să descarci din nou)
• Ești în spatele unui proxy care modifică fișierele (verifică setările de rețea)

Probleme de conectare la baza de date

Dacă aplicația ta PHP nu se poate conecta la MySQL/MariaDB, este posibil să vezi erori precum:

SQLSTATE[HY000] [2002] No such file or directory

sau

Access denied for user 'username'@'localhost'

Pași pentru depanare:

1. Verificați dacă serviciul bazei de date este activ:

sudo systemctl status mysql

Dacă nu rulează, pornește-l:

sudo systemctl start mysql
sudo systemctl enable mysql

1. Verifică dacă extensia MySQL a PHP este instalată:

php -m | grep mysql

Dacă lipsește, instalează-l:

sudo apt install php8.1-mysql
sudo systemctl restart apache2  # or php8.1-fpm for Nginx

1. Verificați acreditările și permisiunile bazei de date. Testați conexiunea:

mysql -u username -p database_name

Dacă aceasta eșuează, verifică:

• Numele de utilizator și parola sunt corecte
• Baza de date există: SHOW DATABASES;
• Utilizatorul are permisiuni: SHOW GRANTS FOR 'username'@'localhost';

Fișierul PHP se afișează ca text simplu în loc să fie executat

Dacă fișierul tău PHP apare ca text simplu în browser:

1. Verificați extensia fișierului: Trebuie să fie .php, nu .txt sau .html

2. Verifică dacă PHP procesează fișierele:

   • Apache: Verificați dacă mod_php este activat: apache2ctl -M | grep php
   • Nginx: Verificați dacă PHP-FPM rulează și dacă calea către socket este corectă

3. Verifică permisiunile fișierului: Serverul web trebuie să poată citi fișierul

4. Verificați dacă fișierul conține cod PHP: Asigurați-vă că începe cu <?php sau <?

5. Verificați configurarea serverului web:

   • Apache: Gazda virtuală s-ar putea să nu fie configurată corect
   • Nginx: Blocul location ~ \.php$ ar putea lipsi sau fi incorect

Probleme la încărcarea fișierelor

Dacă încărcările de fișiere eșuează, este posibil să apară erori precum:

The uploaded file exceeds the upload_max_filesize directive

Verifică aceste setări php.ini:

upload_max_filesize = 64M
post_max_size = 64M
max_execution_time = 300

Important: post_max_size trebuie să fie mai mare decât upload_max_filesize. Dacă setați upload_max_filesize=100M, setați post_max_size=110M sau mai mult.

Dacă încă nu reușesc încărcările:

1. Verificați jurnalul de erori pentru mesaje de eroare specifice
2. Verifică dacă directorul de încărcare există și dacă este accesibil pentru scriere:

sudo chmod 755 /path/to/upload/directory
sudo chown www-data:www-data /path/to/upload/directory

1. Verifică spațiul pe disc: df -h
2. Verificați dacă formularul folosește enctype="multipart/form-data"

Reporniți serverul web după ce faceți modificări în php.ini.

Întrebări frecvente

Cum pot instala PHP 8.1 pe Ubuntu?

Instalați PHP 8.1 folosind managerul de pachete al Ubuntu: sudo apt update && sudo apt install php8.1. PHP 8.1 este disponibil în depozitele implicite ale Ubuntu, deci nu sunt necesare surse de pachete suplimentare.

Care extensii PHP sunt esențiale pentru dezvoltare?

Extensiile esențiale includ php8.1-cli, php8.1-mysql, php8.1-curl, php8.1-xml, php8.1-mbstring, php8.1-zip, php8.1-gd și php8.1-bcmath. Acestea acoperă conectivitatea cu baza de date, cererile HTTP, manipularea șirurilor de caractere și procesarea imaginilor.

Cum configurez PHP cu Apache sau Nginx?

Pentru Apache, instalați libapache2-mod-php8.1 și activați-l cu sudo a2enmod php8.1. Pentru Nginx, instalați php8.1-fpm și configurați Nginx pentru a trimite cererile PHP către socket-ul PHP-FPM utilizând FastCGI.

Cum pot verifica dacă PHP este instalat corect?

Rulați php -v pentru a verifica versiunea PHP. Creați un fișier de test cu <?php phpinfo(); ?> și accesați-l prin serverul vostru web pentru a vedea informații detaliate despre configurația PHP.

Pot să rulez Laravel sau WordPress local cu această configurație?

Da. Laravel necesită Composer și extensiile PHP standard menționate mai sus. WordPress are nevoie de o bază de date MySQL pe lângă PHP. Ambele framework-uri funcționează cu configurații Apache sau Nginx.

Cum instalez Composer pentru proiecte PHP?

Descarcă instalatorul Composer, verifică-i hash-ul și instalează-l global: sudo php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer. Verifică cu composer --version.

Cum rezolv problemele legate de extensiile PHP lipsă?

Verificați extensiile instalate cu php -m. Instalați extensiile lipsă folosind sudo apt install php8.1-numele_extensiei, apoi reporniți serverul web.

Cum configurez raportarea erorilor PHP pentru dezvoltare?

Editează php.ini și setează display_errors=On, error_reporting=E_ALL și log_errors=On. Amintește-ți să dezactivezi afișarea erorilor în mediile de producție.

Care este diferența dintre Apache și Nginx pentru PHP?

Apache folosește mod_php pentru a procesa PHP direct (PHP este integrat în procesul Apache), în timp ce Nginx necesită PHP-FPM (FastCGI Process Manager) pentru a gestiona cererile PHP (PHP rulează ca un serviciu separat). Consultați secțiunea „Alegerea între Apache și Nginx” de mai sus pentru un tabel comparativ detaliat. Ambele abordări funcționează bine; alegeți în funcție de nevoile de performanță, familiaritate și infrastructura existentă.

Pot instala mai multe versiuni de PHP pe același sistem?

Da, folosind unelte precum phpenv sau phpbrew. Totuși, pentru majoritatea scenariilor de dezvoltare, o singură versiune de PHP este suficientă. Folosește managerii de versiuni atunci când trebuie să testezi aplicațiile pe diferite versiuni de PHP.

Concluzie

Acum aveți un mediu de dezvoltare PHP 8.1 complet configurat pe Ubuntu, cu suport pentru serverele web Apache și Nginx. Configurația dvs. include extensiile PHP esențiale, Composer pentru gestionarea dependențelor și configurarea corespunzătoare pentru dezvoltarea locală.

Înainte de a începe următorul tău proiect, ia în considerare configurarea unui Mediu de Dezvoltare Integrat (IDE) precum VS Code cu extensii PHP pentru evidențierea sintaxei, depanare și suport IntelliSense.

Cu mediul tău pregătit, poți explora mai departe dezvoltarea în PHP:

• Învățați noțiunile de bază PHP cu Cum să lucrați cu șiruri de caractere în PHP
• Creează API-uri folosind Cum să folosești API-urile web în PHP
• Înțelege funcțiile din Cum să folosești funcțiile în PHP
• Configurați baze de date cu Cum să instalați și să utilizați PostgreSQL pe Ubuntu

Pentru implementările în producție, luați în considerare utilizarea platformei Linux-Console.net App pentru a vă implementa aplicațiile PHP direct din GitHub, cu scalare automată și certificate SSL.

Mulțumim că ați învățat împreună cu comunitatea Linux-Console.net.