Fjärrövervakning och hantering av enheter baserade på Lunix/OpenWrt/Lede genom port 80...

Hej alla, detta är min första erfarenhet på Habra. Jag vill skriva om hur man på ett icke-standardiserat sätt hanterar nätverksutrustning i ett externt nätverk. Vad betyder icke-standardiserat: i de flesta fall, för att hantera utrustning i ett externt nätverk behöver du:

• En offentlig IP-adress. Eller om utrustningen är bakom någons NAT, så en offentlig IP och en 'forwardad' port.
• En tunnel (PPTP/OpenVPN/L2TP+IPSec etc.) till en central nod, genom vilken den skulle vara tillgänglig.

Därför kommer 'min cykel' att behövas när standardmetoderna inte passar dig, till exempel:

1. Utrustningen ligger bakom NAT och förutom vanlig http (port 80) är allt stängt. En helt normal situation för stora federala företagsnätverk. Det kan ta tid att skriva in portar, och de gör det inte omedelbart, snabbt eller för dig.
2. Instabil och/eller 'smal' kommunikationskanal. Låg hastighet, ständiga förluster. Smärta och besvikelse vid försök att organisera en tunnel.
3. Kostsam kommunikationskanal, där varje megabyte bokstavligt talat räknas. Till exempel satellitkommunikation. Dessutom stora fördröjningar och en 'smal' bandbredd.
4. En situation där du behöver 'jonglera' med en stor mängd små routrar, där OpenWrt/Lede är installerat på ena sidan för att utöka möjligheterna, medan tillgången på resurser (minne) på routern långt ifrån räcker till allt.

Notering nummer ett Vad hindrar dig från att sätta in ett 'flashminne' i USB-porten på routern för att utöka routerns minne?

Oftast handlar det om kostnadskrav på lösningen som helhet, men ibland spelar formfaktorn också en avgörande roll. Till exempel, på platsen finns TP-Link ML3020, vars enda USB-port används av en 2G/3G-modem, allt är inpackat i något litet plastfodral och placerat högt (på en mast), långt borta (på fältet, 30 km från den närmaste mobiloperatörens basstation). Ja, du kan sätta in en USB-hub och öka antalet portar, men erfarenheten visar att detta är skrymmande och opålitligt.

Så jag har försökt beskriva min typiska situation: 'någonstans långt borta, finns en mycket viktig, ensam och liten router som kör Linux. Det är viktigt att veta minst en gång om dagen att den är "levande" och vid behov skicka kommandon till den, till exempel "sol, starta om!"

Låt oss gå vidare till implementeringen:

1) På routern, via cron var 5/10/1440 minut, eller när som helst, behöver vi skicka en http-förfrågan till servern med hjälp av wget, spara resultatet av förfrågan i en fil, göra filen körbar och köra den.

Min rad i cron ser ungefär ut så här:

Fil /etc/crontabs/root:

  * /5 * * * * wget "http://xn--80abgfbdwanb2akugdrd3a2e5gsbj.xn--p1ai/a.php?u=user&p=password" -O /tmp/wa.sh && chmod 777 /tmp/wa.sh && /tmp/wa.sh

, där:
xn--80abgfbdwanb2akugdrd3a2e5gsbj.xn--p1ai — domän för min server. Jag nämner direkt: ja, det går att ange en specifik ip-adress till servern, vi gjorde så tidigare, men vårt land, i en rättfärdig strävan att bekämpa något jag inte vet vad, stängde tillgången till en stor del av 'molnen' från DigitalOcean och Amazon. Om du använder en symbolisk domän kan du, om en sådan situation uppstår, enkelt sätta upp ett reservmoln, omdirigera domänen dit och återupprätta övervakning av enheter.

a.php — namnet på skriptet på servern. Ja, jag vet att det är fel, att namnge variabler och filnamn med en bokstav… låt oss säga att vi sparar några byte för att skicka förfrågan 🙂
u — användarnamn, inloggning för enheten
p — lösenord
‘-O /tmp/wa.sh’ — filen på den avlägsna routern där serverns svar kommer att sparas, som till exempel kommandot reboot.

Anteckning nummer två: Aaaa, varför använder vi wget istället för curl, eftersom man genom curl kan skicka https-förfrågningar och inte bara GET utan även POST? Aaaa, därför att, som i det gamla skämtet, ‘Det går inte att få ner det i krukan!’. Curl innehåller krypteringsbibliotek som är runt 2 MB stora, och därför är det osannolikt att du kan skapa en bild för en liten TP-LINK ML3020 till exempel. Men med wget — absolut.

2) På servern (i mitt fall Ubuntu) kommer vi att använda Zabbix. Varför: jag vill att det ska vara snyggt (med diagram) och bekvämt (skicka kommandon via kontextmenyn). Zabbix har en fin funktion kallad zabbix-agent. Via agenten kommer vi att anropa ett php-skript på servern, som kommer att returnera information om huruvida vår router registrerades under den angivna tidsperioden. För att lagra information om registreringstider och kommandon för enheter använder jag MySQL, en separat tabell users med ungefär dessa fält:

		SKAPA TABELL `users` (
		  `id` varchar(25) NOT NULL,
		  `passwd` varchar(25) NOT NULL,
		  `description` varchar(150) NOT NULL,
		  `category` varchar(30) NOT NULL,
		  `status` varchar(10) NOT NULL,
		  `last_time` varchar(20) NOT NULL, // sista anslutningstid
		  `last_ip` varchar(20) NOT NULL, // sista anslutningens IP
		  `last_port` int(11) NOT NULL, // sista anslutningens port
		  `task` text NOT NULL, // uppgift som routern får
		  `reg_task` varchar(150) NOT NULL, // "regelbundet" uppgift, om vi vill att uppgiften ska utföras alltid vid registrering
		  `last_task` text NOT NULL, // uppgiftslogg
		  `response` text NOT NULL, // här skrivas svaret från enheten
		  `seq` int(11) NOT NULL
		) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Alla källor kan hämtas från Git-repositoriet på adressen: https://github.com/BazDen/iotnet.online.git
Nu PHP-skript som placeras på serversidan (för bekvämlighet kan de läggas i mappen /usr/share/zabbix/):

Fil a.php:

set_charset("utf8");
	// Här söker vi efter vår router i databastabellen
	$sql_users=$conn->prepare("SELECT task, reg_task, response, last_time FROM users WHERE id=? AND passwd=? AND status='active';");
	$sql_users->bind_param('ss', $user, $password);
	$sql_users->bind_result($task, $reg_task, $response, $last_time);
	$sql_users->execute();
	$sql_users->store_result();
	if (($sql_users->num_rows)==1){
		$sql_users->fetch();
		// Här skickar vi routern dess uppgifter
		echo $task;
		echo "n";
		echo $reg_task;
		// Här skriver vi tidpunkten för svaret och själv svaret från routern
		$response_history="[".date("Y-m-d H:i")."] ".$message;
		// Uppgiften har skickats, nu måste vi ta bort den, och efter att den har tagits bort markerar vi i loggen att uppgiften har slutförts
		$last_ip=$_SERVER["REMOTE_ADDR"];
		$last_port=$_SERVER["REMOTE_PORT"];
		$ts_last_conn_time=$last_time;
		$sql_users=$conn->prepare("UPDATE users SET task='', seq=1 WHERE (id=?);");
		$sql_users->bind_param('s', $user);
		$sql_users->execute();
		if (strlen($message)>1){
			$sql_users=$conn->prepare("UPDATE users SET response=?, seq=1 WHERE (id=?);");
			$sql_users->bind_param('ss', $response_history, $user);
			$sql_users->execute();
		}
		// Nu måste vi spara tidpunkten för registreringen av användaren, dess ip och meddelandet från dem. För nu bara meddelandet
		$ts_now=time();
		$sql_users=$conn->prepare("UPDATE users SET last_time=?, last_ip=?, last_port=? WHERE (id=?);");
		$sql_users->bind_param('ssss', $ts_now, $last_ip, $last_port, $user);
		$sql_users->execute();
	}
	// Om vi inte hittade routern i vår databas, eller dess status är "inaktiv", kommer kommandot reboot... att skickas till den
	// Varför så hårt? För eftersom routrar ibland försvinner, är det ett litet sätt att straffa "nya ägare". 
	else
	{
	echo "reboot";
	}
	$sql_users->close();
	?>

Filen agent.php (detta är skriptet för den anropade zabbix-agenten):

set_charset("utf8");
	$sql_users=$conn->prepare("SELECT seq FROM users WHERE id=? AND passwd=? AND status='active';");
	$sql_users->bind_param('ss', $user, $password);
	$sql_users->bind_result($seq);
	$sql_users->execute();
	$sql_users->store_result();
	// Datautbyte sker genom seq-fältet. Vid registrering ställer utrustningen in detta fält till "1"
	if (($sql_users->num_rows)==1){
		$sql_users->fetch();
		echo $seq;
	}
		
	// Nollställer $seq.
	$sql_users=$conn->prepare("UPDATE users SET seq=0 WHERE id=? AND passwd=? AND status='active';");
	$sql_users->bind_param('ss', $user, $password);
	$sql_users->execute();
	$sql_users->close();
?>		

Och den sista etappen: registrera agenten och lägga till diagram.

Om du inte har installerat zabbix-agent ännu:

apt-get install zabbix-agent

Redigera filen /etc/zabbix/zabbix_agentd.conf.

Lägg till raden:

UserParameter=test,php /usr/share/zabbix/agent.php user password

, där:
test — namnet på vår agent
„php /usr/share/zabbix/agent.php user password“ — skriptet som anropas med autentiseringsuppgifterna för enheten.

Lägga till diagram: öppna zabbix webgränssnitt, välj i menyn:
Inställning -> Nätverksnoder -> Skapa nätverksnod. Här behöver du bara ange namnet på nätverksnod, dess grupp och agentens standardgränssnitt:

Nu behöver vi för denna nätverksnod lägga till en datakomponent. Observera de två fälten: „nyckel“ — det är den parameter som vi angav i filen /etc/zabbix/zabbix_agentd.conf (i vårt fall test), och „uppdateringsintervall“ — jag sätter 5 minuter, eftersom utrustningen registreras på servern också en gång var femte minut.

Och så lägger vi till diagrammet. Jag rekommenderar att välja „Fyllning“ som ritstil.

Resultatet blir något ganska minimalistiskt, till exempel så här:

Till den rimliga frågan: „var det värt det?“, svarar jag: självklart, se „skälen till att skapa cykeln“ i början av artikeln.

Om min första grafomana erfarenhet väcker intresse hos läsarna, vill jag i nästa artiklar beskriva hur man skickar kommandon till fjärrutrustningen. Jag har också lyckats implementera hela systemet även för enheter baserade på RouterOS (Mikrotik-enheter).

Källa: habr.com