Iniziamo col dire che ci sono casi in cui è necessario creare un'applicazione con connessione al database. Questo viene fatto per non dover approfondire lo sviluppo del backend e concentrarsi sul frontend a causa della mancanza di risorse e competenze. Non mi permetto di dire che la mia soluzione sarà sicura, ma funziona.
Poiché non mi piace pagare per hosting, ho utilizzato la rete del mio lavoro, che ha un IP pubblico. Ecco la sua struttura:
Ho accesso a diversi computer, precisamente a 192.168.1.2 (che è anche 192.168.0.2) dove è installato Linux, e a 192.168.0.3 con Windows. Per la mia applicazione ho scelto MySQL e ho verificato cosa ci fosse su Linux. Lì era già installato, ma nessuno conosceva la password, e chi la conosceva l'ha dimenticata (quelli che ci lavoravano prima di me). Scoprendo che non serviva a nessuno, l'ho disinstallato e ho provato a reinstallarlo. Non c'era abbastanza memoria e poiché per correggere questo errore avrei dovuto collegare un monitor insieme a tastiera e mouse, ho deciso di abbandonare l'idea. Inoltre, la macchina con Windows è molto più potente e, per di più, ne ho una sul laptop a casa. In realtà non descriverò l'installazione, ci sono molti manuali e video a riguardo. Dopo aver installato MySQL sulla macchina Windows, ho deciso di fare un backup delle tabelle dal laptop alla workstation.
Ecco come si fa (nel mio caso):
mysqldump -uroot -p your_base > dump_file.sql
Poi nella nuova base dati creiamo il database e ripristiniamo il backup sulla "nuova" macchina.
mysql -h localhost -u root -p
create database your_base;
use your_base;
mysql -uroot -p your_base < dump_file.sql
show tables;
Il file di backup deve essere copiato sul nuovo server e, se non si trova nella directory dell'utilità, è necessario specificare il percorso completo. (Io ho semplicemente caricato il backup su GitHub e l'ho clonato sulla nuova macchina). Aggiungerei come sono state create le tabelle, ma non ho salvato screenshot e penso che non sia difficile nemmeno per uno studente del secondo o terzo anno.
Quando ho ripristinato tutte le tabelle, è arrivato il momento di abilitare l'accesso remoto al database. In generale, tali comandi non hanno portato a risultati (sono stati conferiti solo diritti di lettura select).
create user 'client'@'%' IDENTIFIED by 'client';
grant select on your_base . * to 'client'@'%';
flush privileges;
In realtà, potevo collegarmi al database solo usando il comando.
mysql -h localhost -u client -pclient
ma non riuscivo a utilizzare questo.
mysql -h 192.168.0.3 -u client -pclient
Questo non funzionava nemmeno e non riuscivo a connettermi attraverso questo indirizzo e come root.
Il programma mysql workbench mi ha aiutato, basta cambiare localhost in % nelle impostazioni e funziona, anche se per client non ha funzionato. Ora puoi connetterti al database dalla console o dal codice da qualsiasi indirizzo.
Inoltre, devi configurare la rete come domestica o di azienda e disattivare il firewall di Windows, altrimenti non sarai nemmeno in grado di pingare questa macchina (figurarsi di connetterti al database).
La metà del lavoro è fatta, ora devo poter collegarmi al database da casa.
Come si può vedere dallo schema di rete, per arrivare a Internet è necessario percorrere il tragitto da 192.168.0.3 a 192.168.1.1 (router); procediamo all'indietro. Configuriamo il percorso da 192.168.1.1 a 192.168.1.2 in questo modo:
In sintesi, l'immagine non si vede — lo scriverò a mano:
route add 192.168.0.0 mask 255.255.255.0 gateway 192.168.1.2
Questo è possibile farlo solo in una sottorete, quindi non si può inoltrare direttamente agli indirizzi 192.168.0.2 o 192.168.0.3.
Questo è necessario affinché il router sappia dove si trova la sottorete 192.168.0.0/24 (studiate le basi delle reti, è utile).
Ora aggiungiamo l'inoltro della porta 3306 (la porta di MySQL per impostazione predefinita (a meno che non l'abbiate cambiata durante l'installazione)) all'indirizzo 192.168.1.2.
Rimane da fare la cosa più difficile: configurare il forwarding su una macchina Linux (che ha due schede di rete, 192.168.1.2 (interfaccia enp3s1) e 192.168.0.2 (interfaccia enp3s0)) affinché le schede di rete sappiano di dover inoltrare dal 192.168.1.2 al 192.168.0.2, e poi alla nostra macchina Windows con MySQL.
sudo iptables -A FORWARD -i enp3s1 -o enp3s0 -p tcp --syn --dport 3306 -m conntrack --ctstate NEW -j ACCEPT
sudo iptables -A FORWARD -i enp3s1 -o enp3s0 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
sudo iptables -A FORWARD -i enp3s0 -o enp3s1 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
sudo iptables -t nat -A PREROUTING -i enp3s1 -p tcp --dport 3306 -j DNAT --to-destination 192.168.0.3
sudo iptables -t nat -A POSTROUTING -o enp3s0 -p tcp --dport 3306 -d 192.168.0.3 -j SNAT --to-source 192.168.1.2
E l'ultima riga salva i comandi in modo che non vengano persi al riavvio del sistema
sudo service iptables-persistent save
Quindi, la prima riga indica che accettiamo la prima connessione, la seconda e la terza che è possibile inviare pacchetti in entrambe le direzioni, la quarta e la quinta indicano la sostituzione degli indirizzi di destinazione e sorgente. E voilà, si può connettersi da casa tramite MySQL. E infine, il mio codice in C++ che lo fa:
//DataBaseConnection.cpp
#include "DataBaseConnection.h"
DataBaseConnection::DataBaseConnection()
{
}
void DataBaseConnection::Connect()
{
// Получаем дескриптор соединения
conn = mysql_init(NULL);
if (conn == NULL)
{
// Если дескриптор не получен – выводим сообщение об ошибке
fprintf(stderr, "Error: can'tcreate MySQL-descriptorn");
//exit(1); //Если используется оконное приложение
}
// Подключаемся к server
if (!mysql_real_connect(conn, "192.168.0.3", "root", "password", "your_base", NULL, NULL, 0))
{
// Se non è possibile stabilire una connessione con server
// базы данных выводим сообщение об ошибке
fprintf(stderr, "Error: can't connect to database: %sn", mysql_error(conn));
}
else
{
// Если соединение успешно установлено выводим фразу - "Success!"
fprintf(stdout, "Success!n");
}
}
std::vector<std::string> DataBaseConnection::Query()
{
vectordrum.clear();
std::string query = "SELECT * FROM drum where id=0";
const char * q = query.c_str();
qstate = mysql_query(conn, q);
if (!qstate)
{
res = mysql_store_result(conn);
while (row = mysql_fetch_row(res))
{
//printf("ID: %s,Position: %s, Image: %sn", row[0], row[1], row[2]);
vectordrum.push_back(row[2]);
}
}
else
{
std::cout << "Query failed:" << mysql_error(conn) << std::endl;
}
return vectordrum;
}
void DataBaseConnection::Close()
{
// Закрываем соединение с сервером базы данных
mysql_close(conn);
}
DataBaseConnection::~DataBaseConnection()
{
vectordrum.clear();
}
//DataBaseConnection.h
#pragma once
#include <iostream>
#include <mysql.h>
#include <vector>
#pragma comment(lib,"mysqlcppconn.lib")
#pragma comment(lib,"libmysql.lib")
class DataBaseConnection
{
public:
DataBaseConnection();
void Connect();
std::vector<std::string> Query();
void Close();
~DataBaseConnection();
MYSQL *conn;
MYSQL_ROW row;
MYSQL_RES *res;
int qstate;
std::vector<std::string> vectordrum;
};
Ora puoi tranquillamente inviare questo programma a chiunque, e non è necessario riscriverlo per farlo funzionare localmente.
Fonte: habr.com
