റിമോട്ട് കണക്ഷനായി ഡാറ്റാബേസ് ലഭ്യമാക്കുന്നു

ഒരു ഡാറ്റാബേസിലേക്ക് ഒരു കണക്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ആപ്ലിക്കേഷൻ നിർമ്മിക്കേണ്ട സാഹചര്യങ്ങളുണ്ടെന്ന വസ്തുതയിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം. കൈകളുടേയും കഴിവുകളുടേയും അഭാവം നിമിത്തം ബാക്കെൻഡ് ഡെവലപ്‌മെന്റിലേക്ക് അധികം കടക്കാതിരിക്കാനും ഫ്രണ്ടെൻഡിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാനുമാണ് ഇത് ചെയ്യുന്നത്. എന്റെ പരിഹാരം സുരക്ഷിതമായിരിക്കുമെന്ന് എനിക്ക് പറയാനാവില്ല, പക്ഷേ അത് പ്രവർത്തിക്കുന്നു.

ഹോസ്റ്റിംഗിന് പണം നൽകുന്നത് എനിക്ക് ഇഷ്ടമല്ലാത്തതിനാൽ, എന്റെ ജോലിസ്ഥലത്ത് ഞാൻ നെറ്റ്‌വർക്ക് ഉപയോഗിച്ചു, അവിടെ ഒരു വെളുത്ത IP ഉണ്ട്. അതിന്റെ ഘടന ഇതാ:

എനിക്ക് നിരവധി കമ്പ്യൂട്ടറുകളിലേക്ക് ആക്‌സസ് ഉണ്ട്, കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ 192.168.1.2 (അതായത് 192.168.0.2) അവിടെ ലിനക്സ് ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്, കൂടാതെ 192.168.0.3 വിൻഡോസിലും. പൊതുവേ, ഞാൻ എന്റെ ആപ്ലിക്കേഷനായി mysql തിരഞ്ഞെടുത്തു, Linux-ൽ എന്താണ് ലഭ്യമെന്ന് നോക്കി. ഇത് ഇതിനകം അവിടെ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്, പക്ഷേ ആർക്കും പാസ്‌വേഡ് അറിയില്ല, അറിയുന്നവർ മറന്നു (എനിക്ക് മുമ്പ് ജോലി ചെയ്തവർ). ആർക്കും ആവശ്യമില്ലെന്ന് മനസ്സിലാക്കിയ ഞാൻ അത് ഇല്ലാതാക്കി വീണ്ടും ഇൻസ്റ്റാൾ ചെയ്യാൻ ശ്രമിച്ചു. മതിയായ മെമ്മറി ഇല്ലായിരുന്നു, ഈ പിശക് പരിഹരിക്കുന്നതിന് ഞാൻ ഒരു മോണിറ്ററും കീബോർഡും അതിലേക്ക് ഒരു മൗസുമായി ബന്ധിപ്പിക്കേണ്ടതിനാൽ, ഈ കാര്യം ഉപേക്ഷിക്കാൻ ഞാൻ തീരുമാനിച്ചു. മാത്രമല്ല, വിൻഡോസ് ഉള്ള മെഷീൻ കൂടുതൽ ശക്തവും പ്ലസ് ആണ്, എന്റെ ലാപ്‌ടോപ്പിൽ ഇത് വീട്ടിൽ ഉണ്ട്. തത്വത്തിൽ, ഞാൻ ഇൻസ്റ്റാളേഷൻ തന്നെ വിവരിക്കില്ല; അതിനെക്കുറിച്ച് ധാരാളം മാനുവലുകളും വീഡിയോകളും ഉണ്ട്. ഒരു വിൻഡോസ് മെഷീനിൽ mysql ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, എന്റെ ലാപ്‌ടോപ്പിൽ നിന്ന് എന്റെ വർക്ക്സ്റ്റേഷനിലേക്ക് ടേബിളുകൾ ബാക്കപ്പ് ചെയ്യാൻ ഞാൻ തീരുമാനിച്ചു.

ഇത് ഇതുപോലെ ചെയ്തു (എന്റെ കാര്യത്തിൽ):

mysqldump -uroot -p your_base > dump_file.sql

അടുത്തതായി, ഞങ്ങൾ പുതിയ ഡാറ്റാബേസിൽ ഒരു ഡാറ്റാബേസ് സൃഷ്ടിക്കുകയും "പുതിയ" മെഷീനിൽ ബാക്കപ്പ് പുനഃസ്ഥാപിക്കുകയും ചെയ്യുന്നു.

mysql -h localhost -u root -p

create database your_base;
use your_base;

mysql -uroot -p your_base < dump_file.sql

show tables;

ബാക്കപ്പ് ഫയൽ പുതിയ മെഷീനിൽ സ്ഥാപിക്കണം, ഒരുപക്ഷേ, യൂട്ടിലിറ്റി ഉള്ള ഡയറക്ടറിയിൽ ഇല്ലെങ്കിൽ, അതിലേക്കുള്ള മുഴുവൻ പാതയും. (ഞാൻ ഇപ്പോൾ GitHub-ലേക്ക് ബാക്കപ്പ് അപ്‌ലോഡ് ചെയ്യുകയും ഒരു പുതിയ മെഷീനിലേക്ക് ക്ലോൺ ചെയ്യുകയും ചെയ്തു). പട്ടികകൾ എങ്ങനെ സൃഷ്ടിക്കപ്പെടുന്നുവെന്ന് ഞാൻ കൂട്ടിച്ചേർക്കും, പക്ഷേ ഞാൻ സ്ക്രീൻഷോട്ടുകൾ സംരക്ഷിച്ചില്ല, 2-3 വർഷത്തെ വിദ്യാർത്ഥിക്ക് പോലും ഇത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ലെന്ന് ഞാൻ കരുതുന്നു.

എല്ലാ പട്ടികകളും പുനഃസ്ഥാപിക്കുമ്പോൾ, ഡാറ്റാബേസിലേക്ക് വിദൂര ആക്സസ് ലഭ്യമാക്കാനുള്ള സമയമാണിത്. പൊതുവേ, അത്തരം കമാൻഡുകൾ വിജയത്തിലേക്ക് നയിച്ചില്ല (ഇത് തിരഞ്ഞെടുക്കാൻ വായന അനുമതി മാത്രം നൽകി)

create user 'client'@'%' IDENTIFIED by 'client';
grant select on your_base . * to 'client'@'%';
flush privileges;

കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, കമാൻഡ് ഉപയോഗിച്ച് മാത്രമേ എനിക്ക് ഡാറ്റാബേസിലേക്ക് കണക്റ്റുചെയ്യാൻ കഴിയൂ,

mysql -h localhost -u client -pclient

എന്നാൽ ഇയാൾക്ക് ഇനി അത് ചെയ്യാൻ കഴിഞ്ഞില്ല

mysql -h 192.168.0.3 -u client -pclient

ഇത് എനിക്ക് വേണ്ടി പ്രവർത്തിച്ചില്ല, എനിക്ക് ഈ വിലാസം വഴി റൂട്ട് ആയി ബന്ധിപ്പിക്കാൻ കഴിഞ്ഞില്ല.

mysql വർക്ക് ബെഞ്ച് പ്രോഗ്രാം സഹായിച്ചു; ക്രമീകരണങ്ങളിൽ, ലോക്കൽ ഹോസ്റ്റ് % ആയി മാറ്റുക, ക്ലയന്റ് സഹായിച്ചില്ലെങ്കിലും ഇത് പ്രവർത്തിക്കുന്നു. ഇപ്പോൾ നിങ്ങൾക്ക് കൺസോളിൽ നിന്നോ ഏതെങ്കിലും വിലാസത്തിൽ നിന്നുള്ള കോഡിൽ നിന്നോ ഡാറ്റാബേസിലേക്ക് കണക്റ്റുചെയ്യാനാകും.

നിങ്ങൾ ഒരു ഹോം അല്ലെങ്കിൽ ബിസിനസ് നെറ്റ്‌വർക്ക് ഉണ്ടാക്കുകയും വിൻഡോസ് ഫയർവാൾ ഓഫ് ചെയ്യുകയും വേണം, അല്ലാത്തപക്ഷം നിങ്ങൾക്ക് ഈ മെഷീൻ പിംഗ് ചെയ്യാൻ പോലും കഴിയില്ല (ഡാറ്റാബേസിലേക്ക് കണക്റ്റുചെയ്യുക).

പകുതി ജോലി പൂർത്തിയായി, ഇപ്പോൾ എനിക്ക് വീട്ടിൽ നിന്ന് ഡാറ്റാബേസുമായി ബന്ധിപ്പിക്കാൻ കഴിയണം.

നെറ്റ്‌വർക്ക് ഡയഗ്രാമിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഇന്റർനെറ്റിലേക്ക് പോകുന്നതിന് നിങ്ങൾ 192.168.0.3 മുതൽ 192.168.1.1 (റൗട്ടർ) ലേക്ക് പോകേണ്ടതുണ്ട്, നമുക്ക് വിപരീത ദിശയിലേക്ക് പോകാം. 192.168.1.1 മുതൽ 192.168.1.2 വരെയുള്ള റൂട്ട് ഇതുപോലെ ക്രമീകരിക്കാം:

പൊതുവേ, ചിത്രം കാണിക്കുന്നില്ല, അതിനാൽ ഞാൻ ഇത് കൈകൊണ്ട് എഴുതാം:

route add 192.168.0.0 mask 255.255.255.0 gateway 192.168.1.2

ഇത് ഒരു സബ്‌നെറ്റിൽ മാത്രമേ ചെയ്യാൻ കഴിയൂ, അതായത്, നിങ്ങൾക്ക് 192.168.0.2 അല്ലെങ്കിൽ 192.168.0.3 എന്ന വിലാസത്തിലേക്ക് ഉടൻ കൈമാറാൻ കഴിയില്ല.

സബ്‌നെറ്റ് 192.168.0.0/24 എവിടെയാണെന്ന് റൂട്ടറിന് അറിയാൻ ഇത് ആവശ്യമാണ് (നെറ്റ്‌വർക്കുകളുടെ അടിസ്ഥാനകാര്യങ്ങൾ പഠിക്കുന്നത് ഉപയോഗപ്രദമാണ്).

ഇപ്പോൾ 3306 എന്ന വിലാസത്തിലേക്ക് പോർട്ട് ഫോർവേഡിംഗ് 192.168.1.2 (സ്ഥിര mysql പോർട്ട് (ഇൻസ്റ്റാളേഷൻ സമയത്ത് നിങ്ങൾ അത് മാറ്റിയില്ലെങ്കിൽ)) ചേർക്കുന്നു.

ഒരു ലിനക്സ് മെഷീനിൽ ഫോർവേഡിംഗ് ചെയ്യുക എന്നതാണ് ഏറ്റവും ബുദ്ധിമുട്ടുള്ള കാര്യം (ഇതിന് രണ്ട് നെറ്റ്‌വർക്ക് കാർഡുകൾ 192.168.1.2 (enp3s1 ഇന്റർഫേസ്), 192.168.0.2 (enp3s0 ഇന്റർഫേസ്) എന്നിവയുണ്ട്, അതിനാൽ നെറ്റ്‌വർക്ക് കാർഡുകൾക്ക് 192.168.1.2 ൽ നിന്ന് എന്താണ് കൈമാറേണ്ടതെന്ന് അറിയാൻ കഴിയും. 192.168.0.2 ലേക്ക്, തുടർന്ന് 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
и последняя строчка сохраняет введенные команды чтобы они при перезапуске оси не стерлись
sudo service iptables-persistent save

ആ. ആദ്യത്തെ കണക്ഷൻ ഞങ്ങൾ അംഗീകരിക്കുന്നു എന്നാണ് ആദ്യ വരി അർത്ഥമാക്കുന്നത്, 1-ഉം 2-ഉം ഞങ്ങൾക്ക് രണ്ട് ദിശകളിലേക്കും പാക്കറ്റുകൾ അയയ്ക്കാം, 3-ഉം 4-ഉം അർത്ഥമാക്കുന്നത് ലക്ഷ്യസ്ഥാനവും ഉറവിട വിലാസങ്ങളും മാറ്റുന്നു എന്നാണ്. കൂടാതെ voila, നിങ്ങൾക്ക് വീട്ടിൽ നിന്ന് mysql വഴി കണക്റ്റുചെയ്യാനാകും. ഒടുവിൽ, ഇത് ചെയ്യുന്ന എന്റെ C++ കോഡ്:

//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); //Если используется оконное приложение
	}
	// Подключаемся к серверу
	if (!mysql_real_connect(conn, "192.168.0.3", "root", "password", "your_base", NULL, NULL, 0))
	{
		// Если нет возможности установить соединение с сервером 
		// базы данных выводим сообщение об ошибке
		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;
};

ഇപ്പോൾ നിങ്ങൾക്ക് ഈ പ്രോഗ്രാം സുരക്ഷിതമായി ആർക്കും അയയ്‌ക്കാൻ കഴിയും, കൂടാതെ ഇത് പ്രാദേശികമായി പ്രവർത്തിക്കുന്നതിന് നിങ്ങൾ അത് വീണ്ടും എഴുതേണ്ടതില്ല.

അവലംബം: www.habr.com