Redis (Remote Dictionary Server) yra atvirojo kodo duomenų bazė, kuri naudoja papildomą atmintį ir rakto reikšmes greitesniam duomenų pateikimui. Redis yra idealus pasirinkimas, jeigu turite poreikį į greitį orientuotai sistemai. Kadangi duomenys laikomi RAM atmintyje, tai sumažina laiką, reikalingą pasiekti duomenis diske. Redis palaiko tokius duomenų tipus, kaip string'us, hash'us, sąrašus, set'us ir pan.

Šioje pamokoje pateiksime instrukciją, kaip naudoti duomenų kešavimą Ubuntu 20.04 serveryje pasitelkiant Redis serverį su PHP.

0. Preliminarūs reikalavimai:

• Mūsų parengtas Ubuntu 20.04 serveris
• Naudotojas turintis sudo teises
• LAMP tarnybų paketas
  
  

1. Redis serverio diegimas ir minimalus konfigūravimas

Prieš pradedant diegimą atnaujinkite serverio paketus ir įdiekite Redis:

sudo apt update
sudo apt install redis-server

Toliau atsidarykite Redis konfigūracijos failą su norimu teksto redaktoriumi (mes naudojame nano):

sudo nano /etc/redis/redis.conf

Šiame faile susiraskite eilutę su supervised ir reikšmę no pakeiskite į systemd. Šis pakeitimas leis Redis serverį administruoti kaip tarnybą suteikiant daugiau galimybių lengvai administruoti atliekamas operacijas:

. . .

# If you run Redis from upstart or systemd, Redis can interact with your
# supervision tree. Options:
# supervised no - no supervision interaction
# supervised upstart - signal upstart by putting Redis into SIGSTOP mode
# supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET
# supervised auto - detect upstart or systemd method based on
# UPSTART_JOB or NOTIFY_SOCKET environment variables
# Note: these supervision methods only signal "process is ready."
# They do not enable continuous liveness pings back to your supervisor.
supervised systemd

. . .

Atlikus koregavimus išsaugokite juos ir perkraukite Redis tam, kad pakeitimai įsigaliotų:

sudo systemctl restart redis.service

Ir patikrinkite ar Redis veikia sėkmingai:

sudo systemctl status redis

2. Redis papildinio diegimas

Kešavimo veikimui reikalingas php-redis paketas, kuris įdiegiamas paleidus šią komandą:

sudo apt install -y php-redis

Užbaigus diegimą perkraukite Apache:

sudo systemctl restart apache2

3. Duomenų bazės kūrimas

Prisijunkite prie duomenų bazių serverio:

sudo mysql -u root -p

ir įveskite savo prisijungimo slaptažodį. Tada sukuriame naują duomenų bazę:

CREATE DATABASE imones_db;

Duomenų bazei sukuriame naudotoją ir suteikiame jam visas teises valdyti ją:

CREATE USER 'naudotojas'@'localhost' IDENTIFIED BY 'StiprusSlaptazodis';
GRANT ALL PRIVILEGES ON imones_db.* TO 'naudotojas'@'localhost';
FLUSH PRIVILEGES;

Tada pasirinkite savo duomenų bazę:

USE imones_db;

Sukurkite darbuotojai lentelę. Ši lentelė bus naudojama laikyti standartiniams darbuotojų duomenims, kaip ID, vardas ir pavardė:

CREATE TABLE darbuotojai (darbuotojo_id INT AUTO_INCREMENT PRIMARY KEY, vardas VARCHAR(50), pavarde VARCHAR(50) );

Įveskite kelių galimų darbuotojų duomenis. Nenaudokite darbuotojo_id duomens, nes jis aprašytas kaip AUTO_INCREMENT reikšmė:

INSERT INTO darbuotojai (vardas, pavarde) VALUES ('PETRAS', 'PETRAITIS');
INSERT INTO darbuotojai (vardas, pavarde) VALUES ('JONAS', 'JONAITIS');
INSERT INTO darbuotojai (vardas, pavarde) VALUES ('VARDAS', 'PAVARDE');
INSERT INTO darbuotojai (vardas, pavarde) VALUES ('VARDENIS', 'PAVARDENIS');

Paleiskite darbuotojai užklausą, kuri turi pateikti įvestus duomenis:

SELECT darbuotojo_id, vardas, pavarde from darbuotojai;

Ir sutikrinkite ar visi įvesti darbuotojai yra matomi lentelėje:

4. PHP skripto sukūrimas

Sukuriame PHP skriptą svetainės root direktorijoje. Failas jungsis prie duomenų bazės ir tikrins darbuotojai lentelę. Sukurkite naują failą:

sudo nano /var/www/html/darbuotojai.php

ir įkelkite PHP skriptą. Svarbu, kad sutikrintumėte visus kintamiuosius, kurie skirsis jūsų kuriamoje duomenų bazėje. Skriptą rasite atskirame faile darbuotojai.php, kuris prisegtas žemiau po įrašu.

Paaiškiname kelias esmines skripto dalis:

$redis = new Redis(); 
$redis->connect('127.0.0.1', 6379);

Šios dvi eilutės prijungia Redis serverį ir inicijuoja $redis kintamąjį skripte pateikiant užklausą į Redis serverį.

$sql = 'select
    darbuotojo_id,
    vardas,
    pavarde                                 
    from darbuotojai
    ';
$cache_key = md5($sql);

Kintamasis $sql atlieka SQL komandą, kuri pasiima įrašus iš duomenų bazės. Redis serveris naudoja $cache_key kintamąjį saugoti duomenis susietus su raktu. Šis skriptas naudoja md5 šifravimo algoritmą SQL komandoje tam, kad būtų sutrumpinamas raktas ir galimos problemos paeiškos būtų lengvesnės.

if ($redis->exists($cache_key)) {
$data_source = "Data from Redis Server";
$data = unserialize($redis->get($cache_key));
...

} else { 

 $data_source = 'Data from MySQL Database'; 

...     

 $redis->set($cache_key, serialize($data)); 
 $redis->expire($cache_key, 10);        

}

Aukščiau pateiktas kodas tikrina, ar Redis serveryje yra raktas $cache_key. Jei raktas yra, skriptas iš naujo nebetikrina duomenų ir papildomai nebeįrašo duomenų į $data kintamąjį. Jei Redis serveryje nėra $cache_key rakto, kodas nuskaito duomenis iš MySQL duomenų bazės iš naujo ir talpina juos naudodamas komandą $redis-> set.

Komanda $redis-> expire nustato galiojimo laiką sekundėmis, kurį raktas išlaiko atmintyje prieš jį ištrinant. Duomenų galiojimo laikas yra 10 sekundžių. Galite pakeisti šią vertę, kad atitiktų jūsų poreikius.

5. Redis kešavimo patikrinimas

Apsilankykite adresu:

http://jūsų_ip_adresas/darbuotojai.php

ir matysite duomenis, kurie bus užkraunami iš duomenų bazės:

Perkraukite puslapį ir jums bus pateikti kešuoti PHP duomenys iš Redis serverio:

Ankstesnė išvestis patvirtina, kad PHP skriptas veikia taip, kaip tikėtasi, ir duomenys teikiami iš greitos atminties talpyklos Redis serveryje. Tai sumažina duomenų nuskaitymo iš disko paieškos laiką. Taip pat galite pabandyti atnaujinti puslapį po 10 sekundžių, kad būtų panaikinamas kešavimas.

Pasitelkiant šį kešavimo būdą galite pagreitinti tam tikrų svetainės dalių ar aplikacijų užkrovimą ir pagerinti svetainės greitaveiką.

Duomenų bazių migravimas veiksmas atliekamas norint migruoti svetaines tarp skirtingų serverių. Šis veiksmas taip pat labai aktualus vykdant programinės įrangos kūrimą, kai reikia perkelti duomenis į kitą aplinką. Ne visada migravimas tarp sistemų atliekamas sklandžiai, todėl parengėme instrukciją, kaip tai atlikti paprastai ir greitai.

Šioje instrukcijoje bus naudojamos komandos veikiančios tiek MySQL tiek MariaDB duomenų bazėse. Instrukcija tinkama visoms Linux operacinėms sistemoms.

0. Preliminarūs reikalavimai:

• Linux virtualiai dedikuotas serveris;
• Papildomas naudotojas turintis sudo teises;
• Įdiegta MySQL arba MariaDB duomenų bazių valdymo sistema;
• Duomenų bazė esanti serveryje.

1. Duomenų bazės eksportavimas

Duomenų bazių ekportavimui į SQL tekstinį failą gali būti naudojama mysqldump komandą. Tai palengviną duomenų bazių migravimą. Šiam veiksmui atlikti turite naudoti duomanų bazių naudotojo, kuris turi bent duomenų bazės skaitymo teises.

Duomenų bazių eksportavimui naudojame šią komandą:
mysqldump -u naudotojas -p db_pavadinimas > duomenys.sql

• nautodojas - naudotojo vardas su kuriuo galite prisijungti prie duomenų bazių;
• db_pavadinimas - eksportuojamos duomenų bazės pavadinimas;
• duomenys.sql - duomenų bazės failo pavadinimas, kuriame bus išsaugomi DB duomenys tekstiniu formatu.

Komanda nepateiks jokio atsakymo, tačiau galite patikrinti ar failas buvo sėkmingai sukurtas su komanda:
head -n 5 data-dump.sql

Failo viršus turi būti panašus į šį, nurodant duomenų bazės pavadinimą:

-- MySQL dump 10.13 Distrib 5.7.16, for Linux (x86_64)
-- Host: localhost Database: database_name

---

-- Server version 5.7.16-0ubuntu0.16.04.1

Jeigu vis dėlto bus susiduriama su problemomis eksportuojant duomenis, Jums bus pateikiama klaida nurodanti priežastis.

2. Duomenų bazės inportavimas

Tam, kad galėtumėte atlikti duomenų bazės importavimą visą pirmą reikia susikurti tuščią duomenų bazę. Prisijungiame prie mySQL tarnybos su root teisėmis:
mysql -u root -p


Prisijungę prie sukurkite naują DB įvykdydami šią komandą:
CREATE DATABASE nauja_db;


Bus pateikiamas atsakymas nurodantis, kad DB buvo sukurta sėkmingai:

Query OK, 1 row affected (0.00 sec)

Tada atsijunkite iš MySQL paspausdami CTRL+D. Komandinėje eilutėje galite importuoti duomenų bazės failą naudodami šią komandą:
'mysql -u username -p nauja_db < duomenu_kopija.sql'

• nautodojas - naudotojo vardas su kuriuo galite prisijungti prie duomenų bazių;
• nauja_db - naujos duomenų bazės pavadinimas;
• duomenu_kopija.sql - duomenų bazės failo kopija.
  
  
  Jeigu perkėlimas atliktas sėkmingai, nebus patiekiamas papildomas atsakymas. Jeigu vis dėlto bus susiduriama su problemomis eksportuojant duomenis, Jums bus pateikiama klaida nurodanti priežastis. Norint patikrinti importavimą, prisijunkite prie MySQL ir paleiskite komandą USE nauja_db, o tada SHOW TABLES. Jums bus pateikiamos duomenų bazės lentelės.
  
  
  mysqldump turi ir daugiau papildomų nustatymų su kuriais galite įvykdyti ir daugiau veiklų su DB kopijomis. Daugiau informacijos apie šios komandos naudojimą rasite šiuo adresu:

https://dev.mysql.com/doc/refman/5.7/en/mysqldump.html

0. Preliminarūs reikalavimai

1. Serverio paruošimas diegimui

apt-get update 
apt-get install build-essential

yum update
yum groupinstall "Development Tools"

dnf update
dnf groupinstall "Development Tools"

2. SQLite3 paketo atsisiuntimas

cd ~
mkdir sqlite3 && cd sqlite3
wget [nuoroda į failą sqlite-autoconf-<versija>.tar.gz]
tar xvfz sqlite-autoconf-<versija>.tar.gz

3. SQLite sistemos diegimas ir konfigūravimas

cd sqlite-autoconf-<versija>
./configure
make
sudo make install

4. Versijos patikrinimas

sqlite3 --version

CREATE TABLE example_table (
    id INTEGER NOT NULL AUTO_INCREMENT,
    name VARCHAR(50),
    address VARCHAR(150),
    username VARCHAR(16),
    PRIMARY KEY (id),
    INDEX (username)
);

explain example_table;

+----------+--------------+------+-----+---------+----------------+
| Field    | Type         | Null | Key | Default | Extra          |
+----------+--------------+------+-----+---------+----------------+
| id       | int(11)      | NO   | PRI | NULL    | auto_increment |
| name     | varchar(50)  | YES  |     | NULL    |                |
| address  | varchar(150) | YES  |     | NULL    |                |
| username | varchar(16)  | YES  | MUL | NULL    |                |
+----------+--------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

CREATE INDEX index_name ON table_name(column_name);

ALTER TABLE table_name ADD INDEX ( column_name );

wget https://launchpad.net/test-db/employees-db-1/1.0.6/+download/employees_db-full-1.0.6.tar.bz2
tar xjvf employees_db-full-1.0.6.tar.bz2
cd employees_db
mysql -u root -p -t < employees.sql

mysql -u root -p
use employees;

SET GLOBAL query_cache_size = 0;
SHOW VARIABLES LIKE "query_cache_size";

+------------------+-------+
| Variable_name    | Value |
+------------------+-------+
| query_cache_size | 0     |
+------------------+-------+
1 row in set (0.00 sec)

SELECT COUNT(*) FROM salaries WHERE salary BETWEEN 60000 AND 70000;

+----------+
| count(*) |
+----------+
|   588322 |
+----------+
1 row in set (0.60 sec)

EXPLAIN SELECT COUNT(*) FROM salaries WHERE salary BETWEEN 60000 AND 70000;

+----+-------------+----------+------+---------------+------+---------+------+---------+-------------+
| id | select_type | table    | type | possible_keys | key  | key_len | ref  | rows    | Extra       |
+----+-------------+----------+------+---------------+------+---------+------+---------+-------------+
|  1 | SIMPLE      | salaries | ALL  | NULL          | NULL | NULL    | NULL | 2844738 | Using where |
+----+-------------+----------+------+---------------+------+---------+------+---------+-------------+
1 row in set (0.00 sec)

ALTER TABLE salaries ADD INDEX ( salary );
SELECT COUNT(*) FROM salaries WHERE salary BETWEEN 60000 AND 70000;

+----------+
| count(*) |
+----------+
|   588322 |
+----------+
1 row in set (0.14 sec)

Užklausų optimizavimas greičiui

SELECT * FROM SALARIES WHERE salary < 40000 LIMIT 1;

+--------+--------+------------+------------+
| emp_no | salary | from_date  | to_date    |
+--------+--------+------------+------------+
|  10022 |  11950 | 2000-09-02 | 2001-09-02 |
+--------+--------+------------+------------+
1 row in set (0.00 sec)

SELECT * FROM employees WHERE last_name like 'Bre%' OR first_name like 'Bre%';

SELECT * FROM employees WHERE last_name like 'Bre%' UNION SELECT * FROM employees WHERE first_name like 'Bre%';

Apibendrinimas

mysql> SHOW * FROM lentelės_pavadinimas;

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

. . .
#slow_query_log         = 1
#slow_query_log_file    = /var/log/mysql/mysql-slow.log
#long_query_time = 2
#log-queries-not-using-indexes
. . .

. . .
slow_query_log = 1
slow_query_log_file = /var/log/mysql-slow.log
long_query_time = 2
log_queries_not_using_indexes
. . .

. . .
slow_query_log = 1
slow_query_log_file = /var/log/mysql-slow.log
long_query_time = 2
log_queries_not_using_indexes

sudo systemctl restart mysql

sudo less /var/log/mysql_slow.log

MYSQL_PWD=jūsų_slaptažodis mysqldump -u jūsų_naudotojo_vardas --all-databases --routines --triggers > /tmp/all-databases.sql

service mariadb stop

rpm -e mariadb-bench

cp -a /var/lib/mysql/ /var/lib/mysql_backup

cd /etc/yum.repos.d/

touch MariaDB.repo

[mariadb]
name = MariaDB
baseurl = http://yum.mariadb.org/5.5/centos7-amd64
gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB
gpgcheck=1

yum install mariadb

service mariadb start

mysql -V

Spartus veikimas (gali būti apdorojama iki 220 000 įrašų per sekundę);

Palaiko

OrientDB palaido MySQL užklausas bei kalbą.

yum install java-1.8.0-openjdk

cd /opt/
wget -O orientdb-community-2.2.29.tar.gz http://orientdb.com/download.php?file=orientdb-community-2.2.29.tar.gz&os=linux

tar xvzf orientdb-community-2.2.29.tar.gz

mv orientdb-community-2.2.29/ orientdb

useradd -r orientdb -s /sbin/nologin

chown -R orientdb:orientdb /opt/orientdb/

nano /opt/orientdb/bin/orientdb.sh

ORIENTDB_DIR="/opt/orientdb"
ORIENTDB_USER="orientdb"

nano /opt/orientdb/bin/orientdb.service

#
# Copyright (c) OrientDB LTD (http://orientdb.com/)
#

[Unit]
Description=OrientDB Server
After=network.target
After=syslog.target

[Install]
WantedBy=multi-user.target

[Service]
User=orientdb
Group=orientdb
ExecStart=/opt/orientdb/bin/server.sh

mv /opt/orientdb/bin/orientdb.service /etc/systemd/system/

systemctl daemon-reload

systemctl start orientdb
systemctl enable orientdb

netstat -ln | grep 2480

• Ubuntu:

  sudo apt-get install mysql-server
  

• Centos:

  sudo yum install mysql-server
  

/etc/init.d/mysqld start

/etc/init.d/mysqld restart

/etc/init.d/mysqld stop

/etc/init.d/mysqld status

mysql -u root -p

• Visos MySQL komandos baigiasi kabliataškio (;) simboliu. Jeigu nėra padedamas kabliataškis komanda nebus vykdoma;
• Taip pat nors ir nėra privaloma, tačiau verta paminėti, jog suprantamumo dėlei įprastai MySQL komandos yra rašomos didžiosiomis raidėmis, o duomenų bazės, lentelės, vartotojai ar paprastas tekstas yra rašomas mažosiomis raidėmis. Bendru atveju MySQL komandos bus įvykdytos nepriklausomai ar jas rašant didžiosiomis ar mažosiomis raidėmis.

SHOW DATABASES;

+--------------------+
| Database           |
+--------------------+
| information_schema |
| admin_default      |
| mysql              |
| performance_schema |
| roundcube          |
| test_asdasd        |
+--------------------+
6 rows in set (0.00 sec)

CREATE DATABASE database_name;

DROP DATABASE database_name;

USE database_name;

SHOW tables; 

CREATE TABLE potluck (id INT NOT NULL PRIMARY KEY AUTO_INCREMENT, 
name VARCHAR(20),
food VARCHAR(30),
confirmed CHAR(1), 
signup_date DATE);

DESCRIBE potluck;

INSERT INTO `potluck` (`id`,`name`,`food`,`confirmed`,`signup_date`) VALUES (NULL, "John", "Casserole","Y", '2012-04-11');

Query OK, 1 row affected (0.00 sec)

SELECT * FROM potluck;

UPDATE `potluck` 
SET 
`confirmed` = 'N' 
WHERE `potluck`.`name` ='John';

ALTER TABLE potluck ADD email VARCHAR(40);

ALTER TABLE potluck ADD email VARCHAR(40) AFTER name; 

ALTER TABLE potluck DROP email;

DELETE from <lentelės_pavadinimas> where <stulpelio_pavadinimas>=[laukelio_turinys];

DELETE from potluck  where name='Sandy';

CREATE USER 'newuser'@'localhost' IDENTIFIED BY 'password';

GRANT ALL PRIVILEGES ON * . * TO 'newuser'@'localhost';

FLUSH PRIVILEGES;

GRANT <teisių_tipas> ON <duomenų_bazė>.<lentelė> TO ‘<vartotojas>’@'localhost’;

• ALL PRIVILEGES - visos galimos teisės;
• CREATE - leidimas sukurti naują lentelę ar duomenų bazę;
• DROP - leidimas pašalinti lentelę ar duomenų bazę;
• DELETE - leidimas pašalinti eilutę (įrašą) iš lentelės;
• INSERT - leidimas įterpti eilutę (įrašą) į lentelę;
• SELECT - leidimas naudoti SELECT komanda, kurios pagalba vartotojas galės peržiūrėti duomenų bazėje saugomus duomenis;
• UPDATE - leidimas atnaujinti esamus įrašus;
• GRANT OPTION - leidimas suteikti ar pašalinti vartotojams teises.

REVOKE <teisių_tipas> ON <duomenų_bazė>.<lentelė> FROM ‘<vartotojas>’@'localhost’;

DROP USER ‘demo’@‘localhost’;

quit

mysql -u<vartotojas> -p

service mysqld stop

mysqld_safe --skip-grant-tables

mysql -u root

use mysql;
update user set Password=PASSWORD('jūsų_naujasis_slaptažodis') where user='root';
flush privileges;
exit;

service mysqld restart

shell> mysqld --verbose --help

nano -w /etc/my.cnf

# Žemiau pateikiamos reikšmės bus pritaikomos visiems MySQL klientams
[client]
#password       = jusu_slaptazodis
port            = 3306
socket          = /var/run/mysqld/mysqld.sock

# Pateikiamos specifinių programų reikšmės

# MySQL serveris
[mysqld]
port            = 3306
socket          = /var/run/mysqld/mysqld.sock
skip-locking
key_buffer = 256M
key_buffer_size = 512M
max_allowed_packet = 1M
table_cache = 256
sort_buffer_size = 1M
read_buffer_size = 1M
read_rnd_buffer_size = 4M
myisam_sort_buffer_size = 64M
thread_cache_size = 8
query_cache_size= 512M
tmp_table_size = 256M
max_heap_table_size = 256M

# Dauginame iš esamo server CPU branduolių kiekio*2 thread_concurrency reikšmei nustatyti
thread_concurrency = 4

# Jei nesijungiate prie MySQL serverio iš išorės, tuomet šią nuostatą galite aktyvuoti.
#skip-networking

# Pašalinkite ženklą # , jei naudojate BDB lenteles
#bdb_cache_size = 64M
#bdb_max_lock = 100000

# Pašalinkite ženklą # , jei naudojate InnoDB lenteles

#innodb_data_home_dir = /var/lib/mysql/
#innodb_data_file_path = ibdata1:10M:autoextend
#innodb_log_group_home_dir = /var/lib/mysql/
#innodb_log_arch_dir = /var/lib/mysql/

# Galite nustatyti sesijos kintamojo .._buffer_pool_size dydį iki 50 - 80 %
# serverio virtualios atminties dydžio.

#innodb_buffer_pool_size = 256M
#innodb_additional_mem_pool_size = 20M

# Galite nustatyti reikšmę .._log_file_size iki 25 % sesijos kintamojo 
# .._buffer_pool_size dydžio

#innodb_log_file_size = 64M
#innodb_log_buffer_size = 8M
#innodb_flush_log_at_trx_commit = 1
#innodb_lock_wait_timeout = 50

[mysqldump]
quick
max_allowed_packet = 16M

[mysql]
no-auto-rehash

# Pašalinkite žemiau pateiktos reikšmės komentaro simbolį # jei nesate detaliai susipažinę su SQL
#safe-updates

[isamchk]
key_buffer = 128M
sort_buffer_size = 128M
read_buffer = 2M
write_buffer = 2M

[myisamchk]
key_buffer = 128M
sort_buffer_size = 128M
read_buffer = 2M
write_buffer = 2M

[mysqlhotcopy]
interactive-timeout

service mysqld restart

• Intensyviai naudojamai MySQL duomenų bazei išskirkite atskirą dedikuotą serverį, tuomet serverio resursai bus skirti tik MySQL tarnybos palaikymui;
• Optimizuokite MySQL duomenų bazių lenteles;
• Nuolatos stebėkite MySQL programinės įrangos resursų suvartojimą, atitinkamai atlikite pakeitimus konfigūraciniame faile my.cnf ;
• Naudojantiems InnoDB pagrindu veikiančias duomenų bazes, rekomenduojame peržiūrėti Percona MySQL sprendimą.