🖥️🔥 Remote Desktop Sederhana dengan Python dan Laragon

98 views 22:02 0 Comments 03/20/2025

Halo, coder kece! 👋 Kali ini, kita bakal bikin sesuatu yang seru banget: Remote Desktop sederhana menggunakan Python, dan yang lebih keren lagi, kita bakal menjalankannya dengan Laragon! 🚀✨

Yup, kita akan membuat server dan client berbasis GUI yang bisa menjalankan perintah dari jarak jauh, seperti membuka Notepad, mengambil screenshot, dan membuka DXDiag. Penasaran? Yuk, langsung gaspol! 💨

🖥️ Apa Itu RDP (Remote Desktop Protocol)?

RDP (Remote Desktop Protocol) adalah sebuah protokol yang memungkinkan seseorang mengontrol komputer lain dari jarak jauh melalui jaringan. Dengan RDP, kita bisa menjalankan perintah, membuka aplikasi, bahkan melihat tampilan layar komputer target seolah-olah kita sedang menggunakannya langsung.

Tapi dalam proyek ini, kita tidak menggunakan RDP bawaan Windows maupun aplikasi pihak lain, melainkan membuat versi sederhana dari remote desktop menggunakan Python.

🎯 Cara Kerja Remote Desktop Sederhana Ini

  1. Server (Komputer yang dikontrol):
    • Menunggu koneksi dari client.
    • Menerima perintah dari client (misalnya, buka Notepad, ambil screenshot).
    • Mengirimkan hasil perintah atau file screenshot kembali ke client.
  2. Client (Komputer pengontrol):
    • Menghubungkan diri ke server.
    • Mengirimkan perintah ke server.
    • Menerima respons dari server.

Dengan cara ini, kita bisa mengendalikan komputer lain dari jarak jauh secara sederhana.

🛠️ Library & Tools yang Digunakan

Dalam proyek ini, kita menggunakan beberapa library Python dan tools pendukung. Yuk, kita bahas satu per satu! 🔍

1️⃣ Python & Laragon 🐍💙

Python adalah bahasa pemrograman utama yang kita gunakan untuk membangun aplikasi ini.
Sedangkan Laragon adalah environment yang kita pakai untuk menjalankan Python dengan mudah di Windows, mirip seperti XAMPP tapi lebih fleksibel.

Kenapa pakai Laragon?

  • Bisa menjalankan Python tanpa perlu ribet setting PATH di Windows.
  • Ringan dan cepat, cocok buat pengembangan aplikasi lokal.

2️⃣ Socket 🔗 (Bawaan Python)

Library bawaan Python yang digunakan untuk membuat komunikasi antara server dan client melalui jaringan.

  • Server akan mendengarkan koneksi dari client.
  • Client akan menghubungkan diri ke server dan mengirimkan perintah.

Contoh penggunaan:

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('0.0.0.0', 8888))
server_socket.listen(1)

3️⃣ Tkinter 🖼️

Library bawaan Python yang digunakan untuk membuat tampilan GUI (Graphical User Interface).

Contoh penggunaan:

import tkinter as tk
from tkinter import ttk
root = tk.Tk()
root.title("Aplikasi GUI")
root.mainloop()

Dengan Tkinter, kita bisa membuat:

  • Text Area untuk menampilkan log aktivitas.
  • Entry Field untuk mengetik perintah.
  • Button untuk mengirim perintah ke server.

4️⃣ PyAutoGUI 🖥️📸

Digunakan untuk menangkap screenshot layar secara otomatis.

Fungsi utama:

  • Mengambil screenshot dan menyimpannya dalam format gambar.
  • Bisa digunakan untuk kontrol otomatis GUI.

Cara install:

pip install pyautogui

Contoh penggunaan:

import pyautogui
screenshot = pyautogui.screenshot()
screenshot.save("screenshot.png")

5️⃣ Pillow 🖼️

Library yang digunakan untuk manipulasi gambar di Python.
Kita pakai untuk menyimpan hasil screenshot yang diambil dari PyAutoGUI.

Cara install:

pip install pillow

Contoh penggunaan:

from PIL import Image
img = Image.open("screenshot.png")
img.show()

⚙️ Langkah Instalasi dan Konfigurasi Python di Laragon

1️⃣ Aktifkan Virtual Environment 🛠️

Sebelum menginstal library, kita harus menjalankan virtual environment agar proyek tetap rapi dan tidak bentrok dengan sistem Python lainnya.

💡 Langkah-langkahnya:
📌 Buka terminal Laragon, masuk dalam direktori project kamu, lalu jalankan perintah berikut:

🔹 Membuat virtual environment:

python -m venv venv

🔹 Aktifkan virtual environment:

  • Windows: 
venv\Scripts\activate
  • Linux/Mac:
source venv/bin/activate

✅ Jika berhasil, di terminal akan muncul tanda (venv) sebelum nama direktori.

2️⃣ Install Library yang Dibutuhkan 📦

Setelah virtual environment aktif, install library yang diperlukan dengan perintah:

pip install pyautogui
pip install pillow

🎯 Tahapan Pengembangan

🚀 Kode Server (server.py)

Buka Laragon, jalankan terminal, lalu buat file server.py. Copy-paste kode ini:

import socket  # Impor modul socket untuk komunikasi jaringan
import threading  # Impor modul threading untuk menjalankan beberapa proses
import tkinter as tk  # Impor tkinter untuk GUI
from tkinter import scrolledtext, ttk  # Impor komponen GUI tambahan dari tkinter
import subprocess  # Impor subprocess untuk menjalankan perintah sistem
import pyautogui  # Impor pyautogui untuk mengambil screenshot
import os  # Impor modul os untuk interaksi dengan sistem operasi

class ServerApp:
    def __init__(self, root):
        self.root = root  # Inisialisasi root window
        self.root.title("Server RDP Sederhana")  # Set judul window
        self.root.geometry("500x600")  # Set ukuran window
        self.root.configure(bg="#f0f0f0")  # Set warna latar belakang window

        # Membuat area teks dengan scrollbar
        self.text_area = scrolledtext.ScrolledText(root, wrap=tk.WORD, width=50, height=20, font=("Helvetica", 10), bg="#ffffff", fg="#000000")
        self.text_area.pack(pady=20, padx=20)  # Menempatkan area teks di window

        # Menampilkan alamat IP pada area teks
        local_ip = socket.gethostbyname(socket.gethostname())
        self.text_area.insert(tk.END, f"Selamat datang di RDP Python Sederhana, Alamat IP: {local_ip}\n")

        # Membuat tombol untuk memulai server
        self.start_button = ttk.Button(root, text="Mulai Server", command=self.start_server)
        self.start_button.pack(pady=10)  # Menempatkan tombol di window

        # Membuat tombol untuk menghentikan server
        self.stop_button = ttk.Button(root, text="Hentikan Server", command=self.stop_server)
        self.stop_button.pack(pady=10)  # Menempatkan tombol di window

        self.server_socket = None  # Inisialisasi socket server
        self.client_sockets = []  # Inisialisasi daftar socket klien

        # Styling untuk tombol
        style = ttk.Style()
        style.configure("Start.TButton", font=("Helvetica", 12, "bold"), background="#4CAF50", foreground="black", padding=10, relief="raised", borderwidth=4)
        style.configure("Stop.TButton", font=("Helvetica", 12, "bold"), background="#f44336", foreground="black", padding=10, relief="raised", borderwidth=4)
        style.map("Start.TButton", foreground=[('pressed', 'yellow'), ('active', 'blue')], background=[('pressed', '!disabled', 'black'), ('active', 'white')])
        style.map("Stop.TButton", foreground=[('pressed', 'yellow'), ('active', 'blue')], background=[('pressed', '!disabled', 'black'), ('active', 'white')])

        self.start_button.configure(style="Start.TButton")
        self.stop_button.configure(style="Stop.TButton")

        # Membuat label footer
        self.footer_label = tk.Label(root, text="dibuat oleh audhighasu.com", font=("Arial", 10), bg="#f0f0f0")
        self.footer_label.pack(side=tk.BOTTOM, pady=10)  # Menempatkan label footer di window

    def start_server(self):
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # Membuat socket server
        self.server_socket.bind(('0.0.0.0', 8888))  # Mengikat socket ke alamat IP dan port
        self.server_socket.listen(1)  # Server mulai mendengarkan koneksi
        self.text_area.insert(tk.END, "Server berjalan...\n")  # Menampilkan pesan di area teks
        threading.Thread(target=self.accept_connections, daemon=True).start()  # Membuat thread untuk menerima koneksi

    def stop_server(self):
        if self.server_socket:
            for client_socket in self.client_sockets:
                client_socket.close()  # Menutup semua koneksi klien
            self.server_socket.close()  # Menutup socket server
            self.server_socket = None
            self.client_sockets = []  # Mengosongkan daftar klien
            self.text_area.insert(tk.END, "Server dan semua koneksi klien dihentikan.\n")  # Menampilkan pesan server dihentikan

    def accept_connections(self):
        while True:
            try:
                client_socket, addr = self.server_socket.accept()  # Menerima koneksi dari klien
                self.client_sockets.append(client_socket)  # Menambahkan socket klien ke daftar
                self.text_area.insert(tk.END, f"Koneksi diterima dari {addr}\n")  # Menampilkan alamat klien di area teks
                threading.Thread(target=self.handle_client, args=(client_socket,), daemon=True).start()  # Membuat thread untuk menangani klien
            except socket.error:
                break  # Keluar dari loop jika server dihentikan

    def handle_client(self, client_socket):
        while True:
            try:
                message = client_socket.recv(1024).decode()  # Menerima pesan dari klien
                if message:
                    if message.strip().lower() == "buka notepad":
                        subprocess.Popen(["notepad.exe"])  # Membuka Notepad
                        self.text_area.insert(tk.END, "Perintah untuk membuka Notepad diterima dan dieksekusi.\n")
                    elif message.strip().lower() == "ambil screenshot":
                        screenshot = pyautogui.screenshot()  # Mengambil screenshot
                        screenshot_file = "server_screenshot.png"
                        screenshot.save(screenshot_file)  # Menyimpan screenshot
                        self.text_area.insert(tk.END, "Screenshot layar server diambil dan disimpan.\n")
                        self.send_file(client_socket, screenshot_file)  # Mengirim file screenshot ke klien
                    elif message.strip().lower() == "buka dxdiag":
                        subprocess.Popen(["dxdiag.exe"])  # Membuka Dxdiag
                        self.text_area.insert(tk.END, "Perintah untuk membuka Dxdiag diterima dan dieksekusi.\n")
                    else:
                        self.text_area.insert(tk.END, f"Klien: {message}\n")  # Menampilkan pesan dari klien
            except socket.error:
                self.text_area.insert(tk.END, "Koneksi terputus\n")  # Menampilkan pesan jika koneksi terputus
                client_socket.close()  # Menutup socket klien
                break

    def send_file(self, client_socket, file_path):
        # Kirim nama file terlebih dahulu
        filename = os.path.basename(file_path)
        client_socket.send(f"FILE:{filename}".encode())  # Mengirim informasi nama file
        client_socket.recv(1024)  # Menunggu konfirmasi dari klien

        # Mengirim isi file dalam bentuk binary
        with open(file_path, 'rb') as file:
            while True:
                data = file.read(1024)
                if not data:
                    break
                client_socket.send(data)
        
        client_socket.send(b'END_OF_FILE')  # Mengirim sinyal akhir file
        self.text_area.insert(tk.END, "Screenshot telah dikirim ke klien.\n")  # Menampilkan pesan bahwa screenshot telah dikirim

if __name__ == "__main__":
    root = tk.Tk()  # Membuat instance Tkinter
    app = ServerApp(root)  # Membuat instance aplikasi server
    root.mainloop()  # Memulai loop utama Tkinter

📡 Kode Client (client.py)

Sekarang buat file client.py, lalu copy kode ini:

import socket  # Impor modul socket untuk komunikasi jaringan
import threading  # Impor modul threading untuk eksekusi konkuren
import tkinter as tk  # Impor modul tkinter untuk GUI
from tkinter import scrolledtext, messagebox, ttk  # Impor komponen GUI tambahan dari tkinter
import os  # Impor modul os untuk interaksi dengan sistem operasi

class ClientApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Aplikasi Desktop Remote Python Sederhana")  # Atur judul jendela
        self.root.geometry("500x700")  # Atur ukuran jendela
        self.root.configure(bg="#2c3e50")  # Atur warna latar belakang jendela

        # Styling
        style = ttk.Style()
        style.configure("TButton", font=("Helvetica", 12), padding=6)
        style.configure("TLabel", font=("Helvetica", 12), background="#2c3e50", foreground="white")
        style.configure("TEntry", font=("Helvetica", 12), padding=5)

        # Area teks dengan scrollbar
        self.text_area = scrolledtext.ScrolledText(root, wrap=tk.WORD, width=60, height=15, font=("Consolas", 10), bg="#ecf0f1", fg="#2c3e50")
        self.text_area.pack(pady=20, padx=20)

        # Label dan entri IP server
        self.ip_label = ttk.Label(root, text="IP Server:")
        self.ip_label.pack(pady=5)
        self.ip_entry = ttk.Entry(root, width=60)
        self.ip_entry.pack(pady=5)

        # Tombol koneksi
        self.connect_button = ttk.Button(root, text="Sambung", command=self.connect_to_server)
        self.disconnect_button = ttk.Button(root, text="Putus", command=self.disconnect_from_server)
        self.connect_button.pack(pady=5)
        self.disconnect_button.pack(pady=5)

        # Entri pesan dan tombol kirim
        self.entry = ttk.Entry(root, width=60)
        self.entry.pack(pady=5)
        self.send_button = ttk.Button(root, text="Kirim Pesan", command=self.send_message)
        self.send_button.pack(pady=5)

        # Tombol fungsi
        function_buttons_frame = ttk.Frame(root)
        function_buttons_frame.pack(pady=5)
        self.open_notepad_button = ttk.Button(function_buttons_frame, text="Buka Notepad", command=self.open_notepad)
        self.take_screenshot_button = ttk.Button(function_buttons_frame, text="Ambil Screenshot", command=self.take_screenshot)
        self.open_dxdiag_button = ttk.Button(function_buttons_frame, text="Buka Dxdiag", command=self.open_dxdiag)
        self.open_notepad_button.pack(side=tk.LEFT, padx=5)
        self.take_screenshot_button.pack(side=tk.LEFT, padx=5)
        self.open_dxdiag_button.pack(side=tk.LEFT, padx=5)

        # Label footer
        self.footer_label = ttk.Label(root, text="Dibuat oleh audhighasu.com")
        self.footer_label.pack(side=tk.BOTTOM, pady=10)

        self.client_socket = None  # Inisialisasi socket klien sebagai None

    def connect_to_server(self):
        ip_address = self.ip_entry.get()
        try:
            self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.client_socket.connect((ip_address, 8888))
            self.text_area.insert(tk.END, f"Terhubung ke server di {ip_address}\n")
            self.receive_messages()
        except Exception as e:
            messagebox.showerror("Kesalahan Koneksi", f"Tidak dapat terhubung ke server: {e}")

    def disconnect_from_server(self):
        if self.client_socket:
            self.client_socket.close()
            self.client_socket = None
            self.text_area.insert(tk.END, "Terputus dari server.\n")

    def send_message(self):
        if self.client_socket:
            message = self.entry.get()
            self.client_socket.sendall(message.encode())
            self.text_area.insert(tk.END, f"Anda: {message}\n")
            self.entry.delete(0, tk.END)

    def open_notepad(self):
        if self.client_socket:
            self.client_socket.sendall("buka notepad".encode())  # Perintah yang dikoreksi untuk sesuai dengan perintah yang diharapkan server
            self.text_area.insert(tk.END, "Perintah untuk membuka Notepad terkirim.\n")

    def take_screenshot(self):
        if self.client_socket:
            self.client_socket.sendall("ambil screenshot".encode())
            self.text_area.insert(tk.END, "Perintah untuk mengambil screenshot terkirim.\n")

    def open_dxdiag(self):
        if self.client_socket:
            self.client_socket.sendall("buka dxdiag".encode())
            self.text_area.insert(tk.END, "Perintah untuk membuka Dxdiag terkirim.\n")

    def receive_messages(self):
        def receive():
            while True:
                try:
                    message = self.client_socket.recv(1024).decode()
                    if message.startswith("FILE:"):
                        filename = message.split(":")[1]
                        self.client_socket.send(b'OK')
                        self.download_file(filename)
                    else:
                        self.text_area.insert(tk.END, f"Server: {message}\n")
                except:
                    self.text_area.insert(tk.END, "Koneksi hilang\n")
                    self.client_socket.close()
                    break

        threading.Thread(target=receive, daemon=True).start()

    def download_file(self, filename):
        with open(filename, 'wb') as file:
            while True:
                data = self.client_socket.recv(1024)
                if data == b'END_OF_FILE':
                    break
                file.write(data)

        self.text_area.insert(tk.END, f"Screenshot disimpan sebagai {filename}\n")

if __name__ == "__main__":
    root = tk.Tk()
    app = ClientApp(root)
    root.mainloop()

🏃‍♂️ Cara Menjalankan Proyek Python di Laragon

Setelah instalasi library selesai, sekarang saatnya menjalankan proyek! masuk kedalam direktori project kamu menggunakan terminal bawaan laragon

1️⃣ Pastikan Virtual Environment Aktif 🌐

Sebelum menjalankan script, aktifkan virtual environment dengan cara:

🔹 Buka terminal Laragon, lalu jalankan:

  • Windows: venv\Scripts\activate
  • Linux/Mac: source venv/bin/activate

✅ Jika berhasil, akan muncul tanda (venv) di awal terminal.

2️⃣ Jalankan Script Python 🏗️

Setelah virtual environment aktif, jalankan script dengan perintah:

python server.py

dan

python client.py

Tampilan server.py

Tampilan client.py

3️⃣ Keluar dari Virtual Environment 🔚

Setelah selesai menjalankan proyek, keluar dari virtual environment dengan perintah:

deactivate

🔹 Ini akan mengembalikan terminal ke mode normal.

🏗️ Cara Membuat Aplikasi Python Menjadi .EXE di Laragon

Kalau mau bikin aplikasi Python jadi file executable (.exe) supaya bisa dijalankan tanpa harus install Python, kita bisa pakai PyInstaller.

1️⃣ Pastikan Virtual Environment Aktif

Sebelum lanjut, aktifkan virtual environment dulu:

  • Windows : env\Scripts\activate
  • Linux/Mac : source venv/bin/activate

✅ Pastikan tanda (venv) muncul di awal terminal.

2️⃣ Install PyInstaller 🔧

Kalau belum ada, install dulu PyInstaller:

pip install pyinstaller

🔹 Pastikan instalasi sukses tanpa error.

3️⃣ Buat File .EXE 🚀

Misalnya, kita punya script main.py, jalankan perintah ini untuk membuat executable:

pyinstaller --onefile --noconsole server.py

pyinstaller --onefile --noconsole client.py

🔹 Penjelasan opsi:

  • --onefile → Menggabungkan semua file jadi satu .exe
  • --noconsole → Menghilangkan jendela CMD saat aplikasi dijalankan

4️⃣ Cek Hasilnya 📂

Setelah proses selesai, cek folder dist/. Di dalamnya ada file server.exe dan client.exe, dan ini bisa langsung dijalankan tanpa perlu Python lagi! 🎉

✅ Cara menjalankan:
Klik dua kali server.exe dan client.exe atau jalankan lewat CMD:

dist\main.exe

5️⃣ Buat Installer (Opsional) 📦

Kalau mau bikin installer (setup.exe) biar gampang diinstall, bisa pakai Inno Setup atau NSIS. Ini akan membantu buat installer profesional seperti aplikasi Windows lainnya.

🔎 Kesimpulan: Membangun dan Menjalankan Aplikasi RDP Controller di Laragon

Dalam proyek ini, kita telah membangun aplikasi otomatisasi kendali jarak jauh (RDP Controller) menggunakan Python yang terintegrasi dengan Laragon. Berikut adalah rangkuman langkah-langkah secara sistematis:

1️⃣ Memahami Konsep RDP & Library yang Digunakan

  • Apa itu RDP?
    RDP (Remote Desktop Protocol) adalah protokol yang digunakan untuk mengontrol komputer lain dari jarak jauh melalui jaringan.
  • Library yang Digunakan:
    • PyAutoGUI → Untuk mengontrol mouse dan keyboard secara otomatis.
    • Pillow → Untuk menangani manipulasi gambar dan screenshot.

2️⃣ Persiapan & Instalasi Python di Laragon

  • Pastikan Laragon sudah terpasang dan Python telah dikonfigurasi di dalamnya.
  • Buat Virtual Environment (Venv) agar proyek lebih rapi dan terisolasi. bashSalinEditpython -m venv venv
  • Aktifkan Virtual Environment:

3️⃣ Instalasi Library yang Dibutuhkan

Setelah venv aktif, install library

4️⃣ Menjalankan Aplikasi RDP Controller

  1. Buat script main.py yang menggunakan PyAutoGUI untuk mengontrol sesi RDP.
  2. Jalankan aplikasi dengan: bashSalinEditpython main.py
  3. Pastikan aplikasi berjalan sesuai dengan yang diharapkan.

5️⃣ Konversi Aplikasi ke .EXE (Opsional)

Agar bisa dijalankan tanpa perlu install Python:

  1. Install PyInstaller
  2. Buat file .exe
  3. Hasilnya ada di folder dist, yang bisa langsung dijalankan.

🚀 Kesimpulan Akhir

✅ Aplikasi RDP Controller telah berhasil dibuat dan dijalankan dengan Python dalam Laragon.
✅ Library yang digunakan memungkinkan kontrol otomatisasi RDP secara efisien.
✅ Aplikasi dapat dikemas menjadi executable (.exe) agar lebih mudah digunakan.

Dengan langkah-langkah ini, kamu sekarang punya sistem kendali jarak jauh yang bisa digunakan sesuai kebutuhan! 💻🔥

Tag: ,

Tinggalkan Balasan

Alamat email Anda tidak akan dipublikasikan. Ruas yang wajib ditandai *