Cum se instalează Jupyter Notebook cu proxy Nginx pe Debian 12

Jupyter este o aplicație web gratuită și open-source pentru calcul interactiv și știința datelor. Jupyter este compatibilă cu toate limbajele de programare și oferă mai multe programe software, cum ar fi JupyetrLab, care oferă un mediu de editare multi-notebook bogat în funcții și cu file, Notebook ca o modalitate ușoară și simplificată de creare a notelor, Qtconsole și multe altele.

Înainte de a începe, asigurați-vă că aveți următoarele:

  • Un server Debian 12
  • Un utilizator non-root cu privilegii de administrator
  • Un nume de domeniu a indicat adresa IP a serverului

Instalarea pachetelor Python

Înainte de a instala Jupyter, trebuie să instalați Python, managerul de pachete Pip Python, venv pentru crearea unui mediu virtual Python și git. În această secțiune, veți instala aceste pachete cu ajutorul managerului de pachete APT.

Pentru a începe, executați comanda de mai jos pentru a actualiza indexul pachetului Debian.

actualizare sudo apt

Acum instalați Python și dependențele precum Pip, venv și pachetul Python Dev. Introduceți „ Y ” pentru a confirma instalarea.

sudo apt instalează python3 python3-pip python3-dev python3-venv git

După finalizarea instalării, executați comanda „ pip3 ” de mai jos pentru a actualiza versiunea de Pip.

pip3 instalează --break-system-package --upgrade pip

Acum verificați versiunea Python și Pip cu comanda de mai jos.

python3 --version 
pip3 --version

Puteți vedea mai jos că sunt instalate Python 3.11 și Pip 24.3 .

Configurarea mediului virtual Python

După ce ați instalat Python și alte dependențe, veți crea un nou mediu virtual Python pentru instalarea Jupyter. Astfel, instalarea Jupyter va fi izolată în mediul virtual. De asemenea, aveți nevoie de un utilizator Linux dedicat, așa că asigurați-vă că aveți utilizatorul pregătit.

Conectați-vă la utilizatorul dvs. cu comanda de mai jos.

su - nume de utilizator

Rulați comanda „ python3 ” de mai jos pentru a crea un nou mediu virtual Python, „ venv ”. Aceasta va instala Python și Pip în mediul dvs. virtual, care este separat de sistemul dvs.

python3 -m venv venv

Activați mediul virtual Python „ venv ”. Odată activat, promptul shell va deveni de genul „ (venv) numeutilizator@gazdă … ”.

sursă venv/bin/activate

Dacă doriți să dezactivați „ venv ”, executați comanda „ deactivate ” de mai jos.

deactivate

Instalarea Jupyter

Acum că ați creat și activat mediul virtual Python, puteți începe instalarea Jupyter prin intermediul managerului de pachete Pip Python.

Pentru a instala Jupyter, executați comanda „ pip3 ” de mai jos.

pip3 install jupyter

Mai jos puteți vedea instalarea Jupyter într-un mediu virtual.

După finalizarea instalării, verificați versiunea Jupyter cu următoarea comandă.

jupyter --version

În rezultatul următor, puteți vedea versiunea fiecărei componente Jupyter instalate.

Activați autentificarea în Jupyter Notebook

După ce ați instalat Jupyter, veți configura instalarea Jupyter Notebook activând autentificarea prin parolă.

Mai întâi, executați comanda de mai jos pentru a genera configurația pentru Jupyter Notebook. Aceasta va genera o nouă configurație pentru „ ~/.jupyter/jupyter_notebook_config.py ”.

jupyter notebook --geenrate-config

Acum setați parola pentru Jupyter Notebook folosind comanda de mai jos. Introduceți parola când vi se solicită și repetați.

jupyter notebook password

În cele din urmă, executați comanda „ deactivate ” pentru a vă deconecta din mediul virtual „venv”.

deactivate

Rularea Jupyter Notebook ca serviciu Systemd

În această secțiune, veți crea un nou serviciu systemd care va rula Jupyter Notebook. Astfel, Jupyter Notebook va rula în fundal ca serviciu systemd și îl puteți gestiona cu ușurință cu utilitarul „ systemctl ”.

Creați un nou fișier de serviciu systemd „ /etc/systemd/system/jupyter.service ” cu următorul editor „ nano ”.

sudo nano /etc/systemd/system/jupyter.service

Introduceți configurația de mai jos pentru a rula Jupyter Notebook ca serviciu systemd.

[Unitate] 
Descriere=Jupyter Notebook 


[Unit]
Description=Jupyter Notebook

[Service]
Type=simple
PIDFile=/run/jupyter.pid
ExecStart=/home/alice/venv/bin/jupyter-notebook --config=/home/alice/.jupyter/jupyter_notebook_config.py --allow-root
User=root
Group=root
WorkingDirectory=/home/alice/venv
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Salvați fișierul și ieșiți din editor.

Acum executați comanda „ systemctl ” de mai jos pentru a reporni managerul systemd și a aplica modificările.

sudo systemctl daemon-reload

În cele din urmă, porniți și activați serviciul „ jupyter ” cu comanda de mai jos.

sudo systemctl enable --now jupyter 
sudo systemctl status jupyter

În următoarea ieșire, puteți vedea că serviciul „ jupyter ” rulează pe sistemul dumneavoastră.

Permiterea accesului de la distanță la Jupyter Notebook

În această secțiune, veți activa accesul de la distanță la Jupyter. Acest lucru trebuie făcut dacă doriți să configurați un proxy invers în fața instalării Jupyter.

Conectați-vă la contul de utilizator și deschideți configurația Jupyter „~/.jupyter/jupyter_notebook_config.py” cu următorul editor „nano”.

su - username
nano ~/.jupyter/jupyter_notebook_config.py

Pentru a activa accesul la distanță, eliminați comentariile de la opțiunea „ c.ServerApp.allow_remote_access ” și schimbați valoarea la „ True ”.

c.ServerApp.allow_remote_access = True

Salvați și ieșiți din fișier când ați terminat.

Apoi, executați comanda „ systemctl ” de mai jos pentru a reporni serviciul „ jupyter ” și a aplica modificările. Astfel, noul token va fi generat și poate fi găsit în fișierul jurnal.

sudo systemctl restart jupyter

În cele din urmă, verificați starea serviciului „ jupyter ” cu următoarea comandă.

sudo systemctl status jupyter

Uită-te la partea de jos a mesajului și copiază token-ul generat pentru Jupyter  Notebook.

Setarea Nginx ca proxy invers

Acum, că Jupyter Notebook rulează ca serviciu, următorul pas este să instalați Nginx și să îl configurați ca proxy invers pentru Jupyter Notebook. În acest fel, puteți securiza cu ușurință Jupyter Notebook cu HTTPS.

Instalați pachetul „ nginx ” cu comanda „ apt ” de mai jos.

sudo apt install nginx -y

După finalizarea instalării, creați o nouă configurație de blocuri pentru serverul Nginx „ /etc/nginx/sites-available/jupyter ” cu următorul editor „ nano ”.

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

Introduceți configurația de mai jos pentru a configura Nginx ca proxy invers pentru Jupyter Notebook. Asigurați-vă că schimbați parametrul „ server_name ” cu numele domeniului dvs.

server {
listen 80;
server_name lab.howtoforge.local;

access_log /var/log/nginx/howtoforge.local.access.log;
error_log /var/log/nginx/howtoforge.local.error.log;

location / {
proxy_pass http://127.0.0.1:8888;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Host $http_host;
proxy_http_version 1.1;
proxy_redirect off;
proxy_buffering off;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_read_timeout 86400;
}
}

Salvați fișierul și ieșiți din editor.

Apoi, executați comanda de mai jos pentru a activa blocul de server „ jupyter ” și a verifica configurația Nginx.

sudo ln -s /etc/nginx/sites-available/jupyter /etc/nginx/sites-enabled/ 
sudo nginx -t

Dacă aveți setările Nginx corecte, veți vedea un mesaj de genul „ sintaxa este ok – testul a reușit ”.

În cele din urmă, executați comanda „ systemctl ” de mai jos pentru a reporni serverul web Nginx și a verifica starea Nginx.

sudo systemctl restart nginx 
sudo systemctl status nginx

Dacă Nginx rulează, puteți vedea un rezultat de genul următor:

Accesarea Jupyter Notebook

Deschideți browserul web și accesați numele de domeniu al instalării Jupyter Notebook, cum ar fi http://lab.howtoforge.local/. Dacă instalarea a reușit, vi se va solicita autentificarea cu parola Jupyter.

Introduceți parola și faceți clic pe „ Autentificare ”.

Acum veți vedea tabloul de bord Jupyter Notebook astfel:

[mai mult...]

Cum se folosește grep pentru a căuta șiruri de caractere în fișiere în shell-ul Linux

Comanda grep din Linux este un utilitar puternic de căutare de text care permite utilizatorilor să caute în fișiere sau fluxuri de text modele specifice. Aceasta este prescurtarea de la „ global regular expression print ” (afișarea expresiei regulate globale) și acceptă căutarea după șiruri de text simple și expresii regulate mai complexe. Comanda este adesea combinată cu alte comenzi pentru a filtra și rafina ieșirea. În mod implicit, grep returnează toate liniile care conțin modelul. Totuși, oferă diverse opțiuni pentru personalizarea căutării, cum ar fi sensibilitatea la majuscule/minuscule, numărarea aparițiilor sau căutarea recursivă prin directoare. Acest lucru o face un instrument esențial pentru administratorii de sistem, dezvoltatori și oricine lucrează cu seturi mari de date într-un mediu de tip Unix.

Comanda grep este utilizată în principal pentru a căuta într-un text sau fișier linii care conțin o potrivire cu cuvintele/șirurile specificate. În mod implicit, grep afișează liniile potrivite și poate fi utilizată pentru a căuta linii de text care corespund uneia sau mai multor expresii regulate și afișează doar liniile potrivite.

Comanda grep face parte din utilitarele de bază ale oricărei distribuții Linux, deci este preinstalată în mod implicit pe AlmaLinux, CentOS, Debian, Linux Mint, Ubuntu, RHEL și RockyLinux.

Sintaxa de bază a comenzii grep

Sintaxa de bază a comenzii grep este următoarea:

grep 'word' filename
grep 'word' file1 file2 file3
grep 'string1 string2'  filename
cat otherfile | grep 'something'
command | grep 'something'
command option1 | grep 'data'
grep --color 'data' fileName

Cum se utilizează comanda grep pentru căutarea într-un fișier

În primul exemplu, voi căuta utilizatorul „tom” în fișierul passwd de Linux. Pentru a căuta utilizatorul „tom” în fișierul /etc/passwd , trebuie să introduceți următoarea comandă:

grep tom /etc/passwd

Mai jos este prezentat exemplul de ieșire:

tom:x:1000:1000:tom,,,:/home/tom:/bin/bash

Aveți opțiunea de a instrui grep să ignore majusculele/minusculele cuvintelor, adică să potrivească abc, Abc, ABC și toate combinațiile posibile cu opțiunea -i, așa cum se arată mai jos:

grep -i "tom" /etc/passwd

Utilizarea recursivă a grep-ului

Dacă aveți o grămadă de fișiere text într-o ierarhie de directoare, de exemplu, fișierele de configurare Apache din /etc/apache2/ și doriți să găsiți fișierul în care este definit un anumit text, utilizați opțiunea -r a comenzii grep pentru a efectua o căutare recursivă. Aceasta va efectua o operațiune de căutare recursivă prin fișiere pentru șirul „197.167.2.9” (așa cum se arată mai jos) în directorul /etc/apache2/ și toate subdirectoarele sale:

grep -r "domeniulmeu.com" /etc/apache2/

Alternativ, se poate utiliza următoarea comandă:

grep -R "domeniulmeu.com" /etc/apache2/

Mai jos sunt prezentate exemple de rezultate pentru o căutare similară pe un server Nginx:

grep -r "domeniulmeu.com" /etc/nginx/ 
/etc/nginx/sites-available/domeniulmeu.com.vhost: if ($http_host != "www.domeniulmeu.com") {

Aici, veți vedea rezultatul pentru domeniul_mydomain.com pe o linie distinctă, precedat de numele fișierului (de exemplu /etc/nginx/sites-available/mydomain.com.vhost) în care a fost găsit. Includerea numelor de fișiere în datele de ieșire poate fi ușor suprimată utilizând opțiunea -h (așa cum se explică mai jos): grep -h -R “mydomain.com” /etc/nginx/. Mai jos este prezentat exemplul de ieșire:

grep -r "domeniulmeu.com" /etc/nginx/ 
if ($http_host != "www.domeniulmeu.com") {

Folosirea grep pentru a căuta doar cuvinte

Când căutați „abc”, comanda grep va găsi tot felul de rezultate, de exemplu, kbcabc, abc123, aarfbc35 și multe alte combinații, fără a respecta limitele cuvintelor. Puteți obliga comanda grep să selecteze doar acele linii care conțin potriviri pentru a forma cuvinte întregi (cele care se potrivesc doar cu cuvântul abc), așa cum se arată mai jos:

grep -w "abc" fișier.txt

Exemplu:

Pentru a căuta două cuvinte diferite, trebuie să utilizați comanda egrep, așa cum se arată mai jos:

egrep -w 'cuvânt1|cuvânt2' /calea/către/fișier

Comanda grep are capacitatea de a raporta numărul de potriviri pentru un anumit model pentru fiecare fișier folosind opțiunea -c (count) (așa cum se arată mai jos):

grep -c 'word' /calea/către/fișier

În plus, utilizatorii pot folosi opțiunea „-n” care precede fiecare linie de ieșire cu numărul liniei din fișierul text din care a fost obținută (așa cum se arată mai jos):

grep -n 'root' /etc/passwd

Mai jos sunt prezentate exemplele de ieșiri:

1:root:x:0:0:root:/root:/bin/bash

Grep inversează potrivirea

Utilizatorii pot folosi opțiunea -v pentru a inversa potrivirea, ceea ce înseamnă că va afișa doar acele linii care nu conțin cuvântul dat. De exemplu, puteți afișa toate liniile care nu conțin cuvântul par utilizând următoarea comandă:

grep -v par /calea/către/fișier

Cum se listează doar numele fișierelor care corespund

Trebuie să utilizați opțiunea -l pentru a lista numele de fișiere al căror conținut menționează un anumit cuvânt, de exemplu, cuvântul „primary”, utilizând următoarea comandă:

grep -l 'primar' *.c

În cele din urmă, aveți opțiunea de a obliga grep să afișeze ieșirea în anumite culori utilizând următoarea comandă:

grep --color root /etc/passwd

Mai jos sunt prezentate exemple de rezultate:

Cum se face ca comanda grep să gestioneze mai multe modele de căutare

Pot exista situații în care doriți să căutați mai multe modele într-un anumit fișier (sau set de fișiere). În astfel de scenarii, ar trebui să utilizați opțiunea de linie de comandă „ -e” oferită de grep.

De exemplu, să presupunem că vrei să cauți cuvintele „how” (cum), „to” (să) și „forge” (falsificare) în toate fișierele text prezente în directorul de lucru curent. Iată cum poți face acest lucru:

grep -e cum se face -e la falsificarea unui fișier *.txt

Iată comanda în acțiune:

Opțiunea „ -e” din linia de comandă este utilă și în scenariile în care modelul începe cu o cratimă (-). De exemplu, dacă doriți să căutați, să zicem, „-how”, atunci următoarea comandă nu va fi utilă:

grep -how *.txt

Atunci când folosești opțiunea -e din linia de comandă, comanda înțelege exact ce încerci să cauți în acest caz:

grep -e -how *.txt

Iată ambele comenzi în acțiune:

Cum se limitează ieșirea grep la un anumit număr de linii

În cazul în care doriți să limitați ieșirea grep la un anumit număr de linii, puteți face acest lucru folosind opțiunea de linie de comandă „ -m” . De exemplu, să presupunem că doriți să căutați cuvântul „how” în testfile1.txt, care conține următoarele linii:

Dar cerința este ca grep să oprească căutarea după ce au fost găsite 3 linii care conțin modelul căutat. Așadar, pentru a face acest lucru, puteți rula următoarea comandă:

grep "how" -m3 fișiertest1.txt

Iată comanda în acțiune:

Trecând mai departe, iată ce spune pagina de manual a comenzii:

Dacă intrarea este o intrare standard dintr-un fișier obișnuit și se generează NUM linii corespondente, grep asigură că intrarea standard este poziționată imediat după ultima linie corespondentă înainte de ieșire, indiferent de prezența liniilor de context la final. Acest lucru permite unui proces apelant să reia o căutare.

De exemplu, dacă aveți un script bash care are o buclă și doriți să obțineți o potrivire per iterație a buclei, atunci utilizarea  „grep -m1” va face ceea ce este necesar.

Cum se face ca grep să obțină modele dintr-un fișier

Dacă doriți, puteți face ca comanda grep să obțină modele dintr-un fișier. Opțiunea -f din linia de comandă a instrumentului vă permite să faceți acest lucru.

De exemplu, să presupunem că vrei să cauți în toate fișierele .txt din directorul curent cuvintele „cum” și „să”, dar vrei să furnizezi aceste șiruri de intrare printr-un fișier numit, să zicem, „input”, iată cum poți face acest lucru:

grep -f input *.txt

Iată comanda în acțiune:

Iar modelul pe care vrei să-l cauți este „ce mai faci?”. Așadar, pentru a te asigura că grep afișează doar liniile care corespund complet acestui model, folosește-l în felul următor:

grep -x „how are you?” *.txt

Iată comanda în acțiune:

Cum să forțezi grep să nu afișeze nimic în ieșire

Pot exista situații în care nu este nevoie de comanda grep pentru a genera nimic în rezultat. În schimb, doriți doar să știți dacă a fost găsită o potrivire pe baza stării de ieșire a comenzii. Acest lucru se poate realiza folosind opțiunea -q din linia de comandă.

În timp ce opțiunea -q dezactivează ieșirea, starea de ieșire a instrumentului poate fi confirmată cu comanda „echo $?”. În cazul grep, comanda se închide cu starea „0” atunci când are succes (adică a fost găsită o potrivire), în timp ce se închide cu starea „1” atunci când nu a fost găsită nicio potrivire.

Următoarea captură de ecran prezintă atât scenariile de succes, cât și cele nereușite:

Cum se face ca grep să afișeze numele fișierelor care nu conțin modelul de căutare

În mod implicit, comanda grep afișează numele fișierelor care conțin modelul de căutare (precum și liniile potrivite). Acest lucru este destul de logic, deoarece asta se așteaptă de la acest instrument. Cu toate acestea, pot exista cazuri în care cerința ar putea fi obținerea numelor acelor fișiere care nu conțin modelul căutat.

Acest lucru este posibil și cu grep – opțiunea -L vă permite să faceți acest lucru. De exemplu, pentru a găsi toate acele fișiere text din directorul curent care nu conțin cuvântul „how”, puteți rula următoarea comandă:

grep -L "how" *.txt

Iată comanda în acțiune:

Cum se suprimă mesajele de eroare produse de grep

Dacă doriți, puteți forța grep să dezactiveze orice mesaje de eroare afișate în ieșire. Acest lucru se poate face folosind opțiunea -s din linia de comandă. De exemplu, luați în considerare următorul scenariu în care grep produce o eroare/avertisment legat de directorul pe care îl întâlnește:

Deci, în acest tip de scenariu, opțiunea -s din linia de comandă ajută. Vedeți mai jos.

Deci puteți vedea că eroarea/avertismentul a fost dezactivat.

Cum se face grep să caute recursiv în directoare

După cum reiese din exemplul folosit la punctul anterior, comanda grep nu efectuează o căutare recursivă în mod implicit. Pentru a vă asigura că căutarea grep este recursivă, utilizați opțiunea -d din linia de comandă și transmiteți-i valoarea „recurse”.

grep -d recursiv "how" *

Nota 1 : Mesajul de eroare/avertisment legat de director despre care am discutat la punctul anterior poate fi, de asemenea, dezactivat folosind opțiunea —d — tot ce trebuie să faceți este să îi transmiteți valoarea „skip”.

Nota 2 : Folosiți opțiunea „–exclude-dir=[DIR]” pentru a exclude directoarele care corespund modelului DIR din căutările recursive.

Cum se face ca grep să termine numele de fișiere cu caracterul NULL

După cum am discutat deja, opțiunea -l din linia de comandă a comenzii grep este utilizată atunci când doriți ca instrumentul să afișeze doar numele fișierelor în ieșire. De exemplu:

Însă, după cum probabil știți deja, caracterul newline poate face parte și dintr-un nume de fișier. Așadar, atunci când se lucrează cu cazuri în care numele fișierelor conțin un newline și sunt separate/terminate prin newline, devine dificil să se lucreze la ieșirea grep (mai ales când se accesează ieșirea printr-un script).

Ar fi bine dacă caracterul de separare/terminare nu ar fi un nou rând. Ei bine, te vei bucura să afli că grep oferă o opțiune -Z în linia de comandă care asigură că numele fișierelor sunt urmate de un caracter NULL și nu de un nou rând.

Deci, în cazul nostru, comanda devine:

grep -lZ "how" *.txt

Iată cum am confirmat prezența caracterului NULL:

Mai jos este o opțiune conexă din linia de comandă pe care ar trebui să o cunoașteți:

-z, --null-data
 Tratează intrarea ca un set de linii, fiecare terminată de un octet zero (caracterul ASCII NUL) în loc de o linie nouă. La fel ca opțiunile -Z sau --null, această opțiune poate fi utilizată cu comenzi precum sort -z pentru a procesa nume de fișiere arbitrare.

Cum se utilizează GREP pentru a găsi erori în fișierele jurnal

Grep este briceagul elvețian al administratorului Linux atunci când vine vorba de depanarea erorilor din servicii. Majoritatea serviciilor Linux au fișiere jurnal în care raportează erorile. Aceste fișiere jurnal pot fi uriașe, iar grep este o comandă versatilă și rapidă pentru a căuta, de exemplu, adresa IP a unui sistem care se conectează, un șir de erori sau adresa de e-mail a unui utilizator de e-mail afectat în fișierul mail.log.

Exemple:

Căutați conexiuni legate de o anumită adresă de e-mail. Aici, „ user@domain.tld ” se află în fișierul mail.log al serverului.

grep user@domain.tld /var/log/mail.log

Rezultat:

22 aug. 09:45:10 mail dovecot: pop3-login: Autentificare: user=< user@domain.tld >, method=PLAIN, rip=192.168.0.112, lip=78.46.229.46, mpid=17596, TLS, session=<3uoa5ffQovld3Uep> 
22 aug. 09:45:10 mail dovecot: pop3( user@domain.tld )<17596><3uoa5ffQovld3Uep>: Deconectat: Deconectat top=0/0, retr=1/6647, del=1/1, size=6630 
22 aug. 09:45:10 mail dovecot: pop3-login: Autentificare: user=< user@domain.tld >, method=PLAIN, rip=192.168.0.112, lip=78.46.229.46, mpid=17673, TLS, session=<fIIx6PfQkuBd3Uep> 
22 aug. 09:45:10 mail dovecot: pop3( user@domain.tld )<17673><fIIx6PfQkuBd3Uep>: Deconectat: Deconectat top=0/0, retr=0/0, del=0/0, size=0 
22 aug. 09:45:10 mail dovecot: pop3-login: Autentificare: user=< user@domain.tld >, method=PLAIN, rip=192.168.0.112, lip=78.46.229.46, mpid=17868, TLS, session=<bd5L7ffQPsld3Uep> 
22 aug. 09:45:10 mail dovecot: pop3( user@domain.tld )<17868><bd5L7ffQPsld3Uep>: Deconectat: Deconectat top=0/0, retr=0/0, del=0/0, size=0 
22 aug. 09:45:10 mail dovecot: pop3-login: Autentificare: user=< user@domain.tld >, method=PLAIN, rip=192.168.0.112, lip=78.46.229.46, mpid=17964, TLS, session=<sbpn7vfQevpd3Uep> 
22 aug. 09:45:10 mail dovecot: pop3( user@domain.tld )<17964><sbpn7vfQevpd3Uep>: Deconectat: Deconectat top=0/0, retr=0/0, del=0/0, size=0 
22 aug. 09:45:10 mail postfix/smtpd[6932]: NOQUEUE: respingere: RCPT de la necunoscut[1.2.3.4]: 504 5.5.2 <1.2.3.4>: Comanda Helo respinsă: este necesar un nume de gazdă complet calificat; from=< maillist@mailserver.com > to=< user@domain.tld > proto=ESMTP helo=<1.2.3.4>

Pentru a monitoriza continuu un fișier jurnal pentru conexiunile pentru această adresă de e-mail, combinați comenzile tail și grep astfel:

tail -f /var/log/mail.log | grep utilizator@domeniu.tld

Pentru a ieși din funcția de ceas, apăsați tastele [strg] + c.

[mai mult...]

Cum se instalează Joomla cu Nginx pe serverul Ubuntu 24.04

Joomla este un sistem de management al conținutului bazat pe PHP. Pentru a-l instala, trebuie să instalați PHP pe sistemul dvs. În această secțiune, veți instala stiva LEMP (Linux, Nginx, MariaDB și PHP-FPM) ca dependențe pentru Joomla.

Mai întâi, rulați comanda de mai jos pentru a vă actualiza indexul pachetului Ubuntu.

sudo apt update

Instalați dependențele stivei LEMP cu comanda de mai jos. Introdu „ Y ” pentru a confirma instalarea.

sudo apt install nginx mariadb-server php-fpm php-curl php-common php-json php-intl php-xml php-gd php-mysql php-imagick php-mbstring php-zip

După finalizarea instalării, verificați starea serviciului Nginx cu următoarele:

sudo systemctl enable nginx 
sudo systemctl start nginx 
sudo systemctl status nginx

Puteți vedea că serviciul Nginx rulează.

Acum verificați serviciul MariaDB pentru a vă asigura că serviciul rulează și este activat cu comanda de mai jos:

sudo systemctl enable mariadb 
sudo systemctl start mariadb
sudo systemctl status mariadb

În cele din urmă, rulați următoarea comandă pentru a verifica serviciul PHP-FPM. PHP-FPM ar trebui să ruleze în mod implicit pe fișierul sock.

sudo systemctl enable php8.3-fpm 
sudo systemctl start php8.3-fpm 
sudo systemctl status php8.3-fpm

Configurarea PHP-FPM

Acum că stiva LEMP este instalată, veți configura instalarea PHP-FPM și veți modifica unele configurații implicite după cum este necesar pentru Joomla.

Deschideți configurația PHP-FPM „ /etc/php/8.3/fpm/php.ini ” cu editorul „ nano ”.

sudo nano /etc/php/8.3/fpm/php.ini

Modificați configurația implicită cu următoarele:

memory_limit=512M 
upload_max_filesize=64M 
post_max_size=64M 
max_execution_time=120 
output_buffering = Off 
extension=intl

Salvați fișierul și ieșiți din editor.

Acum reporniți serviciul PHP-FPM pentru a aplica modificările.

sudo systemctl restart php8.3-fpm

În cele din urmă, puteți verifica fișierul PHP sock pentru serviciul PHP-FPM cu comanda de mai jos.

ss -pl | grep php

Puteți vedea mai jos fișierul sock pentru PHP-FPM se află la „ /var/run/php/php8.3-fpm.sock ”.

Configurarea serverului MariaDB

În această secțiune, veți securiza instalarea serverului MariaDB, apoi veți crea o nouă bază de date și un utilizator pentru Joomla. Veți folosi „mariadb-secure-installation” pentru a securiza serverul MariaDB și apoi prin clientul „mariadb” pentru a crea o nouă bază de date și utilizator.

Pentru a securiza serverul MariaDB, rulați comanda „ mariab-secure-installation ” de mai jos.

sudo mariadb-secure-installation

Acum vi se va cere să configurați serverul MariaDB cu următoarele:

  • Pentru instalarea implicită a serverului MariaDB fără o parolă root, apăsați ENTER când sunteți întrebat despre parolă.
  • Autentificarea locală pentru utilizatorii root MariaDB este securizată în mod implicit, introduceți „n” când vi se cere să schimbați metoda de autentificare în „unix_socket”.
  • Introduceți „Y” pentru a crea o nouă parolă root MariaDB. Apoi, introduceți parola puternică pentru utilizatorul dvs. root MariaDB și repetați.
  • Când vi se cere să dezactivați autentificarea de la distanță pentru utilizatorul root MariaDB, introduceți „Y” pentru a fi de acord.
  • Instalarea implicită a serverului MariaDB vine cu baza de date „test” și permite unui utilizator anonim să o acceseze.
  • Introduceți „Y” pentru ambele setări pentru a elimina „testul” implicit al bazei de date și a elimina privilegiul anonim.
  • În cele din urmă, introduceți „Y” pentru a confirma privilegiile de reîncărcare a tabelului.

Odată ce MariaDB este securizat, veți crea o nouă bază de date și un utilizator pentru Joomla.

Conectați-vă la serverul MariaDB cu comanda „ mariadb ” de mai jos. Introduceți parola de root MariaDB când vi se solicită.

sudo mariadb -u root -p

Acum rulați următoarele interogări pentru a crea o nouă bază de date „ joomladb ” și un nou utilizator „ joomla ” cu parola „ p4ssword ”.

CREATE DATABASE joomladb;
CREATE USER joomla@localhost IDENTIFIED BY 'p4ssword';
GRANT ALL PRIVILEGES ON joomladb.* TO joomla@localhost;
FLUSH PRIVILEGES;

Apoi, executați interogarea de mai jos pentru a verifica privilegiile utilizatorului „ joomla ”. Veți vedea că utilizatorul „ joomla ” poate accesa baza de date „ joomladb ”.

SHOW GRANTS FOR joomla@localhost;

În cele din urmă, tastați „ quit ” pentru a ieși de pe serverul MariaDB.

Descărcarea codului sursă Joomla

În acest moment, ați instalat și configurat dependențe pentru Joomla. Acum veți descărca codul sursă Joomla și veți configura directorul document-root/webroot pentru instalarea Joomla. Accesați directorul „/var/www” și descărcați codul sursă Joomla cu comanda „wget” de mai jos. Verificați pagina de descărcare Joomla și luați linkul pentru cea mai recentă versiune.

cd /var/www/ 
wget https://downloads.joomla.org/cms/joomla5/5-1-4/Joomla_5-1-4-Stable-Full_Package.zip

Acum rulați comanda „unzip” de mai jos pentru a extrage codul sursă Joomla în directorul „joomla”.

unzip Joomla_5-1-4-Stable-Full_Package.zip -d joomla

În cele din urmă, rulați comanda „chmod” de mai jos pentru a schimba proprietatea directorului „/var/www/joomla” la utilizatorul „www-data”.

sudo chown -R www-data:www-data /var/www/joomla

Configurarea blocului serverului Nginx

Acum veți crea o nouă configurație de bloc de server Nginx pentru rularea Joomla. Așa că asigurați-vă că aveți numele de domeniu pregătit și că ați indicat adresa IP a serverului.

Creați un nou fișier server Nginx „ /etc/nginx/sites-available/joomla ” cu următorul editor „ nano ”.

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

Introduceți configurația de mai jos și modificați opțiunea „ server_name ” cu numele domeniului dumneavoastră.

server {
listen 80;
server_name howtoforge.local;
server_name_in_redirect off;

access_log /var/log/nginx/localhost.access_log;
error_log /var/log/nginx/localhost.error_log info;

root /var/www/joomla;
index index.php index.html index.htm default.html default.htm;

# Support API
location /api/ {
try_files $uri $uri/ /api/index.php?$args;
}

# Support Clean (aka Search Engine Friendly) URLs
location / {
try_files $uri $uri/ /index.php?$args;
}

# add global x-content-type-options header
add_header X-Content-Type-Options nosniff;

# deny running scripts inside writable directories
location ~* /(images|cache|media|logs|tmp)/.*\.(php|pl|py|jsp|asp|sh|cgi)$ {
return 403;
error_page 403 /403_error.html;
}

location ~ \.php$ {
fastcgi_pass unix:/var/run/php/php8.3-fpm.sock;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include /etc/nginx/fastcgi.conf;
}

# caching of files
location ~* \.(ico|pdf|flv)$ {
expires 1y;
}

location ~* \.(js|css|png|jpg|jpeg|gif|swf|xml|txt)$ {
expires 14d;
}

}

Salvați fișierul și ieșiți din editor.

Acum rulați comanda de mai jos pentru a activa blocul de server „ joomla ” și pentru a verifica configurația dvs. Nginx. Dacă aveți setări Nginx adecvate, veți vedea o ieșire „ Sintaxa este OK ”.

sudo ln -s /etc/nginx/sites-available/joomla /etc/nginx/sites-enabled/ 
sudo nginx -t

În cele din urmă, rulați comanda „systemctl” de mai jos pentru a reporni serviciul Nginx și a aplica modificările.

sudo systemctl restart nginx

Securizarea Joomla cu HTTPS

În acest ghid, veți securiza Joomla cu HTTPS. Dacă utilizați domeniul public, puteți securiza Joomla prin certificate SSL/TLS prin Certbot și Letsencerypt.

Instalați „Certbot” și pluginul Certbot Nginx cu comanda „apt” de mai jos. Introduceți „Y” pentru a confirma instalarea.

sudo apt install certbot python3-certbot-nginx

După finalizarea instalării, rulați următoarea comandă „certbot” pentru a genera certificate SSL/TLS și a vă asigura instalarea Joomla cu HTTPS. Asigurați-vă că schimbați numele domeniului și adresa de e-mail cu informațiile dvs.

sudo certbot --nginx --agree-tos --redirect --hsts --staple-ocsp --email kyrie@howtoforge.local -d howtoforge.local

Când ați terminat, instalarea dvs. Joomla este securizată cu HTTPS prin certificate SSL/TLS de la Letsencrypt.

Instalarea Joomla

Deschideți browserul web și vizitați numele de domeniu Joomla, cum ar fi https://askit.local/ . Veți vedea asistentul de instalare Joomla.

Selectați limba implicită și introduceți numele site-ului.

Introduceți noul utilizator de administrator, adresa de e-mail și parola pentru Joomla.

Introduceți detaliile despre baza de date MariaDB și despre utilizator, apoi faceți click pe „ Instalare Joomla ” pentru a continua cu instalarea.

După finalizarea instalării, faceți clic pe „ Deschidere site ” pentru a deschide pagina de pornire implicită sau pe „ Deschidere administrator ” pentru a accesa tabloul de bord de administrare Joomla.

Pentru pagina de pornire Joomla implicită, veți vedea următoarele.

Acum introduceți utilizatorul și parola de administrator și faceți click pe „ Autentificare”.

Dacă aveți utilizatorul și parola corecte, veți vedea următorul tablou de bord de administrare Joomla.

[mai mult...]

Cum se instalează Craft CMS pe Rocky Linux 9

Cerințe preliminare

  • Un server care rulează Rocky Linux 9 cu minim 1 GB RAM.
  • Un utilizator non-root cu privilegii sudo.
  • Un nume de domeniu complet calificat (FQDN) ca craftcms.example.comindicarea către serverul dvs.
  • Un cont SMTP cu un serviciu de e-mail precum Amazon SES sau Mailgun.
  • Totul este actualizat. 
    $ sudo dnf update
  • Sunt necesare câteva pachete esențiale pentru ca tutorialul și Craft CMS să ruleze. Unele dintre acestea vor fi deja pe serverul dvs. 
    $ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y

Pasul 1 – Configurați firewall

Primul pas este configurarea firewall-ului. Rocky Linux folosește Firewalld Firewall. Verificați starea firewall-ului.

$ sudo firewall-cmd --state
funcţionare

Firewall-ul funcționează cu diferite zone, iar zona publică este cea implicită pe care o vom folosi. Listați toate serviciile și porturile active pe firewall.

$ sudo firewall-cmd --permanent --list-services

Ar trebui să arate următoarea ieșire.

cockpit dhcpv6-client ssh

Permiteți porturile HTTP și HTTPS.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Verificați din nou starea paravanului de protecție.

$ sudo firewall-cmd --permanent --list-services

Ar trebui să vedeți o ieșire similară.

cockpit dhcpv6-client http https ssh

Reîncărcați paravanul de protecție pentru a activa modificările.

$ sudo firewall-cmd --reload

Pasul 2 – Instalați Nginx

Rocky Linux 9 este livrat cu o versiune mai veche de Nginx. Trebuie să utilizați depozitul oficial Nginx pentru a instala cea mai recentă versiune.

Creați și deschideți fișierul /etc/yum.repos.d/nginx.repopentru editare.

$ sudo nano /etc/yum.repos.d/nginx.repo

Lipiți următorul cod în el.

[nginx-stable]
nume=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
activat=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=adevărat

[nginx-mainline]
nume=nginx repository principal
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
activat=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=adevărat

După ce ați terminat, salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Instalați Nginx.

$ sudo dnf install nginx -y

Verificați instalarea.

$ nginx -v
Versiunea nginx: nginx/1.24.0

Activați și porniți serviciul server Nginx.

$ sudo systemctl enable nginx --now

Verificați starea serviciului.

$ sudo systemctl status nginx
? nginx.service - nginx - server web de înaltă performanță
     Încărcat: încărcat (/usr/lib/systemd/system/nginx.service; activat; presetat: dezactivat)
     Activ: activ (în rulare) din Luni 2023-12-04 14:01:19 UTC; acum 3s
       Documente: http://nginx.org/en/docs/
    Proces: 59396 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exit, status=0/SUCCESS)
   PID principal: 59397 (nginx)
      Sarcini: 2 (limită: 10866)
     Memorie: 1,9 M
        CPU: 10 ms
     CGroup: /system.slice/nginx.service
             ??59397 „nginx: proces principal /usr/sbin/nginx -c /etc/nginx/nginx.conf”
             ??59398 „nginx: proces de lucru”

Pasul 3 – Instalați PHP și extensii

Rocky Linux 9 este livrat implicit cu PHP 8.1. Pentru a rămâne mereu pe cea mai recentă versiune de PHP sau dacă doriți să instalați mai multe versiuni de PHP, trebuie să folosim depozitul REMI.

Primul pas este să luați depozitul Epel.

$ sudo dnf install epel-release -y

Apoi, instalați depozitul Remi.

$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm

Verificați fluxurile PHP disponibile.

$ dnf module list php -y
 Rezumatul profilurilor fluxului de nume php 8.1 comun [d], devel, limbaj de scripting PHP minim  Depozitul modular al lui Remi pentru Enterprise Linux 9 - x86_64 Rezumatul profilurilor fluxului de nume php remi-7.4 comun [d], devel, limbaj de scripting PHP minim php remi-8.0 comun [d], devel, limbaj de scripting PHP minim php remi-8.1 comun [d], devel, limbaj de scripting PHP minim php remi-8.2 comun [d], devel, limbaj de scripting PHP minim php remi-8.3 comun [d], devel, limbaj de scripting PHP minim  Sugestie: [d]efectuat, [activat], [x]dezactivat, [instalat]

Versiunea implicită este 8.1. La momentul scrierii acestui tutorial, Craft CMS este compatibil cu PHP 8.2. Prin urmare, activați depozitul PHP 8.2 al lui Remi.

$ sudo dnf module reset php -y
$ sudo dnf module enable php:remi-8.2

Instalați PHP și extensiile sale solicitate de Craft CMS.

$ sudo dnf install php php-cli php-common php-json php-gmp php-fpm php-xmlrpc php-bcmath php-imagick php-curl php-zip php-gd php-mysql php-xml php-mbstring php-xmlrpc php-pintlql

Verificați versiunea de PHP instalată.

$ php --version
PHP 8.2.13 (cli) (construit: 21 noiembrie 2023 09:55:59) (NTS gcc x86_64)
Drepturi de autor (c) Grupul PHP
Zend Engine v4.2.13, Copyright (c) Zend Technologies
    cu Zend OPcache v8.2.13, Copyright (c), de Zend Technologies

Activați și porniți serviciul PHP-FPM.

$ sudo systemctl enable php-fpm --now

Verificați starea serviciului PHP.

$ sudo systemctl status php-fpm
? php-fpm.service - Managerul de procese PHP FastCGI
     Încărcat: încărcat (/usr/lib/systemd/system/php-fpm.service; activat; presetat: dezactivat)
     Activ: activ (în rulare) din Luni 2023-12-04 14:05:58 UTC; acum 6 secunde
   PID principal: 61410 (php-fpm)
     Stare: „Pregătit pentru a gestiona conexiunile”
      Sarcini: 6 (limită: 10866)
     Memorie: 16,6 M
        CPU: 96 ms
     CGroup: /system.slice/php-fpm.service
             ??61410 „php-fpm: proces principal (/etc/php-fpm.conf)”
             ??61411 "php-fpm: pool www"
             ??61412 "php-fpm: pool www"
             ??61413 "php-fpm: pool www"
             ??61414 "php-fpm: pool www"
             ??61415 "php-fpm: pool www"

Pasul 4 – Configurați PHP-FPM

Deschis php.inipentru editare.

$ sudo nano /etc/php.ini

Pentru a seta dimensiunile de încărcare a fișierelor, modificați valorile variabilelor upload_max_filesizeși post_max_size. Această valoare decide dimensiunea fișierului pe care îl puteți încărca în Craft CMS. Pentru scopurile noastre, îl setăm la 128 MB. Îl poți seta după bunul plac.

$ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 128M/' /etc/php.ini
$ sudo sed -i 's/post_max_size = 8M/post_max_size = 128M/' /etc/php.ini

Configurați limita de memorie PHP în funcție de resursele și cerințele serverului dvs.

$ sudo sed -i 's/memory_limit = 128M/memory_limit = 256M/' /etc/php.ini

Deschideți fișierul /etc/php-fpm.d/www.conf.

$ sudo nano /etc/php-fpm.d/www.conf

Trebuie să setăm utilizatorul/grupul de procese PHP Unix la nginx . Găsiți liniile user=www-datași group=www-dataîn fișier și schimbați-le în nginx.

...
; Utilizator Unix/grup de procese
; Notă: Utilizatorul este obligatoriu. Dacă grupul nu este setat, grupul implicit al utilizatorului
; va fi folosit.
; RPM: utilizator apache ales să ofere acces la aceleași directoare ca httpd
utilizator = nginx
; RPM: Păstrați un grup permis să scrie în directorul jurnalului.
grup = nginx
...

Găsiți liniile listen.owner = nobody, listen.group = nobody, listen.mode = 0660din fișier și modificați-le după cum urmează după ce le-ați decomentat.

; Setați permisiunile pentru socket Unix, dacă este folosit unul. În Linux, citiți/scrieți
; permisiunile trebuie setate pentru a permite conexiuni de la un server web. Multe
; Sistemele derivate din BSD permit conexiuni indiferent de permisiuni. Proprietarul
; și grupul poate fi specificat fie prin nume, fie prin ID-urile lor numerice.
; Valori implicite: utilizatorul și grupul sunt setate ca utilizator care rulează
; modul este setat la 0660
listen.owner = nginx
ascultă.grup = nginx
listen.mode = 0660

Salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Reporniți procesul PHP-fpm. Asigurați-vă că aveți instalat Nginx înainte de a reporni serviciul PHP, altfel acesta va eșua, deoarece nu va putea găsi nginxgrupul.

$ sudo systemctl restart php-fpm

Schimbați grupul directorului de sesiuni PHP în Nginx.

$ sudo chgrp -R nginx /var/lib/php/session

Pasul 5 – Instalați Composer

Composer acționează ca un manager de dependență pentru PHP. Este, de asemenea, managerul de dependență al cadrului PHP Laravel, care este ceea ce alimentează Craft CMS.

Descărcați scriptul de instalare Composer.

$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"

Verificați programul de instalare descărcat.

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

Veți primi următorul rezultat.

Installer verified

Rulați scriptul de instalare pentru a descărca cea mai recentă versiune de Composer.

$ php composer-setup.php

Eliminați scriptul de instalare.

$ php -r "unlink('composer-setup.php');"

Mutați fișierul binar descărcat în /usr/local/bindirector.

$ sudo mv composer.phar /usr/local/bin/composer

Confirmați instalarea.

$ composer --version
Composer version 2.6.5 2023-10-06 10:11:52

Pasul 6 – Instalați și configurați PostgreSQL

Rocky Linux 9 este livrat implicit cu PostgreSQL 13. Vom folosi PostgreSQL 16 în schimb din depozitul său oficial.

Instalați depozitul RPM PostgreSQL.

$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm

Dezactivați modulul PostgreSQL încorporat.

$ sudo dnf -qy module disable postgresql

Acum, puteți instala PostgreSQL folosind comanda de mai jos.

$ sudo dnf install -y postgresql16-server postgresql16-contrib

Pachetul postgresql-contribconține câteva utilități suplimentare.

Verificați versiunea.

$ psql --version
psql (PostgreSQL) 16.1

Inițializați baza de date PostgreSQL.

$ sudo /usr/pgsql-16/bin/postgresql-16-setup initdb
Se inițializează baza de date... OK

Activați serviciul PostgreSQL.

$ sudo systemctl enable postgresql-16

Porniți serviciul PostgreSQL.

$ sudo systemctl start postgresql-16

Verificați starea serviciului PostgreSQL.

$ sudo systemctl status postgresql-16
? postgresql-16.service - Server de baze de date PostgreSQL 16
     Încărcat: încărcat (/usr/lib/systemd/system/postgresql-16.service; activat; prestabilit: dezactivat)
     Activ: activ (în rulare) din Luni 2023-12-04 22:28:34 UTC; acum 2 secunde
       Documente: https://www.postgresql.org/docs/16/static/
    Proces: 72143 ExecStartPre=/usr/pgsql-16/bin/postgresql-16-check-db-dir ${PGDATA} (code=exit, status=0/SUCCESS)
   PID principal: 72148 (postgres)
      Sarcini: 7 (limită: 10866)
     Memorie: 17,4 M
        CPU: 45 ms
     CGroup: /system.slice/postgresql-16.service
             ??72148 /usr/pgsql-16/bin/postgres -D /var/lib/pgsql/16/data/
             ??72149 "postgres: logger"
             ??72150 "postgres: checkpointer"
             ??72151 "postgres: scriitor de fundal"
             ??72153 "postgres: walwriter"
             ??72154 "postgres: lansatorul de autovacuum"
             ??72155 „postgres: lansatorul de replicare logică”

04 decembrie 22:28:33 craftcms.nspeaks.com systemd[1]: Se pornește serverul de baze de date PostgreSQL 16...
Dec 04 22:28:33 craftcms.nspeaks.com postgres[72148]: 2023-12-04 22:28:33.999 UTC [72148] LOG: redirecționarea ieșirii jurnalului către procesul de colectare a jurnalului
Dec 04 22:28:33 craftcms.nspeaks.com postgres[72148]: 2023-12-04 22:28:33.999 UTC [72148] SFAT: Ieșirea viitoare a jurnalului va apărea în directorul „jurnal”.
04 decembrie 22:28:34 craftcms.nspeaks.com systemd[1]: A pornit serverul de baze de date PostgreSQL 16.

Puteți vedea că serviciul este activat și rulează implicit.

Lansați shell-ul PostgreSQL.

$ sudo -i -u postgres psql

Creați baza de date Craft CMS.

postgres=# CREAȚI BAZĂ DE DATE craftcms;

Creați utilizatorul Craft CMS și alegeți o parolă puternică.

postgres-# CREAȚI UTILIZATOR craftuser CU PAROLA 'Parola_dvs';

Schimbați proprietarul bazei de date în utilizatorul Craft CMS.

postgres-# ALTER DATABASE craftcms OWNER TO craftuser;

Acordați toate privilegiile din baza de date utilizatorului Craft CMS.

postgres-# ACORDĂ TOATE PRIVILEGIILE PE BAZĂ DE DATE craftcms CĂTRE craftuser;

Ieși din shell.

postgres-# \q

Verificați dacă acreditările dvs. funcționează.

$ psql --username craftuser --parola --host localhost craftcms
Password:
psql (16.1)
Tastați „help” pentru ajutor.

craftcms =>

Ieșiți din shell tastând \q.

Pasul 7 – Instalați și configurați Redis

Rocky Linux 9 este livrat implicit cu Redis 6.2. Cu toate acestea, vom folosi Redis 7.0 pe care îl vom instala folosind Remi Repository.

Deoarece am instalat depozitul Remi în timpul instalării PHP, putem sări peste acea parte. Listați toate modulele Redis disponibile.

$ sudo dnf module list redis
Rocky Linux 9 - AppStream
Rezumatul profilurilor fluxului de nume
redis 7 comun [d] baza de date persistentă cheie-valoare Redis

Depozitul modular al lui Remi pentru Enterprise Linux 9 - x86_64
Rezumatul profilurilor fluxului de nume
redis remi-5.0 common [d] baza de date persistentă cheie-valoare Redis
redis remi-6.0 common [d] baza de date persistentă cheie-valoare Redis
redis remi-6.2 common [d] baza de date persistentă cheie-valoare Redis
redis remi-7.0 common [d] baza de date persistentă cheie-valoare Redis
redis remi-7.2 common [d] baza de date persistentă cheie-valoare Redis

Sugestie: [d]efectuat, [activat], [x]dezactivat, [instalat]

Activați cel mai recent modul Redis 7.2.

$ sudo dnf module enable -y redis:remi-7.2

Instalați Redis.

$ sudo dnf install redis

Verificați versiunea.

$ redis-server --version
Server Redis v=7.2.3 sha=00000000:0 malloc=jemalloc-5.3.0 biți=64 build=7bd3173e4e30c3e4

Activați serviciul Redis.

$ sudo systemctl enable redis

Porniți serviciul Redis.

$ sudo systemctl start redis

Verificați starea serviciului.

$ sudo systemctl status redis
? redis.service - baza de date persistentă cheie-valoare Redis
     Încărcat: încărcat (/usr/lib/systemd/system/redis.service; activat; presetat: dezactivat)
    Drop-in: /etc/systemd/system/redis.service.d
             ??limit.conf
     Activ: activ (în rulare) din Luni 2023-12-04 22:36:25 UTC; acum 1 min 32s
   PID principal: 72877 (server redis)
     Stare: „Pregătit să accepte conexiuni”
      Sarcini: 5 (limită: 10866)
     Memorie: 7,5 M
        CPU: 176 ms
     CGroup: /system.slice/redis.service
             ??72877 „/usr/bin/redis-server 127.0.0.1:6379”

04 decembrie 22:36:25 craftcms.nspeaks.com systemd[1]: Se pornește baza de date persistentă cheie-valoare Redis...
04 decembrie 22:36:25 craftcms.nspeaks.com systemd[1]: a început baza de date persistentă cheie-valoare Redis.

Următorul pas este să adăugați autentificare la serverul Redis. Începând cu Redis v6.0, cea mai bună modalitate de a adăuga autentificare este utilizarea ACL (liste de control acces). Deschideți /etc/redis/redis.conffișierul pentru editare.

$ sudo nano /etc/redis/redis.conf

Găsiți # aclfile /etc/redis/users.aclintrarea de linie și decomentați-o eliminând simbolul hash ( #) din fața ei.

aclfile /etc/redis/users.acl

Salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Apoi, creați și deschideți /etc/redis/users.aclfișierul pentru editare.

$ sudo nano /etc/redis/users.acl

Adăugați următoarea linie la acesta.

user navjot pe +@all ~* >parola ta

Salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Reporniți serverul Redis pentru a implementa modificarea.

$ sudo systemctl restart redis

Deschideți shell-ul Redis.

$ redis-cli

Utilizați PINGcomanda. Va da o eroare de autentificare.

127.0.0.1:6379> PING
(eroare) NOAUTH Este necesară autentificarea.

Utilizați AUTHcomanda pentru a vă autentifica.

127.0.0.1:6379> AUTH navjot parola ta
Bine

Folosiți PINGcomanda din nou.

127.0.0.1:6379> PING
Bine

Ieși din shell.

127.0.0.1:6379> ieșire

De asemenea, va trebui să instalați extensia PHP Redis.

$ sudo apt install php-redis

Pasul 8 – Instalați Craft CMS

Înainte de a instala Craft CMS, puteți verifica dacă îndepliniți toate cerințele de server pentru a-l rula folosind următoarea comandă.

$ curl -Lsf https://raw.githubusercontent.com/craftcms/server-check/HEAD/check.sh | bash

Veți obține următoarea ieșire.

Se execută verificarea serverului Craft...

Craft CMS Verificator de cerințe

Acest script verifică dacă configurația serverului dvs. web îndeplinește cerințele pentru rularea unei instalări Craft CMS.
Verifică dacă serverul rulează versiunea corectă de PHP, dacă au fost încărcate extensii PHP adecvate,
și dacă setările fișierului php.ini sunt corecte.

Rezultate:
--------

PHP 8.2+: OK

Extensia BCMath: OK

extensia ctype: OK

Extensia cURL: OK

Extensia DOM: OK

Extensia informațiilor fișierului: OK

Extensia GD sau extensia ImageMagick: OK

extensia iconv: OK

Extensie interna: OK

Extensie JSON: OK

Extensie șir multiocteți (cu supraîncărcarea funcției dezactivată): OK

Extensia OPcache (cu save_comments): OK

Extensia OpenSSL: OK

Extensie PCRE (cu suport UTF-8): OK

Extensie PDO: OK

Extensie de reflecție: OK

Extensie SPL: OK

Extensie zip: OK

ignore_user_abort(): OK

password_hash(): OK

proc_close(): OK

proc_get_status(): OK

proc_open(): OK

proc_terminate(): OK

allow_url_fopen: OK

apeluri ini_set: OK

Limită memorie: OK

-------------------------------------------
Erori: 0 Avertismente: 0 Total verificări: 27

Odată ce totul este în regulă, puteți continua. Creați directorul rădăcină web.

$ sudo mkdir /var/www/html/craftcms -p

Setați utilizatorul conectat în prezent ca proprietar al acestui director.

$ sudo chown -R $USER:$USER /var/www/html/craftcms

Comutați la director.

$ cd /var/www/html/craftcms

Descărcați și instalați Craft CMS folosind Composer. Punctul ( .) de la sfârșitul comenzii înseamnă că instalarea trebuie efectuată în directorul curent.

$ compozitor create-project craftcms/craft .

În timpul instalării, vi se vor cere mai multe detalii privind baza de date și contul de administrator. URL-ul site-ului și limba acestuia, după cum se arată mai jos.

> @php craft Configurare/bine ai venit

   ______ .______ ___ _______ .___________.
  / || _ \ / \ | ____|| |
 | ,----'| |_) | / ^ \ | |__ `---| |----`
 | | | / / /_\ \ | __| | |
 | `----.| |\ \----./ _____ \ | | | |
  \______|| _| `._____/__/ \__\ |__| |__|

     ANEWINSTALL
               ______ .___ ___. _______.
              / || \/ | / |
             | ,----'| \ / | | (----`
             | | | |\/| | \ \
             | `----.| | | | .----) |
              \______||__| |__| |_______/


Generarea unui ID de aplicație... gata (CraftCMS--923f03f1-9bea-4c3d-a7ca-1466645ce75d)
Generarea unei chei de securitate... gata (iMdcUi6wQyf9MshEda__vZcCwILbclxz)

Bun venit la Craft CMS!

Ești gata să începi configurarea? (da|nu) [nu]:da
Ce driver de bază de date folosești? (mysql sau pgsql) [mysql] pgsql
Numele serverului bazei de date sau adresa IP: [127.0.0.1]
Port baza de date: [5432]
Nume utilizator baza de date: [root] craftuser
Parola bazei de date:
Numele bazei de date: craftcms
Prefixul tabelului bazei de date:
Testarea acreditărilor bazei de date... succes!
Folosind schema implicită „publică”.
Salvarea acreditărilor bazei de date în fișierul .env... gata

Instalați Craft acum? (da|nu) [da]:da

Nume de utilizator: [admin] navjot
E-mail: navjot@example.com
Parolă:
Confirma:
Numele site-ului: tutoriale Howtoforge
Adresa URL a site-ului: https://craftcms.example.com
Limba site-ului: [en-US]
*** instalarea Craft

Faceți Redis să funcționeze cu Craft CMS

Instalați yiisoft/yii2-redispachetul.

$ composer require --prefer-dist yiisoft/yii2-redis:"~2.0.0"

Deschideți /var/www/html/craftcms/config/app.phpfișierul pentru editare.

$ nano config/app.php

Veți vedea următorul conținut în el.

use craft\helpers\App;

return [
    'id' => App::env('CRAFT_APP_ID') ?: 'CraftCMS',
];

Schimbați-l după cum urmează.

use craft\helpers\App;
return [
    'id' => App::env('CRAFT_APP_ID') ?: 'CraftCMS',
    'components' => [
        'cache' => function() {
            $config = [
                'class' => yii\redis\Cache::class,
                'keyPrefix' => Craft::$app->id,
                'defaultDuration' => Craft::$app->config->general->cacheDuration,

                // Full Redis connection details:
                'redis' => [
                    'hostname' => App::env('REDIS_HOSTNAME') ?: 'localhost',
                    'port' => 6379,
                    'username' => App::env('REDIS_USERNAME') ?: null,
                    'password' => App::env('REDIS_PASSWORD') ?: null,
                ],
            ];

            return Craft::createObject($config);
        },
    ],
];

Salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită. Acest lucru permite Redis ca stocare cache pentru Craft CMS. De asemenea, puteți utiliza Redis pentru stocarea datelor de sesiune PHP, coada de joburi și ca driver mutex. Puteți găsi configurația pentru aceasta în documentația Craft CMS .

De asemenea, trebuie să adăugați configurația Redis la .envfișier.

$ nano .env

Adăugați următorul cod la sfârșitul fișierului.

REDIS_HOSTNAME=localhost
REDIS_USERNAME=navjot
REDIS_PASSWORD=parola ta

Alegeți opțiunile așa cum se arată mai sus. După ce ați terminat, schimbați grupul directorului în nginx. În acest fel, atât utilizatorul conectat în prezent, cât și Nginx vor avea acces la Craft CMS.

$ sudo chgrp -R nginx /var/www/html/craftcms

Acordați nginxpermisiunea grupului de a scrie în director.

$ sudo chmod -R g+w /var/www/html/craftcms

De aici încolo, nu va trebui să schimbați din nou permisiunile și puteți face toate operațiunile fără a utiliza privilegiile root.

Pasul 9 – Instalați SSL

Trebuie să instalăm Certbot pentru a genera certificatul SSL. Vom folosi programul de instalare a pachetului Snapd pentru asta. Deoarece Rocky Linux nu este livrat cu acesta, instalați programul de instalare Snapd. Este necesar ca depozitul EPEL (Extra Packages for Enterprise Linux) să funcționeze. Dar, din moment ce l-am instalat deja la pasul 3, putem merge direct înainte.

Instalați Snapd.

$ sudo dnf install -y snapd

Activați și porniți serviciul Snap.

$ sudo systemctl enable snapd --now

Instalați pachetul de bază Snap și asigurați-vă că versiunea dvs. de Snapd este actualizată.

$ sudo snap install core && sudo snap refresh core

Creați linkurile necesare pentru ca Snapd să funcționeze.

$ sudo ln -s /var/lib/snapd/snap /snap
$ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh

Instalați Certbot.

$ sudo snap install --classic certbot

Utilizați următoarea comandă pentru a vă asigura că comanda Certbot poate fi rulată prin crearea unei legături simbolice către /usr/bindirector.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Verificați dacă Certbot funcționează corect.

$ certbot --versiune
certbot 2.7.4

Rulați următoarea comandă pentru a genera un certificat SSL.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m nume@example.com -d craftcms.example.com

Comanda de mai sus va descărca un certificat în /etc/letsencrypt/live/craftcms.example.comdirectorul de pe serverul dvs.

Generați un certificat de grup Diffie-Hellman .

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Verificați serviciul de planificare a reînnoirii Certbot.

$ sudo systemctl list-timers

Veți găsi snap.certbot.renew.serviceunul dintre serviciile programate să ruleze.

URMĂTOAREA STÂNGA ULTIMA UNITATE A TRUCĂ SE ACTIVĂ     
------------------------------------------------------------ -------------------------------------------------------------               
Luni 2023-12-04 23:38:47 UTC 18min rămas Luni 2023-12-04 22:19:02 UTC Acum 1h 0min dnf-makecache.timer dnf-makecache.service
Mar 2023-12-05 00:00:00 UTC 40 min rămase - - logrotate.timer logrotate.service
Mar 2023-12-05 09:36:00 UTC Mai sunt 10 ore - - snap.certbot.renew.timer snap.certbot.renew.service

Faceți o rulare uscată a procesului pentru a verifica dacă reînnoirea SSL funcționează bine.

$ sudo certbot renew --dry-run

Dacă nu vedeți nicio eroare, sunteți gata. Certificatul dumneavoastră se va reînnoi automat.

Pasul 10 – Configurați SELinux

Schimbați contextul de securitate al fișierului pentru Craft CMS.

$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/craftcms(/.*)?"

Aplicați politica.

$ sudo restorecon -Rv /var/www/html/craftcms/

Aplicați politica pentru a permite Nginx să acorde acces la PostgreSQL.

$ sudo setsebool -P httpd_can_network_connect_db 1

Aplicați politica pentru a permite conexiunile cu gazde externe.

$ sudo setsebool -P httpd_can_network_connect 1

Cu MariaDB 10.11, te vei confrunta cu o altă problemă și anume că SELinux împiedică PHP-FPM să se conecteze la MariaDB. Acest lucru poate fi rezolvat prin instalarea unui modul SELinux. Primul pas este crearea unui type enforcementfișier.

Creați fișierul my-phpfpm.teîn directorul dvs. de acasă și deschideți-l pentru editare.

$ cd ~
$ nano my-phpfpm.te

Lipiți următorul cod în el.

module my-phpfpm 1.0;

require {
        type unconfined_service_t;
        type httpd_t;
        type httpd_sys_content_t;
        class dir write;
        class unix_stream_socket connectto;
}

#============= httpd_t ==============

#!!!! This avc is allowed in the current policy
allow httpd_t httpd_sys_content_t:dir write;

#!!!! This avc is allowed in the current policy
allow httpd_t unconfined_service_t:unix_stream_socket connectto;

Salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Următorul pas este să îl convertiți într-un modul de politică folosind următoarea comandă. Nu modificați numele fișierului în comandă, altfel nu va funcționa. Modulul este numit my-phpfpmși numele fișierului ar trebui să fie același cu numele modulului.

$ sudo checkmodule -M -m -o my-phpfpm.mod my-phpfpm.te

Apoi, trebuie să compilam modulul de politici pentru a crea un pachet de politici.

$ sudo semodule_package -o my-phpfpm.pp -m my-phpfpm.mod

Pasul final este să încărcați pachetul de politici utilizând semodulecomanda care instalează politica de utilizat.

$ sudo semodule -i my-phpfpm.pp

Pasul 11 ​​- Configurați Nginx

Deschideți fișierul /etc/nginx/nginx.confpentru editare.

$ sudo nano /etc/nginx/nginx.conf

Adăugați următoarea linie înainte de linie include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size 64;

Salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Creați și deschideți fișierul /etc/nginx/conf.d/craftcms.confpentru editare.

$ sudo nano /etc/nginx/conf.d/craftcms.conf

Lipiți următorul cod în el. Înlocuiește-l craftcms.example.comcu numele tău de domeniu. Asigurați-vă că valoarea client_max_body_sizeeste setată la 128MB, ceea ce am setat pentru Craft CMS în timp ce configurați PHP mai devreme.

server {

    listen 443 ssl http2;
    listen [::]:443 ssl http2;

    server_name craftcms.example.com;
    root /var/www/html/craftcms/web;

    index index.php;
    client_max_body_size 128M;

    access_log  /var/log/nginx/craftcms.access.log;
    error_log   /var/log/nginx/craftcms.error.log;

    ssl_certificate      /etc/letsencrypt/live/craftcms.example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/craftcms.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/craftcms.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;

    location / {
        try_files $uri/index.html $uri $uri/ /index.php?$query_string;
    }

    location ~ [^/]\.php(/|$) {
        try_files $uri $uri/ /index.php?$query_string;
        fastcgi_index index.php;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_keep_conn on;
        include fastcgi_params;
        fastcgi_pass unix:/run/php-fpm/www.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
        fastcgi_param HTTP_PROXY "";
    }
}
# enforce HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name  craftcms.example.com;
    return 301   https://$host$request_uri;
}

Salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Verificați configurația dvs. Nginx.

$ sudo nginx -t

Reporniți serverul Nginx.

$ sudo systemctl reporniți nginx

Pasul 12 – Accesați Craft CMS

Deschideți adresa URL https://craftcms.example.comîn browser și veți fi direcționat la următoarea pagină.

Pentru a accesa pagina de administrare, vizitați adresa URL https://craftcms.example.com/adminși veți fi direcționat către pagina de autentificare.

Introduceți acreditările dvs. de administrare și faceți click pe tasta Conectare pentru a vă conecta. Veți fi direcționat la următorul tablou de bord.

Acum puteți începe să utilizați Craft CMS pentru a vă construi site-ul web.

Pasul 13 – Backup și restaurare Craft CMS

Puteți face copii de rezervă ale bazei de date Craft CMS din interiorul panoului de administrare, vizitând Tabloul de bord de administrare >> Utilități >> Backup baze de date.

Faceți clic pe butonul Backup pentru a descărca backupul bazei de date. De asemenea, puteți crea backup folosind terminalul. Rulați următoarea comandă pentru a crea copia de rezervă. Introduceți parola când vi se solicită.

$ mysqldump -u craftcmsuser -p craftcms > ~/craftcms.database.sql

De asemenea, puteți crea copia de rezervă a bazei de date folosind utilitarul de linie de comandă Craft CMS. Avantajul acestui utilitar este că nu trebuie să treceți acreditările bazei de date. Citiți mai multe despre utilitarul consolei de comandă Craft CMS aici .

$ cd /var/www/html/craftcms
$ php craft db/backup ~/
Copierea de rezervă a bazei de date... gata
Fișier de rezervă: /home/navjot/craftcms.database.sql (200.019 KB)

Dacă nu specificați nicio locație în comanda de mai sus, fișierul de rezervă va fi scris în /var/www/html/craftcms/storage/backupsdirector.

Pentru a face backup la fișiere, copiați și salvați întregul /var/www/html/craftcmsfolder.

$ cd /var/www/html
$ tar -zcf ~/craftcms.tar.gz craftcms

Pentru a-l restaura pe un nou server, extrageți fișierele în /var/www/htmlfolder.

$ tar -xzf craftcms.tar.gz -C /var/www/html/

Creați o bază de date cu aceleași acreditări pe noul server și restaurați baza de date folosind următoarea comandă. Introduceți parola când vi se solicită.

$ mysqlimport -u craftcmsuser -p craftcms craftcms.database.sql

Pasul 14 – Actualizați CMS Craft

Există două moduri de a actualiza Craft CMS. Unul este din interiorul panoului de administrare. Când o actualizare este disponibilă, veți primi o notificare. Faceți clic pe notificare pentru a face upgrade. Craft CMS va face backup automat pentru baza de date înainte de a efectua o actualizare.

De asemenea, îl puteți actualiza prin terminal.

Pentru a verifica toate actualizările disponibile, executați următoarea comandă.

$ cd /var/www/html/craftcms/
$ php craft update

Dacă este disponibilă o actualizare, rulați următoarea comandă pentru a o aplica.

$ php craft update all
[mai mult...]

Cum se instalează și se utilizează Nessus Vulnerability Scanner pe Ubuntu 24.04

Pentru a instala Nessus pe un sistem Linux, puteți descărca cu ușurință pachetul (DEB sau RPM) și apoi îl puteți instala manual prin comanda „ dpkg ” pentru Debian sau „rpm” pentru sistemul de operare RedHat. În cele din urmă, puteți porni serviciul Nessus prin „ systemctl ”.

Descărcați fișierul Nessus DEB utilizând comanda „curl” de mai jos. Asigurați-vă că vizitați pagina de descărcare Nessus pentru a obține cea mai recentă versiune.

curl --request GET \ 
--url '<https://www.tenable.com/downloads/api/v2/pages/nessus/files/Nessus-10.8.3-ubuntu1604_amd64.deb>' \ 
--output 'Nessus-10.8.3-ubuntu1604_am'64.3-ubuntu1604_am'

Odată descărcat, rulați comanda „ dpkg ” de mai jos pentru a instala Nessus prin fișierul DEB.

sudo dpkg -i Nessus-10.8.3-ubuntu1604_amd64.deb

După finalizarea instalării, rulați următoarea comandă „ systemctl ” pentru a porni și a activa serviciul „ nessusd ”. Apoi, verificați-l pentru a vă asigura că serviciul funcționează.

sudo systemctl enable --acum nessusd 
sudo systemctl status nessusd

În rezultatul de mai jos, puteți vedea că „ nessusd ” este activat și rulează.

Configurarea UFW (Firewall necomplicat)

Acum că rulați Nessus, să configuram UFW (Uncomplicated Firewall) și să deschidem porturile pentru OpenSSH și portul „8834/tcp” pentru tabloul de bord Nessus.

Rulați comanda „ufw” de mai jos pentru a activa profilul „ OpenSSH ” pentru a permite accesul SSH, apoi deschideți portul „ 8834/tcp ” pentru aplicația web Nessus.

sudo ufw allow OpenSSH 
sudo ufw allow 8834/tcp

Acum rulați comanda de mai jos pentru a porni și activa UFW, apoi introduceți „y” pentru a confirma. Veți obține o ieșire precum „ Firewall-ul este activ și activat la pornirea sistemului ”.

sudo ufw enable

n cele din urmă, verificați UFW cu următoarea comandă. Veți vedea acel UFW cu starea „ activ ” și permis accesul la „ OpenSSH ” și portul „ 8834/tcp ”.

sudo ufw status

Expertul de instalare Nessus

Acum că ați deschis portul „8834/tcp”, sunteți gata să configurați asistentul de instalare Nessus din browserul dvs. web. Deschideți browserul web și vizitați https://192.168.10.60:8834 . Dacă instalarea Nessus are succes, veți primi asistentul de instalare Nessus.

Faceți click pe „ Continuați ” pentru a începe configurarea Nessus.

Înregistrați-vă la Tenable introducând numele și prenumele și adresa de e-mail. Codul de activare va fi trimis pe e-mailul dvs., așa că asigurați-vă că utilizați e-mailul corespunzător.

Când este activat, veți vedea următoarele:

Acum introduceți numele de utilizator și parola care vor fi folosite pentru a vă conecta la tabloul de bord Nessus.

În continuare, instalarea ar trebui să înceapă. Acest Nessus descarcă pluginurile necesare.

După finalizarea procesului, vi se va solicita pagina de autentificare Nessus. Introduceți numele de utilizator și parola, apoi faceți clic pe „ Conectați-vă”.

Dacă aveți acreditările corecte, veți vedea următorul tablou de bord Nessus.

Dacă instalarea pluginului eșuează, puteți instala plugin-uri Nessus prin utilitarul „ nessuscli ”.

cd /opt/nessus/sbin 
./nessuscli update

Adăugarea lui Nessus la System PATH

Implicit, Nessus este instalat în directorul „ /opt/nessus ”. Există, de asemenea, două directoare bin pentru comanda Nessus. În această secțiune, veți adăuga directorul bin Nessus la calea sistemului prin intermediul fișierului „ ~/.bashrc ”.

Deschideți fișierul „ ~/.bashrc ” cu editorul „vim”.

vim ~/.bashrc

Lipiți următoarea configurație pentru a adăuga calea binară Nessus „ /opt/nessus/bin ” și „/opt/nessus/sbin” la calea sistemului PATH .

export $PATH:/opt/nessus/bin:/opt/nessus/sbin

Salvați fișierul și ieșiți din editor.

Acum rulați comanda de mai jos pentru a reîncărca fișierul „ ~/.bashrc ” în sesiunea curentă și verificați calea sistemului . Veți vedea directoarele „ /opt/nessus/bin ” și „ /opt/nessus/sbin ” disponibile în PATH.

source ~/.bashrc 
echo $PATH

Acum puteți rula comanda „ nessuscli ” ca orice altă comandă. Comanda de mai jos va afișa calea completă a fișierelor binare „nessuscli” și „nessusd”.

which nessuscli
which nessusd

Scanează cu Nessus

În această secțiune, veți învăța cum să scanați cu Nessus și să generați rapoarte HTML pentru scanare. Această secțiune va folosi tabloul de bord de administrare Nessus.

  • Pe tabloul de bord Nessus, faceți clic pe butonul Scanare nouă
  • Selectați șablonul Basic Network Scan

  • Introduceți numele scanării, descrierea, folderul implicit pentru a salva rezultatul scanării și adresa IP țintă sau numele gazdei

  • Odată creat, faceți clic pe butonul de redare  pentru a începe scanarea

  • După scanare, puteți vedea următorul rezultat:

Faceți clic pe meniul „ Rapoarte ” pentru a genera un raport HTML al rezultatului scanării. Mai jos este rezultatul scanării noastre pe pagina HTML.

[mai mult...]

Cum se instalează software-ul de bugetare reală pe serverul Debian 12

Înainte de a instala Actual, trebuie să vă asigurați că Node.js, Git și managerul de pachete Yarn sunt instalate pe sistemul dumneavoastră. În acest moment, Actual necesită Node v18 sau mai recent, care poate fi instalat din depozitul oficial Debian.

Mai întâi, rulați comanda „ apt ” de mai jos pentru a vă actualiza indexul pachetelor Debian și pentru a instala pachete de bază, cum ar fi Node.js, NPM și Git. Introdu „ Y ” pentru a confirma instalarea.

sudo apt update 
sudo apt install nodejs npm git

Accesați directorul „ server actual ” și instalați dependențe JavaScript cu comanda „ yarn ” de mai jos.

cd actual-server 
yarn install

Puteți vedea mai jos instalarea dependențelor JavaScript prin managerul de pachete Yarn.

Se descarcă codul sursă al bugetului real

După ce dependențele sunt instalate, sunteți gata să descărcați codul sursă Actual, să instalați dependențe prin Yarn, să configurați Actual cu fișierul „config.json” și apoi să rulați Actual prin linia de comandă. De asemenea, aveți nevoie de un utilizator dedicat pentru a instala și rula Actual pe sistemul dumneavoastră.

Conectați-vă la utilizatorul dvs. cu comanda de mai jos.

su - username

Descărcați codul sursă al bugetului real cu comanda „ git ” de mai jos.

git clone https://github.com/actualbudget/actual-server.git

ccesați directorul „ server actual ” și instalați dependențe JavaScript cu comanda „ yarn ” de mai jos.

cd actual-server 
yarn install

Puteți vedea mai jos instalarea dependențelor JavaScript prin managerul de pachete Yarn. După finalizarea instalării, creați un nou fișier „ config.json ” folosind editorul „ nano ”.

nano config.json

Introduceți configurația de mai jos pentru a rula Actual pe adresa IP locală cu portul implicit 5006.

{ 
"hostname": "127.0.0.1", 
"port": 5006 
}

Salvați fișierul și ieșiți din editor.

În cele din urmă, rulați comanda „ pornire fire ” de mai jos pentru a porni software-ul propriu-zis. Aceasta va deschide portul 5006 pe localhost sau adresa „ 127.0.0.1 ” care va fi folosită de aplicație.

yarn start

Apăsați Ctrl+c pentru a încheia procesul.

Acum că ați instalat și configurat Actual, să creăm un nou fișier de serviciu systemd pentru rularea Actual în fundal ca serviciu systemd.

Creați un nou fișier de serviciu systemd „ /etc/systemd/system/actual.service ” cu următorul editor „ nano ”.

sudo nano /etc/systemd/system/actual.service

Introduceți configurația de mai jos pentru a rula Actual în fundal ca serviciu systemd. Asigurați-vă că schimbați „ Utilizator ” și „ Grup ” implicit cu numele dvs. de utilizator, apoi schimbați „Directorul de lucru ” cu calea corectă.

[Unit] 
Description=Actual-Server (https://actualbudget.org) 
After=network.target 

[Service] 
User=flash 
Group=flash 
WorkingDirectory=/home/flash/actual-server/ 
ExecStart=/usr/local/bin/yarn start 
Restart=on-watchdog 

[Install] 
WantedBy=multi-user.target

Salvați fișierul și părăsiți editorul când ați terminat.

Acum rulați comanda „ systemctl ” de mai jos pentru a reîncărca managerul systemd și a aplica modificările.

sudo systemctl daemon-reload

Apoi, porniți și activați „ actual.service ” folosind următoarea comandă. Acest lucru va porni „ actual.service ” în fundal și îl va permite să ruleze automat la pornirea sistemului.

sudo systemctl enable --now actual.service

Verificați starea „ actual.service ” cu comanda de mai jos. Ar trebui să vedeți că „ actual.service ” rulează și este activat pe sistemul dumneavoastră.

sudo systemctl status actual.service

În acest moment, Actual este activ și rulează în fundal ca un serviciu systemd. În această secțiune, veți instala Nginx și îl veți configura ca proxy invers pentru Actual. După aceea, veți genera certificate SSL pentru implementarea dvs. reală prin Certbot și Letsencrypt.

Mai întâi, rulați comanda „ apt ” de mai jos pentru a instala pluginul Nginx, Certbot și Python3 Certbot Nginx. Introdu „ Y ” pentru a continua cu instalarea.

sudo apt install nginx certbot python3-certbot-nginx -y

După finalizarea instalării, creați un nou fișier bloc al serverului Nginx „ /etc/nginx/sites-available/actual-budget ” cu editorul „ nano ”.

sudo nano /etc/nginx/sites-available/actual-budget

Introduceți configurația de mai jos și asigurați-vă că modificați parametrul „ server_name ” cu numele domeniului dumneavoastră.

server {
listen 80;
server_name budget.howtoforge.local;

location / {
include /config/nginx/proxy.conf;
include /config/nginx/resolver.conf;

proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;

set $upstream_app 127.0.0.1;
set $upstream_port 5006;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
}
}

Când ați terminat, salvați fișierul și ieșiți din editor. Acum rulați comanda de mai jos pentru a activa blocul de server „ buget real ” și pentru a verifica configurațiile dvs. Nginx. Dacă nu există nicio eroare, veți obține o ieșire precum „ sintaxa este ok – testul a reușit ”.

sudo ln -s /etc/nginx/sites-available/actual-budget /etc/nginx/sites-enabled/ 
sudo nginx -t

Apoi, rulați comanda de mai jos pentru a reporni și a verifica starea serviciului Nginx. Asigurați-vă că serverul web Nginx rulează.

sudo systemctl restart nginx 
sudo systemctl status nginx

În cele din urmă, rulați comanda „ cerbot ” de mai jos pentru a genera certificate SSL și a vă asigura instalarea actuală a software-ului. Asigurați-vă că schimbați numele domeniului și adresa de e-mail în următoarea comandă.

sudo certbot --nginx --agree-tos --redirect --hsts --staple-ocsp --email < alice@howtoforge.local > -d budget.howtoforge.local

Când procesul este încheiat, instalarea dvs. reală ar trebui să fie securizată cu HTTPS prin Certbot și Letsencrypt. Certificatele dvs. SSL sunt disponibile în directorul „ /etc/letsencrypt/live/domain.com ” iar HTTPS este activat automat pe fișierul blocat de server. Vizitați numele de domeniu al instalării dvs. actuale, cum ar fi https://budget.local . Dacă reușiți, veți vedea mesajul de bun venit către Actual și vă va solicita să configurați o parolă.

Introduceți noua parolă și repetați, apoi faceți clic pe „ OK”.

Odată ce parola este configurată, introduceți parola pentru a vă conecta la Tabloul de bord real.

Pentru prima dată, vi se va cere să vizualizați datele demonstrative sau să începeți din nou. Dacă sunteți familiarizat cu Actual, puteți face clic pe „ Începe proaspăt ”, dar dacă sunteți nou la Actual, faceți clic pe „ Vizualizare demo ” pentru a înțelege utilizarea de bază reală.

Mai jos este un exemplu de date demonstrative din sistemul de bugetare reală.

[mai mult...]

Cum se instalează Emby Media Server pe Debian 12

Emby este o alternativă open-source la Plex Media Server. Emby acceptă mai multe sisteme de operare, cum ar fi Linux, FreeBSD, Windows și MacOS. În ceea ce privește clienții, acesta acceptă aproape orice dispozitiv, de la smartphone-uri la desktop. Aceasta înseamnă că vă puteți accesa fișierele media aproape oriunde.

Emby Media Server este un server media open-source care acceptă mai multe sisteme de operare, cum ar fi FreeBSD, Linux și Windows. Puteți instala cu ușurință Emby Media Server descărcând pachete specifice pentru sistemele dvs. de operare.

Pentru a începe, rulați următoarea comandă pentru a vă actualiza depozitul Debian și pentru a actualiza toate pachetele la cea mai recentă versiune.

sudo apt update && sudo apt upgrade 
sudo reboot

Acum vizitați  Pagina de descărcare Emby și copiați linkul către cea mai recentă versiune de Emby. Asigurați-vă că ați selectat distribuția ca Debian. Apoi, descărcați Emby folosind comanda wget de mai jos.

wget https://github.com/MediaBrowser/Emby.Releases/releases/download/4.7.14.0/emby-server-deb_4.7.14.0_amd64.deb

Odată descărcat, rulați comanda dpkg de mai jos pentru a instala Emby pe mașina dvs. Debian.

sudo dpkg -i emby-server-deb_*.deb 
sudo apt install -f

După ce Emby este instalat, serviciul emby-server ar trebui să ruleze și să fie activat automat. Rulați comanda systemctl de mai jos pentru a o verifica.

sudo systemctl is-enabled emby-server
sudo systemctl status emby-server

Asigurați-vă că starea serviciului emby-server rulează și este activată după cum urmează:

În mod implicit, emby-server rulează pe portul 8096 . Rulați comanda ss de mai jos pentru a verifica porturile LISTEN de pe sistemul dvs.

ss -tulpn

Asigurați-vă că emby-server rulează pe ambele porturi 8096

Instalarea și configurarea Nginx ca proxy invers

În acest tutorial, veți rula Emby cu Nginx ca proxy invers. Acum, veți începe instalarea Nginx și veți crea o nouă configurație de bloc de server care va fi folosită ca proxy invers. Așadar, înainte de asta, asigurați-vă că aveți un nume de domeniu îndreptat către adresa IP a serverului dvs., indiferent dacă este domeniul local sau domeniul public.

Instalați Nginx pe serverul dvs. Debian folosind următoarea comandă apt. Tastați y pentru a confirma și apăsați ENTER pentru a continua.

sudo apt install nginx

Acum rulați comanda de mai jos pentru a verifica serviciul nginx și pentru a vă asigura că serviciul rulează și este activat.

sudo systemctl is-enabled nginx
sudo systemctl status nginx

Dacă nginx rulează, ar trebui să obțineți o ieșire activă (în rulare) , în timp ce este activată, veți vedea o ieșire precum enabled.

Apoi, creați o nouă configurație de bloc de server Nginx /etc/nginx/sites-available/emby-server folosind următoarea comandă de editor nano. Acesta va fi folosit ca proxy invers pentru instalarea dvs. Emby.

sudo nano /etc/nginx/sites-available/emby-server

Adăugați următoarea configurație și asigurați-vă că schimbați numele domeniului în parametrii server_name și add_header Content-Security-Policy .

server {
 listen 80;
 server_name emby.howtoforge.local; #your subdomain.domainname.com here
 
 proxy_hide_header X-Powered-By;
 add_header X-Xss-Protection "1; mode=block" always;
 add_header X-Content-Type-Options "nosniff" always;
 add_header Strict-Transport-Security "max-age=2592000; includeSubdomains" always;
 add_header X-Frame-Options "SAMEORIGIN" always;
 add_header 'Referrer-Policy' 'no-referrer';

 add_header Content-Security-Policy "frame-ancestors mydomain.com emby.mydomain.com;"; #add your domainname and all subdomains listed on your cert
 

 location / {
 proxy_pass http://127.0.0.1:8096; # Local emby ip and non SSL port

 proxy_hide_header X-Powered-By;
 proxy_set_header Range $http_range;
 proxy_set_header If-Range $http_if_range;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header Host $host;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

 #Next three lines allow websockets
 proxy_http_version 1.1;
 proxy_set_header Upgrade $http_upgrade;
 proxy_set_header Connection "upgrade";
 }
}

Salvați fișierul și părăsiți editorul când ați terminat.

Acum rulați comanda de mai jos pentru a activa configurația blocului serverului /etc/nginx/sites-available/emby-server și verificați configurația sintaxei Nginx.

sudo ln -s /etc/nginx/sites-available/emby-server /etc/nginx/sites-enabled/
sudo nginx -t

Dacă aveți o sintaxă Nginx adecvată, ar trebui să obțineți o ieșire precum „ sintaxa este ok – testul este de succes ”.

Acum reporniți serviciul nginx pentru a aplica noua configurație de bloc de server.

sudo systemctl restart nginx

Configurarea UFW (Firewall necomplicat)

În acest ghid, veți rula Emby cu UFW activat. Așadar, asigurați-vă că finalizați acest pas pentru a instala UFW și pentru a adăuga profiluri atât pentru OpenSSH, cât și pentru Nginx Full pentru a deschide traficul SSh, HTTP și HTTPS.

Instalați UFW (Uncomplicated Firewall) folosind următoarea comandă apt. Tastați y pentru a confirma instalarea.

sudo apt install ufw

După finalizarea instalării, rulați următoarea comandă ufw pentru a activa profilurile OpenSSH și Nginx Full . Aceasta va deschide porturi pentru protocoalele SSH , HTTP și HTTPS.

sudo ufw allow OpenSSH 
sudo ufw allow „Nginx Full”

Acum rulați comanda de mai jos pentru a porni și a activa UFW. Tastați y pentru a confirma și a rula UFW.

sudo ufw enable

Când este activat, ar trebui să obțineți o ieșire precum „ Firewall-ul este activ și activat la pornirea sistemului ”.

Acum rulați comanda de mai jos pentru a verifica instalarea UFW.

sudo ufw status

Veți vedea UFW cu starea Activ și profilurile OpenSSH și Nginx Full sunt activate.

Dacă rulați Emby în rețeaua locală, puteți genera un certificat autosemnat pentru a vă asigura instalarea. Pentru domeniul public, este mai bine să utilizați certificate SSl/TLS de la Letsencrypt.

În această secțiune, veți genera certificate SSL/TLS de la letsencrypt prin Certbot. Instalați Certbot și pluginul Certbot nginx folosind comanda de mai jos. Tastați y pentru a confirma instalarea.

sudo apt install certbot python3-certbot-nginx

Odată ce instalarea este finalizată, rulați comanda certbot de mai jos pentru a genera certificate SSL/TLS pentru instalarea dvs. Emby. Asigurați-vă că schimbați informațiile despre numele domeniului și adresa de e-mail cu informațiile dvs.

certbot --nginx --agree-tos --redirect --hsts --staple-ocsp --email bob@howtoforge.local -d emby.howtoforge.local

Odată ce procesul este terminat, fișierele dvs. de certificat SL vor fi disponibile în directorul /etc/letsencrypt/live/domain.com . De asemenea, configurația blocului serverului dvs. Nginx se va configura automat configurată cu HTTPS, care este completată de pluginul Certbot Nginx.

Instalarea Emby Media Server

Lansați browserul web și vizitați numele de domeniu al instalării Emby Media Server (adică: http://emby.howtoforge.local/ ).

Dacă instalarea dvs. are succes, ar trebui să primiți un mesaj de bun venit, cum ar fi „ Bine ați venit la Emby ”. Selectați limba preferată din meniul drop-down și faceți clic pe Următorul.

Creați-vă primul utilizator Emby și asigurați-vă că ați introdus parola puternică. Apoi faceți clic din nou pe Următorul pentru a continua.

Când vi se cere să creați o nouă bibliotecă, puteți face clic pe butonul Bibliotecă nouă sau puteți face clic pe Următorul pentru a continua. Puteți adăuga biblioteca dvs. media mai târziu, după finalizarea instalării.

Selectați limba de date metadate pe care o preferați și faceți clic pe Următorul pentru a continua.

Asigurați-vă că bifați „ Activați maparea automată a portului ” pentru a activa maparea automată a portului. Faceți clic pe Următorul pentru a continua.

Acum bifați opțiunea „ Accept termenii și condițiile” și faceți click pe Următorul.După finalizarea procesului, veți primi mesajul Ați terminat!. Faceți click pe Terminare pentru a finaliza instalarea.

  • Acum faceți clic pe utilizatorul dvs. pentru a vă conecta la Emby Media Server
  • Introduceți utilizatorul și parola de administrator, apoi faceți clic pe Conectare

Dacă aveți utilizatorul și parola adecvate, veți obține tabloul de bord Emby ca următorul:

[mai mult...]

Cum se instalează WildFly Application Server cu Nginx Reverse Proxy pe Debian 12

WildFly, fost JBoss, este un server de aplicații gratuit și open-source care vă ajută să construiți și să implementați aplicații web Java. Este scris în Java și este compatibil cu specificațiile Java EE (Enterprise Edition). WildFly a fost creat de JBoss, dar acum este dezvoltat de RedHat. Este un server de aplicații puternic, gata de producție, modular și ușor, care oferă toate instrumentele și caracteristicile necesare pentru a rula și a implementa aplicații web Java.

WildFly este un server de aplicații multiplatformă care oferă instrumente pentru aplicații Java, cum ar fi EJB-uri, JPA, Servlet-uri, JAX-RS, Batch și securitate.

Înainte de a merge mai departe, adună următoarele:

  • Un server Debian 12 cu 4 GB sau mai multă memorie.
  • Un utilizator non-root cu privilegii de administrator sudo.

Instalarea Java OpenJDK

WildFly este o aplicație Java flexibilă și ușoară pentru a crea aplicații. În această secțiune, veți instala și utiliza Java OpenJDK 17 pentru a instala WildFly pe serverul dumneavoastră Debian.

Mai întâi, rulați următoarea comandă pentru a vă actualiza depozitul Debian.

sudo apt update

Acum, instalați pachetul Java OpenJDK executând comanda de mai jos. Aceasta va instala pachetul implicit-jdk, care este echivalent cu versiunea Java OpenJDK 17 LTS (Suport pe termen lung).

sudo apt install default-jdk

Introduceți y pentru a continua instalarea.

După ce ați instalat Java, verificați versiunea Java folosind comanda de mai jos. Ar trebui să vedeți că Java OpenJDK 17 este instalat.

versiunea java

Instalarea și configurarea WildFly

După ce ați instalat Java OpenJDK, puteți începe instalarea WildFly completând următoarele sarcini:

  • Adăugarea utilizatorului și grupului wildfly
  • Descărcarea pachetului binar WildFly
  • Configurarea instalării WildFly
  • Rularea WildFly ca serviciu Systemd

Să începem.

Adăugarea utilizatorului și grupului wildfly

Mai întâi, veți crea un nou utilizator de sistem și un grup wildfly care va fi folosit pentru a rula instalarea WildFly.

Executați comanda de mai jos pentru a adăuga un nou grup și utilizator numit wildfly executând următoarea comandă. Cu aceasta, veți configura și directorul de pornire implicit pentru utilizatorii wildfly la /opt/wildfly , care va fi folosit ca director de instalare WildFly.

sudo groupadd -r wildfly 
sudo useradd -r -g wildfly -d /opt/wildfly -s /sbin/nologin wildfly

Descărcarea pachetului binar WildFly

După adăugarea unui utilizator systemd, veți descărca pachetul binar WildFly prin wget. Asigurați-vă că vizitați pagina de descărcare WildFly pentru a obține cea mai recentă versiune a acesteia.

Înainte de aceasta, instalați dezarhivarea prin următoarea comandă apt.

sudo apt install unzip -y

După aceea, vizitați pagina de descărcare WildFly și copiați linkul către cea mai recentă versiune WildFly. Descărcați pachetul binar WildFly prin comanda wget, ca următorul. În acest exemplu, veți instala WildFly 30.0.0.

wget https://github.com/wildfly/wildfly/releases/download/30.0.0.Final/wildfly-30.0.0.Final.zip

Apoi, dezarhivați pachetul binar WildFly și mutați directorul extras în /opt/wildfly.

unzip wildfly-30.0.0.Final.zip 
sudo mv wildfly-30.0.0.Final /opt/wildfly

În cele din urmă, rulați comanda de mai jos pentru a schimba proprietatea directorului /opt/wildfly la utilizatorul wildfly.

sudo chown -RH wildfly: /opt/wildfly

Configurarea instalării WildFly

În acest exemplu, veți instala WildFly pe o singură mașină în modul de sine stătător. Deci, fiecare configurație pe care o modificați aici este legată de configurațiile autonome WildFly.

Lansați următoarea comandă nano editor pentru a deschide fișierul /opt/wildfly/bin/standalone.conf .

sudo nano /opt/wildfly/bin/standalone.conf

Modificați valoarea  Xmx512m  din variabila de mediu  JBOSS_JAVA_SIZING pentru a crește dimensiunea implicită a memoriei heap maximă a WildFly, după cum urmează .

Asigurați-vă că ajustați dimensiunea maximă a memoriei heap cu serverul dvs. actual. Următorul exemplu setează memoria heap maximă la 4 GB .

  JBOSS_JAVA_SIZING="-Xms64m -Xmx4096m -XX:MetaspaceSize=96M -XX:MaxMetaspaceSize=256m"

Salvați și părăsiți fișierul când ați terminat.

Acum creați un nou director de configurare /etc/wildfly folosind comanda de mai jos.

sudo mkdir -p /etc/wildfly

Copiați fișierul de configurare WildFly în /etc/wildfly/wildfly.conf și deschideți-l folosind următoarea comandă a editorului nano.

sudo cp /opt/wildfly/docs/contrib/scripts/systemd/wildfly.conf /etc/wildfly/ 
sudo nano /etc/wildfly/wildfly.conf

Schimbați WILDFLY_BIND implicit la 127.0.0.1 și adăugați o variabilă WILDFLY_CONSOLE_BIND pentru a activa administrarea consolei WildFly. Atât WildFly, cât și consola de administrare vor rula în localhost.

# Adresa de legat la 
WILDFLY_BIND=127.0.0.1 

# Activați administratorul 
WILDFLY_CONSOLE_BIND=127.0.0.1

Când ați terminat, salvați și ieșiți din fișier.

Apoi, copiați scriptul de lansare WildFly în /opt/wildfly/bin/launch.sh și faceți-l executabil prin comanda chmod de mai jos

sudo cp /opt/wildfly/docs/contrib/scripts/systemd/launch.sh /opt/wildfly/bin/ 
sudo chmod +x /opt/wildfly/bin/*.sh

Deschideți scriptul de lansare WildFly /opt/wildfly/bin/launch.sh folosind următoarea comandă a editorului nano.

sudo nano /opt/wildfly/bin/launch.sh

Introduceți noua opțiune de comandă „ -bmanagement $4 ” pentru a activa consola de administrare WildFly astfel.

if [[ "$1" == "domeniu" ]]; then 
    $WILDFLY_HOME/bin/domain.sh -c $2 -b $3 -bmanagement $4 
else 
    $WILDFLY_HOME/bin/standalone.sh -c $2 -b $3 -bmanagement $4 
fi

Salvați și închideți fișierul când ați terminat.

În cele din urmă, rulați comanda de mai jos pentru a schimba  directorul de instalare WildFly  /opt/wildfly proprietatea  la utilizatorul wildfly.

sudo chown -RH wildfly: /opt/wildfly

Rularea WildFly ca serviciu Systemd

După configurarea WildFly ca mod independent, veți configura un fișier de serviciu systemd pentru WildFly. Acest lucru vă permite să rulați WIldFly în fundal și să gestionați WildFly cu ușurință prin utilitarul systemctl.

Copiați fișierul serviciului WildFly systemd în /etc/systemd/system/wildfly.service și modificați-l utilizând comanda editorului nano de mai jos.

sudo cp /opt/wildfly/docs/contrib/scripts/systemd/wildfly.service /etc/systemd/system/ 
sudo nano /etc/systemd/system/wildfly.service

În cadrul opțiunii ExecStart , adăugați un nou parametru de pornire $WILDFLY_CONSOLE_BIND pentru a activa consola de administrare WildFly.

ExecStart=/opt/wildfly/bin/launch.sh $WILDFLY_MODE $WILDFLY_CONFIG $WILDFLY_BIND $WILDFLY_CONSOLE_BIND

Când ați terminat, salvați fișierul și ieșiți din editor.

Apoi, rulați comanda systemctl de mai jos pentru a reîncărca managerul systemd.

sudo systemctl daemon-reload

Apoi porniți și activați serviciul wildfly folosind comanda de mai jos.

sudo systemctl start wildfly 
sudo systemctl enable wildfly

Verificați serviciul wildfly pentru a vă asigura că serviciul rulează executând următoarea comandă.

sudo systemctl status wildfly

Dacă serviciul wildfly rulează, va fi afișată următoarea ieșire.

De asemenea, puteți verifica lista de porturi deschise pe sistemul dvs. executând următoarea comandă.

ss -antpl | grep -i java

Ar trebui să vedeți mai multe porturi 8080, 8443 și 9990 pe care le folosește WildFly.

Adăugarea de gestionare a utilizatorilor WildFly

După instalarea WildFly, veți crea un nou utilizator administrator pentru WildFly prin intermediul scriptului /opt/wildfly/bin/add-user.sh .

Rulați scriptul /opt/wildfly/bin/add-user.sh după cum urmează.

sh /opt/wildfly/bin/add-user.sh

Acum veți fi întrebat cu următoarele:

  • Introduceți a pentru a crea un nou utilizator de gestionare WildFly.
  • Introduceți utilizatorul și parola de administrator, apoi repetați-o.
  • Apăsați ENTER când vi se cere configurarea grupului.
  • Introduceți da pentru a vă adăuga utilizatorul la ManagementRealm.

Odată ce procesul este încheiat, ar trebui să vedeți că noul dvs. utilizator a fost adăugat la configurația WildFly.

Configurarea Nginx ca proxy invers

În acest moment, ați realizat instalarea WildFLy, ați activat consola de administrare și ați creat utilizatorul administrator. Următorul pas este să instalați Nginx și să îl configurați ca proxy invers pentru WildFly.

Executați comanda apt de mai jos pentru a instala Nginx pe serverul dvs. Debian. Introduceți y pentru a continua instalarea.

sudo apt install nginx

Odată ce Nginx este instalat, îl veți configura ca proxy invers pentru WildFly.

Creați o nouă configurație pentru anteturile proxy Nginx /etc/nginx/conf.d/proxy_headers.conf utilizând comanda editorului nano de mai jos.

sudo nano /etc/nginx/conf.d/proxy_headers.conf

Introduceți următoarea configurație în fișier.

``` 
proxy_set_header Gazdă $gazdă; 
proxy_set_header X-Forwarded-Proto $schema; 
add_header Front-End-Https activat; 
add_header Cache-Control fără cache; 
```

Salvați și părăsiți fișierul când ați terminat.

Apoi, lansați următoarea comandă nano editor pentru a crea o nouă configurație de bloc de server Nginx /etc/nginx/sites-available/wildfly .

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

Introduceți configurația de mai jos pentru a configura Nginx ca proxy invers pentru instalarea WildFly. Asigurați-vă că schimbați domeniul în cadrul opțiunii server_name , puteți utiliza un nume de domeniu local.

server { 
    listen 80; 
    nume_server wildfly.howtoforge.local; 

    locație / { 
        include conf.d/proxy_headers.conf; 
        proxy_pass http://127.0.0.1:8080; 
    } 

    location /management { 
        include conf.d/proxy_headers.conf; 
        proxy_pass http://127.0.0.1:9990/management; 
    } 

    location /consola { 
        include conf.d/proxy_headers.conf; 
        proxy_pass http://127.0.0.1:9990/console; 
    } 

    location /logout { 
        include conf.d/proxy_headers.conf; 
        proxy_pass http://127.0.0.1:9990/logout; 
    } 

    location /eroare { 
        include conf.d/proxy_headers.conf; 
        proxy_pass http://127.0.0.1:9990; 
    } 

}

Salvați și închideți fișierul când ați terminat.

Acum rulați comanda de mai jos pentru a activa fișierul gazdă virtual wildfly și pentru a vă verifica sintaxa Nginx.

sudo ln -s /etc/nginx/sites-available/wildfly /etc/nginx/sites-enabled/ 
sudo nginx -t

Dacă aveți o sintaxă Nginx adecvată, va fi afișată rezultatul „ sintaxa este ok—testul a reușit ” .

În cele din urmă, rulați comanda de mai jos pentru a reporni serviciul Nginx și aplicați modificările pe care le-ați făcut. Apoi, verificați serviciul Nginx pentru a vă asigura că serviciul rulează.

sudo systemctl restart nginx 
sudo systemctl status nginx

Dacă Nginx rulează, ar trebui să obțineți ieșirea activă (în rulare) .

Accesarea WildFly prin Client

Pe computerul dvs. client, deschideți fișierul hosts folosind editorul de text. Pentru utilizatorii Windows, deschideți fișierul C:\Windows\System32\drivers\etc\hosts ca administrator, ca și pentru utilizatorii Linux sau macOS, deschideți fișierul /etc/hosts cu privilegii sudo.

Introduceți următoarea configurație și asigurați-vă că schimbați numele de domeniu local și adresa IP cu informațiile dvs.

192.168.5.15 wildfly.howtoforge.local

Salvați și închideți fișierul când ați terminat.

Lansați browserul web și vizitați domeniul local WildFly (de exemplu: http:wildfly.howtoforge.local/). Dacă instalarea dvs. are succes, ar trebui să vedeți pagina de index WildFly implicită, care este după cum urmează:

Acum faceți clic pe linkul Consola de administrare pentru a accesa consola de administrare WildFly. Aceasta va deschide o filă nouă și veți fi redirecționat către consola de administrare WildFly cu calea URL /consola.

Introduceți utilizatorul și parola de administrator pentru consola de administrare WildFly, apoi faceți clic pe Conectare.

Dacă aveți utilizatorul și parola corecte, ar trebui să vedeți consola de administrare WildFly în felul următor.

Apoi, faceți clic pe meniul Runtime și selectați serverul dvs. Ar trebui să vedeți confirmarea că WildFly funcționează.

În cele din urmă, selectați meniul Stare și ar trebui să vedeți starea detaliată a instalării WildFly, inclusiv configurația heap schimbată la 4GB.

[mai mult...]

Cum se instalează Rancher pe serverul Debian 12

Rancher este o platformă open-source de gestionare a containerelor, concepută pentru a facilita implementarea, gestionarea și guvernarea clusterelor Kubernetes. Spre deosebire de o distribuție Kubernetes care înlocuiește Kubernetes în sine, Rancher acționează ca o soluție de management care se află deasupra unuia sau mai multor clustere Kubernetes, oferind o platformă centralizată de pe care administratorii își pot supraveghea întreaga infrastructură de containere.

Înainte de a instala Rancher, trebuie să vă asigurați că Docker este instalat pe sistemul dvs. În această secțiune, veți instala Docker Engine prin intermediul depozitului oficial Docker în sistemul Debian.

Mai întâi, rulați comanda de mai jos pentru a vă actualiza indexul pachetelor și pentru a instala pachete precum „ca-certificates” și „curl”.

sudo apt update && sudo apt install ca-certificates curl -y

Acum executați următoarea comandă pentru a adăuga cheia GPG pentru depozitul Docker.

sudo install -m 0755 -d /etc/apt/keyrings 
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc 
sudo chmod a+r /etc/apt/keyrings/docker.asc

Apoi, rulați următoarea comandă pentru a adăuga depozitul Docker la sistemul dumneavoastră Debian. Aceasta va detecta automat versiunea dvs. Debian.

echo \ 
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \ 
$(. /etc/os-release && echo "$VERSION_CODENAME") stabil" | \ 
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Acum că ați adăugat depozitul Docker și cheia GPG, executați comanda de mai jos pentru a vă reîmprospăta indexul pachetului și pentru a instala Docker Engine în sistem. În acest exemplu, veți instala Docker Engine cu pachete suplimentare, cum ar fi Docker Compose și pluginul Docker Buildx.

sudo apt update && sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Introduceți „Y” pentru a continua instalarea.

Odată ce instalarea este finalizată, verificați starea serviciului Docker folosind comanda „systemctl” de mai jos. Veți vedea că Docker rulează și este activat pe mașina dvs. Debian.

sudo systemctl este activat docker 
sudo systemctl status docker

În cele din urmă, puteți executa comanda „docker” de mai jos pentru a rula containerul „hello-word”.

sudo docker rulează hello-world

Dacă aveți succes, veți primi următorul mesaj „ hello world ” de la Docker.

Acum că Docker este instalat, sunteți gata să instalați Rancher. În această secțiune, veți descărca imaginea Rancher, apoi veți rula containerul Rancher prin Docker. În acest exemplu, vom folosi certificatele autosemnate care sunt generate automat de containerul Rancher. Vom folosi, de asemenea, cea mai recentă versiune a imaginii Rancher.

Descărcați imaginea Rancher folosind comanda „docker pull” de mai jos. În acest exemplu, vom folosi cea mai recentă versiune Rancher.

sudo docker pull rancher/rancher:latest

Odată ce imaginea Rancher este descărcată, executați comanda „docker run” pentru a rula Rancher. Cu aceasta, containerul Rancher va rula în fundal și va exporta porturile 80 și 443 pe serverul Debian gazdă.

sudo docker run -d --restart=unless-stop \ 
-p 80:80 -p 443:443 \ 
--privileged \ 
rancher/rancher:latest

Verificați starea containerului folosind comanda de mai jos.

sudo docker ps

În rezultatul de mai jos, puteți vedea că Rancher rulează pe portul 443 . De asemenea, puteți vedea ID-ul containerului și numele containerului.

În plus, dacă aveți o eroare, puteți verifica jurnalul Racher cu următoarea comandă „docker”.

docker ps -a 
docker log container-name sau container id

Opțiunea „ps -a” vă va afișa containerele care rulează și au ieșit, iar comanda „docker log” este folosită pentru a verifica jurnalele containerului.

În acest moment, Rancher rulează pe sistemul dumneavoastră Debian ca container. Pentru următorul pas, vă veți conecta la tabloul de bord Rancher pentru a vedea nodul unic Kubernetes care rulează deasupra instalării Rancher.

Deschideți browserul web și vizitați adresa IP a serverului Debian, urmată de portul 8080 , cum ar fi https://192.168.10.41:8080/ . Dacă instalarea dvs. este reușită, veți primi următoarea pagină de conectare la Rancher.

Înapoi la terminal și rulați comanda de mai jos pentru a obține parola Rancher. Asigurați-vă că schimbați ID-ul containerului cu instalarea și copiați parola.

sudo docker înregistrează CONTAINER ID 2>&1 | grep „Bootstrap Password:”

Acum introduceți parola și faceți clic pe Conectare cu utilizatorul local.

Apoi, copiați parola generată pentru rancherul dvs. și asigurați-vă că acceptați termenii și licența.

Acum veți vedea următorul tablou de bord Rancher. În exemplul de mai jos, puteți vedea clusterul Kubernetes cu un singur nod creat cu K3s.

Faceți click pe clusterul Kubernetes local și veți obține mai multe informații despre clusterul dvs. Kubernetes.

Mai întâi, descărcați KubeConfig pe computerul local. Din tabloul de bord Rancher, faceți clic pe meniul fișier de mai jos.

Instalați „kubectl” pe sistemul dumneavoastră cu comanda de mai jos. Pe Debian 12, puteți instala pachetul „ kubernetes-client ” prin APT.

sudo apt install kubernetes-client -y

Setați KUBECONFIG implicit la fișierul dvs. În acest exemplu, fișierul KubeConfig este „kubeconfig.yaml”.

exportă KUBECONFIG=~/kubeconfig.yaml

În cele din urmă, rulați comanda „kubectl” de mai jos pentru a obține poduri de listă pe toate spațiile de nume Kubernetes.

kubectl obține pods --all-namespaces

Veți vedea că fiecare pod pentru clusterul Kubernetes din Rancher rulează.

[mai mult...]

Cum se instalează Fast API cu MongoDB pe Ubuntu 24.04

FastAPI este un cadru web bazat pe Python pentru crearea de servicii API. Este un cadru modern, rapid și de înaltă performanță care acceptă operațiuni asincrone.

Pentru a începe cu acest ghid, asigurați-vă că aveți următoarele:

  • Un sistem Ubuntu 24.04
  • Un utilizator non-root cu privilegii de administrator.

Mai întâi, rulați comanda de mai jos pentru a vă actualiza indexul pachetului și instalați „gnupg” și „curl” în sistemul dumneavoastră.

sudo apt update && sudo apt install gnupg curl -y

Executați comanda de mai jos pentru a adăuga cheia GPG pentru serverul MongoDB.

curl -fsSL https://www.mongodb.org/static/pgp/server-8.0.asc | \ 
sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg \ 
--dearmor

Adăugați depozitul MongoDB folosind comanda de mai jos.

echo „deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu noble/mongodb-org/8.0 multiverse” | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list

După ce depozitul este adăugat, rulați următoarea comandă pentru a vă reîmprospăta indexul pachetului și pentru a instala serverul MongoDB. Introduceți „Y” pentru a confirma instalarea.

sudo apt update && sudo apt install mongodb-org

Când instalarea este finalizată, porniți și activați serviciul MongoDB „mongod”, apoi verificați starea serviciului MongoDB pentru a vă asigura că rulează.

sudo systemctl enable --acum mongod 
sudo systemctl status mongod

Puteți vedea mai jos că serverul MongoDB rulează.

În plus, vă puteți conecta la serverul MongoDB cu comanda „mongosh” de mai jos. Pentru a ieși, apăsați Ctrl+d.

mongosh

Cu MongoDB instalat, veți instala pachetele Python și veți configura directorul proiectului și mediul virtual.

Instalați modulele Python, Pip și Venv cu următoarea comandă. Introduceți „Y” pentru a confirma instalarea.

sudo apt install python3 python3-pip python3-venv

Odată ce instalarea este finalizată, conectați-vă la utilizatorul dvs.

su - username

Acum creați un nou director „ ~/app ” și mutați-vă în el. Acest director va fi folosit pentru a stoca proiectul dvs. FastAPI.

mkdir -p ~/app; cd ~/app

Executați comanda de mai jos pentru a crea un nou mediu virtual „ venv ” și activați-l. Cu aceasta, promptul dumneavoastră shell va deveni ca „ (venv) user@hostname ”.

python3 -m venv .venv 
sursă .venv/bin/activate

De aici, mediul tău de lucru trebuie să fie în mediul virtual „venv”. Vă puteți deconecta de la „venv” folosind comanda de mai jos.

deactivate

Acum că ați creat și activat mediul virtual Python, să instalăm FastAPI și să creăm structura proiectului.

Cu comanda „pip3”, executați-o pentru a instala pachetele „fastapi” și „uvicorn”.

pip3 install fastapi uvicorn
  • „fastapi” este principalul cadru web FastAPI pentru construirea de API-uri în Python
  • „Uvicorn” este implementarea serverului web ASGI (Asynchronous Server Gateway Interface) în Python.

După finalizarea instalării, creați noi fișiere și directoare cu următoarea comandă.

mkdir -p server/{models,routes}
touch main.py server/{app.py,database.py} server/models/itemModels.py server/routes/item.py

Mai jos este structura proiectului nostru FastAPI.

server/app.py

Acum că proiectul dvs. este gata, să modificăm fișierul „server/app.py”, care este principala aplicație a proiectului dumneavoastră FastAPI.

Deschideți fișierul „ app.py ” cu editorul de text și copiați următorul script.

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
 return {"message": "Hello FastAPI!"}
  • Importați modulul FastAPI în proiectul dvs. și legați-l la variabila „aplicație”.
  • Creați o nouă funcție „rădăcină” care returnează „Hello FastAPI!”
  • Funcția „rădăcină” a răspuns la metoda GET de pe URL-ul rădăcină
  • „async” marchează funcția dumneavoastră ca o funcție asincronă și ar putea folosi „wait” în corpul său atunci când este apelată

principal.py

În această secțiune, vom modifica fișierul „main.py” care va fi folosit pentru a rula proiectul FastAPI prin „uvicorn” (server web ASGI în Python).

Acum deschideți și modificați scriptul „ main.py ” și introduceți următorul cod.

import uvicorn 

if __name__ == "__main__": 
uvicorn.run ("server.app:app", host="0.0.0.0", port=8080, reload=True)
  • Importați modulul „uvicorn”.
  • Când scriptul „main.py” este executat, acesta va încărca „aplicația” sau modulul FastAPI în „server/app.py”
  • FastAPI va rula pe „0.0.0.0” cu portul „8080”
  • Activați reîncărcarea automată când codul se schimbă prin „reload=True”

Rulați proiectul FastAPI

Acum că proiectul dvs. este gata, să rulăm primul proiect FastAPI. Executați scriptul „main.py” după cum urmează și FastAPI-ul dumneavoastră va rula pe sistemul dumneavoastră.

python3 main.py

Acum deschideți browserul web și vizitați http://SERVERIP:8080/ . Dacă instalarea a reușit, veți vedea „Hello FastAPI!” mesaj. Îl poți accesa și prin „curl” din terminal.

În cele din urmă, puteți accesa documentația API pe http://SERVERIP:8080/docs > care este furnizată de Swagger UI.

În acest ghid, veți crea un API de bază cu FastAPI și MongoDB. API-ul dvs. ar trebui să poată face CRUD cu serverul de baze de date MongoDB. În ceea ce privește acest pas, vă veți conecta proiectul la serverul MongoDB.

Mai întâi, rulați comanda „pip3” de mai jos pentru a instala driverul MongoDB „ motor ” în proiectul dumneavoastră. „motor” oferă acces API non-blocant și bazat pe corutine la serverul MongoDB.

pip3 install motor

server/database.py

După ce modulul „ motor ” este instalat, să modificăm scriptul „ server/database.py ”. Deschideți fișierul „server/database.py” cu editorul de text și introduceți următorul script. Acesta va fi folosit pentru a vă conecta la serverul MongoDB prin modulul „motor”.

from motor.motor_asyncio import AsyncIOMotorClient

MONGODB_HOST = "mongodb://localhost:27017"

connection = AsyncIOMotorClient(MONGODB_HOST)

database = connection.items
item_collection = database.get_collection("item_collection")
  • Importați „AsyncIOMotorClient” din „motor.motor_asyncio”
  • Creați o nouă constantă „MONGODB_HOST” și indicați către serverul MongoDB „mongodb://localhost:27017”
  • Conectați-vă la serverul MongoDB prin variabila „conexiune”.
  • Conectați-vă la baza de date „articole” prin variabila „bază de date”.
  • Accesați colecțiile din baza de date cu variabila „item_collection”.

Crearea modelului bazei de date cu pydantic

       În această secțiune, vă veți proiecta datele prin „ pydantic ”, care oferă modelare pentru baza noastră de date MongoDB.

Instalați modulul „pydantic” cu comanda „pip3” de mai jos. Modulul „ pydantic ” este o bibliotecă de validare a datelor care vă permite să creați schema bazei de date prin model.

pip3 install pydantic

Acum deschideți fișierul „ server/models/itemModels.py ” cu editorul de text și copiați următorul script.

from pydantic import BaseModel, Field
from typing import Optional

class Item(BaseModel):
 name: str
 category: str
 stocks: int
 price: int = Field(gt=0)

 class Config:
 json_schema_extra = {
 "example": {
 "name": "Company Smart Watch",
 "category": "smartwatch",
 "stocks": 10,
 "price": 1000,
 }
 }

class ItemUpdate(BaseModel):
 name: Optional[str] = None
 category: Optional[str] = None
 stocks: Optional[int] = None
 price: Optional[int] = None

 class Config:
 json_schema_extra = {
 "example": {
 "name": "New Smart watch",
 "category": "new-smartwatch",
 "stocks": 5,
 "price": 500,
 }
 }
  • Importați modulele „BaseModel” și „Field” din „pydantic”
  • Importați modulul „Opțional” din „tastare”
  • Creați următoarea schemă de bază de date „Articol” pentru FastAPI:
    • „nume” și „categorie” cu șir de tip
    • „stocuri” și „preț” cu categoria întreg
    • „prețul” trebuie să fie mai mare decât 0
  • Extindeți modelul de date prin clasa „Config” oferind un exemplu de date pe care utilizatorul le poate include în cerere
  • Creați următoarea schemă „ItemUpdate” cu fiecare câmp opțional.

 Adăugarea de operațiuni CRUD

        În acest moment, ați creat o conexiune la serverul MongoDB și ați creat schema bazei de date prin „pydantic”. Să trecem la crearea operațiunilor CRUD cu FastAPI și MongoDB.

Deschideți din nou scriptul „ server/database.py ” și creați o nouă funcție „ item_helper ” cu tipul „ dict ”. Apelați această funcție pentru a obține date detaliate despre un articol.

def item_helper(item) -> dict:
 return {
 "id": str(item["_id"]),
 "name": item["name"],
 "category": item["category"],
 "stocks": item["stocks"],
 "price": item["price"],
 }

Adăugați următoarea linie pentru a importa modulul „ ObjectId ” din „bson.objectid”. „ ObjectId ” face parte din tipul de date din BSON, pe care MongoDB îl folosește pentru stocarea datelor și reprezentarea datelor JSON.

from bson.objectid import ObjectId

Creați un articol

        În primul rând, veți crea o funcție asincronă care va putea adăuga date noi la baza de date MongoDB.

Creați o nouă funcție „a dd_item ” ca următorul:

# Adăugați un articol nou
async def add_item(item_details: dict) -> dict :
 item = await item_collection.insert_one(item_details)
 new_item = await item_collection.find_one({"_id": item.inserted_id})
 return item_helper(new_item)
  • Funcția „add_item” acceptă datele din dicționar ale detaliilor articolului dvs
  • Prin „item_collection” pentru a accesa documentele din baza de date și pentru a executa interogarea „insert_one” pentru a adăuga un nou articol
  • Noul articol va fi tipărit după operarea cu succes

Preluați toate articolele

       În al doilea rând, veți crea o nouă funcție „get_items” care va putea prelua toate elementele disponibile din baza de date.

Creați o nouă funcție „ get_items ” pentru a prelua toate articolele din MongoDB.

# preluati toate elementele
async def get_items():
 items = []
 async for item in item_collection.find():
 items.append(item_helper(item))
 return items
  • Veți crea o listă goală de „articole”
  • Folosind interogarea „find()” pentru a căuta toate datele și a le trece în buclă
  • Fiecare articol va fi adăugat la lista „articole” prin metoda „adăugați”.
  • După finalizarea buclei, articolele dvs. vor fi afișate

Preluați un articol specific bazat pe id

          Apoi, veți crea o nouă funcție care va putea prelua date pentru un anumit selector „id”. Aceasta vă va afișa date detaliate despre anumite articole.

Creați o nouă funcție „ get_item ” pentru a prelua date despre anumite articole. Funcția „get_item” va accepta un șir de „id” ca selector și va returna un dicționar.

# preluare un anumit articol 
 async def get_item(id: str) -> dict:
 item = await item_collection.find_one({"_id": ObjectId(id)})
 if item:
 return item_helper(item)
 return "Articol nu a fost găsit."
  • Interogarea „find_one()” va fi folosită pentru a prelua date bazate pe „id”
  • Dacă se găsește un articol, detaliile vor fi afișate folosind formatul de dicționar „item_helper”.
  • Dacă articolul nu este disponibil, răspunsul este „Articol nu a fost găsit”

Actualizați un articol

        Acum veți crea o nouă funcție pentru actualizarea unui articol. De asemenea, vă puteți actualiza parțial articolul prin API.

Definiți noua funcție „ change_item ” ca următoarele coduri:

# update item
async def change_item(id: str, data: dict):
 if len(data) < 1:
 return "Please input your data"
 find_item = await item_collection.find_one({"_id": ObjectId(id)})
 if find_item:
 item_update = await item_collection.update_one({"_id": ObjectId(id)}, {"$set": data})
 if item_update:
 return True
 return False
  • Funcția „change_item” ia două argumente, „id-ul” articolului țintă și „data” ca date noi
  • Dacă datele sunt goale sau „< 1”, operațiunea s-a încheiat
  • Această funcție va găsi un articol pe baza selectorului „id”.
  • Dacă „id-ul” este găsit, „item_update” va fi executat
  • Dacă „item_update” are succes, returnați „True” sau returnați „False” dacă nu

Ștergeți un articol

       În cele din urmă, veți crea funcția „delete_item” pentru ștergerea articolelor printr-un anumit selector. Pentru a șterge un articol, vom crea funcția „ delete_item ” și vom folosi selectorul „id” după cum urmează:

# ștergeți un articol 
  async def delete_item(id: str):
 item = await item_collection.find_one({"_id": ObjectId(id)})
 if item:
 await item_collection.delete_one({"_id": ObjectId(id)})
 return(f'Item {id} deleted.')
 return "Articol negăsit.') return
  • Interogarea „find_one()” va căuta un articol pe baza „id-ului” furnizat
  • Dacă elementul este găsit, acesta va fi șters prin interogarea „delete_one()” și va returna „Id-ul articolului șters”
  • Dacă articolul nu este disponibil, va fi afișat „Articol negăsit”.

Adăugarea rutelor pentru operațiuni CRUD

      În acest moment, am creat funcții asincrone pentru operarea CRUD cu FastAPI. Acum să creăm ruta sau punctul final pentru fiecare operațiune. Editați fișierul „ server/routes/item.py ” folosind editorul preferat.

server/routes/item.py

Mai întâi, adăugați modulele „ APIRouter ” și „ Corps ” din „fastapi”. Apoi, adăugați „ jsonable_encode ” din „fastapi.encoders”.

from fastapi import APIRouter, Body 
from fastapi.encoders import jsonable_encoder

Importați fiecare funcție din fișierul „database.py”.

from server.database import ( 
add_item, 
get_items, 
get_item, 
change_item, 
delete_item, 
)

Importați modelele „Item” și „ItemUpdate” din fișierul „itemModels.py”.

from server.models.itemModels import ( 
Item, 
ItemUpdate, 
)

Apelați clasa „APIRouter” prin variabila „router”.

router = APIRouter()

Traseu pentru adăugarea unui articol nou

          Acum să adăugăm o rută pentru adăugarea de elemente noi. În acest exemplu, puteți adăuga un nou articol prin POST la adresa URL „ /item ”.

Adăugați următoarele linii pentru a configura rute pentru adăugarea de elemente noi. Fiecare POST către adresa URL rădăcină a articolului va fi tratată ca inserare date noi.

# add new item operation 
@router.post("/") 
async def add_item_data(item: Item = Body(...)): 
item = jsonable_encoder(item) 
new_item = await add_item(item) 
return new_item
  • Funcția „add_item_data” acceptă schema „Articol”, care va face parte din „Corps” la cererea dvs.
  • Articolul dvs. va fi convertit în format de dicționar prin „jsonable_encoder”
  • Introduceți datele din dicționar prin funcția „add_item” (consultați database.py) deasupra variabilei „new_item”
  • Returnați datele introduse „new_item” ca răspuns

Traseu pentru a obține toate articolele

Adăugați următorul script pentru a configura o rută pentru preluarea datelor. Fiecare solicitare GET către adresa URL a elementului rădăcină va prelua toate datele dvs.

# obține toate articolele disponibile 
@router.get("/") 
asincron def get_item_data(): 
items = await get_items() 
if items: 
return items 
return "Niciun articol disponibil."
  • Creați funcția „get_item_data” care va executa funcția „get_item” din fișierul „database.py”
  • Dacă articolele sunt disponibile, veți primi lista tuturor articolelor dvs
  • Dacă nu există niciun articol, veți primi răspunsul „Niciun articol disponibil”.

Traseu pentru a obține un articol specific

        Pentru a obține detalii despre un anumit articol, vom folosi „id” ca selector. Fiecare cerere GET către „/id” va returna un articol detaliat al „id-ului” solicitat.

# Afișați detaliile articolului prin ID-ul 
@router.get("/{id}") 
asincron def get_item_details(id): 
item_details = await get_item(id) 
if item_details: 
return item_details 
return "Articol nu a fost găsit."
  • Funcția „get_item_details” va fi creată și va transmite „id” de la adresa URL
  • Funcția „get_item” (vezi database.py) va fi apelată și va trece, de asemenea, „id” ca argument
  • Dacă articolul este găsit, vor fi afișate detaliile articolului
  • Dacă niciun articol cu ​​acel „id” specific, veți primi „Articol nu a fost găsit”

Rută pentru actualizarea unui articol

         Copiați următorul cod pentru a seta ruta pentru elementul actualizat:

# Update Item 
@router.put("/{id}") 
asincron def update_item(id: str, data: ItemUpdate = Body(...)): 
data = {k:v for k, v in data.dict().items() if v is not None} 
updated_item = await change_item(id, data) 
if updated_item} 
return: {f'item} 
return. "Eroare"
  • Funcția „update_item” va lua două argumente, „id” ca selector și „data”, care se bazează pe modelul „ItemUpdate”
  • Datele vor fi verificate în variabila „date”.
  • „updated_item” va executa funcția „change_item” din fișierul „database.py”
  • Dacă actualizarea a reușit, veți vedea rezultatul „Succes”

Rută pentru ștergerea unui articol

       Introduceți următoarele rânduri pentru a crea funcția „remove_item” pentru ștergerea articolelor. Fiecare operație DELETE la un anumit „/id” va elimina elementul potrivit cu „id”.

# ștergeți elementul prin id 
@router.delete("/{id}") 
asincron def remove_item(id): 
item_to_delete = await delete_item(id) 
if item_to_delete: 
return item_to_delete 
return{f'Item {id} Nu este disponibil.'}
  • Funcția „remove_item” va executa „delete_item” și va trece selectorul „id”
  • Operația de ștergere va fi stocată și executată prin variabila „item_to_delete”.
  • Când un articol nu este disponibil, veți primi returnarea „Id articol nu este disponibil”

server/app.py

  • Acum că ați terminat fișierul „server/routes/item.py”, să-l includem în „server/app.py”.
  • Deschideți fișierul „ app.py ” folosind editorul de text.
  • Importați „routerul” din fișierul „ server/routes/item.py ” ca „ ItemRouter ”.
de la server.routes.item import router ca ItemRouter

Introduceți „ItemRouter” cu prefixul implicit „ /item ”. Operațiunile CRUD vor fi gestionate prin adresa URL „ /item ”.

app.include_router(ItemRouter, tags="["Articol"], prefix="/item")

Acum punctul final CRUD va fi disponibil la următoarele:

  • Adăugați un articol nou: POST la „ /item ”
  • Preluați toate articolele: GET la „ /item ”
  • Preluați un anumit articol: GET la „/item/id” . „ID” este generat de MongoDB
  • Actualizați elementul: PUT la „/item/id”
  • Ștergeți elementul: DELETE în „/item/id”

Testați operațiunile CRUD

În primul rând, asigurați-vă că proiectul dvs. FastAPI rulează sau puteți executa scriptul „main.py” în felul următor:

python3 main.py

Navigați prin http://SERVERIP:8080/docs  și veți vedea fiecare rută pe care ați creat-o.

Mai jos este un exemplu de adăugare a unui articol nou.

Preluați toate articolele disponibile prin API.

Preluați anumite elemente prin selectorul „id”.

Actualizați datele parțiale din anumite articole.

Mai jos sunt datele actualizate.

Mai jos este operația de ștergere prin selectorul „id”.

[mai mult...]