Share
Diferențele dintre SQL bine scrise și nu sunt vaste, iar în producție pe un site cu o cerere ridicată, ele produc repercusiuni grave asupra performanței și fiabilității serviciilor. În acest ghid voi discuta cum să scrieți întrebări rapide și ce factori contribuie la a le face să funcționeze lent.
Astăzi există o mulțime de discuții despre Big Data și noile tehnologii. NoSQL și soluțiile bazate pe cloud sunt excelente, însă o mulțime de aplicații web populare (cum ar fi WordPress, phpBB, Drupal, software-ul VBulletin Forum etc.) încă rulează pe MySQL. Migrarea la aceste soluții mai noi nu poate fi la fel de simplă ca doar optimizarea configurației pe care o aveți deja în producție. În plus, performanța MySQL este foarte bună, mai ales versiunea Percona.
Nu faceți greșeala obișnuită de a arunca tot mai multă putere de calcul în rezolvarea problemei de interogări lente și încărcări serioase ale serverului, mai degrabă decât de a aborda problemele care stau la baza. Adăugarea de putere CPU, SSD sau RAM este o formă de optimizare dacă doriți, dar nu despre asta voi vorbi aici. De asemenea, fără un site optimizat, pe măsură ce creșteți cu câștigurile hardware, problemele se vor multiplica exponențial. Deci, nu este o soluție solidă pe termen lung.
Fiind bun la SQL este întotdeauna o unealtă vitală pentru un dezvoltator de web, iar reparația este adesea la fel de simplă ca adăugarea unui index sau modificarea ușoară a modului în care este utilizată masa, într-adevăr vă ajută să știți cum să utilizați RDBMS bine. În acest caz, ne concentrăm asupra unei populații baze de date open source, adesea folosite împreună cu PHP, și anume MySQL.
Dezvoltatori web, arhitecți de baze de date / DBA și administratori de sistem care sunt familiarizați cu MySQL. Dacă nu sunteți familiarizat cu MySQL ca un începător, atunci acest ghid nu va avea prea mult sens, dar voi încerca să-l păstrez cât mai informativ posibil pentru noii veniți la MySQL.
Vă recomandăm să încercați pașii furnizați pe propria bază de date MySQL (faceți o copie de rezervă, bineînțeles!). Dacă nu aveți nicio bază de date pentru a lucra, de exemplu, creați schemele bazei de date, dacă este cazul.
Backup-ul MySQL este ușor cu mysqldump comanda de utilitate:
bash $ mysqldump myTable> myTable-backup.sql
Puteți afla mai multe despre mysqldump.
Pe scurt și în nici o ordine de importanță, următoarele toate joacă un rol semnificativ în performanța interogării și a serverului:
Accentsconagua
Unde clauza (și utilizarea funcțiilor interne MySQL, cum ar fi DACĂ și DATA de exemplu)Ordonează prin Vom aborda toate aceste domenii în acest ghid. De asemenea, dacă nu îl folosiți deja, instalați-l pe Percona, care este un înlocuitor de tip drop-in pentru MySQL, care va aduce o creștere serioasă a performanței. Pentru a vedea un punct de referință al lui Percona vs. MySQL, uitați-vă la această comparație.
Indicii sunt utilizați de MySQL pentru a găsi rapid rânduri cu valori specifice ale coloanelor, de exemplu în interiorul unui UNDE. Fără un index, MySQL trebuie să înceapă cu primul rând și apoi să citească întreaga tabelă pentru a găsi rândurile relevante. Cu cât masa este mai mare, cu atât costă mai mult.
Dacă tabelul are un index pentru coloanele în cauză, MySQL poate determina rapid poziția de a căuta în mijlocul fișierului de date fără a fi nevoie să se uite la toate datele. Acest lucru este mult mai rapid decât citirea succesivă a fiecărui rând.
Când limbajul de scripting se conectează la baza de date, dacă ați configurat conexiuni persistente, va fi capabil să reutilizeze o conexiune existentă fără a trebui să creeze o conexiune existentă. Acest lucru este optim pentru utilizarea în producție și trebuie activat.
Utilizatorii PHP pot citi mai multe în Manualul PHP.
Cea mai rapidă și mai eficientă metodă pe care am găsit-o pentru a rezolva aceasta este prin utilizarea unui magazin de perechi cheie-valoare, cum ar fi memcached sau Redis.
Cu memcache puteți pur și simplu memora conținutul interogării cu următorul exemplu, de exemplu:
„php conectați ( 'localhost', 11211); $ cacheResult = $ cache-> obține ('key-name'); dacă ($ cacheResult) // ... nu este nevoie să interogați $ result = $ cacheResult; altfel // ... executați interogarea $ mysqli = mysqli ('p: localhost', 'username', 'password', 'table'); // prepend p: pentru nume de gazdă pentru persistanță $ sql = 'SELECT * FROM posts LEFT JOIN userInfo folosind (UID) WHERE posts.post_type =' post '|| posts.post_type = 'articolul' ORDER BY coloana LIMIT 50 '; $ result = $ mysqli-> interogare ($ sql); $ memc-> set ('nume-cheie', $ result-> fetch_array (), MEMCACHE_COMPRESSED, 86400);
// Treceți $ cacheResult la șablon $ template-> assign ('posts', $ cacheResult);
?>“
Acum exemplul ÎNCĂLZIRE LUPĂ interogarea va fi executată doar o dată la fiecare 86.400 secunde (24 de ore), luând astfel o cantitate mare de încărcătură departe de serverul MySQL și reducând conexiunile concurente.
Notă: Prefixați p: la argumentul gazdă în MySQLi pentru conexiuni persistente.
Atunci când datele dvs. devin mari sau dacă cererea dvs. de service se ridică, panica se poate seta. O remediere rapidă pentru a vă asigura că serviciul dvs. rămâne online poate fi ștergător. Dar nu recomand acest lucru, deoarece scuturarea inerent pare sa faca structurile de date prea complicate. Și cum sa explicat foarte elocvent în acest articol din blogul Percona, nu te sfărâma.
Crearea schemelor bazei de date nu este prea greu atunci când acceptați niște reguli de aur, cum ar fi lucrul cu limitările și conștientizarea a ceea ce va fi eficient. Stocarea imaginilor în baza de date ca pată de cerneală tipurile de date, de exemplu, sunt foarte descurajați; stocarea unui nume de fișier într - un varchar coloana cu datetip este mult superioară.
Asigurarea faptului că designul este corect pentru utilizarea necesară este esențială pentru crearea aplicației. Păstrați date separate separate (de ex., Categorii și postări) și asigurați-vă că relațiile "multe la unu" sau "unul la multe" pot fi ușor asociate cu ID-urile. Folosind CHEIE EXTERNĂ facilitate de MySQL este ideal pentru cascadarea contingență de date între mese.
Când vă construiți masa, încercați să rețineți următoarele:
COMANDA DE LA în MySQL.UNIC tipul de index pentru seturile de date unice și să utilizeze ON UPDATE KEY DUPLICATE pentru a păstra o actualizare a datetime sau unix timestamp actualizată, de exemplu, ultima dată când a fost bifat rândul.INT tip dat pentru numere întregi. Dacă nu specificați lungimea, MySQL va calcula ceea ce este necesar.Pentru a optimiza în mod eficient, trebuie să analizăm trei seturi de date fundamentale referitoare la aplicația dvs.:
Analiza se poate face în mai multe moduri. În primul rând, vom lua cea mai directă cale de a privi sub capota interogărilor MySQL. Primul instrument din caseta de instrumente de optimizare este EXPLICA. Folosind acest lucru în interogarea dvs. înainte de SELECTAȚI vă va da următoarea ieșire:
sql mysql> EXPLAIN SELECT * DE LA 'wp_posts' WHERE 'post_type' = 'post'; + ---- + ------------- + ---------- + ------ + ------------ ------ + ------------------ + --------- + ------- + ------ + ------------- + | id | select_type | tabel | tip | posibilele chei | cheie | key_len | ref | rânduri | Extra | + ---- + ------------- + ---------- + ------ + ------------ ------ + ------------------ + --------- + ------- + ------ + ------------- + | 1 | SIMPLE | wp_posts | ref | tipul_status_date | tipul_status_date | 82 | const | 2 | Utilizarea unde | + ---- + ------------- + ---------- + ------ + ------------ ------ + ------------------ + --------- + ------- + ------ + ------------- + 1 rând în set (0.00 sec)
Coloanele enumerate conțin informații utile despre interogarea care se execută. Coloanele de care aveți nevoie să acordați o atenție deosebită sunt possible_keys și Suplimentar.
possible_keys va afișa indexurile pe care motorul MySQL le poate utiliza pentru interogare. Uneori trebuie să forțați un index pentru a vă asigura că interogarea este executată în cel mai rapid mod.
Suplimentar coloana va arăta dacă este condiționată UNDE sau COMANDA DE LA a fost folosit. Cel mai important lucru de observat este dacă Utilizând Filesort apare. Luați în considerare următorul exemplu:
sql EXPLAIN SELECT main_text FROM mesaje WHERE user = 'numele meu de utilizator' && status = '1' && (status_spam_user = 'no_spam' || (status_spam_user = 'neutral' && status_spam_system = 'neutral')) ORDER BY datum DESC LIMIT 6430, 10
Acest tip de interogare poate ajunge pe disc din cauza condiționării în cazul în care, care se întâmplă dacă ne uităm la EXPLICA:
sql id select_type tipul tabelului possible_keys cheie key_len ref rows Extra 1 posturi SIMPLE ref index_user, index_status index_user 32 const 7800 Utilizarea unde; Folosind filer
Deci, această interogare are posibilitatea de a utiliza doi indici și în prezent se lovește de disc din cauza Folosind filer în Suplimentar.
Ce Utilizând Filesort se face este definită aici din manualul MySQL:
"MySQL trebuie să facă o trecere suplimentară pentru a afla cum să regăsiți rândurile în ordine sortată. Soluția se face prin trecerea tuturor rândurilor în funcție de tipul de îmbinare și stocarea cheii de sortare și a indicelui pe rând pentru toate rândurile care se potrivesc cu clauza WHERE. Cheile sunt apoi sortate și rândurile sunt preluate în ordine sortată. "
Acest extra pas va încetini aplicația dvs. și trebuie evitat cu orice preț. Un alt aspect crucial Suplimentar rezultat pentru a evita este Utilizarea temporară, ceea ce înseamnă că MySQL a trebuit să creeze un tabel temporar pentru interogare. Evident, aceasta este o utilizare groaznică a MySQL și trebuie evitată cu orice preț, cu excepția cazului în care nu puteți optimiza mai mult din cauza cerințelor de date. În acest caz, interogarea ar trebui să fie stocată în cache în Redis sau Memcache și să nu fie rulată de utilizatori.
Pentru a rezolva problema cu Utilizând Filesort trebuie să ne asigurăm că MySQL utilizează un INDEX. Are mai multe possible_keys pentru a alege, dar MySQL poate utiliza doar un index în interogarea finală. Deși Indexurile pot fi compozite ale mai multor coloane, inversul nu este adevărat, deși puteți oferi sugestii optimizatorului MySQL cu privire la ce indexuri ați creat.
Optimizatorul MySQL va utiliza statistici bazate pe tabelele de interogări pentru a selecta cel mai bun index pentru domeniul de aplicare al interogării. Ea se bazează pe logica statistică a optimizatorului încorporat, deși cu multiple alegeri acest lucru nu poate fi întotdeauna corect fără a sugera. Pentru a vă asigura că cheia corectă este utilizată (sau nu este utilizată), utilizați FORȚA INDEX, INDICAȚIE DE UTILIZARE și IGNORE INDEX cuvinte cheie în interogarea dvs. Puteți citi mai multe despre sugerarea indexului în manualul MySQL.
Pentru a vă uita la tastele tabelului, utilizați comanda INDEX INDEX.
Puteți specifica mai multe sugestii pentru utilizarea optimizatorului, de exemplu:
sql SELECT * FROM table1 INDEXUL UTILIZĂRII (col1_index, col2_index) WHERE col1 = 1 și col2 = 2 și col3 = 3;
A alerga a EXPLICA vă va arăta ce index a fost utilizat în rezultatul final. Deci, pentru a rezolva exemplul anterior, vom adăuga INDICAȚIE DE UTILIZARE ca atare:
sql EXPLAIN SELECT main_text FROM posts USE INDEX (index_user) WHERE user = 'numele meuUtilizator' && status = '1' && (status_spam_user = 'no_spam' || (status_spam_user = 'neutral' && status_spam_system = 'neutral')) ORDER BY datum DESC LIMIT 6430, 10
Acum, că MySQL are index_status din tabelul de utilizat, interogarea este fixată.
sql id select_type tipul tabelului possible_keys cheie key_len ref rows Extra 1 mesaje SIMPLE ref index_user, index_status index_user 32 const 7800 Folosind unde
pe langa EXPLICA este DESCRIE cuvinte cheie. Cu DESCRIE puteți vedea informațiile despre o masă după cum urmează:
sql mysql> DESCRIBE City; + ------------ + ---------- + ------ + ----- + --------- + - -------------- + | Câmp | Tip | Null | Cheie | Implicit | Extra | + ------------ + ---------- + ------ + ----- + --------- + - -------------- + | Id | int (11) NO | PRI | NULL | auto_increment | | Nume | char (35) NO | | | | | Țară | caractere (3) | NO | UNI | | | | District | caracter (20) | DA | MUL | | | | Populație int (11) NO | | 0 | | +------------+----------+------+-----+---------+----------------+
Puteți crea indexuri în MySQL cu CREEAȚI INDEX sintaxă. Există câteva arome de index. TEXT COMPLET este folosit pentru scopuri de căutare fulltext, și apoi există UNIC pentru a vă asigura că datele sunt păstrate unice.
Pentru a adăuga un index la tabel, utilizați de exemplu următoarea sintaxă:
sql mysql> CREATE INDEX idx_start_of_username ON "utilizatori" (nume de utilizator (10));
Acest lucru va crea un index pe masă utilizatori, care va folosi primele 10 litere din coloana nume de utilizator, care este un tip de date varchar.
În acest caz, orice căutări care necesită a UNDE sort pe nume de utilizator cu meciul aflat în primele 10 caractere ar fi același ca o căutare a întregului tabel.
Indicii au un efect enorm asupra vitezei de retur a datelor de interogare. Doar setarea unei chei primare și a unui index unic nu este, în general, suficientă - cheile compozite sunt în cazul în care nișa reală de reglare se află în MySQL, și cel mai adesea acest lucru necesită o verificare A / B cu EXPLICA.
De exemplu, dacă trebuie să menționăm două coloane în cadrul nostru UNDE condiționată, ar fi ideală o cheie compusă.
sql mysql> CREATE INDEX idx_composite ON utilizatori (nume de utilizator, activ);
Aici această cheie este creată pe nume de utilizator din exemplul anterior și din coloană activ, un ENUM tipul de date care indică dacă contul de utilizator este activ. Deci, acum când interogați datele pentru UNDE numele de utilizator este valabil și contul este activ = 1, setul de date este acum optimizat pentru a face față acestui lucru mai bine.
Activează profilarea pentru a examina mai îndeaproape interogările MySQL. Acest lucru se poate face la timpul de rulare prin setarea profilului = 1, și apoi executați interogarea dvs. și privind rezultatul afișați profiluri.
Cu DOP aici este un fragment de cod care face exact asta:
"php $ db-> interogare ('set profiling = 1'); $ db-> interogare ('selectați titlul, corpul, etichetele din posturi'); $ rs = $ db-> query db-> interogare ('set profiling = 0'); // Dezactivați profilarea după ce interogarea a fost rulată
$ înregistrări = $ rs-> fetchAll (PDO :: FETCH_ASSOC); // Obțineți rezultate din profilare
$ errmsg = $ rs-> errorInfo () [2]; / / Prindeți toate erorile aici "
Dacă nu utilizați DOP, același lucru se poate face și cu mysqli ca atare:
"php $ db = noul mysqli ($ host, $ username, $ password, $ dbname);
$ db-> interogare ('set profiling = 1'); $ db-> interogare ("selectați titlul, corpul, etichetele din postări"); dacă $ result = $ db-> interogare ("SHOW profiles", MYSQLI_USE_RESULT)) în timp ce ($ row = $ result-> fetch_row ()) var_dump ($ row); $ result-> close ();
dacă $ result = $ db-> interogare ("afișați profilul pentru interogarea 1", MYSQLI_USE_RESULT)) în timp ce ($ row = $ result-> fetch_row ()) var_dump ($ row); $ result-> close ();
$ db-> interogare ('set profiling = 0'); "
Aceasta vă va întoarce datele de profil, care vor include timpul de execuție în a doua valoare a matricei asociative:
php array (3) [0] => string (1) "1" [1] => șir (10) "0.00024300" [2] => șir (17) Interogarea a durat 0,00024300 secunde. E suficient de rapid ca să nu-ți faci griji. Dar când numerele se ridică, trebuie să ne uităm mai adânc.
Ca exemplu de lucru, cunoașteți aplicația. Plasați un cec pentru a REMEDIERE constantă în driverul bazei de date pentru baze de date abstracte / baze de date a bazei de date a aplicației dvs. și apoi puteți începe auditarea, permițând un caz de profil și afișând rezultatul cu var_dump / print_r. Acum veți putea naviga și personaliza paginile site-ului dvs. web!
Pentru a efectua un audit complet al interogărilor, activați logarea. Unii dezvoltatori am lucrat cu îngrijorarea că aceasta este o problemă dublă față de faptul că permiterea înregistrării afectează ușor performanța, deci statisticile pe care le înregistrați vor fi ușor mai mici decât în realitate. În timp ce acest lucru este adevărat, multe valori de referință arată că nu este prea mult de o diferență.
Pentru a permite autentificarea în MySQL versiunea 5.1.6, utilizați aplicația globală log_slow_queries și poate specifica un fișier cu slow_query_log_file global. Acest lucru se poate face în promptul runtime ca atare:
setare globală loghslow_queries = 1; setați global slow_query_log_file = /dev/slow_query.log;
Puteți seta acest lucru în mod persistent în /etc/my.cnf sau my.ini fișier de configurare pentru serverul dvs..
bash log_slow_queries = 1; slow_query_log_file = /dev/slow_query.log;
După efectuarea acestei modificări, trebuie să reporniți serverul MySQL, de ex. serviciu MySQL restart pe sistemele Linux.
În noul MySQL 5.6.1, log_slow_queries este depreciat și slow_query_log este folosit în schimb. Activarea MASA deoarece tipul de ieșire permite o experiență mult mai plăcută de depanare și se poate face după cum urmează în MySQL 5.6.1 și mai târziu:
bash log_output = TABLE; log_queries_not_using_indexes = 1; long_query_time = 1
long_query_time specifică numărul de secunde la care este clasificată o interogare lentă. Valoarea implicită este de 10 și minimum 0. Poate lua valori milisecunde prin specificarea unui float; aici am pus-o la 1 secundă. Deci orice interogare care durează mai mult de 1 secundă va fi înregistrată în MASA format de iesire.
Aceasta se va loga la mysql.slow_log și mysql.general_log tabele în interiorul MySQL.
Pentru a dezactiva înregistrarea, setați log_output la NICI UNUL.
log_queries_not_using_indexes este un boolean util care, atunci când este activat împreună cu jurnalul de interogări lent, înseamnă că numai interogările care sunt așteptate să recupereze toate rândurile sunt înregistrate.
Această opțiune nu înseamnă întotdeauna că nu se utilizează niciun index. De exemplu, atunci când o interogare utilizează o scanare completă a indexului, aceasta va fi înregistrată, deoarece indexul nu va limita numărul de rânduri.
Activarea logării pe un site de producție cu trafic va trebui să se facă întotdeauna pe o perioadă scurtă de timp, în timp ce monitorizarea încărcăturii pentru a se asigura că nu afectează serviciul. Dacă vă aflați sub încărcătură mare și aveți nevoie de o reparație urgentă, începeți prin abordarea problemei cu ajutorul instrucțiunii SHOW PROCESSLIST sau prin information_schema.PROCESSLIST tabelul direct, de ex. selectați * din info_schema.PROCESSLIST;.
Logarea tuturor interogărilor în producție vă poate spune foarte mult și este o bună practică în scopuri de cercetare atunci când efectuați un audit, însă lăsându-l să funcționeze timp de câteva zile nu vă va oferi adesea date utile mai mult decât ar face cel mult 48 de ore în medie, cel puțin să capturați orele de vârf de utilizare pentru a avea o privire bună la întrebări și pentru a obține câteva idei de frecvență).
Notă: dacă rulați un site care se confruntă cu valuri de trafic de vârf și apoi perioade de nu prea mult (cum ar fi un site de sport în timpul și în afara sezonului), să fie logice cu cum te uiți la logare. Nu presupuneți că site-ul funcționează rapid. Efectuați auditul și, cel mai important, stabiliți un anumit grafic.
Percona are niște instrumente excelente împreună cu ea, și pt-interogare-digest este un instrument de linie de comandă pentru analizarea jurnalelor de interogări, a proceselor sau a tcpdumps.
Poți să folosești pt-interogare-digest în următoarele moduri:
Analizați un fișier * .log (afișat, de exemplu, din logarea lentă a interogărilor):
bash $ pt-interogare-digest slow.log
Raportați cele mai lente interogări de la host1 în timp real (foarte util!):
bash $ pt-interogare-digest -proceslist h = host1
Utilizați tcpdump pentru a raporta cele mai lente interogări din datele protocolului MySQL:
"bash $ tcpdump -s 65535 -x -nn -q -tttt -i orice -c 1000 port 3306> mysql.tcp.txt
$ pt-interogare-digest-tip tcpdump mysql.tcp.txt "
În cele din urmă, putem salva datele de interogare lentă de la o gazdă la alta pentru o examinare ulterioară. Aici salvăm interogarea digest pentru slow.log la host2:
bash $ pt-interogare-digest -review h = host2 -no-raport slow.log
Pentru a afla cum să utilizați pe deplin pt-interogare-digest instrument de Percona, citiți pagina manuală.
Acest grafic al operațiunilor InnoDB Row arată operațiile de rând pe care InnoDB le-a efectuat: actualizări, citiri, ștergeri și inserări.
Acesta este un subiect important și mă voi atinge destul de mult în acest ghid pentru a vă începe cu monitorizarea MySQL. Este important să observăm, în general, că monitorizarea tuturor serviciilor site-ului dvs. este ideală pentru a ști cu adevărat care sunt performanțele și uzanțele dvs..
Pentru a realiza acest lucru, vă recomandăm să creați o RRDTool-pe bază de soluție, cum ar fi Cactusii cu o configurație MySQL. Obțineți un șablon pentru Cactuși de la tipii de la Percona.
Odată ce ați instalat Cacti și puteți începe să analizați aplicația, permiteți-i puțin timp să treacă astfel încât graficele să se poată dezvolta. După câteva zile, veți începe să vedeți ritmurile de zi și de noapte ale traficului dvs. și veți vedea cât de ocupat este serverul cu adevărat.
Dacă sunteți în căutarea alertelor automate și declanșatoare, căutați în configurarea monitorului, un monitor proactiv open-source pentru sistemele Unix. Cu monitorul puteți crea reguli pentru serverul dvs. și asigurați-vă că sunteți avertizat când încărcarea se ridică, astfel încât să o puteți prinde în timp ce se întâmplă.
Înregistrarea tuturor interogărilor lente care durează mai mult de o secundă pentru a finaliza poate să ne spună ceva, dar și cunoașterea întrebărilor care se execută de sute de ori este la fel de importantă. Chiar dacă aceste interogări sunt scurte pentru a fi executate, cheltuielile aeriene cu cereri ridicate își iau în continuare taxele pe server.
De aceea, rămâneți în jur atunci când actualizați ceva și puneți-l în direct este cel mai important moment pentru orice nouă lucrare de bază de date și schimbări. Întotdeauna avem o politică asupra echipelor mele de a nu sincroniza niciodată schimbările de baze de date noi după o miercuri pe un proiect live. Aceasta trebuie făcută la începutul săptămânii, cel mai târziu marți, astfel încât toate echipele să poată monitoriza și oferi asistență în consecință.
Înainte de a intra live cu noi interogări, trebuie să faceți o comparație cu un instrument de testare a încărcării, cum ar fi ab. Când executați criteriul de referință, trebuie să vizualizați SHOW PROCESSLIST, și, de asemenea, permite logarea și să fie monitorizarea cu instrumente de sistem cum ar fi top, liber și iostat. Acesta este un pas crucial înainte de a pune orice interogare nouă într-o producție live. Dar nu este un test de 100% acid, deoarece traficul viu se poate comporta mult diferit de un punct de referință calculat.
Pentru a compara cu ab, asigurați-vă că aveți pachetul instalat, de exemplu:
bash #centos utilizatori $ sudo yum instalare ab #debian / ubuntu utilizatori $ sudo apt-get install ab
Acum, puteți începe prin testarea aplicației dvs., de exemplu:
bash $ ab -k -c 350 -n 20000 my-domain.com/
-k inseamna sa ține în viață conexiunea și -c 350 este numărul de conexiuni concurente, adică numărul de persoane / clienți care vor lovi simultan site-ul. În cele din urmă -n 20000 este numărul de solicitări care vor fi făcute my-domain.com.
Deci, prin rularea comenzii de mai sus, veți fi lovit http://my-domain.com/ cu 350 de conexiuni simultane până când sunt îndeplinite 20.000 de cereri, iar acest lucru se va face folosind antetul "Keep alive".
După ce procesul finalizează cele 20.000 de cereri, veți primi feedback despre statistici. Acest lucru vă va spune cât de bine a efectuat site-ul sub stresul pe care l-ați pus la folosirea parametrilor de mai sus. Aceasta este o modalitate bună de a ști într-un sens automat dacă interogarea dvs. a schimbat ceva.
Solicitarea sumelor și încărcarea serverului au un impact imens asupra performanței, iar timpul de interogare poate fi afectat datorită acestui fapt. În tot ce ar trebui să activați jurnalul lent de interogări pentru a prinde acest lucru în producție și, ca regulă pentru dezvoltare, trebuie să vă asigurați că toate interogările sunt executate în fracțiuni de o milisecundă (0.0xx sau mai rapid) pe un server inactiv.
Implementarea memcache va avea un impact dramatic asupra cerințelor de încărcare și va fi folosit pentru a descărca în mod serios resursele care au fost epuizate în procesarea interogărilor. Asigurați-vă că utilizați memcached efectiv și comparați aplicația cu un cache fierbinte (preîncărcat cu valori) față de unul rece.
Pentru a evita trecerea în producție cu o memorie cache goală, un script de pre-încărcare este o modalitate bună de a asigura că memoria cache va fi citită și nu veți obține un număr mare de solicitări care vor veni imediat la întoarcerea de la un timp de nefuncționare, supra-capacitatea de eșec.
Deci, dacă ați activat înregistrarea, ați găsit câteva interogări lente în aplicația dvs. Hai să le rezolvăm! De exemplu, în scopuri, voi demonstra diverse probleme comune pe care le veți întâlni și logica pentru a le remedia.
Dacă nu ați găsit încă interogări lente, atunci puteți verifica setările pentru unde long_query_time dacă utilizați metoda de logare a interogărilor. În caz contrar, după ce ați verificat toate interogările dvs. cu ajutorul profilării (setarea profilului = 1), faceți o listă a interogărilor care durează mai mult decât fracțiile de o milisecundă pentru a finaliza (0.000x secunde) și să începem pe acele.
Iată câteva șase probleme comune pe care le întâlnesc în optimizarea interogărilor MySQL:
COMANDA DE LA utilizând fișierul de fișiere.sql mysql> explicați selectați * din produsele în care produsele.price> 4 și products.stock> 0 comanda după nume; + ---- + ------------- + ---------- + ------ + ------------ --- + ------ + --------- + ------ + ------ + --------------- -------------- + | id | select_type | tabel | tip | posibilele chei | cheie | key_len | ref | rânduri | Extra | + ---- + ------------- + ---------- + ------ + ------------ --- + ------ + --------- + ------ + ------ + --------------- -------------- + | 1 | SIMPLE | produse | ALL | NULL | NULL | NULL | NULL | 1142 | Folosind unde; Utilizarea fișierelor de fișiere | +----+-------------+----------+------+---------------+------+---------+------+------+-----------------------------+
Evitarea filelor despre acest lucru este imposibilă din cauza ORDER BY nume. Indiferent de permutarea indexului pe care îl folosiți, cel mai bun lucru pe care îl veți obține este Folosind unde; Utilizând Filesort în tine Suplimentar coloană. Pentru a optimiza acest lucru, salvați rezultatul în Memcache sau faceți comanda în stratul logic al aplicației.
COMANDA DE LA pe UNDE și a ÎNCĂLZIRE LUPĂ COMANDA DE LA are o taxă semnificativă pe interogări. De exemplu, următorul text este unul de bază ÎNCĂLZIRE LUPĂ a produse tabelul și categorii tabel cu ajutorul unui ID întreg. Când comanda este eliminată, la fel este și sortarea fișierelor.
"sql mysql> Explicați selectați produsele. * din produse folosiți indicele (idx_price) stânga se alăture categoriilor folosind (catID) unde products.price> 4 și catID = 4 ORDER BY stock ASC limită 10; + - + - + - + - - - - - - - - - - - - - - - - - | | id | select_type | table | type | possible_keys | key | key_len | ref | - + - + - + - + - + | 1 | SIMPLE | produse | ALL | idx_price | NULL | NULL | NULL | 986 | | const | 1 | Utilizarea indexului | + - + - + - + - + - + - + - + - + - + - +
mysql> Explicați produsele selectate. * din produse folosiți indicele (idx_price) categoriile stânga se alăture folosind (catID) unde products.price> 4 și catID = 4; + - +
