Accesso al server Linux tramite un bot di Telegram in Python

Spesso si verificano situazioni in cui l'accesso al server è necessario qui e ora. Tuttavia, non sempre la connessione SSH è il modo più comodo, poiché potresti non avere a disposizione un client SSH, l'indirizzo del server o una coppia «utente/password». Certamente, c'è Webmin, che semplifica l'amministrazione, ma non fornisce accesso immediato.

Perciò ho deciso di implementare una soluzione semplice ma interessante. In particolare, scrivere un bot Telegram che, avviato direttamente sul server, eseguirà i comandi che gli verranno inviati e restituirà i risultati. Dopo aver studiato alcuni articoli aspetti su questo tema, ho capito che nessuno aveva ancora descritto implementazioni simili.

Questo progetto l'ho realizzato su Ubuntu 16.04, ma per garantire un avvio senza problemi su altre distribuzioni ho cercato di renderlo il più generico possibile.

Registrazione del bot

Registriamo un nuovo bot attraverso @BotFather. Inviamogli /newbot e proseguiamo come da istruzioni. Avremo bisogno del token del nuovo bot e del tuo id (puoi ottenerlo, ad esempio, da @userinfobot).

Preparazione di Python

Per avviare il bot utilizzeremo la libreria telebot (pip install pytelegrambotapi). Con la libreria subprocess eseguiremo comandi sul server.

Avvio del bot

Creiamo il file bot.py sul server:
nano bot.py

E incolliamo il codice:

from subprocess import check_output
import telebot
import time

bot = telebot.TeleBot("XXXXXXXXX:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")#token del bot
user_id = 0 #id del tuo account
@bot.message_handler(content_types=["text"])
def main(message):
   if (user_id == message.chat.id): #controlliamo che scriva proprio il proprietario
      comand = message.text  #testo del messaggio
      try: #se il comando non è eseguibile - check_output genera un'eccezione
         bot.send_message(message.chat.id, check_output(comand, shell = True))
      except:
         bot.send_message(message.chat.id, "Input non valido") #se il comando non è corretto
if __name__ == '__main__':
    while True:
        try:#aggiungiamo try per un funzionamento ininterrotto
            bot.polling(none_stop=True)#avvio del bot
        except:
            time.sleep(10)#in caso di arresto

Sostituiamo il token del bot con quello fornito da @BotFather e user_id con il valore id del tuo account. Il controllo dell'id utente è necessario affinché il bot dia accesso al tuo server solo a te. La funzione check_output() esegue il comando passato e restituisce il risultato.

Rimane solo da avviare il bot. Per avviare i processi sul server, preferisco usare schermo (sudo apt-get install screen):

screen -dmS ServerBot python3 bot.py

(dove «ServerBot» è l'identificatore del processo)

Il processo si avvierà automaticamente in background. Passiamo alla conversazione con il bot e verifichiamo che tutto funzioni correttamente:

Congratulazioni! Il bot esegue i comandi che riceve. Ora, per accedere al server, basta aprire la chat con il bot.

Ripetizione dei comandi

Spesso, per monitorare lo stato del server, è necessario eseguire gli stessi comandi. Pertanto, implementare la ripetizione dei comandi senza doverli reinviare sarebbe molto utile.

Lo realizzeremo tramite pulsanti inline sotto i messaggi:

from subprocess import check_output
import telebot
from telebot import types # Aggiungiamo l'import delle pulsanti
import time

bot = telebot.TeleBot("XXXXXXXXX:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")# Token del bot
user_id = 0 # id del tuo account
@bot.message_handler(content_types=["text"])
def main(message):
   if (user_id == message.chat.id): # controlliamo che scriva proprio il proprietario
      comand = message.text  # testo del messaggio
      markup = types.InlineKeyboardMarkup() # creiamo la tastiera
      button = types.InlineKeyboardButton(text="Ripeti", callback_data=comand) # creiamo il pulsante
      markup.add(button) # aggiungiamo il pulsante alla tastiera
      try: # se il comando non è eseguibile - check_output genererà un'eccezione
         bot.send_message(user_id, check_output(comand, shell = True, reply_markup = markup)) # chiamiamo il comando e inviamo il messaggio con il risultato
      except:
         bot.send_message(user_id, "Input non valido") # se il comando non è corretto

@bot.callback_query_handler(func=lambda call: True)
def callback(call):
  comand = call.data # leggiamo il comando dal campo dati del pulsante
  try: # se il comando non è eseguibile - check_output genererà un'eccezione
     markup = types.InlineKeyboardMarkup() # creiamo la tastiera
     button = types.InlineKeyboardButton(text="Ripeti", callback_data=comand) # creiamo il pulsante e nel data passiamo il comando
     markup.add(button) # aggiungiamo il pulsante alla tastiera
     bot.send_message(user_id, check_output(comand, shell = True), reply_markup = markup) # chiamiamo il comando e inviamo il messaggio con il risultato
  except:
     bot.send_message(user_id, "Input non valido") # se il comando non è corretto

if __name__ == '__main__':
    while True:
        try: # aggiungiamo un try per un funzionamento ininterrotto
            bot.polling(none_stop=True) # avviamo il bot
        except:
            time.sleep(10) # in caso di errore

Riavviamo il bot:

killall python3
screen -dmS ServerBot python3 bot.py

Controlliamo di nuovo che tutto funzioni correttamente:

Premendo il pulsante sotto il messaggio, il bot deve ripetere il comando dal quale è stato inviato il messaggio.

In conclusion

Senz'altro, questo metodo non si propone di sostituire i metodi classici di connessione, ma consente di ottenere rapidamente informazioni sullo stato del server e di inviargli comandi che non richiedono output complessi.

Fonte: habr.com