15308555518/ doc.rustdesk.com
1
0
Fork 0
mirror of https://github.com/rustdesk/doc.rustdesk.com.git synced 2025-12-25 16:52:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added .ro locale 

Added Romanian Language
This commit is contained in:
Luca-rickrolled-himself 2025-10-22 22:22:13 +03:00
parent 4eede7d63c
commit 8841d0aa28
43 changed files with 4634 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
content/client/_index.ro.md Normal file
View File

@ -0,0 +1,139 @@
---
title: Client RustDesk
weight: 2
pre: "<b>1. </b>"
---
## Introducere
Clientul RustDesk este folosit pe dispozitive pentru a se conecta prin intermediul serverului RustDesk, fie open source, fie Pro. Este disponibil pentru descărcare pe [GitHub](https://github.com/rustdesk/rustdesk/releases/latest).
## Platforme suportate
- Microsoft Windows
- macOS
- Derivate Debian (Ubuntu ≥ 16, Linux Mint etc.)
- Derivate Red Hat (CentOS, Fedora ≥ 18, Rocky Linux etc.)
- Arch Linux / Manjaro
- openSUSE
- NixOS
- AppImage / Flatpak
- Android
- iOS (nu suportă controlul)
- Web
## Instalare
### Windows
Descărcați fișierul .exe de pe GitHub și instalați.
Pentru instalare silențioasă, rulați executabilul de instalare cu `--silent-install`.
### macOS
Descărcați fișierul .dmg de pe GitHub; mai multe informații găsiți pe [pagina macOS](https://rustdesk.com/docs/en/client/mac/).
Deschideți fișierul .dmg și trageți `RustDesk` în `Applications`.
Permiteți rularea RustDesk.
Activați permisiunile solicitate și urmați solicitările din partea stângă a ferestrei RustDesk pentru a finaliza configurarea.
### Linux
Vă rugăm să consultați instrucțiunile de mai jos pentru diferitele „arome” de Linux (instalatoarele sunt pe GitHub sau pot fi disponibile din depozitul distribuției).
#### Derivate Debian
```sh
# vă rugăm să ignorați raportul incorect de utilizare a discului
sudo apt install -fy ./rustdesk-<version>.deb
```
#### Derivate Red Hat
```sh
sudo yum localinstall ./rustdesk-<version>.rpm
```
#### Arch Linux/Manjaro
```sh
sudo pacman -U ./rustdesk-<version>.pkg.tar.zst
```
#### openSUSE (≥ Leap 15.0)
```sh
sudo zypper install --allow-unsigned-rpm ./rustdesk-<version>-suse.rpm
```
#### Nix / NixOS (≥ 22.05)
Intrați temporar într-un shell care are `rustdesk` gata de rulat:
```sh
nix shell nixpkgs#rustdesk
```
Instalați în profilul utilizatorului curent:
```sh
nix profile install nixpkgs#rustdesk
```
Pentru a instala la nivel de sistem în NixOS rulați `nixos-rebuild switch --flake /etc/nixos` după ce modificați `configuration.nix`:
```
environment.systemPackages = with pkgs; [
...
rustdesk
];
```
### Android
Instalați APK-ul din GitHub; mai multe informații găsiți pe [pagina Android](https://rustdesk.com/docs/en/client/android/).
### iOS (iPhone, iPad)
Descărcați aplicația din [App Store](https://apps.apple.com/us/app/rustdesk-remote-desktop/id1581225015).
## Utilizare
Odată instalat (sau rulat ca executabil temporar), RustDesk se va conecta la serverele publice. Veți vedea un mesaj în partea de jos care spune (1) „Ready, For faster connection, please set up your own server”. În partea stângă sus veți vedea (2) ID-ul, (3) parola de o singură utilizare și în dreapta un (4) câmp pentru a vă conecta la un alt calculator dacă cunoașteți ID-ul acestuia.
![](/docs/en/client/images/client.png)
Pentru a accesa setările, faceți clic pe butonul (5) Meniu [ &#8942; ] din dreapta ID-ului.
În Setări veți găsi:
- General – Controlul serviciului, Temă, Hardware Codec, Audio, Înregistrare și Limbă
- Securitate – Permisiuni pentru preluarea controlului, opțiuni de parolă, posibilitatea de a schimba ID-ul și Setări Avansate de Securitate
- Rețea – Aici configurați setările propriului server și proxy-ul
- Afișare – Controlați setările de afișare pentru sesiunile la distanță și alte opțiuni implicite, sincronizarea clipboard-ului etc.
- Cont – Poate fi folosit împreună cu Serverul Pro pentru autentificare în API
- Despre – Afișează informații despre software.
## Configurarea RustDesk
Există mai multe modalități de a configura RustDesk.
Cea mai simplă metodă este folosind RustDesk Server Pro: puteți obține un șir de configurare criptat, care poate fi folosit împreună cu `--config` pentru a importa setările. Pentru a face acest lucru:
1. Deschideți linia de comandă pe sistemul de operare pe care îl folosiți, în folderul unde este instalat RustDesk, de ex. `C:\Program Files\RustDesk` pe Windows sau `/usr/bin` pe Linux.
2. Folosiți comanda `rustdesk.exe --config your-encrypted-string`, ex. `rustdesk.exe --config 9JSPSvJzNrBDasJjNSdXOVVBlERDlleoNWZzIHcOJiOikXZr8mcw5yazVGZ0NXdy5CdyciojI0N3boJye`.
Puteți configura manual un client. Pentru aceasta:
1. Faceți clic pe Setări.
2. Faceți clic pe Rețea.
3. Faceți clic pe Deblocați setările de rețea.
4. Introduceți ID-ul, Relay, API (dacă folosiți server Pro) și cheia.
![](/docs/en/client/images/network-settings.png)
Dacă configurați manual un client, puteți prelua fișierul `RustDesk2.toml` (din folderul utilizatorului) și folosiți `--import-config` într-un mod similar cu exemplul de mai sus.
## Parametri linie de comandă
- `--password` poate fi folosit pentru a seta o parolă permanentă.
- `--get-id` poate fi folosit pentru a obține ID-ul.
- `--set-id` poate fi folosit pentru a seta un ID; rețineți că ID-urile ar trebui să înceapă cu o literă.
- `--silent-install` poate fi folosit pentru a instala RustDesk silențios pe Windows.
Parametrii avansați suplimentari pot fi găsiți [aici](https://github.com/rustdesk/rustdesk/blob/bdc5cded221af9697eb29aa30babce75e987fcc9/src/core_main.rs#L242).
{{% children depth="3" showhidden="true" %}}

146
content/client/android/_index.ro.md Normal file
View File

@ -0,0 +1,146 @@
---
title: Android
weight: 4
---
## Control la distanță
Introduceți ID-ul dispozitivului la distanță pe pagina principală sau selectați un dispozitiv din istoricul recent pentru a verifica.
După ce verificarea este reușită, puteți controla dispozitivul la distanță.
| Home | Conectat cu succes |
| --- | --- |
| ![](/docs/en/client/android/images/connection_home_en.jpg?width=300px) | ![](/docs/en/client/android/images/connection_en.jpg?width=300px) |
Controlul de intrare oferă două moduri: `Mouse mode` și `Touch mode`, care pot fi comutate prin bara de instrumente din partea de jos.
| Setări mouse | Selecție mod |
| --- | --- |
| ![](/docs/en/client/android/images/touch_mode_icon_en.png?width=300px) | ![](/docs/en/client/android/images/touch_mode_en.jpg?width=300px) |
{{% notice note %}}
În `Mouse mode`, puteți, de asemenea, să declanșați butonul `Right Mouse` al dispozitivului la distanță cu un `Two-Finger Tap`.
{{% /notice %}}
## Transfer de fișiere (Android)
> Necesită RustDesk ≥ 1.1.9
În lista de dispozitive de pe pagina principală, selectați dispozitivul.
Apăsați lung sau atingeți meniul din dreapta pentru a selecta `File Transfer`.
| Home | Conectat cu succes |
| --- | --- |
| ![](/docs/en/client/android/images/connection_home_file_en.jpg?width=300px) | ![](/docs/en/client/android/images/file_connection_en.jpg?width=300px) |
- Directorul inițial este directorul Home al dispozitivului; puteți face clic pe <i class="fas fa-home"></i> pentru a reveni rapid la Home.
- Sub bara de titlu se află nivelul directorului; puteți face clic pe folderul corespunzător pentru a sări rapid.
- Faceți clic pe <i class="fas fa-arrow-up"></i> pentru a accesa directorul părinte.
- Calea absolută curentă și statisticile proiectului sunt afișate în partea de jos a listei.
- Faceți clic pe `Local` / `Remote` din bara de titlu pentru a comuta paginile.
### Cum transfer fișiere?
1. **Apăsați lung** pe un fișier sau folder din listă pentru a intra rapid în **modul de selecție multiplă**, care permite selectarea mai multor elemente.
2. După selectarea fișierelor, comutați pagina `Local` / `Remote`. După comutare, veți vedea promptul `Paste here?` în partea de jos a ecranului.
3. Faceți clic pe pictograma de lipire (paste) din imagine pentru a transfera elementele selectate în directorul țintă.
| Mod selecție multiplă | Lipire fișiere |
| --- | --- |
| ![](/docs/en/client/android/images/file_multi_select_en.jpg?width=300px) | ![](/docs/en/client/android/images/file_copy_en.jpg?width=300px) |
## Setare ID / Relay Server
1. Faceți clic pe `Settings` în bara de navigare de jos.
2. Faceți clic pe `ID/Relay Server`.
3. Introduceți hostname-ul/IP-ul serverului dvs. în câmpul `ID Server`. Lăsați `Relay Server` și `API Server` necompletate și introduceți cheia publică (opțional, necesară pentru criptare) în câmpul `Key`. Apăsați **OK** pentru a salva setările. Aplicația se va comuta automat la serverul specificat.
Puteți configura și scanând un cod QR. Pentru a genera codul QR, folosiți următorul format (modificați valorile `host` și `key` cu ale dvs.):
```nolang
config={"host": "xxx", "key": "xxx"}
```
Apoi mergeți la un [generator QR online](https://www.qr-code-generator.com/) și lipiți codul de mai sus.
Imaginea de mai jos este un screenshot de pe Android. Dacă folosiți iOS, verificați meniul din dreapta sus al paginii principale.
![](/docs/en/client/android/images/id_setting_en.jpg?width=300px)
## Partajați ecranul / fișierele telefonului Android
Începând cu versiunea 1.1.9, clientul Android a adăugat funcțiile de partajare a ecranului telefonului și de partajare a sistemului de fișiere al telefonului.
- Este necesar Android 6 sau versiuni mai noi pentru partajarea ecranului
- Este necesar Android 10 sau versiuni mai noi pentru a partaja audio intern al sistemului telefonului
- iOS încă nu suportă partajarea ecranului
### Solicitați permisiuni și porniți serviciile
Faceți clic pe `Share Screen` din bara de navigare de jos.
Configurați permisiunile necesare. De fiecare dată când porniți RustDesk, trebuie să solicitați din nou permisiunile de „Screen Capture” și „Input Control”.
![](/docs/en/client/android/images/server_off_en.jpg?width=300px)
| Permisiuni | Descriere |
| --- | --- |
| Screen Capture | Dacă este activată, permite partajarea capturii ecranului; serviciul de monitorizare va fi activat la pornire |
| Input Control* | Permite celui care controlează să trimită evenimente de intrare către telefon (de ex. simulare touch cu mouse-ul) |
| File transfer* | Permite activarea permisiunii de transfer fișiere; după pornire, puteți controla de la distanță sistemul de fișiere al telefonului |
| Audio capture | Permite partajarea sunetului intern al telefonului (nu microfonul) |
{{% notice note %}}
De mai sus, * indică permisiuni speciale. Pentru a obține astfel de permisiuni, va trebui să accesați manual pagina de setări a sistemului Android. Detaliile sunt descrise mai jos.
{{% /notice %}}
### Cerere permisiune specială - Fișiere
| Cererea permisiunilor pentru fișiere pe Android va deschide automat pagina de setări a sistemului |
| :---: |
| ![](/docs/en/client/android/images/get_file_en.jpg?width=300px) |
### Cerere permisiune specială - input mouse
| Pasul 1: Găsiți „Installed Services” | Pasul 2: Porniți RustDesk Input |
| --- | --- |
| ![](/docs/en/client/android/images/get_input1_en.jpg?width=300px) | ![](/docs/en/client/android/images/get_input2_en.jpg?width=300px) |
{{% notice note %}}
Pagina de setări a sistemului poate diferi în funcție de producător; ajustați conform paginii de setări a dispozitivului dvs.
{{% /notice %}}
| Scurtături control mouse la distanță | Descriere |
| --- | --- |
| Click buton drept mouse | Înapoi |
| Click rotiță mouse | Home |
| Apăsare lungă rotiță mouse | Aplicații recente |
| Derulare rotiță mouse | Simulează glisare verticală |
### Pornire serviciu
După obținerea permisiunii `Screen Capture`, serviciul va porni automat. Puteți, de asemenea, să apăsați butonul `Start Service` pentru a porni manual serviciul. După pornire, acesta poate accepta cereri de control de la distanță din partea altor dispozitive.
Dacă permisiunea `File Transfer` este activată, serviciul poate accepta și cereri de control al fișierelor de la distanță.
După pornirea serviciului, pentru acest dispozitiv va fi generat automat un ID unic și o parolă aleatorie. Alte dispozitive pot controla telefonul folosind ID-ul și parola sau prin confirmare manuală la primirea unei cereri noi.
| Înainte de pornirea serviciului | După pornirea serviciului |
| --- | --- |
| ![](/docs/en/client/android/images/server_off_en.jpg?width=300px) | ![](/docs/en/client/android/images/server_on_en.jpg?width=300px) |
{{% notice note %}}
1. Apăsarea `Start Service` va activa implicit permisiunea `Screen Capture`.
2. Când permisiunea `Screen Capture` nu este obținută, alte dispozitive nu pot trimite cereri de control.
3. În afară de permisiunea `Screen Capture`, comutarea celorlalte permisiuni va afecta doar conexiunile noi și nu va modifica conexiunile deja stabilite. Dacă trebuie să schimbați permisiunile pentru o conexiune activă, închideți mai întâi conexiunea curentă, modificați permisiunile și acceptați din nou cererea de control.
{{% /notice %}}
#### PC
![](/docs/en/client/android/images/android_server_pc_side_en.png?width=700px)
#### Terminal mobil
| Puteți opri serviciul sau închide o conexiune specificată în orice moment | Puteți primi sau iniția chat-uri |
| --- | --- |
| ![](/docs/en/client/android/images/server_on_en.jpg?width=300px) | ![](/docs/en/client/android/images/android_server2_en.jpg?width=300px) |

100
content/client/linux/_index.ro.md Normal file
View File

@ -0,0 +1,100 @@
---
title: Linux
weight: 4
---
## Instalare
### Ubuntu (≥ 18)
```sh
# vă rugăm să ignorați raportul incorect de utilizare a discului
sudo apt install -fy ./rustdesk-<version>.deb
```
Pentru Ubuntu 18.04, rulați mai întâi pașii de mai jos pentru [pipewire](https://github.com/rustdesk/rustdesk/discussions/6148#discussioncomment-9295883).
```sh
sudo apt install software-properties-common
sudo add-apt-repository ppa:pipewire-debian/pipewire-upstream
sudo apt update
```
### CentOS/Fedora (≥ 28)
```sh
sudo yum localinstall ./rustdesk-<version>.rpm
```
### Arch Linux/Manjaro
```sh
sudo pacman -U ./rustdesk-<version>.pkg.tar.zst
```
### openSUSE (≥ Leap 15.0)
```sh
sudo zypper install --allow-unsigned-rpm ./rustdesk-<version>-suse.rpm
```
### AppImage
```sh
# Pentru Fedora
sudo yum install libnsl
./rustdesk-<version>.AppImage
```
```sh
# Pentru Ubuntu
sudo yum install libfuse2
./rustdesk-<version>.AppImage
```
### Flatpak
```sh
flatpak --user remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
flatpak --user install ./rustdesk-<version>.flatpak
flatpak run com.rustdesk.RustDesk
```
## ~~X11 necesar~~
~~RustDesk nu acceptă încă Wayland; trebuie să treceți manual la X11.~~
RustDesk are acum suport experimental pentru Wayland începând cu versiunea 1.2.0.
### Server de afișare
[Ubuntu](https://askubuntu.com/questions/1260142/ubuntu-set-default-login-desktop) |
[Fedora](https://docs.fedoraproject.org/en-US/quick-docs/configuring-xorg-as-default-gnome-session/) |
[Arch Linux](https://bbs.archlinux.org/viewtopic.php?id=218319)
### Ecranul de autentificare
Ecranul de autentificare folosind Wayland nu este încă acceptat. Dacă doriți să accesați ecranul de autentificare după repornire sau deconectare cu RustDesk, trebuie să schimbați ecranul de autentificare la X11; modificați linia de mai jos în `WaylandEnable=false` în `/etc/gdm/custom.conf` sau `/etc/gdm3/custom.conf`:
```ini
#WaylandEnable=false
```
{{% notice note %}}
Vă rugăm **reporniți** sistemul pentru ca modificările de mai sus să aibă efect.
{{% /notice %}}
### Probleme de permisiuni
Dacă SELinux este activat, RustDesk nu va funcționa corect nici în medii X11, nici în Wayland; vedeți problemele relevante în repo.
Puteți rula:
```sh
$ sudo grep 'comm="rustdesk"' /var/log/audit/audit.log | tail -1
type=AVC msg=audit(1697902459.165:707): avc: denied { name_connect } for pid=31346 comm="rustdesk" dest=53330 scontext=system_u:system_r:init_t:s0 tcontext=system_u:object_r:ephemeral_port_t:s0 tclass=tcp_socket permissive=0
```
{{% notice note %}}
Numărul între paranteze după `audit` este un timestamp.
{{% /notice %}}
Dacă ieșirea conține `avc: denied`, trebuie să adăugați politici SELinux; consultați pagina [SELinux](https://rustdesk.com/docs/en/client/linux/selinux/).

53
content/client/mac/_index.ro.md Normal file
View File

@ -0,0 +1,53 @@
---
title: Mac
weight: 3
---
## Instalare
Deschideți fișierul .dmg și trageți `RustDesk` în `Applications` după cum se arată mai jos.
![](/docs/en/client/mac/images/dmg.png)
Asigurați-vă că ați închis toate instanțele RustDesk care rulează. De asemenea, închideți serviciul RustDesk care apare în bara de sistem (tray).
![](/docs/en/client/mac/images/tray.png)
## Permiteți rularea RustDesk
| Deblocați pentru a modifica | Faceți clic pe `App Store and identified developers` |
| --- | --- |
| ![](/docs/en/client/mac/images/allow2.png) | ![](/docs/en/client/mac/images/allow.png) |
## Activarea permisiunilor
{{% notice note %}}
Din cauza unei schimbări în politica de securitate a macOS, API-ul nostru care capturează input-ul local nu mai funcționează implicit. Trebuie să activați permisiunea „Input Monitoring” (Monitorizare intrare) pe Mac-ul local.
Vă rugăm să urmați această discuție: [https://github.com/rustdesk/rustdesk/issues/974#issuecomment-1185644923](https://github.com/rustdesk/rustdesk/issues/974#issuecomment-1185644923).
În versiunea 1.2.4 puteți încerca `Input source 2`, vizibil făcând clic pe pictograma tastaturii din bara de instrumente.
{{% /notice %}}
Pentru a captura ecranul, trebuie să acordați RustDesk permisiunile **Accessibility** și **Screen Recording**. RustDesk vă va ghida către fereastra de setări.
| Fereastra RustDesk | Fereastra de setări |
| --- | --- |
| ![](/docs/en/client/mac/images/acc.png) | ![](/docs/en/client/mac/images/acc3.png?v2) |
Dacă ați activat permisiunile în fereastra de setări, dar RustDesk încă afișează avertismente, eliminați `RustDesk` din fereastra de setări folosind butonul `-`, apoi apăsați `+` și selectați `RustDesk` din `Applications`.
{{% notice note %}}
[https://github.com/rustdesk/rustdesk/issues/3261](https://github.com/rustdesk/rustdesk/issues/3261) <br>
Alte încercări neajutorătoare: <br>
`tccutil reset ScreenCapture com.carriez.RustDesk` <br>
`tccutil reset Accessibility com.carriez.RustDesk` <br>
Este posibil să fie necesară repornirea sistemului.
{{% /notice %}}
| Butonul `-` și `+` | Selectați `RustDesk` |
| --- | --- |
| ![](/docs/en/client/mac/images/acc2.png) | ![](/docs/en/client/mac/images/add.png?v2) |
Vă rugăm să repetați pașii de mai sus și pentru permisiunea **Screen Recording**.
![](/docs/en/client/mac/images/screen.png?v2)

90
content/client/windows/MSI/_index.ro.md Normal file
View File

@ -0,0 +1,90 @@
---
title: MSI
weight: 49
---
>Pachetul MSI acceptă parametri din linia de comandă pentru instalare silențioasă.
## Parametri
## INSTALLFOLDER
Folderul de instalare.
**Implicit**: `[ProgramFiles6432Folder]\[app name]`, de obicei `C:\Program Files\[app name]`.
## CREATESTARTMENUSHORTCUTS
Dacă se creează sau nu scurtătura în meniul Start.
**Implicit**:
1. La instalare. Valoarea implicită este `1`.
2. La upgrade. Se păstrează opțiunile din instalarea precedentă.
| Nr. | Valoare | Descriere |
| :---: | :---: | :---: |
| 1 | `1` | Da |
| 2 | `0` | Nu |
| 3 | `Y` | Da, echivalent cu `1` |
| 4 | `N` | Nu, echivalent cu `0` |
## CREATEDESKTOPSHORTCUTS
Dacă se creează sau nu scurtătura pe desktop.
**Implicit**:
1. La instalare. Valoarea implicită este `1`.
2. La upgrade. Se păstrează opțiunile din instalarea precedentă.
| Nr. | Valoare | Descriere |
| :---: | :---: | :---: |
| 1 | `1` | Da |
| 2 | `0` | Nu |
| 3 | `Y` | Da, echivalent cu `1` |
| 4 | `N` | Nu, echivalent cu `0` |
## INSTALLPRINTER
Dacă se instalează un driver/printer. Imprimanta este folosită pentru a executa job-urile de imprimare ale părții controlate local.
Disponibil începând cu versiunea `1.3.9`.
**Implicit**:
1. La instalare. Valoarea implicită este `1`.
2. La upgrade. Se păstrează opțiunile din instalarea precedentă.
| Nr. | Valoare | Descriere |
| :---: | :---: | :---: |
| 1 | `1` | Da |
| 2 | `0` | Nu |
| 3 | `Y` | Da, echivalent cu `1` |
| 4 | `N` | Nu, echivalent cu `0` |
# Exemple
**Atenție**: Pentru versiunile anterioare datei `2024-08-05` există probleme cu instalarea silențioasă și reparațiile silențioase. Dezinstalați mai întâi, apoi instalați.
## Instalare cu parametri de instalare
Instalare silențioasă, setare cale de instalare, fără scurtătură pe desktop, cu scurtătură în meniul Start.
```
msiexec /i RustDesk-1.msi /qn INSTALLFOLDER="D:\Program Files\RustDesk" CREATESTARTMENUSHORTCUTS="Y" CREATEDESKTOPSHORTCUTS="N" INSTALLPRINTER="N" /l*v install.log
```
**Notă**: `/l*v install.log` înseamnă înregistrarea jurnalului de execuție în `install.log`.
## Upgrade, fără parametri
Upgrade folosind calea și opțiunile de instalare anterioare.
```
msiexec /i RustDesk-2.msi /qn /l*v install.log
```
## Upgrade, modificare opțiuni de instalare
```
msiexec /i RustDesk-1.msi /qn INSTALLFOLDER="C:\Program Files\RustDesk" CREATESTARTMENUSHORTCUTS="N" CREATEDESKTOPSHORTCUTS="N" INSTALLPRINTER="N" /l*v install.log
```

6
content/client/windows/_index.ro.md Normal file
View File

@ -0,0 +1,6 @@
---
title: Windows
weight: 4
---
{{% children depth="3" showhidden="true" %}}

46
content/client/windows/windows-portable-elevation/_index.ro.md Normal file
View File

@ -0,0 +1,46 @@
---
title: Windows Portable Elevation
weight: 49
---
Programele portabile pentru Windows nu au privilegii de administrator, ceea ce poate cauza următoarele probleme:
- Ecranul nu poate fi transmis atunci când fereastra UAC (User Account Control) apare.
- Când apare o fereastră elevată, precum Task Manager, mouse-ul devine nefuncțional.
Prin ridicarea privilegiilor, RustDesk poate crea un proces cu privilegii de administrator la pornire sau în timpul unei sesiuni, permițând realizarea de capturi de ecran și operații cu mouse-ul, evitând astfel problemele de mai sus.
## Ridicare la pornire
Astfel, utilizatorii de la distanță nu trebuie să solicite elevare când se conectează. Există două metode:
* Metoda 1: Schimbați numele programului portabil pentru a include `-qs-` (versiunile 1.2.0, 1.2.1, 1.2.2, 1.2.3 se termină cu `qs.exe`). Faceți clic stânga pentru a rula, apoi apăsați `Accept` în fereastra UAC.
* Metoda 2: Faceți clic dreapta și rulați ca administrator.
## Ridicare la capătul controlat
Capătul controlat poate face direct clic pe `Accept and Elevate` la conectare, sau poate apăsa `Elevate` când este deja conectat.
| Connecting | Connected |
| :---: | :---: |
| ![](/docs/en/client/windows/windows-portable-elevation/images/cm_unauth.jpg) | ![](/docs/en/client/windows/windows-portable-elevation/images/cm_auth.jpg) |
## Solicitarea elevării la capătul care controlează
După selectarea `Request Elevation` din meniul de acțiuni, va apărea următorul dialog. Dacă alegeți `Ask the remote user for authentication`, nu va fi nevoie să introduceți un nume de utilizator și o parolă, dar utilizatorul de la distanță trebuie să aibă drepturi de administrator. Dacă selectați `Transmit the username and password of administrator`, utilizatorul de la distanță trebuie doar să apese Accept în fereastra UAC. După trimiterea cererii, așteptați ca utilizatorul de la distanță să accepte fereastra UAC. La confirmare va apărea un mesaj de succes. Rețineți că **ambele metode necesită ca cineva de la capătul controlat să accepte fereastra UAC**. Prin urmare, dacă nu este nimeni disponibil la celălalt capăt, nu solicitați elevarea de la capătul care controlează.
| Menu | Dialog |
| :---: | :---: |
| ![](/docs/en/client/windows/windows-portable-elevation/images/menu.png) | ![](/docs/en/client/windows/windows-portable-elevation/images/dialog.png) |
| **Wait** | **Success** |
| ![](/docs/en/client/windows/windows-portable-elevation/images/wait.png) | ![](/docs/en/client/windows/windows-portable-elevation/images/success.png) |
## Cum să alegeți
| Scenariu | Metodă |
| :---: | :---: |
| Nu este necesară elevarea | Instalați programul |
| Nu este nimeni disponibil la capătul controlat | Redenumiți<br/>*sau*<br/> Rulați ca administrator |
| Există un utilizator la capătul controlat<br/>*și*<br/> Elevare imediată la conectare<br/>*și*<br/> Conexiune acceptată prin click | Faceți clic `Accept and Elevate` la primirea conexiunii la capătul controlat |
| Există un utilizator la capătul controlat<br/>*și*<br/> Elevare la nevoie | Faceți clic `Elevate` în fereastra de gestionare a conexiunii la capătul controlat<br/>*sau*<br/> Solicitați elevarea de la capătul care controlează |

8
content/dev/_index.ro.md Normal file
View File

@ -0,0 +1,8 @@
---
title: Dezvoltare
weight: 8
pre: "<b>3. </b>"
chapter: true
---
{{% children depth="3" showhidden="true" %}}

8
content/dev/build/_index.ro.md Normal file
View File

@ -0,0 +1,8 @@
---
title: Build
weight: 1
---
Consultați [build.py](https://github.com/rustdesk/rustdesk/blob/master/build.py) pentru pachete versiunii desktop.
{{% children depth="3" showhidden="true" %}}

72
content/dev/build/faq/_index.ro.md Normal file
View File

@ -0,0 +1,72 @@
---
title: Întrebări frecvente pentru Windows
weight: 40
---
## Descărcarea pachetului vcpkg a eșuat
### Eroare
```
-- Fetching https://chromium.googlesource.com/libyuv/libyuv 287158925b0e03ea4499a18b4e08478c5781541b...
CMake Error at scripts/cmake/vcpkg_execute_required_process.cmake:127 (message):
Command failed: D:/program/Git/mingw64/bin/git.exe fetch https://chromium.googlesource.com/libyuv/libyuv 287158925b0e03ea4499a18b4e08478c5781541b --depth 1 -n
```
### Soluție
Folosiți browser-ul pentru a descărca [libyuv-287158925b0e03ea4499a18b4e08478c5781541b.tar.gz](https://chromium.googlesource.com/libyuv/libyuv/+archive/287158925b0e03ea4499a18b4e08478c5781541b.tar.gz), apoi mutați arhiva în `vcpkg/downloads` și reinstalați.
## Pachetul din Cargo.lock nu există
### Eroare
```
$ cargo run
Updating git repository `https://github.com/open-trade/confy`
warning: spurious network error (2 tries remaining): failed to receive response: Operation Timeout
; class=Os (2)
error: failed to get `confy` as a dependency of package `hbb_common v0.1.0 (D:\rustdesk\rustdesk\rustdesk\libs\hbb_common)`
Caused by:
failed to load source for dependency `confy`
Caused by:
Unable to update https://github.com/open-trade/confy#27fa1294
Caused by:
object not found - no match for id (27fa12941291b44ccd856aef4a5452c1eb646047); class=Odb (9); code=NotFound (-3)
```
Poate autorul a folosit `git force push` și commit-ul anterior a fost suprascris.
### Soluție
Rulați `cargo update` pentru a forța actualizarea pachetului.
## VCPKG_ROOT nu este setat
### Eroare
```
thread 'main' panicked at 'Failed to find package: VcpkgNotFound("No vcpkg installation found. Set the VCPKG_ROOT environment variable or run 'vcpkg integrate install'")', libs\scrap\build.rs:7:45
```
### Soluție
Adăugați variabila de mediu `VCPKG_ROOT`, sau rulați comanda cu `VCPKG_ROOT=<vcpkg_dir> cargo run`.
## clang nu este instalat sau LIBCLANG_PATH nu este setat
### Eroare
```
thread 'main' panicked at 'Unable to find libclang: "couldn't find any valid shared libraries matching: ['clang.dll', 'libclang.dll'], set the `LIBCLANG_PATH` environment variable to a path where one of these files can be found (invalid: [])"', C:\Users\selfd\.cargo\registry\src\mirrors.ustc.edu.cn-61ef6e0cd06fb9b8\bindgen-0.59.2\src/lib.rs:2144:31
```
### Soluție
Instalați [LLVM](https://releases.llvm.org/download.html) și adăugați variabila de mediu `LIBCLANG_PATH` care să pointeze la `llvm_install_dir/bin`.

63
content/dev/build/linux/_index.ro.md Normal file
View File

@ -0,0 +1,63 @@
---
title: Linux
weight: 10
---
## Cum se construiește pe Linux
### Ubuntu 18 (Debian 10)
```sh
sudo apt install -y g++ gcc git curl wget nasm yasm libgtk-3-dev clang libxcb-randr0-dev libxdo-dev libxfixes-dev libxcb-shape0-dev libxcb-xfixes0-dev libasound2-dev libpulse-dev cmake
```
### Fedora 28 (CentOS 8)
```sh
sudo yum -y install gcc-c++ git curl wget nasm yasm gcc gtk3-devel clang libxcb-devel libxdo-devel libXfixes-devel pulseaudio-libs-devel cmake alsa-lib-devel
```
### Arch Linux (Manjaro)
```sh
sudo pacman -Syu --needed unzip git cmake gcc curl wget yasm nasm zip make pkg-config clang gtk3 xdotool libxcb libxfixes alsa-lib pulseaudio
```
### Instalare vcpkg
```sh
git clone --recurse-submodules https://github.com/microsoft/vcpkg
cd vcpkg
git checkout 2023.10.19
cd ..
vcpkg/bootstrap-vcpkg.sh
export VCPKG_ROOT=$PWD/vcpkg
vcpkg/vcpkg install --x-install-root="$VCPKG_ROOT/installed"
```
### Corectare libvpx (pentru Fedora)
```sh
cd vcpkg/buildtrees/libvpx/src
cd *
./configure
sed -i 's/CFLAGS+=-I/CFLAGS+=-fPIC -I/g' Makefile
sed -i 's/CXXFLAGS+=-I/CXXFLAGS+=-fPIC -I/g' Makefile
make
cp libvpx.a $VCPKG_ROOT/installed/x64-linux/lib/
cd
```
### Compilare
```sh
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
git clone --recurse-submodules https://github.com/rustdesk/rustdesk
cd rustdesk
mkdir -p target/debug
wget https://raw.githubusercontent.com/c-smile/sciter-sdk/master/bin.lnx/x64/libsciter-gtk.so
mv libsciter-gtk.so target/debug
# Notă: VCPKG_ROOT rămâne setat
cargo run
```

122
content/dev/build/osx/_index.ro.md Normal file
View File

@ -0,0 +1,122 @@
---
title: macOS
weight: 21
---
Există mai multe moduri de a proceda; acest ghid pornește de la premisa că `Xcode`, `Git` și `Homebrew` sunt deja instalate.
Cea mai mare provocare este, probabil, să găsiți versiuni ale tuturor uneltelor care funcționează împreună, în special deoarece părți din toolchain, precum Xcode și LLVM, sunt dictate de versiunea macOS. Versiunile folosite în acest ghid s-ar putea să nu fie exact cele de care aveți nevoie. Un loc bun de început pentru a vedea ce versiuni s-au folosit este să verificați [workflow-ul de build de pe GitHub](https://github.com/rustdesk/rustdesk/blob/master/.github/workflows/flutter-build.yml) pentru versiunea RustDesk pe care doriți să o compilați. Alegeți tag-ul dorit din colțul stânga-sus al paginii. Totuși, asta nu garantează succesul, deoarece tool-urile de pe runner-ul GitHub pot avea versiuni diferite față de cele de pe sistemul dvs. local.
### Export
Folosiți `export` pentru a seta diverse variabile de mediu. Când rulați `export`, variabila este setată doar pentru sesiunea terminalului curent, deci va trebui repetată pentru fiecare fereastră de terminal nouă în care doriți să compilați RustDesk. De regulă este preferabil să adăugați toate `export`-urile într-un script care se execută automat la deschiderea fiecărui terminal, de exemplu `~/.bash_profile`. Comenzile `export` listate aici pot fi adăugate pur și simplu la acel fișier, dar trebuie rulate și în terminalul curent deoarece fișierul nu va fi citit decât la deschiderea unui *nou* terminal.
## Instalați uneltele prin Homebrew
```sh
brew install python3 create-dmg nasm cmake gcc wget ninja pkg-config wget rustup
```
Unele instalări pot eșua deoarece anumite directoare țintă nu există pe sistem. În acest caz, creați folderul, setați proprietarul și permisiunile și rulați din nou comanda `brew`. Exemplu dacă `/usr/local/include` nu există:
```sh
sudo mkdir /usr/local/include
sudo chown <username>:admin /usr/local/include
sudo chmod 775 /usr/local/include
```
## Instalați vcpkg
Vcpkg este folosit pentru a gestiona dependențele C/C++ folosite de RustDesk. Alegeți unde doriți instalarea și rulați următoarele din folderul în care doriți să rezide `vcpkg`. În exemplul de mai jos se folosește `/Users/<username>/repos/` ca locație și tag-ul `2023.04.15` ca versiune.
```sh
git clone https://github.com/microsoft/vcpkg
cd vcpkg
git checkout 2023.04.15
./bootstrap-vcpkg.sh -disableMetrics
./vcpkg install libvpx libyuv opus aom
export VCPKG_ROOT=~/repos/vcpkg
```
## Instalați și configurați Rust
Folosim `rustup` pentru a gestiona Rust, care ar fi fost instalat mai sus prin Homebrew. Totuși, acesta mai trebuie configurat. Urmați instrucțiunile și asigurați-vă că atât `rustup`, cât și `rustc` sunt în `PATH`. În exemplu se folosește versiunea Rust `1.75.0`, dar este posibil să aveți nevoie de o versiune diferită. Puteți instala și administra mai multe versiuni de Rust cu `rustup`.
```sh
rustup-init
rustup default 1.75.0
rustup component add rustfmt
```
Pentru o privire de ansamblu asupra toolchain-urilor instalate și a celei implicite, rulați `rustup show`.
## Descărcați sursele RustDesk
Alegeți unde doriți sursele RustDesk și rulați următoarele din folderul în care vreți să apară directorul `rustdesk`. În exemplu se folosește `/Users/<username>/repos/`.
```sh
git clone --recurse-submodules https://github.com/rustdesk/rustdesk
cd rustdesk/libs/portable/
python3 -m pip install --upgrade pip
pip3 install -r requirements.txt
```
Dacă `python3` sau `pip` nu sunt recunoscute, adăugați-le în `PATH` cu ceva de genul (folosiți căile reale de pe sistemul dvs.):
```sh
export PATH=~/Library/Python/3.9/bin:$PATH
```
După aceea rulați din nou comenzile care au eșuat. Nu uitați să editați și `~/.bash_profile` pentru persistență.
## Instalați componentele interfeței
RustDesk poate fi compilat cu [Sciter](https://sciter.com/) sau cu [Flutter](https://flutter.dev/). Ambele necesită componente adiționale, așa că urmați pașii pentru versiunea relevantă (sau pentru ambele).
### Sciter
Din folderul `rustdesk`, rulați:
```sh
wget https://github.com/c-smile/sciter-sdk/raw/master/bin.osx/libsciter.dylib
```
### Flutter
[FVM](https://fvm.app/) vă permite să gestionați ce versiune de Flutter se folosește și este, probabil, cea mai simplă metodă pentru a testa versiuni diferite de Flutter.
```sh
brew tap leoafarias/fvm
brew install fvm cocoapods
```
Instalați și folosiți, de exemplu, Flutter `3.16.9` cu:
```sh
fvm global 3.16.9
```
FVM oferă un setup mai complex care poate furniza versiuni diferite de Flutter pentru proiecte diferite, dar asta depășește scopul ghidului. Ca soluție simplă, adăugați manual locația Flutter implicit furnizată de FVM în `PATH`, ceea ce înseamnă că trebuie să folosiți `fvm global` pentru a comuta versiunea de Flutter:
```sh
export PATH=$HOME/fvm/default/bin:$PATH
```
După aceea, dezactivați telemetria și verificați configurarea:
```sh
flutter --disable-analytics
dart --disable-analytics
flutter doctor -v
```
Nu este grav dacă unele verificări eșuează — important este ca mediul pe care intenționați să-l folosiți să fie corect, în special `Xcode`. Dacă apar probleme, rezolvați-le înainte de a continua.
După ce Flutter este funcțional, instalați „bridge”-ul care leagă Rust de Flutter. Acesta este încă un element cu versiuni care trebuie să se potrivească; în exemplu folosim `1.80.1`:
```sh
cargo install flutter_rust_bridge_codegen --version "1.80.1" --features "uuid"
```
## Build
Compilați din folderul `rustdesk`. Pentru versiunea Sciter rulați:
```sh
python3 ./build.py
```
Pentru versiunea Flutter rulați:
```sh
flutter_rust_bridge_codegen --rust-input ./src/flutter_ffi.rs --dart-output ./flutter/lib/generated_bridge.dart --c-output ./flutter/macos/Runner/bridge_generated.h
python3 ./build.py --flutter
```
Dacă totul merge bine, ar trebui să aveți un fișier `dmg` pregătit pentru instalare în folderul `rustdesk`.

58
content/dev/build/windows/_index.ro.md Normal file
View File

@ -0,0 +1,58 @@
---
title: Windows
weight: 20
---
{{% notice note %}}
Comenzile din linia de comandă de aici trebuie rulate în Git Bash, nu în Command Prompt, altfel veți primi erori de sintaxă.
{{% /notice %}}
## Dependențe
### Mediu de build C++
Descărcați [MSVC](https://visualstudio.microsoft.com/) și instalați-l.
Selectați `Windows` ca OS pentru mașina Developer și bifați `C++`, apoi descărcați și instalați Visual Studio Community. Instalarea poate dura ceva timp.
### Mediu de dezvoltare Rust
Descărcați [rustup-init.exe](https://static.rust-lang.org/rustup/dist/x86_64-pc-windows-msvc/rustup-init.exe) și rulați-l ca administrator pentru a instala `rust`.
### vcpkg
Mergeți în folderul în care doriți să clonați `vcpkg` și folosiți [Git Bash](https://git-scm.com/download/win) pentru a rula comenzile de mai jos; acestea vor descărca `vcpkg` și vor instala versiunea pe 64-bit a pachetelor `libvpx`, `libyuv` și `opus`.
Dacă nu aveți `Git` instalat, descărcați-l de [aici](https://git-scm.com/download/win).
```sh
git clone https://github.com/microsoft/vcpkg
vcpkg/bootstrap-vcpkg.bat
export VCPKG_ROOT=$PWD/vcpkg
vcpkg/vcpkg install libvpx:x64-windows-static libyuv:x64-windows-static opus:x64-windows-static aom:x64-windows-static
```
Adăugați variabila de sistem `VCPKG_ROOT`=`<path>\vcpkg`. `<path>` ar trebui să fie locația în care ați clonat `vcpkg`.
![](/docs/en/dev/build/windows/images/env.png)
### Sciter
Versiunile desktop folosesc [Sciter](https://sciter.com/) pentru GUI; descărcați `sciter.dll` de la: https://raw.githubusercontent.com/c-smile/sciter-sdk/master/bin.win/x64/sciter.dll
### LLVM
`rust-bindgen` depinde de `clang`; descărcați [LLVM](https://github.com/llvm/llvm-project/releases) și instalați-l, apoi adăugați variabila de sistem `LIBCLANG_PATH`=`<llvm_install_dir>/bin`.
Puteți descărca versiunea 15.0.2 a binarelor LLVM aici: [64 bit](https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.2/LLVM-15.0.2-win64.exe) / [32 bit](https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.2/LLVM-15.0.2-win32.exe).
## Build
### Implicit
```sh
git clone --recurse-submodules https://github.com/rustdesk/rustdesk
cd rustdesk
mkdir -p target/debug
wget https://raw.githubusercontent.com/c-smile/sciter-sdk/master/bin.win/x64/sciter.dll
mv sciter.dll target/debug
cargo run
```

50
content/self-host/_index.ro.md Normal file
View File

@ -0,0 +1,50 @@
---
title: Găzduire proprie
description: "Aflați cum să vă găzduiți propriul server RustDesk. Ghid complet care acoperă instalarea, configurarea și implementarea infrastructurii serverului RustDesk pentru acces remote securizat."
keywords: ["rustdesk self-host", "rustdesk server", "remote desktop server", "self-hosting guide", "rustdesk installation", "hbbs hbbr", "rustdesk pro server"]
weight: 5
pre: "<b>2. </b>"
---
Dacă folosiți RustDesk, ar trebui să aveți propriul server RustDesk; aceste documentații vă vor ghida în proces.
Suportul este disponibil prin [Discord](https://discord.com/invite/nDceKgxnkV) pentru OSS și prin [email](mailto:support@rustdesk.com) pentru Pro.
## Cum funcționează un server self-host?
Din punct de vedere tehnic există două executabile (servere):
- `hbbs` - serverul RustDesk ID (rendezvous / signaling), ascultă pe TCP (`21114` - pentru http doar în Pro, `21115`, `21116`, `21118` pentru websocket) și pe UDP (`21116`)
- `hbbr` - serverul RustDesk relay, ascultă pe TCP (`21117`, `21119` pentru websocket)
Când instalați folosind scriptul de instalare / docker compose / pachet deb, ambele servicii vor fi instalate.
Iată câteva [ilustrații](https://github.com/rustdesk/rustdesk/wiki/How-does-RustDesk-work%3F) despre modul în care clientul RustDesk comunică cu `hbbr` / `hbbs`.
Atâta timp cât RustDesk rulează pe o mașină, aceasta va efectua periodic ping către serverul ID (`hbbs`) pentru a-și anunța adresa IP și portul curent.
Când porniți o conexiune de la calculatorul A către calculatorul B, A contactează serverul ID și solicită comunicarea cu B.
Serverul ID încearcă apoi să conecteze A și B direct între ele folosind hole punching (NAT traversal).
Dacă hole punching eșuează, A va comunica cu B prin intermediul serverului relay (`hbbr`).
În majoritatea cazurilor, hole punching are succes și serverul relay nu este utilizat.
Aici este o discuție despre [Ar trebui să vă găzduiți propriul server rustdesk?](https://www.reddit.com/r/rustdesk/comments/1cr8kfv/should_you_selfhost_a_rustdesk_server/)
## Porturi necesare
Porturile necesare pentru găzduirea unui server RustDesk depind în mare măsură de mediul dvs. și de modul în care doriți să folosiți RustDesk. Exemplele din documentație vor sugera, în general, deschiderea tuturor porturilor indicate.
Porturi de bază: \
TCP `21114-21119` \
UDP `21116`
Porturile `21115-21117` sunt minimul necesar pentru funcționarea RustDesk; acestea gestionează semnalizarea, porturile de relay și traversarea NAT.
Porturile TCP `21118` și `21119` sunt porturile WebSocket pentru [RustDesk Web Client](https://rustdesk.com/web/). Aveți nevoie de un reverse proxy pentru a suporta HTTPS; consultați acest [exemplu de configurare Nginx](/docs/en/self-host/rustdesk-server-pro/faq/#8-add-websocket-secure-wss-support-for-the-id-server-and-relay-server-to-enable-secure-communication-for-the-web-client).
Pentru utilizatorii Pro fără un SSL Proxy va fi necesar să deschideți portul TCP `21114` pentru ca API-ul să funcționeze; alternativ, folosind un SSL Proxy se va deschide portul TCP `443`.
{{% children depth="4" showhidden="true" %}}

85
content/self-host/client-configuration/_index.ro.md Normal file
View File

@ -0,0 +1,85 @@
---
title: Configurare client
description: "Configurați clienții RustDesk pentru servere self-hosted. Funcții: generator personalizat de client (Pro) pentru aplicații branduite cu logo-ul dvs., configurare manuală, import/export setări și strategii de implementare enterprise."
keywords: ["rustdesk client configuration", "custom client generator", "rustdesk branded client", "rustdesk white label", "rustdesk enterprise deployment", "rustdesk client setup", "custom rustdesk app", "rustdesk pro client", "rustdesk configuration management", "rustdesk corporate branding"]
weight: 300
pre: "<b>2.3. </b>"
---
## Prezentare generală
Există mai multe modalități de a configura clienții RustDesk pentru a folosi propriul server self-hosted; mai jos sunt prezentate câteva dintre ele.
## 1. Generator de client personalizat (doar Pro, plan basic sau plan custom)
Puteți avea propriul nume, logo, iconiță, configurație, semnare digitală și altele.
În prezent sunt suportate: Windows X64, Mac Arm64 / X64, [Linux](https://twitter.com/rustdesk/status/1788905463678951787) și Android Arm64.
[Video](https://twitter.com/rustdesk/status/1769171628426944539)
![](/docs/en/self-host/client-configuration/images/custom-client-qs.png)
![](/docs/en/self-host/client-configuration/images/web_console_custom_client_config.jpeg)
## 2. Configurare manuală
În fereastra principală a clientului RustDesk faceți clic pe butonul Meniu [ &#8942; ] lângă ID-ul dvs., apoi pe `Network`. Puteți debloca acum setările folosind privilegii elevate și seta `ID`, `Relay`, `API` și `Key`. Este important de reținut că acest `Key` este cheia publică folosită pentru criptarea conexiunii, diferită de cheia de licență primită la achiziția versiunii Pro.
![](/docs/en/self-host/client-configuration/images/network-config.png)
Introduceți host-ul sau adresa IP a `hbbs` în câmpul **ID Server** (pe partea locală și pe partea la distanță). Celelalte două adrese pot fi lăsate necompletate; RustDesk le va deduce automat (dacă nu sunt setate special), iar Relay Server se referă la `hbbr` (port 21117).
de ex.
```nolang
hbbs.example.com
```
sau
```nolang
hbbs.example.com:21116
```
### Setarea `Key`
Pentru a stabili o conexiune criptată către serverul dvs. self-hosted, trebuie să introduceți cheia sa publică. Cheia este de obicei generată la prima rulare a `hbbs` și poate fi găsită în fișierul `id_ed25519.pub` din directorul de lucru / folderul de date.
Ca utilizator `Pro` veți putea, de asemenea, să recuperați `Key` din [web console](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/console/).
![](/docs/en/self-host/rustdesk-server-pro/console/images/console-home.png?v2)
### Setarea `API Server`
Aceasta este pentru utilizatorii `Pro` doar. Dacă vă puteți autentifica în consola web, dar nu reușiți să vă autentificați în clientul RustDesk, cel mai probabil nu ați setat corect `API Server`.
Dacă API Server nu rulează pe portul implicit `21114` (este posibil să nu fi deschis acest port în firewall dacă veniți din versiunea open source), specificați `API Server` în mod explicit.
de ex. dacă API Server rulează pe portul HTTPS implicit, specificați `API Server` cu `https://hbbs.example.com`.
Dacă încă nu puteți confirma valoarea `API Server`, accesați pagina de bun venit a consolei web; `API Server` este afișat în imaginea de mai sus (în caseta de input cu eticheta `API:`).
## 3. Configurare folosind Import sau Export
1. Folosiți pașii [de mai sus](https://rustdesk.com/docs/en/self-host/client-configuration/#manual-config) pentru a configura clientul RustDesk pe un dispozitiv.
2. Pe mașina respectivă mergeți la Settings → Network și deblocați setările.
3. Click pe `Export Server Config`.
4. Lipiți șirul copiat într-un editor de text (Notepad etc.).
5. Mergeți la noul client, copiați șirul în clipboard.
6. În clientul RustDesk accesați Settings → Network, deblocați și click pe `Import Server Config`.
7. Setările vor fi lipite automat.
8. Click `Apply`.
## 4. Configurare automată
Cea mai simplă modalitate de configurare automată este folosirea scripturilor de implementare găsite [aici](https://rustdesk.com/docs/en/self-host/client-deployment/).
## 5. Import setări din `Pro` prin clipboard
![](/docs/en/self-host/rustdesk-server-pro/console/images/console-home.png?v2)
https://github.com/rustdesk/rustdesk-server-pro/discussions/372#discussioncomment-10473298
## 6. Folosiți linia de comandă `--config`
`rustdesk.exe --config <config-string>`
Puteți obține șirul de configurare din consola web (apare în imaginea de mai sus) sau din clientul RustDesk la „Settings → Network” ([discuție](https://github.com/rustdesk/rustdesk/discussions/7118)).

1027
content/self-host/client-configuration/advanced-settings/_index.ro.md Normal file
View File

File diff suppressed because it is too large Load Diff

376
content/self-host/client-deployment/_index.ro.md Normal file
View File

@ -0,0 +1,376 @@
---
title: Deployare client
weight: 400
pre: "<b>2.4. </b>"
---
Cea mai simplă metodă este să folosiți clientul personalizat, https://twitter.com/rustdesk/status/1788905463678951787.
Puteți implementa prin mai multe metode; unele sunt acoperite în [Client Configuration](https://rustdesk.com/docs/en/self-host/client-configuration/).
Alternativ, puteți folosi scripturi de implementare în masă cu RMM, Intune, etc. ID-ul și parola sunt afișate de script. Ar trebui să colectați aceste valori sau să le separați în scripturi diferite pentru a prelua ID-ul și parola.
Parola permanentă poate fi schimbată din valoarea aleatorie într-una preferată prin modificarea conținutului din interiorul parantezelor `()` după `rustdesk_pw` pentru PowerShell și linia corespunzătoare pentru orice altă platformă.
## PowerShell
```powershell
$ErrorActionPreference= 'silentlycontinue'
# Assign the value random password to the password variable
$rustdesk_pw=(-join ((65..90) + (97..122) | Get-Random -Count 12 | % {[char]$_}))
# Get your config string from your Web portal and Fill Below
$rustdesk_cfg="configstring"
################################## Please Do Not Edit Below This Line #########################################
# Run as administrator and stays in the current directory
if (-Not ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator))
{
if ([int](Get-CimInstance -Class Win32_OperatingSystem | Select-Object -ExpandProperty BuildNumber) -ge 6000)
{
Start-Process PowerShell -Verb RunAs -ArgumentList "-NoProfile -ExecutionPolicy Bypass -Command `"cd '$pwd'; & '$PSCommandPath';`"";
Exit;
}
}
# This function will return the latest version and download link as an object
function getLatest()
{
$Page = Invoke-WebRequest -Uri 'https://github.com/rustdesk/rustdesk/releases/latest' -UseBasicParsing
$HTML = New-Object -Com "HTMLFile"
try
{
$HTML.IHTMLDocument2_write($Page.Content)
}
catch
{
$src = [System.Text.Encoding]::Unicode.GetBytes($Page.Content)
$HTML.write($src)
}
# Current example link: https://github.com/rustdesk/rustdesk/releases/download/1.2.6/rustdesk-1.2.6-x86_64.exe
$Downloadlink = ($HTML.Links | Where {$_.href -match '(.)+\/rustdesk\/rustdesk\/releases\/download\/\d{1}.\d{1,2}.\d{1,2}(.{0,3})\/rustdesk(.)+x86_64.exe'} | select -first 1).href
# bugfix - sometimes you need to replace "about:"
$Downloadlink = $Downloadlink.Replace('about:', 'https://github.com')
$Version = "unknown"
if ($Downloadlink -match './rustdesk/rustdesk/releases/download/(?<content>.*)/rustdesk-(.)+x86_64.exe')
{
$Version = $matches['content']
}
if ($Version -eq "unknown" -or $Downloadlink -eq "")
{
Write-Output "ERROR: Version or download link not found."
Exit
}
# Create object to return
$params += @{Version = $Version}
$params += @{Downloadlink = $Downloadlink}
$Result = New-Object PSObject -Property $params
return($Result)
}
$RustDeskOnGitHub = getLatest
$rdver = ((Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\RustDesk\").Version)
if ($rdver -eq $RustDeskOnGitHub.Version)
{
Write-Output "RustDesk $rdver is the newest version."
Exit
}
if (!(Test-Path C:\Temp))
{
New-Item -ItemType Directory -Force -Path C:\Temp | Out-Null
}
cd C:\Temp
Invoke-WebRequest $RustDeskOnGitHub.Downloadlink -Outfile "rustdesk.exe"
Start-Process .\rustdesk.exe --silent-install
Start-Sleep -seconds 20
$ServiceName = 'Rustdesk'
$arrService = Get-Service -Name $ServiceName -ErrorAction SilentlyContinue
if ($arrService -eq $null)
{
Write-Output "Installing service"
cd $env:ProgramFiles\RustDesk
Start-Process .\rustdesk.exe --install-service
Start-Sleep -seconds 20
$arrService = Get-Service -Name $ServiceName
}
while ($arrService.Status -ne 'Running')
{
Start-Service $ServiceName
Start-Sleep -seconds 5
$arrService.Refresh()
}
cd $env:ProgramFiles\RustDesk\
.\rustdesk.exe --get-id | Write-Output -OutVariable rustdesk_id
.\rustdesk.exe --config $rustdesk_cfg
.\rustdesk.exe --password $rustdesk_pw
Write-Output "..............................................."
# Show the value of the ID Variable
Write-Output "RustDesk ID: $rustdesk_id"
# Show the value of the Password Variable
Write-Output "Password: $rustdesk_pw"
Write-Output "..............................................."
```
## Windows batch/cmd
```bat
@echo off
REM Assign the value random password to the password variable
setlocal ENABLEEXTENSIONS ENABLEDELAYEDEXPANSION
set alfanum=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789
set rustdesk_pw=
for /L %%b in (1, 1, 12) do (
set /A rnd_num=!RANDOM! %% 62
for %%c in (!rnd_num!) do (
set rustdesk_pw=!rustdesk_pw!!alfanum:~%%c,1!
)
)
REM Get your config string from your Web portal and Fill Below
set rustdesk_cfg="configstring"
REM ############################### Please Do Not Edit Below This Line #########################################
if not exist C:\Temp\ md C:\Temp\
cd C:\Temp\
curl -L "https://github.com/rustdesk/rustdesk/releases/download/1.2.6/rustdesk-1.2.6-x86_64.exe" -o rustdesk.exe
rustdesk.exe --silent-install
timeout /t 20
cd "C:\Program Files\RustDesk\"
rustdesk.exe --install-service
timeout /t 20
for /f "delims=" %%i in ('rustdesk.exe --get-id ^| more') do set rustdesk_id=%%i
rustdesk.exe --config %rustdesk_cfg%
rustdesk.exe --password %rustdesk_pw%
echo ...............................................
REM Show the value of the ID Variable
echo RustDesk ID: %rustdesk_id%
REM Show the value of the Password Variable
echo Password: %rustdesk_pw%
echo ...............................................
```
## MSI
Puteți folosi MSI în loc de `rustdesk.exe --silent-install`.
https://rustdesk.com/docs/en/client/windows/msi/
## Winget
puteți implementa prin powershell cu winget de asemenea (instalează via managerul Microsoft - parte din cele mai recente instalări Windows)
dintr-o fereastră powershell sau via script (de exemplu prin GPO)
```
winget install --id=RustDesk.RustDesk -e
```
## macOS Bash
```sh
#!/bin/bash
# Assign the value random password to the password variable
rustdesk_pw=$(openssl rand -hex 4)
# Get your config string from your Web portal and Fill Below
rustdesk_cfg="configstring"
################################## Please Do Not Edit Below This Line #########################################
# Root password request for privilege escalation
[ "$UID" -eq 0 ] || exec sudo bash "$0" "$@"
# Specify the mount point for the DMG (temporary directory)
mount_point="/Volumes/RustDesk"
# Download the rustdesk.dmg file
echo "Downloading RustDesk Now"
if [[ $(arch) == 'arm64' ]]; then
rd_link=$(curl -sL https://github.com/rustdesk/rustdesk/releases/latest | grep -Eo "(http|https)://[a-zA-Z0-9./?=_-]*/\d{1}.\d{1,2}.\d{1,2}/rustdesk.\d{1}.\d{1,2}.\d{1,2}.aarch64.dmg")
dmg_file=$(echo $rd_link | grep -Eo "rustdesk.\d{1}.\d{1,2}.\d{1,2}.aarch64.dmg")
curl -L "$rd_link" --output "$dmg_file"
else
rd_link=$(curl -sL https://github.com/rustdesk/rustdesk/releases/latest | grep -Eo "(http|https)://[a-zA-Z0-9./?=_-]*/\d{1}.\d{1,2}.\d{1,2}/rustdesk.\d{1}.\d{1,2}.\d{1,2}.x86_64.dmg")
dmg_file=$(echo $rd_link | grep -Eo "rustdesk.\d{1}.\d{1,2}.\d{1,2}.x86_64.dmg")
curl -L "$rd_link" --output "$dmg_file"
fi
# Mount the DMG file to the specified mount point
hdiutil attach "$dmg_file" -mountpoint "$mount_point" &> /dev/null
# Check if the mounting was successful
if [ $? -eq 0 ]; then
# Move the contents of the mounted DMG to the /Applications folder
cp -R "$mount_point/RustDesk.app" "/Applications/" &> /dev/null
# Unmount the DMG file
hdiutil detach "$mount_point" &> /dev/null
else
echo "Failed to mount the RustDesk DMG. Installation aborted."
exit 1
fi
# Run the rustdesk command with --get-id and store the output in the rustdesk_id variable
cd /Applications/RustDesk.app/Contents/MacOS/
rustdesk_id=$(./RustDesk --get-id)
# Apply new password to RustDesk
./RustDesk --server &
/Applications/RustDesk.app/Contents/MacOS/RustDesk --password $rustdesk_pw &> /dev/null
/Applications/RustDesk.app/Contents/MacOS/RustDesk --config $rustdesk_cfg
# Kill all processes named RustDesk
rdpid=$(pgrep RustDesk)
kill $rdpid &> /dev/null
echo "..............................................."
# Check if the rustdesk_id is not empty
if [ -n "$rustdesk_id" ]; then
echo "RustDesk ID: $rustdesk_id"
else
echo "Failed to get RustDesk ID."
fi
# Echo the value of the password variable
echo "Password: $rustdesk_pw"
echo "..............................................."
echo "Please complete install on GUI, launching RustDesk now."
open -n /Applications/RustDesk.app
```
## Linux
```sh
#!/bin/bash
# Assign a random value to the password variable
rustdesk_pw=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 8 | head -n 1)
# Get your config string from your Web portal and Fill Below
rustdesk_cfg="configstring"
################################## Please Do Not Edit Below This Line #########################################
# Check if the script is being run as root
if [[ $EUID -ne 0 ]]; then
echo "This script must be run as root."
exit 1
fi
# Identify OS
if [ -f /etc/os-release ]; then
# freedesktop.org and systemd
. /etc/os-release
OS=$NAME
VER=$VERSION_ID
UPSTREAM_ID=${ID_LIKE,,}
# Fallback to ID_LIKE if ID was not 'ubuntu' or 'debian'
if [ "${UPSTREAM_ID}" != "debian" ] && [ "${UPSTREAM_ID}" != "ubuntu" ]; then
UPSTREAM_ID="$(echo ${ID_LIKE,,} | sed s/\"//g | cut -d' ' -f1)"
fi
elif type lsb_release >/dev/null 2>&1; then
# linuxbase.org
OS=$(lsb_release -si)
VER=$(lsb_release -sr)
elif [ -f /etc/lsb-release ]; then
# For some versions of Debian/Ubuntu without lsb_release command
. /etc/lsb-release
OS=$DISTRIB_ID
VER=$DISTRIB_RELEASE
elif [ -f /etc/debian_version ]; then
# Older Debian, Ubuntu, etc.
OS=Debian
VER=$(cat /etc/debian_version)
elif [ -f /etc/SuSE-release ]; then
# Older SuSE etc.
OS=SuSE
VER=$(cat /etc/SuSE-release)
elif [ -f /etc/redhat-release ]; then
# Older Red Hat, CentOS, etc.
OS=RedHat
VER=$(cat /etc/redhat-release)
else
# Fall back to uname, e.g. "Linux <version>", also works for BSD, etc.
OS=$(uname -s)
VER=$(uname -r)
fi
# Install RustDesk
echo "Installing RustDesk"
if [ "${ID}" = "debian" ] || [ "$OS" = "Ubuntu" ] || [ "$OS" = "Debian" ] || [ "${UPSTREAM_ID}" = "ubuntu" ] || [ "${UPSTREAM_ID}" = "debian" ]; then
wget https://github.com/rustdesk/rustdesk/releases/download/1.2.6/rustdesk-1.2.6-x86_64.deb
apt-get install -fy ./rustdesk-1.2.6-x86_64.deb > null
elif [ "$OS" = "CentOS" ] || [ "$OS" = "RedHat" ] || [ "$OS" = "Fedora Linux" ] || [ "${UPSTREAM_ID}" = "rhel" ] || [ "$OS" = "Almalinux" ] || [ "$OS" = "Rocky*" ] ; then
wget https://github.com/rustdesk/rustdesk/releases/download/1.2.6/rustdesk-1.2.6-0.x86_64.rpm
yum localinstall ./rustdesk-1.2.6-0.x86_64.rpm -y > null
else
echo "Unsupported OS"
# here you could ask the user for permission to try and install anyway
# if they say yes, then do the install
# if they say no, exit the script
exit 1
fi
# Run the rustdesk command with --get-id and store the output in the rustdesk_id variable
rustdesk_id=$(rustdesk --get-id)
# Apply new password to RustDesk
rustdesk --password $rustdesk_pw &> /dev/null
rustdesk --config $rustdesk_cfg
systemctl restart rustdesk
echo "..............................................."
# Check if the rustdesk_id is not empty
if [ -n "$rustdesk_id" ]; then
echo "RustDesk ID: $rustdesk_id"
else
echo "Failed to get RustDesk ID."
fi
# Echo the value of the password variable
echo "Password: $rustdesk_pw"
echo "..............................................."
```

131
content/self-host/nat-loopback-issues/_index.ro.md Normal file
View File

@ -0,0 +1,131 @@
---
title: Probleme NAT Loopback
weight: 500
pre: "<b>2.5. </b>"
---
{{% notice note %}}
Această explicație implică noțiuni complexe de rețea; vă rugăm să ne ajutați să o îmbunătățim pentru lizibilitate.
{{% /notice %}}
Pentru mai multe detalii despre NAT Loopback, consultați pagina [Wikipedia](https://en.m.wikipedia.org/wiki/Network_address_translation#NAT_hairpinning).
Când implementați un server RustDesk pe rețeaua de acasă sau pe orice rețea din spatele unui NAT/firewall, serverul RustDesk și clienții dvs. **TREBUIE** fie:
A: Să folosească adrese IP locale pentru a se accesa reciproc SAU
B: Să folosească un router/firewall care suportă și are activată funcția NAT Loopback.
Este posibil să observați că nu reușiți să vă conectați la server utilizând **IP-ul public** sau **domeniul** (care, în teorie, indică IP-ul public).
## Problema
În acest exemplu urmărim ce se întâmplă când un dispozitiv LAN încearcă să se conecteze la `rustdesk.example.com`. Să presupunem că IP-ul public al routerului este `172.16.16.1`, IP-ul LAN al serverului este `192.168.11.20`, domeniul dorit este `rustdesk.example.com`, iar clientul folosește `192.168.11.2`.
Când configurați un server în spatele NAT-ului routerului, puteți adăuga o regulă de port forwarding în router astfel încât orice mesaje care vin către IP-ul PUBLIC `172.16.16.1` să fie redirecționate către serverul `192.168.11.20`.
Când un dispozitiv din LAN vrea să acceseze internetul, de exemplu un webserver la `8.8.8.8`, trimite cererea ca provenind de la `192.168.11.2` către router. Routerul va intercepta cererea și o va rescrie astfel încât solicitarea către `8.8.8.8` pare că vine de la `172.16.16.1`. Când `8.8.8.8` răspunde la `172.16.16.1`, routerul caută o conexiune anterioară și redirecționează răspunsul înapoi la `192.168.11.2`.
Dacă utilizatorul de la `8.8.8.8` trimite un mesaj către rețeaua noastră folosind `172.16.16.1`, regula de port forwarding va rescrie destinația `172.16.16.1` către serverul `192.168.11.20`, păstrând sursa cererii `8.8.8.8` astfel încât serverul poate răspunde (mai mult sau mai puțin) direct la `8.8.8.8`.
Dacă cineva de la `8.8.8.8` pretinde că trimite mesaje de la `192.168.11.2`, routerul știe că traficul provenit de la `192.168.11.2` este valid doar din interiorul rețelei LAN și va bloca tipic acel trafic.
Problema apare când încercați să faceți loop-back în LAN. Dacă dispozitivul LAN încearcă să se conecteze la `rustdesk.example.com` (adică `172.16.16.1`), routerul are mai multe opțiuni de procesare. Practic a trimis un pachet de pe portul LAN către portul WAN al său, provenind de la `192.168.11.2` și având destinația `172.16.16.1`. Odată ajuns pe portul WAN, acest pachet este, din perspectiva routerului, nedistinct de un pachet trimis din exterior (un potențial atac).
Funcția NAT Loopback va modifica sursa (partea "From 192.168.11.2") mai devreme în proces, astfel încât routerul să folosească tabela NAT pentru a trece pachetele între server și client înapoi în rețea.
Dacă aveți probleme doar când sunteți în LAN, dar lucrurile funcționează normal din exterior, este foarte probabil să aveți o problemă legată de NAT Loopback.
## Soluții
Există trei metode principale de rezolvare.
### 1. Activați NAT Loopback pe router
Puteți configura NAT Loopback pe router, dacă acesta suportă funcția, dar acest lucru necesită cunoștințe de rețelistică. Unele routere nu au această capacitate, deci nu este soluția universală.
{{% notice note %}}
Un articol de la [MikroTik](https://help.mikrotik.com/docs/display/ROS/NAT#NAT-HairpinNAT) explică conceptul foarte bine. Puteți începe de aici.
{{% /notice %}}
### 2. Rulați un server DNS în LAN
Alegeți una din soluțiile populare, de exemplu [AdGuard Home](https://github.com/AdguardTeam/AdGuardHome/wiki/Docker) sau [Pi-hole](https://github.com/pi-hole/docker-pi-hole). Le puteți rula în Docker sau pe aceeași mașină cu serverul RustDesk. Exemplul de mai jos arată pașii generali.
Ambele sunt, în esență, servere DNS cu funcții de blocare a reclamelor, dar puteți dezactiva blocarea dacă nu o doriți.
Mai întâi, indicați domeniul dvs. către IP-ul LAN al serverului RustDesk (ex.: `192.168.11.20`). Apoi, în setările DHCP ale routerului (ATENȚIE: nu în setarea WAN), setați adresa DNS primară la serverul pe care ați instalat AdGuard Home sau Pi-hole. DNS-ul secundar poate fi DNS-ul ISP sau un DNS public (ex. `1.1.1.1` sau `8.8.8.8`).
Exemple practice:
#### AdGuard Home
Dacă doriți să dezactivați funcția de blocare (pentru a evita probleme), folosiți butonul "Disable protection".
![](/docs/en/self-host/nat-loopback-issues/images/adguard_home_disable_protection.png)
<br>
Accesați setarea "DNS rewrites".
![](/docs/en/self-host/nat-loopback-issues/images/adguard_home_click_dns_rewrites.png)
<br>
Click pe "Add DNS rewrite", apoi introduceți domeniul (`domain`) și IP-ul LAN al serverului.
![](/docs/en/self-host/nat-loopback-issues/images/adguard_home_dns_rewrite_dialog.png)
Rezultatul final ar trebui să arate astfel:
![](/docs/en/self-host/nat-loopback-issues/images/adguard_home_dns_rewrite_final_result.png)
***Nu uitați să assignați AdGuard Home ca DNS în DHCP-ul routerului!***
<hr>
#### Pi-hole
Dacă doriți să dezactivați blocarea reclamelor, folosiți opțiunea "Indefinitely" din meniul "Disable Blocking".
![](/docs/en/self-host/nat-loopback-issues/images/pi_hole_disable_blocking.png)
Mergeți la "Local DNS → DNS Records" și adăugați o înregistrare cu domeniul și IP-ul serverului.
![](/docs/en/self-host/nat-loopback-issues/images/pi_hole_local_dns_dns_records.png)
***Nu uitați să assignați Pi-hole ca DNS în DHCP-ul routerului!***
### 3. Adăugați reguli în fișierul hosts
Această metodă este recomandată doar pentru un număr mic de dispozitive. Dacă aveți multe dispozitive, folosiți soluția DNS descrisă mai sus, deoarece altfel va trebui să editați hosts pe fiecare dispozitiv.
{{% notice warning %}}
Dacă folosiți această metodă pe un dispozitiv portabil (de ex. laptop), acesta nu va putea accesa serverul când este în afara rețelei LAN.
{{% /notice %}}
Path-uri pentru diferite sisteme de operare:
#### Windows
```text
C:\Windows\system32\drivers\etc\hosts
```
Puteți edita fișierul cu privilegii elevate sau copia fișierul pe Desktop, edita și apoi copia înapoi la locația originală.
#### macOS
```text
/etc/hosts
```
Puteți folosi `vim` (preinstalat):
```sh
sudo vim /etc/hosts
```
#### Linux
```text
/etc/hosts
```
Puteți folosi `vim` sau `nano`:
```sh
sudo vim /etc/hosts
```
Formatul este același pe toate sistemele. IP-ul pe primul loc, urmat de domeniu; câte o intrare pe linie.
Exemplu:
```text
192.168.11.20 rustdesk.example.com
```

134
content/self-host/rustdesk-server-oss/Docker/_index.ro.md Normal file
View File

@ -0,0 +1,134 @@
---
title: Docker
weight: 7
---
> Iată un alt tutorial bun: [Construirea propriului tău Remote Desktop: RustDesk Self-Hosted on Cloud cu Docker (Hetzner)](https://www.linkedin.com/pulse/building-your-own-remote-desktop-solution-rustdesk-cloud-montinaro-bv94f)
## Instalează propriul server cu Docker
### Cerințe
Trebuie să ai instalat Docker/Podman pentru a rula rustdesk-server ca un container Docker. Dacă nu ești sigur, instalează Docker urmând acest [ghid](https://docs.docker.com/engine/install) pentru a te asigura că ai cea mai recentă versiune!
Asigură-te că deschizi următoarele porturi în firewall:
- `hbbs`:
- `21114` (TCP): folosit pentru consola web, disponibil doar în versiunea `Pro`.
- `21115` (TCP): folosit pentru testul tipului NAT.
- `21116` (TCP/UDP): **Reține că `21116` trebuie activat atât pentru TCP, cât și pentru UDP.** `21116/UDP` este folosit pentru înregistrarea ID-ului și serviciul de heartbeat. `21116/TCP` este folosit pentru TCP hole punching și serviciul de conectare.
- `21118` (TCP): folosit pentru a suporta clienții web.
- `hbbr`:
- `21117` (TCP): folosit pentru serviciile Relay.
- `21119` (TCP): folosit pentru a suporta clienții web.
*Dacă nu ai nevoie de suport pentru clienți web, porturile corespunzătoare `21118`, `21119` pot fi dezactivate.*
### Exemple Docker
```sh
sudo docker image pull rustdesk/rustdesk-server
sudo docker run --name hbbs -v ./data:/root -td --net=host --restart unless-stopped rustdesk/rustdesk-server hbbs
sudo docker run --name hbbr -v ./data:/root -td --net=host --restart unless-stopped rustdesk/rustdesk-server hbbr
```
<a name="net-host"></a>
{{% notice note %}}
`--net=host` funcționează doar pe **Linux**, ceea ce face ca `hbbs`/`hbbr` să vadă adresa IP reală de intrare în locul adresei IP a containerului (172.17.0.1).
Dacă `--net=host` funcționează corect, opțiunile `-p` nu se folosesc. Pe Windows, omite `sudo` și `--net=host`.
**Te rugăm să elimini `--net=host` dacă ai probleme de conectivitate pe platforma ta.**
{{% /notice %}}
{{% notice note %}}
Dacă nu poți vedea jurnalele cu `-td`, le poți vizualiza cu `docker logs hbbs`. Sau poți rula cu `-it`; în acest caz `hbbs/hbbr` nu vor rula în modul daemon.
{{% /notice %}}
### Exemple Docker Compose
Pentru a rula fișierele Docker cu `compose.yml` așa cum sunt descrise aici, trebuie să ai instalat [Docker Compose](https://docs.docker.com/compose/).
```yaml
services:
hbbs:
container_name: hbbs
image: rustdesk/rustdesk-server:latest
command: hbbs
volumes:
- ./data:/root
network_mode: "host"
depends_on:
- hbbr
restart: unless-stopped
hbbr:
container_name: hbbr
image: rustdesk/rustdesk-server:latest
command: hbbr
volumes:
- ./data:/root
network_mode: "host"
restart: unless-stopped
```
Dacă trebuie să faci modificări de configurare, de exemplu să setezi ALWAYS_USE_RELAY=Y, poți folosi variabile de mediu în `docker-compose.yml`:
```yaml
services:
hbbs:
container_name: hbbs
image: rustdesk/rustdesk-server:latest
environment:
- ALWAYS_USE_RELAY=Y
command: hbbs
volumes:
- ./data:/root
network_mode: "host"
depends_on:
- hbbr
restart: unless-stopped
hbbr:
container_name: hbbr
image: rustdesk/rustdesk-server:latest
command: hbbr
volumes:
- ./data:/root
network_mode: "host"
restart: unless-stopped
```
### Exemple Podman Quadlet
Dacă dorești să rulezi containerele cu Podman ca serviciu systemd poți folosi aceste configurații Quadlet de exemplu:
```ini
[Container]
AutoUpdate=registry
Image=ghcr.io/rustdesk/rustdesk-server:latest
Exec=hbbs
Volume=/path/to/rustdesk-server/data:/root
Network=host
[Service]
Restart=always
[Install]
WantedBy=default.target
```
sau
```ini
[Container]
AutoUpdate=registry
Image=ghcr.io/rustdesk/rustdesk-server:latest
Exec=hbbr
Volume=/path/to/rustdesk-server/data:/root
Network=host
[Service]
Restart=always
[Install]
WantedBy=default.target
```

13
content/self-host/rustdesk-server-oss/_index.ro.md Normal file
View File

@ -0,0 +1,13 @@
---
title: RustDesk Server OSS
weight: 100
pre: "<b>2.1. </b>"
---
Vă rugăm să vă alăturați [Discord](https://discord.com/invite/nDceKgxnkV) dacă doriți să discutați cu noi despre găzduirea propriei versiuni [open source RustDesk Server](https://github.com/rustdesk/rustdesk-server).
{{% notice note %}}
Dacă ați compilat/instalat propriul server acasă sau la birou și nu reușiți să vă conectați la el printr-un IP sau domeniu public, vă rugăm să verificați [acest articol](https://rustdesk.com/docs/en/self-host/nat-loopback-issues/).
{{% /notice %}}
{{% children depth="3" showhidden="true" %}}

52
content/self-host/rustdesk-server-oss/install/_index.ro.md Normal file
View File

@ -0,0 +1,52 @@
---
title: Instalare
weight: 1
---
## Tutoriale video
Există multe tutoriale video pe YouTube: https://github.com/rustdesk/rustdesk/wiki/FAQ#video-tutorials.
## Cerințe server
Cerințele hardware sunt foarte mici; o configurație minimă a unui server cloud de bază este suficientă, iar cerințele de CPU și memorie sunt minime. Poți folosi, de asemenea, un Raspberry Pi sau ceva similar. În ceea ce privește consumul de rețea, dacă conexiunea directă prin TCP hole punching eșuează, traficul va trece prin relay. Traficul unei conexiuni relay variază între 30 K/s și 3 M/s (ecran 1920x1080), în funcție de setările de rezoluție și de actualizarea ecranului. Dacă este folosit doar pentru activități de birou, traficul este în jur de 100 K/s.
## Firewall
Dacă ai UFW instalat, folosește următoarele comenzi pentru a configura firewall-ul:
```
ufw allow 21114:21119/tcp
ufw allow 21116/udp
sudo ufw enable
```
## Instalare
### Metoda 1: Docker (Recomandat)
```
bash <(wget -qO- https://get.docker.com)
wget rustdesk.com/oss.yml -O compose.yml
sudo docker compose up -d
```
Pentru mai multe detalii, verifică [Docker](/docs/en/self-host/rustdesk-server-oss/docker/).
### Metoda 2: Instalează propriul server ca serviciu systemd folosind un script de instalare ușor de rulat
Scriptul este găzduit la [Techahold](https://github.com/techahold/rustdeskinstall) și este susținut în comunitatea noastră de pe [Discord](https://discord.com/invite/nDceKgxnkV).
În prezent, scriptul va descărca și configura serverele Relay și Signal (hbbr și hbbs), va genera configurațiile și le va găzdui pe o pagină web protejată prin parolă pentru o implementare simplă către clienți.
Rulează următoarele comenzi:
```
wget https://raw.githubusercontent.com/techahold/rustdeskinstall/master/install.sh
chmod +x install.sh
./install.sh
```
Există, de asemenea, un script de actualizare în repository-ul [Techahold](https://github.com/techahold/rustdeskinstall).
După instalare, notează IP/DNS și Key afișate la final și introdu-le în client la Settings > Network > câmpurile `ID server` și `Key`, lăsând celelalte câmpuri necompletate (vezi nota de mai jos).
### Metoda 3: Instalează propriul server ca serviciu systemd folosind pachet .deb pentru distribuții Debian
Te rog [descarcă](https://github.com/rustdesk/rustdesk-server/releases/latest) fișierele .deb și instalează-le cu `apt-get -f install <filename>.deb` sau `dpkg -i <filename>.deb`.
## Configurează clientul
Te rog verifică [această pagină](/docs/en/self-host/client-configuration/#2-manual-config).

10
content/self-host/rustdesk-server-oss/synology/_index.ro.md Normal file
View File

@ -0,0 +1,10 @@
---
title: Synology
weight: 22
---
Synology are două tipuri de instalare pentru containere: „Docker” și „Container Manager”. Dacă folosești DSM 7.2 sau o versiune ulterioară, urmează ghidul pentru DSM 7.2; dacă folosești un sistem mai vechi, urmează ghidul pentru DSM 6.
Dacă folosești Synology împreună cu Portainer, te rugăm să consulți [acest tutorial](https://mariushosting.com/how-to-install-rustdesk-on-your-synology-nas/).
{{% children depth="3" showhidden="true" %}}

71
content/self-host/rustdesk-server-oss/synology/dsm-6/_index.ro.md Normal file
View File

@ -0,0 +1,71 @@
---
title: Synology DSM 6
weight: 22
---
> Un tutorial alternatiu și actualizat de la terți este disponibil [aici](https://mariushosting.com/how-to-install-rustdesk-on-your-synology-nas/).
Acest tutorial se bazează pe versiunile DSM v6 și v7.
{{% notice note %}}
După actualizarea la DSM 7.2, Docker a fost înlocuit cu noul „Container Manager”; te rugăm să consulți [acest articol](/docs/en/self-host/rustdesk-server-oss/synology/dsm-7) în schimb.
{{% /notice %}}
## Instalare Docker
| Deschide Package Center | Instalează Docker |
| --- | --- |
| ![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/package-manager.png) | ![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/docker.png) |
## Instalare RustDesk Server
| Caută rustdesk-server în registrul Docker și instalează făcând dublu click | Imaginea rustdesk-server instalată, dublu click pentru a crea containerul rustdesk-server |
| --- | --- |
| ![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/pull-rustdesk-server.png) | ![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/rustdesk-server-installed.png) |
## Creare container hbbs
După cum s-a menționat mai sus, fă dublu click pe imaginea rustdesk-server pentru a crea un container nou și setează-i numele `hbbs`.
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/hbbs.png)
Click pe `Advanced Settings` din imaginea de mai sus.
- Activează `Enable auto-restart`.
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/auto-restart.png)
- Activează `Use the same network as Docker Host`. Pentru mai multe detalii despre host net, verifică [acest ghid](https://rustdesk.com/docs/en/self-host/rustdesk-server-oss/docker/#net-host).
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/host-net.png)
- Montează un director de pe gazdă (de exemplu `/home/rustdesk/`) la `/root`; hbbs va genera fișiere (baza de date și fișiere `key`) în acest director care trebuie păstrate persistent peste reporniri.
| Mount | Fișiere generate în directorul gazdă |
| --- | --- |
| ![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/mount.png) | ![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/mounted-dir.png) |
- Setează comanda
{{% notice note %}}
Sistemul de operare al Synology este bazat pe Debian, deci host net (`--net=host`) funcționează corect; nu este necesar să mapăm porturi cu opțiunea `-p`.
{{% /notice %}}
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/hbbs-cmd.png?v3)
- Gata
## Creare container hbbr
Repetă pașii de mai sus pentru `hbbs`, dar denumește containerul `hbbr` iar comanda pentru pasul Set Command trebuie să fie `hbbr`.
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/hbbr-config.png)
## Containerele hbbr/hbbs
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/containers.png)
| Dublu click pe container și verifică jurnalul | Confirmă că hbbs/hbbr folosesc rețeaua host |
| --- | --- |
| ![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/log.png) | ![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/network-types.png) |
## Recuperează-ți Key-ul
Accesează folderul montat folosind File Station, descarcă `id_ed25519.pub` și deschide-l cu un editor de text pentru a obține cheia ta.

90
content/self-host/rustdesk-server-oss/synology/dsm-7/_index.ro.md Normal file
View File

@ -0,0 +1,90 @@
---
title: Synology DSM 7.2
weight: 20
---
<!-- Pentru traducători: Când traduceți elemente din interfață (de ex. "butone"), nu doar traduceți literal, consultați denumirile reale din interfața Synology. -->
După actualizarea la DSM 7.2, Synology și-a redenumit pachetul „Docker” în „Container Manager”. Acesta aduce o interfață nouă și include suport pentru "docker-compose" în GUI, ceea ce facilitează crearea containerelor Docker.
## Modele suportate și cerințe
Container Manager aduce suport ARM64 pentru unele modele mai simple, cum ar fi seria J; pentru lista detaliată a modelelor suportate, verifică [site-ul Synology](https://www.synology.com/en-us/dsm/packages/ContainerManager).
De cele mai multe ori nu va fi necesară instalarea de memorie RAM suplimentară pentru a rula Docker și RustDesk Server.
## 1. Instalează Container Manager (Docker)
Deschide „Package Center”, caută și instalează „Container Manager”.
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-7/images/dsm7_install_container_manager_though_package_center.png)
## 2. Creează folderele necesare
După ce ai instalat „Container Manager”, acesta va crea un Shared Folder numit `docker`; vom folosi acest loc pentru datele serverului.
Deschide File Station și creează un folder numit `rustdesk-server` (sau orice denumire preferi). Apoi creează în el un folder numit `data`, exact ca în imagine.
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-7/images/dsm7_create_required_folders.png)
## 3. Creează containerul
Deschide Container Manager, mergi la Projects și click pe Create.
Introdu numele proiectului `rustdesk-server` și schimbă Source din "Upload compose.yml" în "Create compose.yml", apoi copiază conținutul de mai jos în casetă.
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-7/images/dsm7_creating_project_init.png?v2)
```yaml
services:
hbbs:
container_name: hbbs
image: rustdesk/rustdesk-server:latest # Please change this to rustdesk/rustdesk-server-pro:latest if you want to install Pro.
command: hbbs
volumes:
- ./data:/root
network_mode: host
depends_on:
- hbbr
restart: always
hbbr:
container_name: hbbr
image: rustdesk/rustdesk-server:latest # Please change this to rustdesk/rustdesk-server-pro:latest if you want to install Pro.
command: hbbr
volumes:
- ./data:/root
network_mode: host
restart: always
# Because using docker host mode
# Just in case you forgot the ports:
# 21114 TCP for web console, only available in Pro version
# 21115 TCP for NAT type test
# 21116 TCP TCP hole punching
# 21116 UDP heartbeat/ID server
# 21117 TCP relay
```
Sari peste `Web portal settings`, apoi finalizează (Done).
## 4. Verifică că funcționează
Deschide File Station; în `docker/rustdesk-server/data` ar trebui să vezi fișierele `id_ed25519` și `id_ed25519.pub`. Le poți descărca și deschide cu orice editor de text sau cu [Synology Text Editor](https://www.synology.com/en-us/dsm/packages/TextEditor). Aceasta este cheia publică de care ai nevoie pentru clientul RustDesk.
Cheia publică arată aproximativ așa:
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-7/images/dsm7_viewing_public_key_though_syno_text_editor.png)
Verifică [aici](/docs/en/client) pentru configurarea clientului. Sunt necesare doar câmpurile `ID server` și `Key`. `Relay server` nu este necesar deoarece această informație este furnizată automat de către `hbbs`.
## 5. Configurează port forwarding pe router
Accesează pagina de administrare a routerului, caută setările legate de `Port forwarding`; acestea se găsesc de obicei în secțiunea `WAN` sau `Firewall`.
Dacă nu găsești setarea, caută pe Google `{Nume Router} + port forwarding` sau `{Model Router} + port forwarding`. Dacă routerul a fost furnizat de ISP, întreabă-i pe ei.
Deschide următoarele porturi necesare:
* `21114` TCP pentru consola web (doar în versiunea Pro)
* `21115` TCP pentru testul tipului NAT
* `21116` TCP pentru TCP hole punching
* `21116` UDP pentru heartbeat/ID server
* `21117` TCP pentru relay

110
content/self-host/rustdesk-server-oss/windows/_index.ro.md Normal file
View File

@ -0,0 +1,110 @@
---
title: Windows & PM2 sau NSSM
weight: 20
---
{{% notice note %}}
Politicile de securitate Windows pot fi complicate; dacă acest tutorial nu funcționează pentru tine sau întâmpini conexiuni instabile, mută serverul pe o mașină Linux.
{{% /notice %}}
{{% notice note %}}
Versiunea GUI, `RustDeskServer.setup.exe`, nu mai este întreținută și nu este recomandată.
{{% /notice %}}
## La o răscruce
Acum ai două opțiuni: poți folosi PM2 (mai ușor) sau NSSM (puțin mai dificil) pentru a porni RustDesk Server.
Există câteva avantaje în folosirea NSSM:
- Compatibilitate cu versiuni mai vechi de Windows (Windows Server 2008 R2/Windows 7 și anterioare — neconfirmat).
- Potrivit pentru Windows Server.
- Pornire automată la boot fără autentificare (utilizatorul care a creat intrarea de pornire nu trebuie să se autentifice pentru ca serviciul să pornească).
- Rulează ambele binare ca servicii.
- Independent (fără dependență de Node.js).
Avantajele PM2 includ:
- Recomandat dacă rulezi serverul pe același calculator pe care îl folosești zilnic.
- Te autentifici regulat cu utilizatorul care a creat intrarea de pornire RustDesk.
- Mai prietenos pentru utilizator.
## Instalare folosind NSSM
### Instalare NSSM
Te rog [descarcă](https://github.com/dkxce/NSSM/releases/download/v2.25/NSSM_v2.25.zip) și despachetează NSSM, selectând arhitectura corespunzătoare sistemului tău Windows (dacă e x86 folosește conținutul din folderul `win32`, dacă e x64 folosește `win64`). Este recomandat să muți binarul NSSM în `Program Files\NSSM` (odată pornit ca serviciu, NSSM nu poate fi mutat din directorul în care a fost plasat; este mai bine să-l pui în `Program Files`). De asemenea, este indicat să adaugi calea (de ex. `C:\Program Files\NSSM`) la variabila PATH.
### Verificare instalare NSSM
Dacă totul e corect, folderul `C:\Program Files\NSSM` ar trebui să conțină doar fișierul `nssm.exe` (în exemplul nostru folosim unitatea C:, dar poți folosi orice unitate sau cale dorești).
Deschide Command Prompt și rulează `nssm`; dacă vezi pagina de help, poți continua.
### Rulează hbbr și hbbs
Descarcă versiunea pentru Windows a [RustDesk Server](https://github.com/rustdesk/rustdesk-server/releases). Dezarhivează programul în `C:\Program Files\RustDesk Server` (sau oriunde dorești, doar asigură-te că locația nu se schimbă după instalarea serviciului). Revenind în Command Prompt:
Vom folosi `C:\Program Files\RustDesk Server` în exemplu.
```cmd
nssm install "RustDesk hbbs service" "C:\Program Files\RustDesk Server\hbbs.exe"
nssm install "RustDesk hbbr service" "C:\Program Files\RustDesk Server\hbbr.exe"
```
**Notă:**
- Poți schimba `RustDesk hbbs service` cu orice nume dorești pentru serviciul hbbs
- Poți schimba `RustDesk hbbr service` cu orice nume dorești pentru serviciul hbbr
- Poți schimba `C:\Program Files\RustDesk Server\hbbs.exe` cu locația în care ai plasat binarele RustDesk
- Poți schimba `C:\Program Files\RustDesk Server\hbbr.exe` cu locația în care ai plasat binarele RustDesk
**Template comenzi:**
Modelul de comandă dacă vrei să copiezi și să editezi:
```cmd
nssm install <Nume dorit serviciu hbbs> <Cale binar hbbs> <Argumente hbbs>
nssm install <Nume dorit serviciu hbbr> <Cale binar hbbr> <Argumente hbbr>
```
**Pornește serviciile**
După instalarea serviciilor, pornește-le:
```cmd
nssm start <Nume dorit serviciu hbbs>
nssm start <Nume dorit serviciu hbbr>
```
GATA!
(Metoda de mai sus a fost testată pe Windows Server Core 2022 Standard).
## sau
## Instalare folosind PM2
### Instalare Node.js
Te rog [descarcă](https://nodejs.org/dist/v16.14.2/node-v16.14.2-x86.msi) și instalează Node.js. Node.js este mediul de execuție pentru PM2, deci trebuie instalat înainte.
### Instalare PM2
Deschide `cmd.exe` și rulează următoarele comenzi (apăsând Enter după fiecare):
```cmd
npm install -g pm2
npm install pm2-windows-startup -g
pm2-startup install
```
### Rulează hbbr și hbbs
Descarcă versiunea Windows a [RustDesk Server](https://github.com/rustdesk/rustdesk-server/releases). Dezarhivează programul pe unitatea C:. Rulează următoarele comenzi:
```cmd
cd C:\rustdesk-server-windows-x64
pm2 start hbbs.exe
pm2 start hbbr.exe
pm2 save
```
### Vizualizează jurnalele
```cmd
pm2 log hbbr
pm2 log hbbs
```
## Tutoriale alternative
https://pedja.supurovic.net/setting-up-self-hosted-rustdesk-server-on-windows/?lang=lat

97
content/self-host/rustdesk-server-pro/2fa/_index.ro.md Normal file
View File

@ -0,0 +1,97 @@
---
title: 2FA
weight: 16
---
La autentificarea în contul tău, activarea verificării cu două factori (2FA) poate îmbunătăți securitatea contului.
Consola web suportă în prezent două tipuri de 2FA:
1. Verificare prin email
2. TOTP. Este necesară o aplicație de autentificare terță parte pentru a genera codul de verificare, de exemplu [Authy](https://authy.com), [Microsoft Authenticator](https://www.microsoft.com/en-us/security/mobile-authenticator-app/) sau [Google Authenticator](https://play.google.com/store/apps/details?id=com.google.android.apps.authenticator2).
Mai întâi trebuie să accesezi pagina de setări a contului.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/1-settings-account.png)
## Verificare prin email
Pentru a activa verificarea prin email la autentificare, ai nevoie de:
1. Să setezi o adresă de email.
2. Să activezi opțiunea `Enable email login verification`.
3. Să apeși `Submit`.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/2-2fa-email-1.png)
La următoarea autentificare, RustDesk îți va trimite un email cu un cod de verificare, iar pagina web te va redirecționa către ecranul de verificare.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/2-2fa-email-2.png)
## TOTP
TOTP este o metodă 2FA larg utilizată; în consola web a RustDesk Server Pro, 2FA se referă la verificarea TOTP.
### Pregătește o aplicație de autentificare
Mai întâi, instalează o aplicație de autentificare. Poți alege din: [Authy](https://authy.com), [Microsoft Authenticator](https://www.microsoft.com/en-us/security/mobile-authenticator-app/) sau [Google Authenticator](https://play.google.com/store/apps/details?id=com.google.android.apps.authenticator2).
### Activează 2FA
Când pe pagina de setări apare butonul `Enable 2FA`, înseamnă că 2FA nu este activ momentan.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-1.png)
Apasă butonul și va apărea un formular pentru activarea 2FA.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-2.png)
Deschide aplicația de autentificare și adaugă un cont scanând codul QR.
Dacă nu poți scana codul QR, poți introduce manual codul afișat.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-3.png)
După ce ai adăugat contul în aplicația de autentificare, introdu codul generat în aplicație pentru a activa 2FA.
După activare, RustDesk Server Pro va genera și lega 6 coduri de rezervă (backup codes). Aceste coduri pot fi folosite pentru a trece verificarea în cazul în care nu poți folosi aplicația de autentificare.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-4.png)
{{% notice note %}}
1. Aceste coduri de rezervă pot fi folosite o singură dată fiecare.
2. Păstrează codurile de rezervă într-un loc sigur.
{{% /notice %}}
### Verificare la autentificare
Odată activat 2FA, verificarea prin email nu se mai folosește. La autentificare se va folosi verificarea 2FA.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-login-5.png)
La autentificare, vei fi redirecționat către pagina de verificare.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-login-6.png)
### Modificarea setărilor
După ce 2FA este activat, modificarea setărilor contului va necesita verificare 2FA suplimentară.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-settings-1.png)
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-settings-2.png)
### Starea 2FA
2FA are în total 3 stări: neactivat, activat și expirat.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-state-not-enabled.png)
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-state-enabled.png)
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-state-expired.png)
{{% notice note %}}
2FA poate fi folosit în continuare chiar și după ce apare ca "expirat". Aceasta înseamnă doar că setările 2FA nu au fost actualizate o perioadă (implicit 180 de zile). Din motive de securitate, recomandăm reactivarea 2FA pentru a regenera secretul.
{{% /notice %}}

107
content/self-host/rustdesk-server-pro/_index.ro.md Normal file
View File

@ -0,0 +1,107 @@
---
title: RustDesk Server Pro
description: "Complete guide to RustDesk Server Pro - the premium self-hosted remote desktop solution. Features enterprise authentication (OIDC, LDAP, 2FA), web console, API access, and advanced security controls for professional deployment."
keywords: ["rustdesk server pro", "rustdesk pro server", "remote desktop server", "enterprise remote access", "rustdesk professional", "self-hosted rdp", "rustdesk enterprise", "remote desktop solution", "rustdesk licensing", "rustdesk web console"]
weight: 200
pre: "<b>2.2. </b>"
---
RustDesk Server Pro oferă mai multe funcționalități comparativ cu versiunea open source.
- Conturi
- [Consolă web](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/console/)
- [API](https://github.com/rustdesk/rustdesk/wiki/FAQ#api-of-rustdesk-server-pro)
- [OIDC](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/oidc/), [LDAP](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/ldap/), [2FA](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/2fa/)
- Agendă de adrese
- Management jurnale (conexiuni, transfer fișiere, alarme etc.)
- Management dispozitive
- [Sincronizare setări de securitate](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/strategy/)
- [Control acces](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/permissions/)
- [Multiple servere relay](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/relay/) (selectează automat cel mai apropiat relay)
- [Generator client personalizat](https://rustdesk.com/docs/en/self-host/client-configuration/#1-custom-client-generator-pro-only)
- WebSocket
- Client web self-host
{{% notice note %}}
Dacă ai construit propriul server acasă sau la birou și nu te poți conecta printr-un IP/domeniu public, verifică [acest articol](https://rustdesk.com/docs/en/self-host/nat-loopback-issues/).
{{% /notice %}}
{{% notice note %}}
Recomandăm lecturarea acestei pagini înainte de a continua: [Cum funcționează serverul self-hosted?](/docs/en/self-host/#how-does-self-hosted-server-work).
{{% /notice %}}
## Cerințe hardware
Un VPS la nivel minim este suficient pentru majoritatea cazurilor. Software-ul serverului nu este intensiv în CPU sau memorie. Serverul nostru public pentru ID găzduit pe un Vultr 2 CPU/4 GB deservește peste 1 milion de endpoint-uri. Fiecare conexiune relay consumă în medie 180 KB pe secundă. 1 nucleu CPU și 1 GB RAM sunt suficiente pentru a susține 1000 de conexiuni relay concurente.
## Articole/tutoriale
[Ghid pas cu pas: Self-Host RustDesk Server Pro în cloud cu Docker pentru acces securizat](https://www.linkedin.com/pulse/step-by-step-guide-self-host-rustdesk-server-pro-cloud-montinaro-fwnmf/)
## Tutoriale video
[Ghid pentru începători: Self-Host RustDesk Server Pro pentru utilizatori Linux începători](https://www.youtube.com/watch?v=MclmfYR3frk)
[Ghid rapid: Self-Host RustDesk Server Pro pentru utilizatori Linux avansați](https://youtu.be/gMKFEziajmo)
## Licență
Poți obține o licență de la https://rustdesk.com/pricing.html; verifică pagina de [licențiere](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/license/) pentru detalii.
## Începe
### 1. Instalare
```
bash <(wget -qO- https://get.docker.com)
wget rustdesk.com/pro.yml -O compose.yml
sudo docker compose up -d
```
Pentru mai multe detalii, verifică [Docker](/docs/en/self-host/rustdesk-server-pro/installscript/docker/).
### 2. Porturi necesare
Trebuie să ai porturile `21114`-`21119` TCP și `21116` UDP deschise; asigură-te că acestea sunt configurate în regulile firewall-ului și în mapările Docker.
Mai multe informații despre aceste porturi sunt disponibile [aici](/docs/en/self-host/rustdesk-server-oss/install/#ports).
### 3. Setează licența
Deschide consola web la `http://<adresa-serverului>:21114`, [autentifică-te](/docs/en/self-host/rustdesk-server-pro/console/#log-in) folosind credențialele implicite `admin`/`test1234`. Urmează [acest ghid](/docs/en/self-host/rustdesk-server-pro/license/#set-license) pentru a introduce licența.
### 4. Configurează HTTPS pentru consola web
> Poți sări peste acest pas în perioada de testare dacă nu dorești HTTPS, dar amintește-ți să schimbi adresa API a clientului după instalarea HTTPS.
Iată un tutorial simplu pentru [configurare HTTPS manuală](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/faq/#set-up-https-for-web-console-manually).
### 5. Configurează clientul să folosească serverul self-hosted
https://rustdesk.com/docs/en/self-host/client-configuration/
### 6. Configurează WebSocket
Pentru a activa clientul web sau pentru ca [clientul desktop/mobile](/docs/en/self-host/client-configuration/advanced-settings/#allow-websocket) să funcționeze corect cu WebSocket, adaugă următoarele setări în configurația reverse proxy-ului tău.
https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/faq/#8-add-websocket-secure-wss-support-for-the-id-server-and-relay-server-to-enable-secure-communication-for-all-platforms
## Upgrade server
Acest [ghid](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/faq/#there-is-a-new-version-of-rustdesk-server-pro-out-how-can-i-upgrade) explică cum să faci upgrade pentru RustDesk Server Pro între versiuni și acoperă diferite metode de instalare.
## Migrare pe un host nou și backup/restore
Aici este un [tutorial detaliat](https://github.com/rustdesk/rustdesk-server-pro/discussions/184).
## Migrare licență
Urmărește acest [ghid](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/license/#invoices-license-retrieval-and-migration) pentru migrarea licenței.
## Upgrade licență
Urmărește [acest ghid](/docs/en/self-host/rustdesk-server-pro/license/#renewupgrade-license) pentru a-ți upgrada licența pentru mai mulți utilizatori sau dispozitive.
## Despre securitate
https://github.com/rustdesk/rustdesk/discussions/9835

263
content/self-host/rustdesk-server-pro/console/_index.ro.md Normal file
View File

@ -0,0 +1,263 @@
---
title: Consolă web
weight: 10
---
Consola web este integrată în RustDesk Server Pro și rulează pe portul `21114`.
Funcționalități:
- Răsfoire dispozitive
- Adăugare/modificare utilizatori și grupuri de utilizatori
- Modificare permisiuni de acces ale dispozitivelor
- Răsfoire jurnale de conexiuni și alte jurnale
- Actualizare setări
- Management sincronizare setări client
- Gestionare agende partajate
- Generare build client personalizat
## Autentificare
Portul implicit al consolei web este 21114. Introdu `http://<adresa-serverului>:21114` în browser pentru a accesa consola, așa cum se arată în figura de mai jos. Numele de utilizator/parola implicită pentru administrator este `admin`/`test1234`:
![](/docs/en/self-host/rustdesk-server-pro/console/images/console-login.png)
Dacă ai nevoie de suport HTTPS, instalează un server web precum `Nginx` sau folosește `IIS` pe Windows.
După autentificare schimbă parola: din meniul contului (colțul din dreapta sus) selectează `Settings` pentru a intra pe pagina de modificare a parolei, așa cum se arată mai jos. Poți crea și un alt cont de administrator și șterge pe cel implicit. Este recomandat să activezi verificarea prin email la autentificare.
<a name=console-home></a>
![](/docs/en/self-host/rustdesk-server-pro/console/images/console-home.png?v2)
Utilizatorii non-administrator pot, de asemenea, să se autentifice pentru a-și vizualiza dispozitivele și jurnalele și pentru a-și modifica setările de utilizator.
## Configurări automate
Făcând click pe `Windows EXE` poți obține configurațiile pentru propriul RustDesk Server Pro — utile pentru configurarea clienților.
Pentru clienții Windows poți omite configurația serverului personalizat și pune informațiile de configurare direct în numele fișierului `rustdesk.exe`. Așa cum se arată mai sus, mergi la pagina de bun venit a consolei și apasă `Windows EXE`. **Client ≥ 1.1.9 necesar.**
Poți folosi aceasta în combinație cu [config client](https://rustdesk.com/docs/en/self-host/client-configuration/) și [scripturi de deployment](https://rustdesk.com/docs/en/self-host/client-deployment/) pentru a configura clienții.
## Crearea unui utilizator nou în afară de utilizatorul implicit `admin`
{{% notice note %}}
Planul `Individual` nu are această funcționalitate.
{{% /notice %}}
1. Click pe `Users` în meniul din stânga.
2. Creează un cont nou și activează `administrator`.
3. Autentifică-te cu noul cont administrativ.
4. Șterge utilizatorul `admin` din pagina `Users`.
## Crearea unui utilizator nou
1. Click pe `Users` în meniul din stânga.
2. Creează un utilizator nou.
3. Selectează grupul din care să facă parte (dacă trebuie să adaugi grupuri noi, vezi secțiunea următoare).
## Adăugarea unui grup nou
1. Click pe `Groups` în meniul din stânga.
2. Creează un grup nou.
3. După creare poți permite accesul între grupuri: click `Edit`.
4. Selectează grupurile relevante cărora vrei să le permiți acces (se adaugă automat în grupul corespunzător).
## Configurarea mai multor servere relay
1. Mergi la `Settings` în meniul din stânga.
2. Click pe `Relay` din submenu.
3. Apasă `+` lângă `Relay Servers`.
4. Introdu adresa DNS sau IP a serverului Relay și apasă <kbd>Enter</kbd>.
5. Dacă ai mai multe servere Relay continuă să apeși `+` și ajustează setările Geo dacă este necesar (amintește-ți să copiezi cheia către celelalte servere).
## Setare sau schimbare licență
1. Mergi la `Settings` în meniul din stânga.
2. Click pe `License` din submenu.
3. Apasă `Edit` și lipește codul licenței.
4. Apasă `OK`.
## Vizualizare jurnale
În meniul din stânga click pe `Logs`.
## Configurare emailuri
Exemplu folosind Gmail:
1. Mergi la `Settings` în meniul din stânga.
2. Click pe `SMTP` din submenu.
3. Introdu serverul SMTP `smtp.gmail.com`.
4. În `SMTP Port` introdu 587.
5. În `Mail Account` pune contul Gmail, ex. `myrustdeskserver@gmail.com`.
6. Introdu parola (s-ar putea să ai nevoie de o parolă de aplicație).
7. În `From` pune același cont Gmail `myrustdeskserver@gmail.com`.
8. Click `Check` pentru a salva.
## Atribuirea utilizatorilor/strategiilor/grupurilor de dispozitive prin Consola Web
Utilizatorul este contul RustDesk conectat pe dispozitiv sau atribuit dispozitivului prin click pe **Edit** lângă dispozitiv; click în câmpul **User** și alege din listă. Poți atribui în masă dispozitive unui utilizator din **User List** → **More → Assign Devices**.
Pentru a adăuga un dispozitiv într-un grup de dispozitive, click pe **Edit** lângă dispozitiv în **Device List** și modifică **Group**, sau mergi la lista **Device Groups**, click pe numele grupului și ajustează dispozitivele din acel grup.
Pentru a atribui o strategie unui dispozitiv, plasează cursorul în partea dreaptă a listei **Strategy** și click pe **Edit Devices**, **Edit Users** sau **Edit Device Groups** pentru a adăuga device-urile, dispozitivele utilizatorilor sau grupurile de dispozitive corespunzătoare strategiei selectate.
---
## Token API
Mai întâi trebuie să mergi la **Settings → Tokens → Create** și să creezi un token cu permisiunile necesare: **Device, Audit Log, User, Group, Strategy, Address Book**.
Odată creat, poți folosi aceste token-uri din linia de comandă sau din CLI Python pentru a efectua acțiuni cu permisiunile respective.
### Atribuire via token din linia de comandă
Poți folosi executabilul RustDesk cu parametrul `--assign` pentru a face atribuiri din linia de comandă:
Exemplu:
```bash
"C:\Program Files\RustDesk\rustdesk.exe" --assign --token <generatedtoken> --user_name <username>
```
Parametri suportati
| Parameter | Descriere | RustDesk Server Pro | RustDesk Client |
| --------------------------------------- | ------------------------------------- | ------------------- | --------------- |
| `--user_name <username>` | Atribuie un utilizator dispozitivului | | |
| `--strategy_name <strategyname>` | Atribuie o strategie dispozitivului | | |
| `--address_book_name <addressbookname>` | Atribuie dispozitivul la o agendă | | |
| `--address_book_tag <addressbooktag>` | Atribuire folosind tag-ul agendei | | |
| `--address_book_alias <alias>` | Atribuire folosind aliasul | 1.5.8 | 1.4.1 |
| `--address_book_password <password>` | Setează parola pentru înregistrare | 1.6.6 | 1.4.3 |
| `--address_book_note <note>` | Setează nota pentru înregistrare | 1.6.6 | 1.4.3 |
| `--device_group_name <devicegroupname>` | Atribuie dispozitiv la grup | | |
| `--note <note>` | Adaugă o notă dispozitivului | 1.6.6 | 1.4.3 |
| `--device_username <device_username>` | Setează username pentru dispozitiv | 1.6.6 | 1.4.3 |
| `--device_name <device_name>` | Setează numele dispozitivului | 1.6.6 | 1.4.3 |
Linia de comandă pe Windows nu afișează output implicit. Pentru a obține output rulează comanda astfel: `"C:\Program Files\RustDesk\rustdesk.exe" <arg1> <arg2> ... | more` sau `"C:\Program Files\RustDesk\rustdesk.exe" <arg1> <arg2> ... | Out-String` (vezi discuție referință în repo).
### Unelte CLI Python
#### Management utilizatori (`users.py`)
**Afișează help:**
`./users.py -h`
**Vezi utilizatori:**
`./users.py --url <url> --token <token> view [--name <username>] [--group_name <group_name>]`
**Filtre:**
`--name`: username
`--group_name`: grup utilizatori
**Exemplu:**
`./users.py --url https://example.com --token <token> view --group_name admins`
**Operații:**
`view` poate fi înlocuit cu `enable`, `disable`, sau `delete`.
**Exemplu (dezactivează utilizator):**
`./users.py --url https://example.com --token <token> disable --name testuser`
---
#### Management dispozitive (`devices.py`)
**Afișează help:**
`./devices.py -h`
**Vezi dispozitive:**
`./devices.py --url <url> --token <token> view [--id <device_id>] [--device_name <device_name>] [--user_name <user_name>] [--group_name <group_name>] [--device_group_name <device_group_name>] [--offline_days <days>]`
**Filtre:**
`--id`: ID dispozitiv
`--device_name`: nume dispozitiv
`--user_name`: utilizator atribuit
`--group_name`: grup utilizatori
`--device_group_name`: grup dispozitive
`--offline_days`: zile de când este offline
**Exemplu:**
`./devices.py --url https://example.com --token <token> view --user_name mike`
**Operații:**
`view` poate fi înlocuit cu `enable`, `disable`, `delete`, sau `assign`.
**Exemplu (atribuie device):**
`./devices.py --url https://example.com --token <token> assign --device_name PC01 --assign_to user_name=mike`
---
#### Management agendă (`ab.py`)
**Afișează help:**
`./ab.py -h`
**Vezi agende partajate:**
`./ab.py --url <url> --token <token> view-ab [--ab-name <address_book_name>]`
**Obține GUID-ul agendei personale:**
`./ab.py --url <url> --token <token> get-personal-ab`
**Adaugă o agendă partajată:**
`./ab.py --url <url> --token <token> add-ab --ab-name <name> [--note <note>] [--password <password>]`
**Actualizează sau șterge o agendă partajată:**
`./ab.py --url <url> --token <token> update-ab --ab-guid <guid> [--ab-update-name <new_name>] [--note <note>]`
`./ab.py --url <url> --token <token> delete-ab --ab-guid <guid>`
**Vezi peer-ii dintr-o agendă:**
`./ab.py --url <url> --token <token> view-peer --ab-guid <guid> [--peer-id <peer_id>] [--alias <alias>]`
**Adaugă/actualizează/șterge un peer:**
`./ab.py --url <url> --token <token> add-peer --ab-guid <guid> --peer-id <peer_id> [--alias <alias>] [--note <note>] [--tags tag1,tag2]`
`./ab.py --url <url> --token <token> update-peer --ab-guid <guid> --peer-id <peer_id> [--alias <alias>] [--note <note>] [--tags tag1,tag2]`
`./ab.py --url <url> --token <token> delete-peer --ab-guid <guid> --peer-id <peer_id>`
**Management tag-uri:**
`./ab.py --url <url> --token <token> view-tag --ab-guid <guid>`
`./ab.py --url <url> --token <token> add-tag --ab-guid <guid> --tag-name <name> [--tag-color 0xFF00FF00]`
`./ab.py --url <url> --token <token> update-tag --ab-guid <guid> --tag-name <name> --tag-color 0xFFFF0000`
`./ab.py --url <url> --token <token> delete-tag --ab-guid <guid> --tag-name <name>`
**Management reguli de acces:**
`./ab.py --url <url> --token <token> view-rule --ab-guid <guid>`
`./ab.py --url <url> --token <token> add-rule --ab-guid <guid> [--rule-type user|group|everyone] [--rule-user <user>] [--rule-group <group>] --rule-permission ro|rw|full`
`./ab.py --url <url> --token <token> update-rule --rule-guid <rule_guid> --rule-permission rw`
`./ab.py --url <url> --token <token> delete-rule --rule-guid <rule_guid>`
**Exemplu (adaugă regulă read-only pentru utilizatorul "mike"):**
`./ab.py --url https://example.com --token <token> add-rule --ab-guid <guid> --rule-user mike --rule-permission ro`
---
#### Audits (`audits.py`)
**Afișează help:**
`./audits.py -h`
**Vezi audituri conexiuni:**
`./audits.py --url <url> --token <token> view-conn [--remote <peer_id>] [--conn-type <type>] [--page-size <n>] [--current <n>] [--created-at <"YYYY-MM-DD HH:MM:SS">] [--days-ago <n>]`
**Vezi audituri fișiere:**
`./audits.py --url <url> --token <token> view-file [--remote <peer_id>] [--page-size <n>] [--current <n>] [--created-at <"YYYY-MM-DD HH:MM:SS">] [--days-ago <n>]`
**Vezi audituri alarme:**
`./audits.py --url <url> --token <token> view-alarm [--device <device_id>] [--page-size <n>] [--current <n>] [--created-at <"YYYY-MM-DD HH:MM:SS">] [--days-ago <n>]`
**Vezi audituri consolă:**
`./audits.py --url <url> --token <token> view-console [--operator <username>] [--page-size <n>] [--current <n>] [--created-at <"YYYY-MM-DD HH:MM:SS">] [--days-ago <n>]`
**Filtre:**
`--remote`: Peer ID (pentru conexiuni sau audituri fișiere)
`--conn-type`: 0=Remote Desktop, 1=File Transfer, 2=Port Transfer, 3=View Camera, 4=Terminal
`--device`: ID dispozitiv (pentru audit alarme)
`--operator`: username operator (pentru audit consolă)
`--created-at`: Filtru după timp local, ex. "2025-09-16 14:15:57"
`--days-ago`: Filtru pentru înregistrări mai noi decât numărul de zile
`--page-size` / `--current`: Paginare
**Exemplu:**
`./audits.py --url https://example.com --token <token> view-conn --remote 123456789 --days-ago 7`
## Căutarea unui dispozitiv
1. Mergi la Devices.
2. În câmpul Device Name tastează numele și apasă `Query` sau <kbd>Enter</kbd>.
3. Pentru wildcard adaugă `%` la început, sfârșit sau ambele părți ale termenului de căutare.

413
content/self-host/rustdesk-server-pro/faq/_index.ro.md Normal file
View File

@ -0,0 +1,413 @@
---
title: Întrebări frecvente (FAQ)
description: "Întrebări frecvente despre instalarea, configurarea, licențierea, depanarea și migrarea RustDesk Server Pro. Găsește răspunsuri la probleme comune, configurare SSL, gestionare baze de date și proceduri de upgrade."
keywords: ["rustdesk server pro faq", "rustdesk pro help", "rustdesk installation help", "rustdesk troubleshooting", "rustdesk server setup", "rustdesk license issues", "rustdesk ssl configuration", "rustdesk migration guide", "rustdesk pro support", "rustdesk server questions"]
weight: 600
---
## Cum instalez folosind Simple Install Script?
1. Obține o licență de la https://rustdesk.com/pricing.html — vezi pagina de [license](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/license/) pentru detalii.
2. Pornește un VPS, un server fizic sau o mașină virtuală Linux.
3. Dacă vrei să folosești DNS și SSL, creează un nume DNS, ex. `rustdesk.domeniultau.com`.
4. Urmează instrucțiunile de pe această pagină: https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/installscript/#install.
5. Copiază și lipește comanda în terminalul Linux.
6. Urmează pașii interactivi din script.
7. După instalare poți accesa `https://rustdesk.domeniultau.com` sau `http://adresa-ip:21114`.
8. Autentifică-te cu `admin` / `test1234`.
9. Introdu codul de licență achiziționat la pasul 1.
## Cum convertesc RustDesk Server Open Source în RustDesk Server Pro?
1. Obține o licență de la https://rustdesk.com/pricing.html și consultă pagina de [license](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/license/).
2. Deschide portul TCP 21114 în firewall.
3. Autentifică-te pe serverul RustDesk existent.
4. Dacă nu ai folosit DNS și dorești SSL, configurează un nume DNS, ex. `rustdesk.domeniultau.com`.
5. Urmează instrucțiunile de pe această pagină: https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/installscript/#convert-from-open-source.
6. Rulează comanda recomandată în terminal.
7. Urmează pașii interactivi.
8. După finalizare accesează `https://rustdesk.domeniultau.com` sau `http://adresa-ip:21114`.
9. Autentifică-te cu `admin` / `test1234`.
10. Introdu codul de licență.
## A apărut o versiune nouă de RustDesk Server Pro — cum fac upgrade?
E recomandat să faci backup la fișierele de date (ex. fișiere sqlite3) înainte: https://github.com/rustdesk/rustdesk-server-pro/discussions/184#discussioncomment-8013375.
- Dacă ai instalat cu script (`install.sh`)
- Rulează [update.sh](/docs/en/self-host/rustdesk-server-pro/installscript/script/#upgrade).
- Docker Compose
```sh
sudo docker compose down
sudo docker compose pull
sudo docker compose up -d
```
Comportamentul poate depinde de versiunea Docker Compose; vezi și discuțiile aferente pentru detalii.
- Docker (fără compose)
```sh
sudo docker ps
# poți folosi și <CONTAINER NAME>, de ex. `hbbs` și `hbbr` dacă ai urmat manualul nostru
sudo docker stop <CONTAINER ID>
sudo docker rm <CONTAINER ID>
sudo docker rmi <IMAGE ID>
sudo docker run ..... # la fel ca în instalarea inițială
```
Exemplu de flux:
```sh
root@hz:~# sudo docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
30822972c220 rustdesk/rustdesk-server-pro "hbbr" 10 seconds ago Restarting (1) 2 seconds ago hbbr
0f3a6f185be3 rustdesk/rustdesk-server-pro "hbbs" 15 seconds ago Up 14 seconds hbbs
root@hz:~# sudo docker kill hbbr hbbs
hbbr
hbbs
root@hz:~# sudo docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
root@hz:~# sudo docker rm hbbr hbbs
hbbr
hbbs
root@hz:~# sudo docker rmi rustdesk/rustdesk-server-pro
Untagged: rustdesk/rustdesk-server-pro:latest
... (output truncated)
root@hz:~# sudo docker run --name hbbs -v ./data:/root -td --net=host --restart unless-stopped rustdesk/rustdesk-server-pro hbbs
root@hz:~# sudo docker run --name hbbr -v ./data:/root -td --net=host --restart unless-stopped rustdesk/rustdesk-server-pro hbbr
root@hz:~# sudo docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4eb9da2dc460 rustdesk/rustdesk-server-pro "hbbr" 5 seconds ago Restarting (1) Less than a second ago hbbr
0cc5387efa8d rustdesk/rustdesk-server-pro "hbbs" 8 seconds ago Up 7 seconds hbbs
```
Pentru mai multe detalii vezi și: https://www.cherryservers.com/blog/how-to-update-docker-image
## Am instalat cu script — cum pornesc/oprim serviciile?
Serviciile sunt gestionate cu systemd, poți folosi:
`sudo systemctl stop|start|restart rustdesk-hbbs rustdesk-hbbr`, ex: `sudo systemctl restart rustdesk-hbbs`.
## Unde găsesc jurnalele (logs) pe Linux când am instalat cu script?
Jurnalele se află în `/var/log/rustdesk-server`. Le poți citi cu `tail /var/log/rustdesk-server/hbbs.log` sau `tail /var/log/rustdesk-server/hbbs.error`.
## Cum verific statusul serviciilor RustDesk instalate cu script?
Rulează: `sudo systemctl status rustdesk-hbbs` sau `sudo systemctl status rustdesk-hbbr`.
## Cum schimb parola de admin?
1. Deschide `https://rustdesk.domeniultau.com` sau `http://adresa-ip:21114`.
2. Autentifică-te cu `admin` / `test1234`.
3. Click pe `admin` (colțul din dreapta sus).
4. Click pe `Settings`.
5. Completează noile parole în câmpurile afișate.
## Cum mut licența pe un alt server?
Urmărește pașii descriși aici: https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/license/#invoices-and-migration
## E-mail-urile nu funcționează de pe VPS
Mulți furnizori VPS blochează porturile 465 și 25.
Verificare simplă: în Linux folosește `telnet your.mailserver.com 25`. Pe Windows PowerShell: `Test-NetConnection -ComputerName your.mailserver.com -Port 25`.
Asigură-te că folosești porturile corecte pentru serverul tău de mail.
## Pot face deployment folosind PowerShell sau altceva similar?
Da — găsești scripturi utile aici: https://rustdesk.com/docs/en/self-host/client-deployment/
## Cum raportez un bug?
Deschide un issue pe GitHub: https://github.com/rustdesk/rustdesk-server-pro/issues
## De ce RustDesk Server Pro nu este gratuit dacă îl găzduiesc singur?
1. RustDesk a devenit un loc de muncă cu normă întreagă pentru mai multe persoane; menținerea proiectului costă timp și bani.
2. Dorim să continuăm dezvoltarea pe termen lung.
3. Versiunea open source rămâne open source și încurajăm contribuțiile în conformitate cu licența AGPL.
## Nu mă pot conecta la dispozitive din grupuri diferite — de ce?
Trebuie să permiți acces cross-group (între grupuri):
1. Adaugă grupurile necesare.
2. Click `Edit`.
3. Selectează grupurile cărora dorești să le permiți acces (se adaugă automat în grupul corespunzător).
## Cum obțin configurații automat?
1. Descarcă cei mai noi clienți de pe GitHub: https://github.com/rustdesk/rustdesk/releases/latest
2. În consola web, pe pagina principală, click pe `Windows EXE`.
3. Completează host și API (dacă sunt diferite).
4. Click `Submit`.
5. Scanează QR code pe Android și redenumește .exe conform indicațiilor.
## Oferiți găzduire pentru RustDesk Server Pro?
Contactează echipa de [vânzări](mailto://sales@rustdesk.com).
## Există ghiduri video?
Da — canalul nostru YouTube: https://youtube.com/@RustDesk
## De ce apar jurnalele sau numele dispozitivelor goale?
Asigură-te că API-ul este configurat corect pe dispozitivul controlat: https://github.com/rustdesk/rustdesk-server-pro/issues/21#issuecomment-1637935750
## Cum dezinstalez RustDesk Server Pro?
Rulează următoarele comenzi:
```sh
sudo systemctl stop rustdesk-hbbs.service
sudo systemctl disable rustdesk-hbbs.service
sudo systemctl stop rustdesk-hbbr.service
sudo systemctl disable rustdesk-hbbr.service
sudo systemctl daemon-reload
sudo rm /etc/systemd/system/rustdesk-hbbs.service
sudo rm etc/systemd/system/rustdesk-hbbr.service
sudo rm /usr/bin/hbbs
sudo rm /usr/bin/hbbr
sudo rm -rf /var/lib/rustdesk-server/
sudo rm -rf /var/log/rustdesk-server/
```
Dacă scriptul a instalat Nginx, îl poți elimina cu:
```sh
sudo apt remove nginx
```
## Cum elimin dispozitive din lista de dispozitive din consola web?
Mai întâi dezactivează dispozitivul, apoi opțiunea de ștergere va fi disponibilă.
## Cum actualizez RustDesk pe Windows cu PowerShell?
```ps
$ErrorActionPreference= 'silentlycontinue'
$rdver = ((Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\RustDesk\").Version)
if ($rdver -eq "1.2.6")
{
Write-Output "RustDesk $rdver is the newest version."
Exit
}
if (!(Test-Path C:\Temp))
{
New-Item -ItemType Directory -Force -Path C:\Temp > null
}
cd C:\Temp
Invoke-WebRequest "https://github.com/rustdesk/rustdesk/releases/download/1.2.6/rustdesk-1.2.6-x86_64.exe" -Outfile "rustdesk.exe"
Start-Process .\rustdesk.exe --silent-install -wait
```
## Eroare `Key mismatch`
Configurează clientul cu cheia corectă: https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/relay/
## Eroare `Failed to connect to relay server`
Asigură-te că `hbbr` rulează. Mai multe informații despre `hbbr` găsești aici: https://rustdesk.com/docs/en/self-host/rustdesk-server-oss/install/.
Dacă `hbbr` nu rulează pe aceeași mașină ca `hbbs`, ai multiple servere relay sau folosești un port diferit de 21117, trebuie să-i spui explicit lui `hbbs` despre acesta. Vezi: https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/relay/.
## Resetare MFA pentru contul Admin
https://github.com/rustdesk/rustdesk/discussions/6576
## Configurare manuală HTTPS pentru consola web
### 1. Cumpără un nume de domeniu și pointează-l către IP-ul serverului
- Cumpără un domeniu de la un registrar (GoDaddy, Namecheap, Namesilo etc.).
- Configurează înregistrarea A în panoul registrarului sau la providerul DNS pentru a indica IP-ul serverului.
Exemplu: dacă domeniul tău este `example.com` și IP-ul serverului este `123.123.123.123`, folosește subdomeniul `rustdesk.example.com`. Urmează pașii din panoul Namesilo pentru a adăuga o înregistrare A.
![](/docs/en/self-host/rustdesk-server-pro/faq/images/namesilo-dns-button.png)
![](/docs/en/self-host/rustdesk-server-pro/faq/images/namesilo-add-a-record.png)
![](/docs/en/self-host/rustdesk-server-pro/faq/images/namesilo-dns-table.png)
Verifică propagarea DNS pe https://www.whatsmydns.net. Înlocuiește `YOUR_DOMAIN` cu subdomeniul tău, ex. `rustdesk.example.com`.
### 2. Instalează Nginx
- Debian/Ubuntu: `sudo apt-get install nginx`
- Fedora/CentOS: `sudo dnf install nginx` sau `sudo yum install nginx`
- Arch: `sudo pacman -S nginx`
- openSUSE: `sudo zypper install nginx`
- Gentoo: `sudo emerge -av nginx`
- Alpine: `sudo apk add --no-cache nginx`
Verifică cu `nginx -h`.
### 3. Instalează Certbot
- Metoda 1: dacă ai `snap`, rulează `sudo snap install certbot --classic`.
- Metoda 2: instalează `python3-certbot-nginx`, ex. `sudo apt-get install python3-certbot-nginx`.
- Metoda 3: folosește pachetul `certbot-nginx` din managerul distro-ului.
Verifică cu `certbot -h`.
### 4. Configurează Nginx
Există două opțiuni:
- Dacă există `/etc/nginx/sites-available` și `/etc/nginx/sites-enabled`, creează fișierul:
```sh
cat > /etc/nginx/sites-available/rustdesk.conf << EOF
server {
server_name YOUR_DOMAIN;
location / {
proxy_set_header X-Real-IP \$remote_addr;
proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
proxy_pass http://127.0.0.1:21114/;
}
}
EOF
sudo ln -s /etc/nginx/sites-available/rustdesk.conf /etc/nginx/sites-enabled/rustdesk.conf
```
- Dacă nu există `sites-available`/`sites-enabled` dar există `/etc/nginx/conf.d`, creează:
```sh
cat > /etc/nginx/conf.d/rustdesk.conf << EOF
server {
server_name YOUR_DOMAIN;
location / {
proxy_set_header X-Real-IP \$remote_addr;
proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
proxy_pass http://127.0.0.1:21114/;
}
}
EOF
```
Verifică conținutul fișierului creat.
### 5. Permite porturile firewall pentru domeniu
```sh
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw --force enable
sudo ufw --force reload
```
### 6. Generează certificatul SSL
Înlocuiește `$YOUR_DOMAIN` cu domeniul tău și rulează:
```sh
sudo certbot --nginx --cert-name $YOUR_DOMAIN --key-type ecdsa --renew-by-default --no-eff-email --agree-tos --server https://acme-v02.api.letsencrypt.org/directory -d $YOUR_DOMAIN
```
Dacă cere email, introdu adresa ta.
Fișierul `rustdesk.conf` ar trebui să conțină setările SSL generate de Certbot.
Erori frecvente și soluții:
- Mesajul `Successfully deployed certificate for YOUR_DOMAIN to /etc/nginx/.../default` în loc de `.../rustdesk.conf`: Certbot nu găsește fișierul; repornește nginx sau copiază blocul `server{...}` în `rustdesk.conf` și asigură-te că `location` conține proxy_pass către 127.0.0.1:21114.
- `too many certificates (5) already issued for this exact set of domains in the last 168 hours`: folosește un alt subdomeniu temporar și reia pașii.
- `Error getting validation data`: verifică firewall-ul.
Rulează `sudo service nginx restart` dacă modifici manual `rustdesk.conf`.
### 7. Autentificare în web
- Deschide `https://YOUR_DOMAIN` în browser, autentifică-te cu `admin` / `test1234` și schimbă parola.
### 8. Adaugă suport WebSocket securizat (WSS) pentru id server și relay
Adaugă următoarele în primul bloc `server` din fișierul `rustdesk.conf`, apoi repornește Nginx. Clientul web va fi accesibil la `https://YOUR_DOMAIN/web`. Clienții personalizați pot folosi WebSocket activând `allow-websocket=Y` în opțiuni avansate. Atenție: clienții WebSocket folosiți exclusiv vor folosi relay și nu TCP/UDP direct (cu excepția conexiunilor IP directe). Dacă folosești doar clienți WebSocket, poți închide porturile 21114–21119 și păstra doar 443 deschis.
```nginx
location /ws/id {
proxy_pass http://127.0.0.1:21118;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "Upgrade";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_read_timeout 120s;
}
location /ws/relay {
proxy_pass http://127.0.0.1:21119;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "Upgrade";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_read_timeout 120s;
}
```
{{% notice note %}}
Dacă ai implementat anterior pentru clienți web și vrei să-l folosești pe toate platformele, trebuie să adaugi `proxy_read_timeout`.
{{% /notice %}}
### 9. Bypass CORS dacă folosești clientul web public `https://rustdesk.com/web`
Adaugă următorul cod în secțiunea `location /` din `rustdesk.conf` pentru a ocoli restricțiile CORS ale browserului. Sare peste acest pas dacă folosești clientul tău web.
```nginx
if ($http_origin ~* (https?://(www\.)?rustdesk\.com)) {
add_header 'Access-Control-Allow-Origin' "$http_origin" always;
add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, DELETE, PATCH, OPTIONS' always;
add_header 'Access-Control-Allow-Headers' 'Origin, Content-Type, Accept, Authorization' always;
add_header 'Access-Control-Allow-Credentials' 'true' always;
}
if ($request_method = 'OPTIONS') {
add_header 'Access-Control-Allow-Origin' "$http_origin" always;
add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, DELETE, PATCH, OPTIONS' always;
add_header 'Access-Control-Allow-Headers' 'Origin, Content-Type, Accept, Authorization' always;
add_header 'Access-Control-Allow-Credentials' 'true' always;
add_header 'Content-Length' 0;
add_header 'Content-Type' 'text/plain charset=UTF-8';
return 204;
}
```
## SELinux
If `Waiting for RustDesk Relay service to become active...` appears when install, it may be caused by SELinux. You can try the following commands:
```sh
sudo semanage fcontext -a -t NetworkManager_dispatcher_exec_t 'hbbs'
sudo semanage fcontext -a -t NetworkManager_dispatcher_exec_t 'hbbr'
sudo restorecon -v '/usr/bin/hbbs'
sudo restorecon -v '/usr/bin/hbbr'
```
## Firewall
### Firewall în cloud
Dacă rulezi pe AWS/Azure/Google/DigitalOcean, deschide inbound UDP (21116) și TCP (21114-21119) în consola furnizorului cloud.
- [AWS] https://docs.aws.amazon.com/network-firewall/latest/developerguide/getting-started.html
- [Azure] https://learn.microsoft.com/en-us/azure/virtual-network/network-security-groups-overview
- [Google] https://cloud.google.com/firewall/docs/firewalls
- [DigitalOcean] https://docs.digitalocean.com/products/networking/firewalls/
### Firewall pe server on-premise
Scriptul RustDesk folosește `ufw`. Pe unele distribuții (ex. CentOS 9) poți utiliza `firewall-cmd`:
```sh
sudo firewall-cmd --permanent --add-port=21115/tcp
sudo firewall-cmd --permanent --add-port=21116/tcp
sudo firewall-cmd --permanent --add-port=21117/tcp
sudo firewall-cmd --permanent --add-port=21118/tcp
sudo firewall-cmd --permanent --add-port=21119/tcp
sudo firewall-cmd --permanent --add-port=21116/udp
```
Pentru IP direct:
```sh
sudo firewall-cmd --permanent --add-port=21114/tcp
```
Pentru DNS/Domeniu:
```sh
sudo firewall-cmd --permanent --add-port=80/tcp
sudo firewall-cmd --permanent --add-port=443/tcp
```
După aceea rulează `sudo firewall-cmd --reload`.
## Am schimbat parola de admin în consolă și nu mă pot autentifica — există o resetare simplă?
1. Asigură-te că ai `rustdesk-utils` instalat (https://github.com/rustdesk/rustdesk-server-pro) și execută comanda din directorul unde se află baza de date, ex. `/var/lib/rustdesk-server`.
2. Comanda este `rustdesk-utils set_password username password`. Dacă s-a efectuat cu succes va afișa *Done*.
Există și alte comenzi utile în `rustdesk-utils`: `genkeypair`, `validatekeypair [public key] [secret key]`, `doctor [rustdesk-server]`, `reset_email_verification` și `reset_2fa_verification`.
https://github.com/rustdesk/rustdesk-server-pro/discussions/183
## Adăugarea certificatului root CA în containerul Docker (pentru eșec TLS cu SMTP, OIDC etc.)
https://github.com/rustdesk/rustdesk-server-pro/issues/99#issuecomment-2235014703

78
content/self-host/rustdesk-server-pro/installscript/Docker/_index.ro.md Normal file
View File

@ -0,0 +1,78 @@
---
title: Docker
weight: 3
---
## Docker Compose (Recomandat)
Cu Docker Compose TREBUIE să folosești `network_mode: "host"` pentru a te asigura că licențierea funcționează. Instalează Docker urmând acest [ghid](https://docs.docker.com/engine/install) pentru a avea cea mai recentă versiune.
Copiază conținutul de mai jos în `compose.yml`.
```yaml
services:
hbbs:
container_name: hbbs
image: docker.io/rustdesk/rustdesk-server-pro:latest
command: hbbs
volumes:
- ./data:/root
network_mode: "host"
depends_on:
- hbbr
restart: unless-stopped
hbbr:
container_name: hbbr
image: docker.io/rustdesk/rustdesk-server-pro:latest
command: hbbr
volumes:
- ./data:/root
network_mode: "host"
restart: unless-stopped
```
Apoi rulează `sudo docker compose up -d` sau `podman-compose up -d`.
> Pentru `podman-compose` pe Debian/Ubuntu: `sudo apt install podman-compose`.
{{% notice note %}}
Cum să [configurezi HTTPS pentru consola web manual](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/faq/#set-up-https-for-web-console-manually).
{{% /notice %}}
## Comenzi Docker
Instalează Docker urmând acest [ghid](https://docs.docker.com/engine/install) pentru a fi la zi.
Sau poți instala Docker cu o singură comandă:
```
bash <(wget -qO- https://get.docker.com)
```
Rulează comenzile de mai jos (imaginea s6 poate necesita `./data:/data` în loc de `./data:/root`):
```sh
sudo docker image pull rustdesk/rustdesk-server-pro
sudo docker run --name hbbs -v ./data:/root -td --net=host --restart unless-stopped docker.io/rustdesk/rustdesk-server-pro hbbs
sudo docker run --name hbbr -v ./data:/root -td --net=host --restart unless-stopped docker.io/rustdesk/rustdesk-server-pro hbbr
```
{{% notice note %}}
Exemplele de mai sus folosesc `sudo` și `--net=host`; acestea nu funcționează pe Windows — elimină-le pe Windows și, dacă renunți la `--net=host`, verifică instrucțiunile de mai jos pentru maparea porturilor.
{{% /notice %}}
Pentru sisteme unde nu poți folosi `--net=host`, poți mapa explicit porturile:
```sh
macaddrhbbs=$(echo -n A0-62-2F; dd bs=1 count=3 if=/dev/random 2>/dev/null |hexdump -v -e '/1 "-%02X"')
sudo docker run --name hbbs -p 21114:21114 -p 21115:21115 -p 21116:21116 -p 21116:21116/udp -p 21118:21118 -v ./data:/root -td --mac-address="$macaddrhbbs" --restart unless-stopped docker.io/rustdesk/rustdesk-server-pro hbbs
sudo docker run --name hbbr -p 21117:21117 -p 21119:21119 -v ./data:/root -td --restart unless-stopped docker.io/rustdesk/rustdesk-server-pro hbbr
```
{{% notice note %}}
Cum să [configurezi HTTPS pentru consola web manual](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/faq/#set-up-https-for-web-console-manually).
{{% /notice %}}
Dacă întâmpini probleme cu SELinux pe Fedora, vezi acest [issue](https://github.com/rustdesk/rustdesk-server/issues/230).

86
content/self-host/rustdesk-server-pro/installscript/Script/_index.ro.md Normal file
View File

@ -0,0 +1,86 @@
---
title: install.sh
weight: 4
---
{{% notice note %}}
Nu uita să obții licența de la [https://rustdesk.com/pricing/](https://rustdesk.com/pricing/), vezi pagina de [license](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/license/) pentru detalii.
Te rugăm să citești mai întâi ghidul pentru [instalarea OSS](https://rustdesk.com/docs/en/self-host/rustdesk-server-oss/install/) înainte de a rula acest instalator simplu. Acolo găsești detalii tehnice utile.
{{% /notice %}}
## Instalare
Copiază și lipește comanda de mai jos în terminalul tău Linux pentru a instala RustDesk Server Pro.
`wget -qO- https://raw.githubusercontent.com/rustdesk/rustdesk-server-pro/main/install.sh | bash`
{{% notice note %}}
Recomand folosirea [imaginii Docker](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/installscript/docker/#docker-compose); aceasta simplifică mult implementarea și actualizările. Consumă foarte puține resurse.
Rulează scriptul de instalare din directorul tău home, nu dintr-un director în care nu ai permisiuni de scriere.
{{% /notice %}}
Ce face scriptul:
- Instalează dependențe necesare
- Configurează UFW dacă este disponibil
- Creează directorul de lucru `/var/lib/rustdesk-server` și directorul de log `/var/log/rustdesk-server`
- Instalează executabilele în `/usr/bin`
- Descarcă și extrage serviciile RustDesk Pro în directorul menționat
- Creează servicii systemd pentru `hbbs` și `hbbr` (numele serviciilor: `rustdesk-hbbs.service` și `rustdesk-hbbr.service`)
- Dacă alegi opțiunea Domain, instalează Nginx și Certbot pentru a expune API-ul pe portul `443` (HTTPS) și a obține automat certificat SSL pe portul `80`. Când HTTPS este gata, accesează `https://domeniul-tau` (fără :21114).
{{% notice note %}}
Cum să [configurezi HTTPS pentru consola web manual](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/faq/#set-up-https-for-web-console-manually).
{{% /notice %}}
{{% notice note %}}
Dacă serviciul systemd nu pornește, problema poate fi legată de SELinux; vezi secțiunea relevantă din FAQ.
{{% /notice %}}
{{% notice note %}}
Dacă clientul nu poate conecta la server sau nu poți accesa consola web, verifică setările de firewall: https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/faq/#firewall
{{% /notice %}}
## Upgrade
Copiază și lipește comanda de mai jos în terminal pentru a actualiza instalarea RustDesk Server Pro; comanda poate fi păstrată local și programată cu cron.
`wget -qO- https://raw.githubusercontent.com/rustdesk/rustdesk-server-pro/main/update.sh | bash`
{{% notice note %}}
Dacă întâmpini probleme cu acest script, inspectează-l și execută pașii manual, unul câte unul.
Rulează scriptul din directorul tău home, nu dintr-un director fără permisiuni de scriere.
{{% /notice %}}
Ce face update.sh:
- Verifică dacă există versiuni noi ale RustDesk Server Pro
- Dacă găsește o versiune nouă, elimină fișierele API vechi și descarcă noile executabile și fișiere API
## Conversie din open source
Pentru a converti o instalare Open Source la Pro, rulează comanda de mai jos în terminal:
`wget -qO- https://raw.githubusercontent.com/rustdesk/rustdesk-server-pro/main/convertfromos.sh | bash`
{{% notice note %}}
Adaugă regula firewall pentru portul TCP `21114` — acesta este portul suplimentar folosit de consola web și pentru autentificarea utilizatorilor în clientul RustDesk.
{{% /notice %}}
{{% notice note %}}
Dacă întâmpini probleme cu acest script, recomand trecerea la instalarea Docker sau rularea pașilor din script manual, unul câte unul.
{{% /notice %}}
Ce face `convertfromos.sh`:
- Dezactivează și elimină serviciile vechi
- Instalează dependențe necesare
- Configurează UFW dacă este disponibil
- Creează folderul `/var/lib/rustdesk-server` și copiază certificatele acolo
- Șterge `/var/log/rustdesk` și creează `/var/log/rustdesk-server`
- Descarcă și extrage serviciile RustDesk Pro în directorul respectiv
- Creează servicii systemd pentru `hbbs` și `hbbr` (numele serviciilor: `rustdesk-hbbs.service` și `rustdesk-hbbr.service`)
- Dacă alegi Domain, instalează Nginx și Certbot pentru a expune API-ul pe portul `443` (HTTPS) și a obține automat certificat SSL pe portul `80`.

30
content/self-host/rustdesk-server-pro/installscript/_index.ro.md Normal file
View File

@ -0,0 +1,30 @@
---
title: Instalare
weight: 2
---
## Metoda 1: Docker (Recomandat)
```
bash <(wget -qO- https://get.docker.com)
wget rustdesk.com/pro.yml -O compose.yml
sudo docker compose up -d
```
Pentru mai multe detalii, verifică [Docker](/docs/en/self-host/rustdesk-server-pro/installscript/docker/).
## Metoda 2: install.sh
Dacă ești confortabil cu Linux, poți folosi scriptul de mai jos. În caz contrar, dacă scriptul eșuează este posibil să întâmpini probleme dificile de diagnosticat.
`bash <(wget -qO- https://raw.githubusercontent.com/rustdesk/rustdesk-server-pro/main/install.sh)`
Pentru mai multe detalii, verifică [install.sh](/docs/en/self-host/rustdesk-server-pro/installscript/script/).
## Conversie din versiunea open source
### Docker
Dacă ai instalat versiunea open-source folosind Docker, nu există o metodă directă de conversie in-place. Va trebui să rulezi un container nou cu imaginea Pro. Înainte de asta, fă backup la cheia ta privată (fișierul `id_ed25519`, nu `id_ed25519.pub`). După configurarea noului container, copiază fișierul privat `id_ed25519` în directorul de lucru al noului container și repornește containerul.
### install.sh
Dacă ai instalat versiunea open-source folosind `install.sh`, urmează pașii de pe această pagină: /docs/en/self-host/rustdesk-server-pro/installscript/script/#convert-from-open-source

61
content/self-host/rustdesk-server-pro/installscript/windows/_index.ro.md Normal file
View File

@ -0,0 +1,61 @@
---
title: Instalare Windows (învechit)
weight: 5
---
{{% notice note %}}
Politicile de securitate Windows pot fi complicate; dacă acest tutorial nu funcționează pentru tine sau întâmpini conexiuni instabile, mută serverul pe o mașină Linux.
{{% /notice %}}
{{% notice note %}}
Versiunea GUI, `RustDeskServer.setup.exe`, nu mai este întreținută și nu este recomandată.
{{% /notice %}}
## Instalare
Redistribuibilul Microsoft Visual C++ este necesar pentru a rula RustDesk pe Windows. Îl poți descărca de aici: https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist
1. Obține o licență de la https://rustdesk.com/pricing.html — vezi pagina de [license](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/license/) pentru detalii.
2. Descarcă installer-ul pentru Windows de pe [GitHub](https://github.com/rustdesk/rustdesk-server-pro/releases/latest).
3. Dezarhivează pachetul pentru Windows.
4. Rulează installer-ul și urmează pașii afișați pe ecran. Alternativ, poți instala manual folosind [PM2 sau NSSM](https://rustdesk.com/docs/en/self-host/rustdesk-server-oss/windows/).
5. După finalizare, deschide RustDesk Server.
6. Urmează instrucțiunile din interfață pentru configurare.
7. Click pe `Services` și apoi `Start`.
8. După instalare poți accesa `http://adresa-ta-ip:21114`.
9. Autentifică-te cu `admin` / `test1234`.
10. Introdu codul de licență achiziționat la pasul 1.
## Folosirea IIS ca proxy
Asigură-te că `Dynamic Content Compression` este instalat (este o caracteristică IIS care se instalează din Server Roles).
1. Deschide IIS (sau instalează-l).
2. Creează un site nou pentru RustDesk cu binding-urile necesare (ideal port 443) și certificatul corespunzător. Setările de bază pot indica către un director gol. (Dacă folosești site-ul implicit, asigură-te că nu sunt alte fișiere în folder).
3. În IIS instalează [Application Request Routing](https://www.iis.net/downloads/microsoft/application-request-routing) și [URL Rewrite](https://learn.microsoft.com/en-us/iis/extensions/url-rewrite-module/using-the-url-rewrite-module).
## Application Request Routing
1. În consola IIS, deschide Application Request Routing la nivel de server.
2. Mergi la Server Proxy Settings.
3. Activează proxy-ul; poți lăsa celelalte setări la valorile implicite.
4. Salvează setările și treci la pasul URL Rewrite.
## URL Rewrite
1. Selectează site-ul din panoul din stânga și dublu-click pe `URL Rewrite`.
2. Click pe `Add rules`.
3. Creează o regulă nouă de reverse proxy.
4. Configurează adresa locală (portul intern 21114):
- Inbound Rule – adresa internă RustDesk (21114)
- Outbound Rules – `From` este adresa internă 21114 și `To` este adresa externă.
Notă: Nu adăuga `http://` sau `https://` înaintea adreselor — sunt gestionate automat. Asigură-te că adresele sunt accesibile atât intern, cât și extern.
## Compresie
1. Dezactivează `Dynamic Content Compression`.
## Depanare
Dacă primești eroarea 500.52 adaugă variabilele menționate în articolul: [IIS acting as reverse proxy: Where the problems start](https://techcommunity.microsoft.com/t5/iis-support-blog/iis-acting-as-reverse-proxy-where-the-problems-start/ba-p/846259).
Este posibil să fie necesar să schimbi setările SSL la `Require SSL → Ignore`.

37
content/self-host/rustdesk-server-pro/ldap/_index.ro.md Normal file
View File

@ -0,0 +1,37 @@
---
title: LDAP
weight: 17
---
## Configurare
Accesează pagina de setări `LDAP` așa cum se vede mai jos.
![](/docs/en/self-host/rustdesk-server-pro/ldap/images/ldap.png)
- **LDAP Host:** Numele de gazdă sau adresa IP a serverului LDAP. Exemplu: `ldap.example.com` sau `192.0.2.1`.
- **LDAP Port:** Portul pe care ascultă serverul LDAP. Portul implicit pentru LDAP este `389`, iar pentru LDAPS (LDAP peste SSL) este `636`.
- **Base DN:** Punctul de plecare pentru căutarea în LDAP. Exemplu: `dc=example,dc=com`.
- **Scope:** Determină aria de căutare în directorul LDAP. Poate fi `one` (intrările imediat sub Base DN) sau `sub` (inclusiv sub-arbori sub Base DN).
- **Bind DN / Password:** Numele de utilizator (DN) și parola contului de serviciu. Acest cont este folosit pentru a face bind la LDAP și a autentifica alți utilizatori. De obicei este un DN de tip `cn=admin,dc=example,dc=com`.
- **Filter:** Filtrul de căutare pentru interogarea LDAP. Exemplu: `(objectClass=person)` sau `(&(age=28)(!(name=Bob)))`.
- **Username Attribute:** Atributul care conține numele de utilizator. Exemplu: `uid` sau `sAMAccountName`. Implicit folosește `uid` și `cn`. Discuție aici: https://github.com/rustdesk/rustdesk-server-pro/issues/140#issuecomment-1916804393.
- **StartTLS:** Determină dacă se folosește StartTLS pentru a upgrada conexiunea la una securizată.
- **NoTLSVerify:** Determină dacă se sare verificarea certificatului TLS. Recomandat: păstrează setarea pe `false` (să verifice certificatul) decât dacă știi exact ce faci.
## Cum funcționează?
- Cum funcționează autentificările LDAP: trebuie creat un utilizator local înainte, RustDesk creează un utilizator la prima autentificare, etc.?
> RustDesk creează un utilizator la prima autentificare.
- Cum verific dacă LDAP funcționează (ideal o comandă pe care RustDesk o poate rula pentru a returna utilizatorii descoperiți)?
> Când trimiți configurația, sistemul se conectează la serverul LDAP folosind `binddn`/parola furnizate și verifică funcționalitatea.
- Cum pot converti utilizatorii locali în utilizatori LDAP?
> Nu este disponibil momentan.
- Suportă grupuri LDAP?
> Nu este disponibil momentan.

48
content/self-host/rustdesk-server-pro/license/_index.ro.md Normal file
View File

@ -0,0 +1,48 @@
---
title: Licență
weight: 15
---
## Cumpărați o licență
Vă rugăm să achiziționați licența de la [https://rustdesk.com/pricing.html](https://rustdesk.com/pricing.html) și să introduceți o adresă de e‑mail validă în pagina de checkout Stripe. Licența (și factura într‑un e‑mail separat) vă vor fi trimise pe e‑mail după finalizarea cu succes a plății.
![](/docs/ro/self-host/rustdesk-server-pro/license/images/stripe.jpg)
## Setați licența
Vi se va solicita să introduceți licența în consola web (`http://<rustdesk-server-pro-ip>:21114`) sau o puteți modifica ulterior.
| Setați licența | Schimbați licența |
| --- | --- |
| ![](/docs/ro/self-host/rustdesk-server-pro/license/images/set.png) | ![](/docs/ro/self-host/rustdesk-server-pro/license/images/change.png) |
## Reînnoirea/actualizarea licenței
Opțiunile pentru reînnoire sau upgrade ale licenței se găsesc în portalul self‑service de licențe: [https://rustdesk.com/self-host/account/](https://rustdesk.com/self-host/account/). Autentificați‑vă cu e‑mailul folosit la achiziție, așa cum se arată în imaginea de mai sus.
| Pagina licenței cu acțiuni de reînnoire/upgrade | Fereastra de upgrade |
| --- | --- |
| ![](/docs/ro/self-host/rustdesk-server-pro/license/images/renew.jpg?v2) | ![](/docs/ro/self-host/rustdesk-server-pro/license/images/upgrade.png) |
După efectuarea plății, reîmprospătați licența [așa cum e descris mai jos](/docs/ro/self-host/rustdesk-server-pro/license/#refresh-license) pentru a o activa.
### Reîmprospătarea licenței
După plată, trebuie să accesați consola web pentru a o activa manual, așa cum e prezentat mai jos. Faceți click pe `Edit`, apoi pe `OK` — nu e nevoie să modificați nimic, cheia de licență rămâne aceeași.
![](/docs/ro/self-host/rustdesk-server-pro/license/images/updatelic.jpg)
## Facturi, recuperare licență și migrare
Licența poate fi utilizată pe o singură mașină (doar pentru `hbbs`; `hbbr` nu necesită licență). Dacă doriți să migrați licența pe altă mașină, să recuperați licența sau să descărcați facturi, accesați [https://rustdesk.com/self-host/account/](https://rustdesk.com/self-host/account/). Autentificați‑vă cu adresa de e‑mail folosită la checkout‑ul Stripe, dezlegați (unbind) mașina veche din care doriți să migrați, așa cum se arată mai jos — când setați licența în consola web a noului server, aceasta va fi atribuită și înregistrată automat în consolă.
![](/docs/ro/self-host/rustdesk-server-pro/license/images/unbind.jpg)
## Proxy
Dacă serverul dvs. nu poate accesa internetul pentru a verifica licența direct, puteți adăuga un proxy, de ex.: `proxy=http://username:password@example.com:8080 ./hbbs`.
> Alternativ, puteți adăuga `proxy=http://username:password@example.com:8080` în fișierul `.env` din directorul de lucru (unde se află fișierele `id_ed25519` / `db.sqlite3`).
`http` poate fi înlocuit cu `https` sau `socks5`. Dacă nu există `username` / `password` / `port`, se poate folosi `proxy=http://example.com`.

10
content/self-host/rustdesk-server-pro/oidc/_index.ro.md Normal file
View File

@ -0,0 +1,10 @@
---
title: OIDC
weight: 16
---
- Folosiți conturile existente `Google`, `Okta`, `Facebook`, `Azure`, `GitHub`, `GitLab` etc. pentru a crea și a vă autentifica cu ușurință în contul `RustDesk Pro`.
- Pentru specificații vedeți [OpenID Connect Core 1.0 incorporating errata set 1](https://openid.net/specs/openid-connect-core-1_0.html).
# Exemple
{{% children depth="4" showhidden="true" %}}

42
content/self-host/rustdesk-server-pro/oidc/azure/_index.ro.md Normal file
View File

@ -0,0 +1,42 @@
---
title: Azure
weight: 16
---
## Tutorial video
[https://www.youtube.com/watch?v=izGxSmifURI](https://www.youtube.com/watch?v=izGxSmifURI)
## Configurare
1. Autentificați‑vă în [portalul Azure](https://portal.azure.com).
2. Căutați și selectați **Microsoft Entra ID**.
3. În meniul din stânga, selectați [**App registrations**](https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/~/RegisteredApps), apoi faceți clic pe **New registration**.
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/1-Azure-NewRegistration.png)
4. Deschideți consola RustDesk Pro, în pagina **Settings** faceți clic pe modulul **OIDC**. Apoi copiați **Callback URL**. Notă: **Callback URL** nu este editabil — partea `Path` este fixă la `api/oidc/callback`, iar partea `Protocol://Host:Port` este originea paginii web curente. De exemplu, dacă consola este accesată prin `http://localhost:8000/<path>`, atunci **Callback URL** va fi `http://localhost:8000/api/oidc/callback`. Dacă este accesată prin `https://192.168.0.1:8000/<path>`, atunci **Callback URL** va fi `https://192.168.0.1:8000/api/oidc/callback`. Deoarece Azure acceptă doar `https://` sau `http://localhost`, selectați adresa corespunzătoare pentru a deschide consola RustDesk Pro.
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/12-RustDesk-Callback.png)
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/2-Azure-Register-RecirectURIs-Restrictions.png)
5. Introduceți **Name**, selectați **Supported account types** și lipiți **Redirect URI** copiat din RustDesk Pro.
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/2-Azure-Register.png)
6. În RustDesk Pro, faceți clic pe **New auth provider**.
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/3-RustDesk-NewAuthProvider.png)
7. În Azure, selectați aplicația pe care doriți să o utilizați, accesați **Overview** și copiați **Application (client) ID**.
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/4-Azure-ClientID.png)
8. În RustDesk Pro, lipiți **Client ID**.
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/5-RustDesk-ClientID.png)
9. În Azure, accesați **Certificates & secrets** și creați un client secret nou sau selectați unul existent (de obicei New).
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/6-Azure-NewOrSelectClientSecret.png)
10. În Azure, copiați valoarea client secret‑ului. Notă: această valoare este vizibilă doar la crearea inițială. Nu va mai fi afișată după părăsirea paginii. Păstrați‑o în siguranță.
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/7-Azure-CopySecretValue.png)
11. În RustDesk Pro, lipiți valoarea client secret‑ului.
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/8-RustDesk-FillClientSecret.png)
12. În RustDesk Pro, completați câmpul **Issuer** cu `https://login.microsoftonline.com/<Directory (tenant) ID>/v2.0`. Înlocuiți `Directory (tenant) ID` cu **Directory (tenant) ID** al contului dvs. Acesta se găsește în panoul **Overview** al aplicației din Azure.
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/9-RustDesk-Issuer.png)
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/10-Azure-TenantID.png)
13. În Azure, accesați meniul **Authentication**. Apoi activați autorizarea, bifând **ID tokens (used for implicit and hybrid flows)**.
![](/docs/ro/self-host/rustdesk-server-pro/oidc/azure/images/11-Azure-Auth.png)
## Referințe
- [Set up an OpenID Connect provider with Azure AD](https://learn.microsoft.com/en-us/power-pages/security/authentication/openid-settings)
- [OpenID Connect on the Microsoft identity platform](https://learn.microsoft.com/en-us/azure/active-directory/develop/v2-protocols-oidc)

51
content/self-host/rustdesk-server-pro/permissions/_index.ro.md Normal file
View File

@ -0,0 +1,51 @@
---
title: Controlul accesului
weight: 16
---
## Permisiuni de acces ale dispozitivului
Un dispozitiv poate fi atribuit fie unui singur utilizator, fie unui singur grup de dispozitive, fie ambelor.
Când dispozitivul este atribuit unui utilizator, acesta poate fi accesat de acel utilizator, de un grup de utilizatori sau prin setările corespunzătoare între grupuri de utilizatori.
Când dispozitivul este atribuit unui grup de dispozitive, acesta poate fi accesat prin setările corespunzătoare între grupuri de utilizatori și grupuri de dispozitive.
Există trei modalități de a atribui un dispozitiv unui utilizator:
- Din pagina dispozitivului din consolă
- Autentificându‑vă în contul de utilizator specificat pe partea client
- Prin linia de comandă (assign)
Există două modalități de a atribui un dispozitiv unui grup de dispozitive:
- Din pagina dispozitivului din consolă
- Prin linia de comandă (assign)
Următoarele două situații vor împiedica accesul la dispozitiv:
- Setați dispozitivul la `disable` în pagina dispozitive din consolă
- Setați utilizatorul la `disable` în pagina utilizatori din consolă
## Setări de acces pentru grupuri de utilizatori
Accesați pagina grupului în consola web și faceți clic pe `Edit` pentru a modifica setările între grupuri, după cum urmează.
Modificările făcute la `Access with other groups` intră în vigoare imediat, fără a fi necesară apăsarea butonului `OK`.
Atât `Can access to`, cât și `Can be accessed from` au aproape aceeași funcție; oferim ambele opțiuni pentru comoditatea dvs. Totuși, acest lucru poate provoca confuzie.
{{% notice note %}}
Utilizatorul și grupul atribuite părții care controlează sunt determinate de utilizatorul care se autentifică, nu de utilizatorul atribuit din consola web. Am proiectat sistemul astfel deoarece anumite părți controlatoare nu au ID de dispozitiv, cum ar fi clientul iOS și clientul web.
{{% /notice %}}
![](/docs/ro/self-host/rustdesk-server-pro/permissions/images/crossgrp.png)
## Setări de acces pentru grupuri de dispozitive
Grupurile de dispozitive oferă un alt mod de a gestiona permisiunile de acces. Iată regulile principale:
1. Un dispozitiv poate fi adăugat doar într‑un singur grup de dispozitive
2. Puteți seta permisiuni de acces pentru utilizatori sau grupuri de utilizatori către grupuri de dispozitive. Aceste permisiuni se cumulează cu permisiunile de acces ale grupurilor de utilizatori — accesul este acordat dacă fie permisiunile grupului de utilizatori, fie permisiunile grupului de dispozitive permit accesul
3. Când un dispozitiv neatribuit este adăugat într‑un grup de dispozitive, acesta nu mai este considerat „neatribuit”
{{% notice note %}}
Funcționalitatea grupurilor de dispozitive necesită RustDesk client >= 1.3.8 și RustDesk Server Pro >= 1.5.0
{{% /notice %}}

152
content/self-host/rustdesk-server-pro/relay/_index.ro.md Normal file
View File

@ -0,0 +1,152 @@
---
title: Configurare servere Relay
weight: 17
---
## RustDesk Pro - Instalare servere relay adiționale cu Geo Location folosind Docker
{{% notice note %}}
[Instalarea simplă](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/installscript/) creează implicit un server relay (procesul `hbbr`) pe aceeași mașină; nu trebuie să specificați explicit un server relay.
Dacă doriți să creați explicit un server relay adițional pe o altă mașină, rulați `hbbr` urmând [instalarea OSS](https://rustdesk.com/docs/en/self-host/rustdesk-server-oss/install/). Veți găsi `hbbr` în `rustdesk-server-linux-amd64.tar.gz`, `rustdesk-server-hbbr_<version>-<arch>.deb`, `rustdesk-server-windows-x86_64.tar.gz` sau în `docker` (`sudo docker run ... rustdesk/rustdesk-server-pro hbbr`).
`hbbr` nu necesită licență și este identic cu versiunea open source.
{{% /notice %}}
Puteți rula mai multe servere relay distribuite geografic și folosi GeoLocation pentru a selecta automat serverul relay cel mai apropiat, oferind o experiență mai rapidă la conectarea la computere remote. `hbbs` verifică automat dacă aceste servere relay sunt online la fiecare câteva secunde și folosește doar cele online.
{{% notice note %}}
Problemă cunoscută: https://github.com/rustdesk/rustdesk/discussions/7934
{{% /notice %}}
> Veți avea nevoie de perechea de chei private `id_ed25519` și `id_ed25519.pub`.
1 - Dacă Docker este deja instalat, conectați‑vă la server prin SSH și creați un volume pentru `hbbr`.
```
# docker volume create hbbr
```
Volume‑ul `hbbr` va fi localizat în `/var/lib/docker/volumes/hbbr/_data`.
2 - Copiați perechea de chei private în locația volume‑ului; în acest exemplu folosim SCP pentru a copia fișierele.
Sintaxa comenzii este `scp <path/filename> username@server:</destination/path>`.
```
# scp id_ed25519 root@100.100.100.100:/var/lib/docker/volumes/hbbr/_data
# scp id_ed25519.pub root@100.100.100.100:/var/lib/docker/volumes/hbbr/_data
```
3 - Desfășurați containerul `hbbr` folosind volumul creat anterior. Acest volume conține perechea de chei private necesară pentru a rula serverul relay privat.
```
# sudo docker run --name hbbr -v hbbr:/root -td --net=host rustdesk/rustdesk-server hbbr -k _
```
4 - Verificați jurnalele pentru a confirma că `hbbr` rulează folosind perechea de chei.
```
# docker logs hbbr
INFO [src/common.rs:121] **Private key comes from id_ed25519**
NFO [src/relay_server.rs:581] Key: XXXXXXXXXXXXXXXXXXXXX
INFO [src/relay_server.rs:60] #blacklist(blacklist.txt): 0
INFO [src/relay_server.rs:75] #blocklist(blocklist.txt): 0
INFO [src/relay_server.rs:81] Listening on tcp :21117
```
În funcție de sistemul de operare, s‑ar putea să doriți să blocați/permiteți IP‑uri folosind un firewall.
În exemplul nostru (Ubuntu) dorim să permitem conexiuni TCP către porturile 21117 și 21119.
```
# sudo ufw allow proto tcp from any to any port 21117,21119
```
**Activați firewall‑ul**
```
# sudo ufw enable
```
**Verificați starea**
```
# ufw status
Status: active
To Action From
-- ------ ----
21117,21119/tcp ALLOW Anywhere
21117,21119/tcp (v6) ALLOW Anywhere (v6)
```
## Configurare RustDesk Pro pentru Geo Location folosind consola web
### Înregistrare și descărcare a bazei de date GeoLite2 City
Pentru a folosi geo location, `hbbs` are nevoie de fișierul bazei de date MaxMind GeoLite2 City. Baza de date este gratuită: înregistrați‑vă pentru a descărca fișierul și a obține o cheie API.
Începeți prin a crea un cont (dacă nu aveți) la [site‑ul MaxMind](https://www.maxmind.com/en/account/login).
Accesați `Download Databases` și descărcați GeoLite2 City; alegeți fișierul gzip și veți obține fișierul `mmdb` după decomprimare.
![](https://github.com/rustdesk/doc.rustdesk.com/assets/642149/e14318fb-ec52-463c-af77-d08c9479c1b5)
Dacă ați instalat RustDesk Pro folosind scriptul de instalare pe o mașină Linux, fișierul `mmdb` trebuie mutat în `/var/lib/rustdesk-server/`.
Pentru instalările Docker, fișierul ar trebui să se afle în volumul mapat la `/root`.
### Obțineți o cheie API pentru automatizare - servere Linux
Trebuie să actualizați acest fișier în mod regulat, și putem folosi un cronjob pentru asta. Veți avea nevoie de o cheie API pentru a accesa link‑ul de descărcare, care este gratuit.
Accesați `Manage License Keys` și generați o cheie nouă.
<br>
![](https://github.com/rustdesk/doc.rustdesk.com/assets/642149/632aeb33-4f5d-4a31-9010-38e01c22d3c9)
<br>
![](https://github.com/rustdesk/doc.rustdesk.com/assets/642149/3e178174-5fbf-46b7-a335-01f77125dfad)
Puteți automatiza [procesul de descărcare](https://dev.maxmind.com/geoip/updating-databases) în mai multe feluri; adăugați următoarea comandă în crontab, înlocuind {Your Access Key} cu cheia API obținută anterior.
```
/usr/bin/curl -L --silent 'https://download.maxmind.com/app/geoip_download?edition_id=GeoLite2-City&license_key={Your Access Key}&suffix=tar.gz' | /bin/tar -C '/var/lib/rustdesk-server/' -xvz --keep-newer-files --strip-components=1 --wildcards '*GeoLite2-City.mmdb'
```
### Modificați setările în consola web RustDesk Pro
Adăugați adresele IP sau numele DNS ale serverelor relay (DNS este suportat începând cu versiunea 1.1.11) la `Relay Servers`. **Portul nu este necesar, portul `21117` este folosit implicit.**
<br>
![](https://github.com/rustdesk/doc.rustdesk.com/assets/642149/c4452ba4-5e1d-437a-ae1d-fc0070bfa26c)
Adăugați un Geo Override introducând adresa IP a serverului și coordonatele unde este localizat serverul.
<br>
![](https://github.com/rustdesk/doc.rustdesk.com/assets/642149/41c558e3-423b-4296-90d3-cb0769f4a369)
Faceți clic pe `Reload Geo` și lista dvs. ar trebui să arate similar.
<br>
![](https://github.com/rustdesk/doc.rustdesk.com/assets/642149/5a0d39a9-4fec-46b4-a7a2-7ed38b6baeb7)
Pentru a confirma rezultatele, verificați jurnalele `hbbs` când faceți clic pe `Reload Geo`; ar trebui să vedeți un mesaj care afișează adresele IP ale serverelor relay și coordonatele acestora.
> Dacă rulați RustDesk Pro pe o mașină Linux folosiți comanda `RUST_LOG=debug ./hbbs` pentru a vedea jurnalele. Dacă rulați într‑un container Docker folosiți `docker logs hbbs`.
```
RUST_LOG=debug ./hbbs
INFO [src/common.rs:130] GEOIP_FILE: ./GeoLite2-City.mmdb
INFO [src/common.rs:159] override 1xx.xxx.xxx.x7: -1.xx 5x.xxx
[src/common.rs:159] override 1xx.xxx.xxx.xx8: -3.xxx 5x.xxxx
[src/common.rs:159] override 7xx.xxx.xxxx.xx1: 6.xxx 5x.xxxx
GEOIP_FILE loaded, #overrides 3
INFO [src/common.rs:119] relay-servers=["1xx.xxx.xxx.x7", "1xx.xxx.xxx.xx8", "7xx.xxx.xxx.xx1"]
NFO [src/rendezvous_server.rs:1467] parsed relay servers: [("1xx.xxxx.xxx.xx7", Some((-1x, xxx))), ("1xx.xxx.xxx.xx8", Some((-3x, xxx))), ("7xx.xxx.xxx.xx1", Some((6x, xxx)))]
```
De asemenea, puteți confirma cererile relay direct pe instanțele `hbbr`, verificând pur și simplu jurnalele containerelor.
```
# docker logs hbbr
INFO [src/relay_server.rs:436] Relayrequest 0593e64e-4fe8-4a59-a94f-b3420ab043eb from [::ffff:100.100.123.233]:52038 got paired
INFO [src/relay_server.rs:442] Both are raw
```

8
content/self-host/rustdesk-server-pro/smtp/_index.ro.md Normal file
View File

@ -0,0 +1,8 @@
---
title: SMTP
weight: 16
---
Configurarea SMTP permite serverului dvs. să trimită notificări prin e‑mail, cum ar fi invitații pentru utilizatori, verificări la autentificare și alerte de conexiune.
[Tutorial video](https://youtu.be/0LyQY1JS4Uc)

67
content/self-host/rustdesk-server-pro/strategy/_index.ro.md Normal file
View File

@ -0,0 +1,67 @@
---
title: Strategie
weight: 200
---
Strategia este un instrument pentru administratorii RustDesk care le permite să actualizeze în masă opțiunile de securitate din paginile de setări ale clientului. Administratorii pot crea strategii diferite și le pot aplica dispozitivelor dorite.
## Crearea strategiilor
Puteți crea o nouă strategie făcând clic pe butonul `+` și efectua diverse acțiuni pe strategie plasând cursorul peste ea și făcând clic pe meniul contextual.
În meniul pop‑up puteți alege să `Enable` sau `Disable` strategia, să o `Rename`, `Duplicate` sau `Delete`. În plus, puteți face clic pe `Edit Devices` pentru a modifica dispozitivele cărora li se aplică strategia sau pe `Edit Users` pentru a modifica utilizatorii cărora li se aplică strategia.
În partea dreaptă a meniului strategiei puteți vedea numărul de dispozitive aplicate efectiv strategiei, ținând cont de prioritatea strategiilor.
![](/docs/ro/self-host/rustdesk-server-pro/strategy/images/strategy_menu.png)
## Strategia pentru dispozitiv, strategia pentru utilizator și strategia pentru grup de dispozitive
Strategiile se aplică în ordinea de prioritate următoare:
1. Strategia pentru dispozitiv (cea mai mare prioritate)
2. Strategia pentru utilizator
3. Strategia pentru grup de dispozitive (cea mai mică prioritate)
Fiecare dispozitiv poate fi gestionat de o singură strategie la un moment dat. Sistemul de priorități funcționează astfel:
- Strategiile pentru dispozitiv au prioritate față de strategiile pentru utilizator și cele pentru grupuri de dispozitive
- Strategiile pentru utilizator au prioritate față de strategiile pentru grupuri de dispozitive
- Strategiile pentru grupuri de dispozitive se aplică tuturor dispozitivelor din grupul respectiv care nu au atribuită o strategie pentru dispozitiv sau pentru utilizator
## Editați dispozitivele
Când faceți clic pe meniul `Edit Devices`, se deschide o fereastră de editare care afișează toate dispozitivele. Puteți modifica starea de selecție a casetelor de bifare și apoi faceți clic pe butonul `Save` pentru a aplica modificările dispozitivelor făcute pe pagina curentă. Dacă trebuie să modificați dispozitive aflate pe alte pagini, navigați către acele pagini. Puteți de asemenea folosi meniul drop‑down din colțul din dreapta sus pentru a filtra dispozitivele.
Formatul coloanei Strategy: device strategy/user strategy/device group strategy, sau "-" pentru strategia implicită.
Iată un exemplu al ferestrei care apare când faceți clic pe `Edit Devices` din meniul "demo1". În acest exemplu, dispozitivul "1981241962" este aplicat strategiei "demo3"; dispozitivul "1279471875" este aplicat strategiei "demo2"; dispozitivul "a123456" este aplicat strategiei "demo1"; dispozitivul "1227624460" este aplicat strategiei implicite.
![](/docs/ro/self-host/rustdesk-server-pro/strategy/images/edit_devices.png)
## Editați utilizatorii
Când faceți clic pe meniul `Edit Users`, se deschide o fereastră de editare care afișează toți utilizatorii. Puteți modifica starea de selecție a casetelor de bifare și apoi faceți clic pe butonul `Save` pentru a aplica modificările utilizatorilor făcute pe pagina curentă. Dacă trebuie să modificați utilizatori aflați pe alte pagini, navigați către acele pagini. Puteți de asemenea folosi meniul drop‑down din colțul din dreapta sus pentru a filtra utilizatorii.
Iată un exemplu al ferestrei care apare când faceți clic pe `Edit Users` din meniul "demo2". În acest exemplu, utilizatorul "admin" este aplicat strategiei "default"; utilizatorul "user1" este aplicat strategiei "demo2"; utilizatorul "user2" este aplicat strategiei "demo3".
![](/docs/ro/self-host/rustdesk-server-pro/strategy/images/edit_users.png)
## Editați grupurile de dispozitive
Când faceți clic pe meniul `Edit Device Group`, se deschide o fereastră de editare care afișează toate grupurile de dispozitive. Puteți modifica starea de selecție a casetelor de bifare și apoi faceți clic pe butonul `Save` pentru a aplica modificările grupurilor de dispozitive făcute pe pagina curentă. Dacă trebuie să modificați grupuri de dispozitive aflate pe alte pagini, navigați către acele pagini. Puteți de asemenea folosi meniul drop‑down din colțul din dreapta sus pentru a filtra grupurile de dispozitive.
Iată un exemplu al ferestrei care apare când faceți clic pe `Edit Device Group` din meniul "demo1". În acest exemplu, grupul de dispozitive "device_group1" este aplicat strategiei "demo1"; grupul "group2" este aplicat strategiei "demo2"; grupul "group3" este aplicat strategiei "default".
![](/docs/ro/self-host/rustdesk-server-pro/strategy/images/edit_device_groups.png)
## Sincronizarea strategiilor
Fiecare dispozitiv poate fi gestionat de o singură strategie, iar dacă acea strategie este dezactivată, dispozitivul nu va mai fi gestionat de nicio strategie. La sincronizarea strategiilor, RustDesk înregistrează timpii (timestamp) locali și ai serverului pentru a determina dacă sincronizarea este necesară. Astfel, după ce sincronizarea strategiilor este finalizată:
* Dacă utilizatorul modifică unele opțiuni, clientul va folosi opțiunile stabilite de utilizator.
* Dacă administratorul modifică conținutul strategiei, opțiunile clientului vor fi sincronizate.
* Dacă administratorul modifică strategia căreia îi aparține dispozitivul, opțiunile clientului vor fi sincronizate.
## Editați strategiile
În partea de jos a unei strategii, faceți clic pe `Edit`, efectuați modificările și apoi faceți clic pe `Submit`. Strategia va fi sincronizată către dispozitive în aproximativ 30 de secunde.

14
content/videos/_index.ro.md Normal file
View File

@ -0,0 +1,14 @@
---
title: Tutoriale video
weight: 50
---
## OSS
[NetworkChuck: Your Remote Desktop SUCKS!! Try this instead (FREE + Open Source)](https://www.youtube.com/watch?v=EXL8mMUXs88)
[Instalare și ghid de utilizare](https://www.youtube.com/watch?v=9nzHm3xGz2I)
[Securitatea RustDesk](https://www.youtube.com/watch?v=EeFqj23jxMk)
## Pro
[Canalul YouTube](https://youtube.com/@rustdesk)

10
hugo.yaml
View File

@ -233,3 +233,13 @@ languages:
landingPageName: "🏠 首頁"
description: "RustDesk完整文檔 - 開源遠端桌面軟體。學習如何自主託管、配置客戶端並在您的基礎架構中部署RustDesk。"
keywords: ["rustdesk", "遠端桌面", "開源", "自主託管", "文檔", "遠端存取", "VNC替代", "teamviewer替代"]
ro:
title: "Documentația RustDesk"
weight: 1
languageName: "Română"
params:
landingPageName: "🏠 Acasă"
disable_cookie: true
description: "Documentație completă pentru RustDesk - software-ul open source pentru desktop remote. Aflați cum să găzduiți singur, să configurați clienți și să implementați RustDesk în infrastructura dvs."
keywords: ["rustdesk", "desktop remote", "open source", "self-host", "documentație", "acces remote", "alternativă VNC", "alternativă TeamViewer"]