rustdesk/doc.rustdesk.com
1
0
Fork 0
mirror of https://github.com/rustdesk/doc.rustdesk.com.git synced 2025-08-17 16:35:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #551 from bonk-dev/master

Browse Source 
docs(pl): add a Polish translation
This commit is contained in:
RustDesk 2025-08-06 19:44:49 +08:00 committed by GitHub
commit 82ef035eb5
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
44 changed files with 4967 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
content/_index.pl.md Normal file
View File

@ -0,0 +1,23 @@
---
title: "Dokumentacja RustDesk"
type: docs
weight: 1
---
RustDesk to pełnoprawna alternatywa open source do zdalnego zarządzania urządzeniami, przeznaczona do samodzielnego hostowania z rozbudowanymi funkcjami bezpieczeństwa oraz minimalną konfiguracją. Masz pełną kontrolę nad swoimi danymi, bez obaw o bezpieczeństwo. Klient jest open source, a do wyboru masz w pełni funkcjonalny **Serwer Profesjonalny** dostępny do zakupu na naszej [stronie](https://rustdesk.com) oraz podstawowy, darmowy i open source'owy serwer bazując na naszym **Serwerze Profesjonalnym**.
## Funkcje
- Działa na Windowsie, macOSie, Linuxie, iOSie, Androidzie i w przeglądarkach.
- Obsługuje kodeki software'owe VP8 / VP9 / AV1 oraz sprzętowe H264 / H265.
- Bądź właścicielem swoich danych – łatwo skonfiguruj samodzielne hostowane rozwiązanie na swojej infrastrukturze.
- Połączenie P2P z szyfrowaniem end-to-end opartym na NaCl.
- Nie wymaga uprawnień administratora ani instalacji na Windowsie, podnoś uprawnienia lokalnie lub zdalnie na żądanie.
- Stawiamy na prostotę i dążymy do jej maksymalizacji tam, gdzie to możliwe.
## Repozytoria na GitHubie
- **Repozytorium Głównego Klienta**: https://github.com/rustdesk/rustdesk
- **Repozytorium Serwera Open Source**: https://github.com/rustdesk/rustdesk-server
- **Repozytorium Serwera Profesjonalnego**: https://github.com/rustdesk/rustdesk-server-pro
- **Repozytorium Dokumentacji**: https://github.com/rustdesk/doc.rustdesk.com
{{% children depth="4" showhidden="true" %}}

144
content/client/_index.pl.md Executable file
View File

@ -0,0 +1,144 @@
---
title: Klient RustDesk
weight: 2
pre: "<b>1. </b>"
---
## Wstęp
Klient służy do łączenia przez nasz serwer RustDeska (open source lub wersji Pro), który jest dostępny do pobrania na [GitHubie](https://github.com/rustdesk/rustdesk/releases/latest).
## Wspierane platformy
- Microsoft Windows
- macOS
- Pochodne Debiana (Ubuntu ≥ 16, Linux Mint, itd.)
- Pochodne Red Hata (CentOS, Fedora ≥ 18, Rocky Linux, etc.)
- Arch Linux/Manjaro
- openSUSE
- NixOS
- AppImage / Flatpak
- Android
- iOS (brak wsparcia dla bycia sterowanym)
- przeglądarki
## Instalacja
### Windows
Pobierz exe z GitHuba i zainstaluj.
Aby zainstalować w trybie cichym, wywołaj instalkę z parametrem `--silent-install`.
### macOS
Pobierz plik dmg z GitHuba. Więcej informacji znajdziesz na [stronie dedykowanej macOSowi](https://rustdesk.com/docs/en/client/mac/).
Otwórz plik dmg i przeciągnij `RustDesk` do `Aplikacji`.
Zezwól RustDeskowi na uruchomienie.
Zezwól na żądane uprawnienia i postępuj zgodnie z instrukcjami wyświetlanymi po lewej stronie RustDeska, aby zakończyć instalację.
### Linux
Zobacz poniższe instrukcje aby zainstalować na różnych dystrybucjach Linuxa (instalatory są dostępne na GitHubie oraz w repozytoriach dystrybucji).
#### Pochodne Debiana
```sh
# zignoruj błędny raport zużycia miejsca na dysku
sudo apt install -fy ./rustdesk-<version>.deb
```
#### Pochodne Red Hata
```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)
Tymczasowo wejdź w shella z `rustdesk`iem gotowym do uruchomienia:
```sh
nix shell nixpkgs#rustdesk
```
Zainstaluj w profilu bieżącego użytkownika:
```sh
nix profile install nixpkgs#rustdesk
```
Aby zainstalować systemowo w NixOSie wykonaj, `nixos-rebuild switch --flake /etc/nixos` po edycji `configuration.nix`:
```
environment.systemPackages = with pkgs; [
...
rustdesk
];
```
### Android
Zainstaluj apk z naszego GitHuba. Więcej informacji możesz znaleźć na [stronie dedykowanej Androidowi](https://rustdesk.com/docs/en/client/android/).
### iOS (iPhone, iPad)
Pobierz aplikację z [App Store'u](https://apps.apple.com/us/app/rustdesk-remote-desktop/id1581225015).
## Użycie
Po instalacji (albo uruchomieniu jako tymczasowy plik wykonwyalny) RustDesk połączy się z publicznymi serwerami. Na dole pojawi się komunikat (1) "Gotowy, Do szybszego połączenia, skonfiguruj swój właśny serwer". W lewym gównym rogu zobaczysz swoje (2) ID, (3) jednorazowe hasło, a po prawej (4) pole tekstowe do wpisania ID komputera, z którym chcesz się połączyć.
<!-- TODO: Add Polish version image -->
![](/docs/en/client/images/client.png)
Aby zobaczyć ustawienia, naciśnij na (5) przycisk Menu [ &#8942; ] z prawej strony ID.
W ustawieniach znajdziesz:
- Ogólne - Sterowanie usługą, Motyw, Kodek sprzętowy, Audio, Nagrywanie i Język
- Zabezpieczenia - Uprawnienia dla osoby przejmującej kontrolę, Opcje hasła, możliwość zmiany ID oraz zaawansowane ustawienia zabezpieczeń
- Sieć - Tutaj możesz ustawić własne ustawienia serwera i proxy.
- Wyświetlanie - Kontroluj ustawienia wyświetlania dla zdalnych sesji i inne domyślne opcje, synchronizację schowka itd.
- Konto - Można to wykorzystać w połączeniu z serwerem profesjonalnym do logowania się do API.
- O aplikacji - Wyświetla informacje o oprogramowaniu.
## Konfigurowanie RustDeska
Jest wiele sposobów na konfigurowanie RustDeska.
Najłatwiejszym sposobem jest używanie serwera profesjonalnego RustDeska, za pomocą którego możesz otrzymać zaszyfrowany string konfiguracyjny. Może on być używany w połączeniu z `--config` w celu zaimportowania ustawień. Aby to zrobić:
1. Uruchom wiersz poleceń w miejscu gdzie RustDesk jest zainstalowany, np.: `C:\Program Files\RustDesk` na Windowsie, `/usr/bin` na Linuxie.
2. Użyj polecenia `rustdesk.exe --config twoj-zaszyfrowany-string` np. `rustdesk.exe --config 9JSPSvJzNrBDasJjNSdXOVVBlERDlleoNWZzIHcOJiOikXZr8mcw5yazVGZ0NXdy5CdyciojI0N3boJye`.
Możesz także ręcznie skonfigurować klienta. Aby to zrobić:
1. Naciśnij na Ustawienia.
2. Kliknij na Sieć.
3. Kliknij na Odblokuj ustawienia sieciowe.
4. Wprowadź swoje ID, Relay, API (jeżeli korzystasz z serwera pro) oraz swój klucz.
<!-- TODO: Add Polish version image -->
![](/docs/en/client/images/network-settings.png)
Jeżeli ręcznie skonfigurujesz klienta, możesz uzyskać plik `RustDesk2.toml` (z katalogu użytkownika) i użyć opcji `--import-config` w podobny sposób jak w powyższym przykładzie.
## Parametry wiersza poleceń
- `--password` może zostać użyte do ustawienia stałego hasła.
- `--get-id` może zostać użyte do pozyskania ID.
- `--set-id` może zostać użyte do ustawienia ID - pamiętaj, że ID musi zaczynać się od litery.
- `--silent-install` może zostać użyte do instalacji RustDeska na Windowsie w trybie cichym.
Dodatkowe zaawansowane parametry mogą zostać znalezione [tutaj](https://github.com/rustdesk/rustdesk/blob/bdc5cded221af9697eb29aa30babce75e987fcc9/src/core_main.rs#L242).
{{% children depth="3" showhidden="true" %}}

146
content/client/android/_index.pl.md Executable file
View File

@ -0,0 +1,146 @@
---
title: Android
weight: 4
---
## Zdalne sterowanie
Wprowadź ID zdalnego urządzenia na stronie głównej (lub wybierz poprzednie urządzenie) aby rozpocząć weryfikację.
Po pomyślnej weryfikacji, możesz zdalnie sterować urządzeniem.
| Strona główna | Połączony |
| --- | --- |
| ![](/docs/en/client/android/images/connection_home_en.jpg?width=300px) | ![](/docs/en/client/android/images/connection_en.jpg?width=300px) |
Istnieją dwa tryby sterowania: `Tryb myszy` oraz `Tryb dotyku`, pomiędzy którymi możesz przechodzić za pomocą dolnego paska narzędzi.
| Ustawienia myszy | Wybór trybu |
| --- | --- |
| ![](/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 %}}
W `trybie myszy` możesz wywołać `prawy przycisk myszy` na zdalny urządznieniu za pomocą `dotknięcia dwoma palcami`.
{{% /notice %}}
## Transfer plików (Android)
> Wymaga RustDeska ≥ 1.1.9
Na liście urządzeń na stronie głównej, wybierz urządzenie.
Prztrzymaj albo naciśnij menu po prawej i wybierz `Transfer plików`.
| Strona główna | Połączony |
| --- | --- |
| ![](/docs/en/client/android/images/connection_home_file_en.jpg?width=300px) | ![](/docs/en/client/android/images/file_connection_en.jpg?width=300px) |
- Początkowy katalog to katalog domowy użytkownika w urządzeniu. Możesz nacisnąć <i class="fas fa-home"></i> aby szybko wrócić do katalogu domowego.
- Pod paskiem tytułu znajduje się poziom katalogu. Możesz kliknąć odpowiedni folder, aby szybko przejść do niego.
- Naciśnij <i class="fas fa-arrow-up"></i> aby przejść do katalogu nadrzędnego.
- Aktualna bezwzględna ścieżka i statystyki projektu zostaną wyświetlone na dole listy.
- Kliknij `Lokalne` / `Zdalne` na pasku tytułu, aby przełączać się między stronami.
### Jak mam przesyłać pliki?
1. **Prztrzymaj** plik lub folder w liście aby szybko przejść do **trybu wielokrotnego wyboru**, w którym możesz wybrać wiele przedmiotów.
2. Po wybraniu plików zmień stronę `Lokalne` / `Zdalne`. Po zmianie wyświetli się komunikat `Wkleić tutaj?` na dole ekranu.
3. Naciśnij ikonę wklejania aby zacząć przesyłać wybrane rzeczy do katalogu docelowego.
| Tryb wielokrotnego wyboru | Wklejanie plików |
| --- | --- |
| ![](/docs/en/client/android/images/file_multi_select_en.jpg?width=300px) | ![](/docs/en/client/android/images/file_copy_en.jpg?width=300px) |
## Ustawienie ID/Serwera przekaźnikowego
1. Naciśnij `Ustawienia` na dolnym pasku nawigacyjnym.
2. Naciśnij `Serwer ID/przekaźnikowy`.
3. Wpisz adres twojego serwera ID w polu `Serwer ID`. Zostaw `Serwer przekaźnikowy` i `Serwer API` puste i wprowadź twój klucz publiczny (opcjonalne, wymagane do szyfrowania) w polu `Klucz.` Naciśnij **OK** aby zapisać ustawienia. Zostaniesz automatycznie przełączony na wybrany serwer.
Możesz również skonfigurować serwer za pomocą kodu QR. Aby wygnerować taki kod, użyj następującego formatu (zazmień wartości `host` i `key` na własne):
```nolang
config={"host": "xxx", "key": "xxx"}
```
Następnie przejdź do [generatora kodów QR](https://www.qr-code-generator.com/) i wklej powyższy kod.
Poniższy obrazek to zrzut ekranu Androida. Jeżeli używasz iOSa, sprawdź menu w prawym górnym rogu na stronie głównej.
![](/docs/en/client/android/images/id_setting_en.jpg?width=300px)
## Udostępniaj ekran/pliki z twojego Androida
Zaczynając od wersji 1.1.9, klient Androidowy wprowadził funkcję udostępniania ekranu smartfona oraz jego plików.
- Android 6 lub nowszy jest wymagany w celu udostępniania ekranu
- Android 10 lub nowszy jest wymagny w celu udostępniania wewnętrznego dźwięku systemu smartfona
- iOS nie wspiera udostępniania ekranu
### Poproś o uprawnienia i uruchom usługi
Naciśnij na `Udostępniaj ekran` na dole paska nawigacyjnego.
Skonfiguruj różne uprawnienia w razie potrzeb. Przy każdym uruchomieniu RustDeska będziesz musiał ponownie wywołać uprawnienia "Przechwytywanie ekranu" i "Sterowanie wejściem (_Input Control_)".
![](/docs/en/client/android/images/server_off_en.jpg?width=300px)
| Uprawnienie | Opis |
| --- | --- |
| Przechwytywanie ekranu | Włączenie uprawnienia do udostępniania zrzutów ekranu; usługa monitorowania zostanie włączona jednocześnie z uruchomieniem systemu |
| Sterowanie wejściem* | Zezwolenie kontrolerowi na sterowanie wejściem telefonu komórkowego, np. obsługą wirtualnego ekranu dotykowego za pomocą myszy |
| Przesyłanie plików* | Włączenie uprawnienia do przesyłania plików. Po uruchomieniu można zdalnie sterować systemem plików tego telefonu |
| Przechwytywanie dźwięku | Udostępnianie muzyki systemowej w telefonie (nie wejścia mikrofonowego) |
{{% notice note %}}
Powyższy symbol * oznacza specjalne uprawnienia. Aby je uzyskać, należy przejść do strony ustawień systemu Android i włączyć je ręcznie. Szczegóły są następujące:
{{% /notice %}}
### Wniosek o specjalne zezwolenie – plik
| Żądanie uprawnień do plików Androida spowoduje automatyczne przejście do strony ustawień systemowych |
| :---: |
| ![](/docs/en/client/android/images/get_file_en.jpg?width=300px) |
### Wniosek o specjalne zezwolenie – wejście myszy
| Krok 1: Znajdź "Zainstalowane usługi" | Krok 2: Uruchom _wejście_ RustDeska |
| --- | --- |
| ![](/docs/en/client/android/images/get_input1_en.jpg?width=300px) | ![](/docs/en/client/android/images/get_input2_en.jpg?width=300px) |
{{% notice note %}}
Strona ustawień systemu różnych dostawców może się różnić, dostosuj ją zgodnie ze stroną swojego systemu.
{{% /notice %}}
| Skróty klawiszowe do sterowania myszą | Opis |
| --- | --- |
| Kliknij prawym przyciskiem myszy | Wróć |
| Kliknij kółko myszy | Strona domowa |
| Prztrzymaj kółko myszy | Ostatnio uruchomione aplikacje |
| Scrollowanie | Symuluj pionowe przesuwanie |
### Uruchom usługę
Po uzyskaniu uprawnienia `Przechwytywanie ekranu` usługa zostanie uruchomiona automatycznie. Można również kliknąć przycisk `Uruchom usługę`, aby uruchomić usługę. Po uruchomieniu usługi może ona przyjmować żądania sterowania pulpitem z innych urządzeń.
Jeśli uprawnienie `Transfer plików` jest włączone, może ono również akceptować żądania kontroli plików z innych urządzeń.
Po uruchomieniu usługi urządzenie otrzyma automatycznie unikalne ID i losowe hasło. Inne urządzenia mogą sterować smartfonem za pomocą ID i hasła lub ręcznie potwierdzać otrzymanie nowego żądania.
| Przed uruchomieniem usługi | Po uruchomieniu usługi |
| --- | --- |
| ![](/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. Kliknięcie przycisku `Uruchom usługę` spowoduje domyślne włączenie uprawnienia `Przechwytywanie ekranu`.
2. Gdy nie uzyskano uprawnienia `Przechwytywanie ekranu`, inne urządzenia nie mogą wysyłać żądań sterowania.
3. Z wyjątkiem uprawnienia `Przechwytywanie kranu`, zmiana innych uprawnień będzie miała wpływ tylko na nowe połączenie i nie wpłynie na istniejące połączenie. Jeśli chcesz zmienić uprawnienia dla istniejącego połączenia, najpierw zamknij bieżące połączenie, zmień uprawnienia, a następnie odbierz żądanie sterowania.
{{% /notice %}}
#### PC
![](/docs/en/client/android/images/android_server_pc_side_en.png?width=700px)
#### Mobilny terminal
| W dowolnym momencie możesz zatrzymać usługę lub zamknąć określone połączenie | Możesz odbierać lub inicjować czaty |
| --- | --- |
| ![](/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.pl.md Executable file
View File

@ -0,0 +1,100 @@
---
title: Linux
weight: 4
---
## Instalacja
### Ubuntu (≥ 18)
```sh
# zignoruj błędny raport o zużyciu miejsca na dysku
sudo apt install -fy ./rustdesk-<version>.deb
```
Dla Ubuntu 18.04 wykonaj poniższe polecenia w celu konfiguracji [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
# Dla Fedory
sudo yum install libnsl
./rustdesk-<version>.AppImage
```
```sh
# Dla 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 jest wymagany~~
~~RustDesk jeszcze nie wspiera Waylanda; musisz ręcznie przełączyć się na X11.~~
RustDesk ma eksperymentalne wsparcie Waylanda od wersji 1.2.0.
### Serwer wyświetlania
[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)
### Ekran logowania
Obsługa ekranów logowania przy użyciu Waylanda nie jest jeszcze wspierana. Jeżeli potrzebujesz ich obsługi (po ponownym uruchomieniu albo wylogowaniu przez RustDesk), musisz zmienić ekran logowania na X11. Musisz zmienić poniższą linię na `WaylandEnable=false` w `/etc/gdm/custom.conf` lub `/etc/gdm3/custom.conf`:
```ini
#WaylandEnable=false
```
{{% notice note %}}
**Uruchom ponownie** system aby powyższe zmiany weszły w życie.
{{% /notice %}}
### Problemy z uprawnieniami
Jeżeli SELinux jest włączony, RustDesk nie będzie porpawnie działał ani w środowiskach X11, ani Waylandowych. Powiązane zgłoszenia znajdziesz [tutaj](https://github.com/search?q=repo%3Arustdesk%2Frustdesk+SElinux&type=issues).
Możesz wykonać:
```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 %}}
Numer w nawiasach po `audit` to znacznik czasu.
{{% /notice %}}
Jeżeli wyjście zawiera `avc: denied`, musisz stworzyć polityki SELinux. Zobacz [SELinux](https://rustdesk.com/docs/en/client/linux/selinux/).

57
content/client/mac/_index.pl.md Executable file
View File

@ -0,0 +1,57 @@
---
title: Mac
weight: 3
---
## Instalacja
Otwórz plik .dmg i przeciągnij `RustDesk` do `Aplikacje` jak poniżej.
![](/docs/en/client/mac/images/dmg.png)
Upewnij się, że zamknąłeś wszystkie uruchomione instancje RustDeska. Dodatkowo bądź pewien, że wyłączyłeś usługę RustDeska (widoczną na pasku zadań).
![](/docs/en/client/mac/images/tray.png)
## Zezwól na uruchomienie RustDesk
| Odblokuj aby zmienić | Kliknij na `App Store i zidentyfikowani deweloperzy` |
| --- | --- |
| ![](/docs/en/client/mac/images/allow2.png) | ![](/docs/en/client/mac/images/allow.png) |
## Włącz uprawnienia
{{% notice note %}}
Ze względu na zmiany w polityce bezpieczeństwa macOSa nasze API, które przechwytuje dane wejściowe po stronie
lokalnej przestało działać. Musisz włączyć uprawnienie "Monitorowanie wejścia" po lokalnej stronie.
Proszę postępować zgodnie z poniższymi instrukcjami.
[https://github.com/rustdesk/rustdesk/issues/974#issuecomment-1185644923](https://github.com/rustdesk/rustdesk/issues/974#issuecomment-1185644923).
W wersji 1.2.4, możesz wypróbować `Źródło wejścia 2`, które można wybrać po kliknięciu na ikonę klawiatury na pasku narzędzi.
{{% /notice %}}
Aby przechwytywać ekran musisz zezwolić RustDeskowi na uprawnienia **Dostępność** i **Nagrywanie ekranu**. RustDesk poprowadzi cię do okna ustawień.
| Okno RustDesk | Okno ustawień |
| --- | --- |
| ![](/docs/en/client/mac/images/acc.png) | ![](/docs/en/client/mac/images/acc3.png?v2) |
Jeżeli już na nie zezwoliłeś, ale RustDesk dalej wyświetla ostrzeżenia: spróbuj usunąć `RustDesk` z okien ustawień używając przycisku `-` i kliknij na przycisk `+`, zaznacz `RustDesk` w `Aplikacje`.
<!-- Translation note: "Inne bezskuteczne próby" ????? -->
{{% notice note %}}
[https://github.com/rustdesk/rustdesk/issues/3261](https://github.com/rustdesk/rustdesk/issues/3261) <br>
Inne bezskuteczne próby: <br>
`tccutil reset ScreenCapture com.carriez.RustDesk` <br>
`tccutil reset Accessibility com.carriez.RustDesk` <br>
Nadal wymagane jest ponowne uruchomienie systemu.
{{% /notice %}}
| Przyciski `-` i `+` | Zaznacz `RustDesk` |
| --- | --- |
| ![](/docs/en/client/mac/images/acc2.png) | ![](/docs/en/client/mac/images/add.png?v2) |
Powtórz powyższe czynności dla uprawnienia **Nagrywanie ekranu**.
![](/docs/en/client/mac/images/screen.png?v2)

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

@ -0,0 +1,90 @@
---
title: MSI
weight: 49
---
Paczka MSI obsługuje parametry linii poleceń w ramach instalacji w trybie cichym.
## Parametry
## INSTALLFOLDER
Folder instalacyjny.
**Domyślnie**: `[ProgramFiles6432Folder]\[app name]`, zazwyczaj `C:\Program Files\[app name]`.
## CREATESTARTMENUSHORTCUTS
Stwórz skrót w menu startowym.
**Domyślnie**:
1. Podczas instalacji. Domyślnie `1`.
2. Podczas aktualizacji. Domyślnie przybiera wartość wybraną podczas ostatniej instalacji.
| Nr | Wartość | Opis |
| :---: | :---: | :---: |
| 1 | `1` | Tak |
| 2 | `0` | Nie |
| 3 | `Y` | Tak, to samo co `1` |
| 4 | `N` | Nie, to samo co `0` |
## CREATEDESKTOPSHORTCUTS
Stwórz skrót na pulpicie.
**Domyślnie**:
1. Podczas instalacji. Domyślnie `1`.
2. Podczas aktualizacji. Domyślnie przybiera wartość wybraną podczas ostatniej instalacji.
| Nr | Wartość | Opis |
| :---: | :---: | :---: |
| 1 | `1` | Tak |
| 2 | `0` | Nie |
| 3 | `Y` | Tak, to samo co `1` |
| 4 | `N` | Nie, to samo co `0` |
## INSTALLPRINTER
Zainstaluj drukarkę. Drukarka jest używana do wykonywania druków ze strony lokalnej.
Od wersji `1.3.9`.
**Domyślnie**:
1. Podczas instalacji. Domyślnie `1`.
2. Podczas aktualizacji. Domyślnie przybiera wartość wybraną podczas ostatniej instalacji.
| Nr | Wartość | Opis |
| :---: | :---: | :---: |
| 1 | `1` | Tak |
| 2 | `0` | Nie |
| 3 | `Y` | Tak, to samo co `1` |
| 4 | `N` | Nie, to samo co `0` |
# Przykłady
**Ostrzeżenie**: Dla wersji sprzed `05-08-2024`, występują problemy z instalacją i naprawą w trybie cichym. Należy najpierw odinstalować i zainstalować ponownie.
## Instalacja z parametrami
Instalacja w trybie cichym: ustaw ścieżkę instalacji, nie twórz skrótu na pulpicie, stwórz skrót w menu startowym.
```
msiexec /i RustDesk-1.msi /qn INSTALLFOLDER="D:\Program Files\RustDesk" CREATESTARTMENUSHORTCUTS="Y" CREATEDESKTOPSHORTCUTS="N" INSTALLPRINTER="N" /l*v install.log
```
**Informacja**: `/l*v install.log` oznacza zapisywanie logów wykonywania do `install.log`.
## Aktualizacja bez parametrów
Aktualizacja z poprzednią ścieżką i opcjami instalacji.
```
msiexec /i RustDesk-2.msi /qn /l*v install.log
```
## Aktualizacja ze zmienionymi parametrami
```
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.pl.md Normal file
View File

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

48
content/client/windows/windows-portable-elevation/_index.pl.md Normal file
View File

@ -0,0 +1,48 @@
---
title: Podnoszenie uprawnień w wersji portable
weight: 49
---
Windows portable programs do not have administrator privileges, which can lead to the following issues:
Programy przenośne nie mają uprawnień administratora w systemie Windows, co może prowadzić do następujących problemów:
- Ekran nie może być przesyłany, gdy pojawia się okno UAC (Kontrola konta użytkownika).
- Gdy pojawia się wyskakujące okno, takie jak Menedżer zadań, mysz przestaje reagować.
Poprzez podwyższenie uprawnień RustDesk może utworzyć proces z uprawnieniami administratora podczas uruchamiania lub sesji, umożliwiając mu wykonywanie zrzutów ekranu i operacji myszą, co pozwala uniknąć powyższych problemów.
## Podniesienie podczas uruchomienia
W ten sposób użytkownicy zdalni nie muszą prosić o podwyższenie uprawnień podczas łączenia się. Istnieją dwie metody:
* Metoda 1: Zmień nazwę programu przenośnego, dodając do niej `-qs-` (wersje 1.2.0, 1.2.1, 1.2.2, 1.2.3 kończą się na `qs.exe`). Kliknij lewym przyciskiem myszy, aby uruchomić program, a następnie kliknij `Akceptuj` w oknie UAC.
* Metoda 2: Kliknij prawym przyciskiem myszy i uruchom jako administrator.
## Podniesienie po stronie kontrolowanej
Kontrolująca strona może bezpośrednio kliknąć `Akceptuj i podnieś uprawnienia` podczas łączenia się lub kliknąć `Podnieś uprawnienia`, gdy połączenie już zostało nawiązane.
| Łączenie | Połączony |
| :---: | :---: |
| ![](/docs/en/client/windows/windows-portable-elevation/images/cm_unauth.jpg) | ![](/docs/en/client/windows/windows-portable-elevation/images/cm_auth.jpg) |
## Żądanie podwyższenia na końcu sterowania
Po wybraniu opcji `Żądaj podwyższenia uprawnień` z menu akcji pojawi się następujące okno dialogowe. Jeśli wybierzesz opcję `Poproś użytkownika zdalnego o uwierzytelnienie`, nie będziesz musiał wprowadzać nazwy użytkownika i hasła, ale użytkownik komputera zdalnego musi mieć uprawnienia administratora. Jeśli wybierzesz opcję `Przekaż nazwę użytkownika i hasło administratora`, użytkownik komputera zdalnego musi jedynie zaakceptować okno UAC. Po wysłaniu żądania należy poczekać, aż użytkownik po drugiej stronie zaakceptuje okno UAC. Po potwierdzeniu pojawi się komunikat o pomyślnym zakończeniu operacji. Należy pamiętać, że **obie metody wymagają, aby ktoś po stronie kontrolowanej zaakceptował okno UAC**. Dlatego też, jeśli po drugiej stronie nie ma nikogo dostępnego, nie należy żądać podwyższenia uprawnień po stronie kontrolującej.
| Menu | Okno dialogowe |
| :---: | :---: |
| ![](/docs/en/client/windows/windows-portable-elevation/images/menu.png) | ![](/docs/en/client/windows/windows-portable-elevation/images/dialog.png) |
| **Czekanie** | **Sukces** |
| ![](/docs/en/client/windows/windows-portable-elevation/images/wait.png) | ![](/docs/en/client/windows/windows-portable-elevation/images/success.png) |
## Którą metodę wybrać
| Sytuacja | Metoda |
| :---: | :---: |
| Nie wymaga podwyższenia | Zainstaluj program |
| Brak użytkownika dostępnego po stronie kontrolowanej | Zmień nazwę<br/>*lub*<br/> Uruchom jako administrator |
| Użytkownik dostępny na stronie kontrolowanej <br/>*oraz*<br/> potrzebne natychmiastowe podniesienie po połączeniu <br/>*oraz*<br/> połączenie poprzez kliknięcie | Kliknij `Zaakceptuj i Podnieś`, gdy otrzymasz połączenie po stronie kontrolowanej |
| Użytkownik dostępny na stronie kontrolowanej <br/>*oraz*<br/> podniesienie na żądanie | Naciśnij `Podnieś uprawnienia` w oknie zarządzania połączeniami po stronie kontrolowanej <br/>*lub*<br/> Poproś o podniesienie uprawnień po stronie kontrolowanej |

8
content/dev/_index.pl.md Executable file
View File

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

8
content/dev/build/_index.pl.md Executable file
View File

@ -0,0 +1,8 @@
---
title: Budowanie
weight: 1
---
Sprawdź [build.py](https://github.com/rustdesk/rustdesk/blob/master/build.py) po informacje na temat pakowania wersji desktopowej.
{{% children depth="3" showhidden="true" %}}

75
content/dev/build/faq/_index.pl.md Normal file
View File

@ -0,0 +1,75 @@
---
title: Często zadawane pytania (Windows)
weight: 40
---
## Błąd przy pobieraniu pakietu vcpkg
### Błąd
```
-- 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
```
### Rozwiązanie
Użyj przeglądarki aby pobrać [libyuv-287158925b0e03ea4499a18b4e08478c5781541b.tar.gz](https://chromium.googlesource.com/libyuv/libyuv/+archive/287158925b0e03ea4499a18b4e08478c5781541b.tar.gz), przenieś do `vcpkg/downloads` i zainstaluj ponownie.
## Paczka w Cargo.lock nie istnieje
### Błąd
```
$ 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)
```
Może autor użył `git force push` i poprzedni commit został nadpisany.
### Rozwiązanie
`cargo update`, wymuś aktualizację paczki.
## VCPKG_ROOT nie ustawiony
### Błąd
```
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
```
### Rozwiązanie
Ustaw zmienną środowiskową `VCPKG_ROOT`, albo uruchom ze zmienną `VCPKG_ROOT=<vcpkg_dir> cargo run`.
## clang nie zainstalowany, lub zmienna LIBCLANG_PATH nie została ustawiona
### Błąd
```
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
```
### Rozwiązanie
Zainstaluj [LLVM](https://releases.llvm.org/download.html), ustaw zmienną środowiskową `LIBCLANG_PATH` jako `llvm_install_dir/bin`.

65
content/dev/build/linux/_index.pl.md Normal file
View File

@ -0,0 +1,65 @@
---
title: Linux
weight: 10
---
## Jak zbudować na Linuxie
### 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
```
### Zainstaluj 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"
```
### Napraw libvpx (dla Fedory)
```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
```
### Zbuduj
```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
# Note: VCPKG_ROOT dalej ustawione
cargo run
```

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

@ -0,0 +1,122 @@
---
title: macOS
weight: 21
---
Jest wiele sposobów żeby to zrobić, ten przewodnik zakłada, że `Xcode`, `Git` i `Homebrew` są już zainstalowane.
Prawdopodobnie największym wyzwaniem jest znalezenie wersji wszystkich narzędzi, które działają ze sobą, zwłaszcza części toolchainu takie jak Xcode i LLVM ze względu na to, że są dyktowane przez wersję twojego macOSa. Wersje w tym przewodniku pewnie nie są tymi, których powinieneś używać. Za początek w szukaniu jakich wersji należy użyć można uznać [Workflow budowania na GitHubie](https://github.com/rustdesk/rustdesk/blob/master/.github/workflows/flutter-build.yml) dla danej wersji RustDeska jaką chcesz zbudować. Wybierz tag, dla którego chcesz wyświetlić plik, w lewym górnym rogu strony. Ale to niekoniecznie zadziała, ponieważ narzędzia macOS dostarczane wraz z programem GitHub Runner mogą nie być w tej samej wersji, co narzędzia zainstalowane w twoim systemie lokalnym.
### Eksport
`export` służy do ustawiania różnych zmiennych środowiskowych. Po uruchomieniu `export` zmienna ta jest ustawiana tylko dla bieżącej sesji terminala, dlatego należy ją powtarzać dla każdego nowego okna terminala, którego chcesz używać do kompilacji RustDesk, teraz lub w przyszłości. Zasadniczo zaleca się dodanie wszystkich poleceń `export` do skryptu, który jest uruchamiany automatycznie dla każdego otwartego terminala, na przykład `~/.bash_profile`. Pełne polecenia `export` wymienione tutaj można po prostu dołączyć do pliku, ale należy je również uruchomić w bieżącym terminalu, ponieważ plik nie jest odczytywany, dopóki nie zostanie otwarty *nowy* terminal.
## Zainstaluj narzędzia, których będziemy używać z Homebrewa.
```sh
brew install python3 create-dmg nasm cmake gcc wget ninja pkg-config wget rustup
```
Niektóre instalacje mogą się nie udać, bo niektóre foldery docelowe nie istnieją w naszym systemie. W takim przypadku stwórz folder, ustaw właściciela i uprawnienia, a potem wykonaj znowu polecenie `brew`. Przykład jeśli`/usr/local/include` nie istnieje:
```sh
sudo mkdir /usr/local/include
sudo chown <username>:admin /usr/local/include
sudo chmod 775 /usr/local/include
```
## Zainstaluj vcpkg
Vcpkg służy do zarządzania zależnościami C/C++ używanymi przez RustDesk. Zdecyduj, gdzie chcesz zainstalować program, i uruchom poniższe polecenie z folderu, w którym ma znajdować się folder `vcpkg`. W tym przykładzie jako lokalizację użyto `/Users/<nazwa użytkownika>/repos/`, a jako wersję użyto tagu `2023.04.15`.
```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
```
## Zainstaluj i skonfiguruj Rusta
Używamy `rustup` do zarządzania Rustem, który został już zainstalowany powyżej za pomocą Homebrew. Jednak nadal wymaga on konfiguracji. Postępuj zgodnie z instrukcjami i upewnij się, że zarówno `rustup`, jak i `rustc` znajdują się w `PATH`. W tym przykładzie używamy wersji Rust `1.75.0`, ale może być konieczne użycie innej wersji. Za pomocą `rustup` można zainstalować i zarządzać wieloma wersjami Rust.
```sh
rustup-init
rustup default 1.75.0
rustup component add rustfmt
```
Aby uzyskać przegląd zainstalowanych i domyślnych zestawów narzędzi Rust, uruchom polecenie `rustup show`.
## Pobierz pliki źródłowe RustDeska
Zdecyduj, gdzie chcesz umieścić pliki źródłowe RustDesk, a następnie uruchom poniższe polecenie z folderu, w którym chcesz umieścić folder `rustdesk`. W tym przykładzie jako lokalizacja została użyta ścieżka `/Users/<nazwa użytkownika>/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
```
Jeśli `python3` lub `pip` są nieznane, dodaj je do `PATH` za pomocą następującego polecenia (użyj rzeczywistych nazw folderów):
```sh
export PATH=~/Library/Python/3.9/bin:$PATH
```
Po wykonaniu tej czynności uruchom ponownie nieudane polecenie (polecenia). Pamiętaj, aby edytować również plik `~/.bash_profile`.
## Zainstaluj komponenty interfejsu użytkownika
RustDesk można skompilować zarówno przy użyciu [Scitera](https://sciter.com/), jak i [Fluttera](https://flutter.dev/). Oba wymagają dodatkowych komponentów, więc postępuj zgodnie z instrukcjami dla odpowiedniej wersji lub dla obu.
### Sciter
Z folderu `rustdesk` uruchom:
```sh
wget https://github.com/c-smile/sciter-sdk/raw/master/bin.osx/libsciter.dylib
```
### Flutter
[FVM](https://fvm.app/) pozwala zarządzać wersjami Fluttera i jest prawdopodobnie najłatwiejszym sposobem na wypróbowanie różnych wersji Fluttera.
```sh
brew tap leoafarias/fvm
brew install fvm cocoapods
```
Zainstaluj i używaj na przykład Flutter `3.16.9`, korzystając z:
```sh
fvm global 3.16.9
```
FVM ma na celu wykorzystanie bardziej złożonej konfiguracji, w której może zapewnić różne wersje Fluttera dla różnych projektów, ale wykracza to poza zakres niniejszego przewodnika. Zamiast tego wystarczy ręcznie dodać lokalizację domyślnego Fluttera dostarczonego przez FVM do `PATH`, co oznacza, że do zmiany wersji Fluttera należy użyć `fvm global`:
```sh
export PATH=$HOME/fvm/default/bin:$PATH
```
Po wykonaniu tej czynności należy wyłączyć telemetrię i sprawdzić, czy wszystko działa poprawnie:
```sh
flutter --disable-analytics
dart --disable-analytics
flutter doctor -v
```
Nie ma znaczenia, jeśli niektóre testy zakończą się niepowodzeniem, co zazwyczaj ma miejsce. Ważne jest, aby test środowiska, z którego zamierzasz korzystać, zakończył się powodzeniem, a mianowicie `Xcode`. Jeśli pojawią się zgłoszone problemy, rozwiąż je przed kontynuowaniem.
Po uruchomieniu Fluttera należy zainstalować "most", który łączy Rusta i Fluttera. Oto kolejna wersja, która dobrze współpracuje z pozostałymi elementami. W tym przykładzie używamy wersji `1.80.1`:
należy
```sh
cargo install flutter_rust_bridge_codegen --version "1.80.1" --features "uuid"
```
## Budowanie
Zbuduj z folderu `rustdesk`. Skompiluj wersję Scitera za pomocą:
```sh
python3 ./build.py
```
Zbuduj wersję Fluttera za pomocą:
```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
```
Jeśli wszystko przebiegnie pomyślnie, w folderze `rustdesk` powinien znajdować się plik `dmg` gotowy do instalacji.

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

@ -0,0 +1,58 @@
---
title: Windows
weight: 20
---
{{% notice note %}}
Podane tutaj polecenia muszą być uruchamiane w Git Bashu a nie w natywnym wierszu poleceń, w innym przypadku będą występować błędy składni.
{{% /notice %}}
## Zależności
### Środowisko budowania C++
Pobierz [MSVC](https://visualstudio.microsoft.com/) i zainstaluj.
Wybierz `Windows` jako system operacyjny dewelopera i zaznacz `C++`, następnie pobierz Visual Studio Community i zainstaluj. Instalacja może zająć chwilę.
### Środowisko programistyczne Rusta
Pobierz [rustup-init.exe](https://static.rust-lang.org/rustup/dist/x86_64-pc-windows-msvc/rustup-init.exe) i uruchom jako administrator aby zainstalować `rusta`.
### vcpkg
Przejdź do foleru do którego chcesz sklonować vcpkg i użyj [Git Basha](https://git-scm.com/download/win) aby wykonać poniższe polecenia; pobierz `vcpkg` i zainstaluj 64-bitową wersję `libvpx`, `libyuv` i `opus`.
Jeżeli nie masz jeszcze zainstalowanego `Gita`, możesz go pobrać [tutaj](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
```
Dodaj systemową zmienną środowiskową `VCPKG_ROOT`=`<sciezka>\vcpkg`. Wartość `<sciezka>` to powyższa lokalizacja gdzie sklonowałeś `vcpkg`.
![](/docs/en/dev/build/windows/images/env.png)
### Sciter
Desktopowe wersje korzystają ze [Scitera](https://sciter.com/) do GUI, z tego powodu musisz pobrać plik [sciter.dll](https://raw.githubusercontent.com/c-smile/sciter-sdk/master/bin.win/x64/sciter.dll).
### LLVM
`rust-bindgen` zależy od `clang`, pobierz [LLVM](https://github.com/llvm/llvm-project/releases) i zainstaluj, następnie dodaj systemową zmienną środowiskową `LIBCLANG_PATH` na `<katalog_instalacyjny_llvm>/bin`.
Możesz pobrać wersję 15.0.2 plików binarnych LLVM tutaj: [64 bitowe](https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.2/LLVM-15.0.2-win64.exe) / [32 bitowe](https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.2/LLVM-15.0.2-win32.exe).
## Budowanie
### Domyślne
```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
```

48
content/self-host/_index.pl.md Executable file
View File

@ -0,0 +1,48 @@
---
title: Samodzielne hostowanie
weight: 5
pre: "<b>2. </b>"
---
Jeżeli używasz RustDeska powinieneś mieć własny serwer RustDeska. Ta dokumentacja pomoże ci w twojej podróży z RustDeskiem.
Wsparcie jest udzielane na naszym [Discordzie](https://discord.com/invite/nDceKgxnkV) dla wersji OSS i [mailowo](mailto:support@rustdesk.com) dla wersji Pro.
## Jak działa samodzielnie hostowany serwer?
Technicznie są dwa pliki wykonywalne (serwery):
- `hbbs` - Serwer ID RustDeska (rendezvous / sygnalizujący), nasłuchuje na TCP (`21114` - HTTP wyłącznie w wersji Pro, `21115`, `21116`, `21118` w ramach web socketów) i UDP (`21116`)
- `hbbr` - Serwer przekaźnikowy RustDeska, nasłuchuje na TCP (`21117`, `21119` w ramach web socketów)
Kiedy zainstalujesz serwer poprzez skrypt instalacyjny / docker compose / pakiet deb, dwie usługi zostaną zainstalowane.
Stworzyliśmy [ilustracje](https://github.com/rustdesk/rustdesk/wiki/How-does-RustDesk-work%3F) przedstawiające to jak klient RustDeska komunikuje się z `hbbr` / `hbbs`.
Dopóki RustDesk działa na komputerze, będzie on stale pingował serwer ID (`hbbs`), aby przekazać serwerowi swój aktualny adres IP i port.
Kiedy nawiązujesz połączenie z komputera A do komputera B, komputer A kontaktuje się z serwerem ID i żąda rozpoczęcia komunikacji z komputerem B.
Następnie serwer ID podejmuje próbę bezpośredniego połączenia pomiędzy A i B używając przebijania się przez NAT (_hole punching_).
Jeżeli hole punching się nie powiedzie, komputer A będzie komunikował się z B poprzez serwer przekaźnikowy (`hbbr`).
W większości przypadków hole punching przechodzi pomyślnie i serwer przekaźnikowy nie jest w ogóle używany.
Tutaj znajdziesz dyskuję na temat [Czy powinieneś samodzielnie hostować serwer rustdeska?](https://www.reddit.com/r/rustdesk/comments/1cr8kfv/should_you_selfhost_a_rustdesk_server/)
## Wymagane porty
Lista wymaganych portów dla samodzielnie hostowanego serwera RustDesk zależy głównie od tego, co chcesz robić z RustDeskiem. Pokazane przykłady w dokumentacji będą zawierały porty sugerowane do otwarcia.
Główne porty: \
TCP `21114-21119` \
UDP `21116`
Powyższy zakres `21115-21117` to minimum portów potrzebnych RustDeskowi do działania. To one zajmują się sygnalizowaniem i przekazywaniem oraz przechodzeniem przez NAT.
Porty TCP `21118` i `21119` są portami WebSocketów dla [klienta webowego RustDeska](https://rustdesk.com/web/). Potrzebujesz wstecznego proxy, jeżeli chcesz używać HTTPS - zobacz [przykładową konfigurację Nginxa](/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).
Użytkownicy Pro bez proxy SSL będą potrzebowali otworzyć port TCP `21114` żeby API było w stanie funckjonować - alternatywnie użyj proxy SSL i otwórz port `443`.
{{% children depth="4" showhidden="true" %}}

83
content/self-host/client-configuration/_index.pl.md Normal file
View File

@ -0,0 +1,83 @@
---
title: Konfiguracja klienta
weight: 300
pre: "<b>2.3. </b>"
---
## Zarys
Istnieje kilka sposobów na konfigurację klientów RustDeska tak, żeby używały twojego samodzielnie hostowanego serwera. Kilka z nich opisujemy poniżej.
## 1. Generator klientów (wyłącznie wersja Pro, z planem podstawowym lub dostosowanym)
Klient może zawierać twoją nazwę, logo, ikonę, konfigurację, być podpisanym - i więcej.
Aktualnie wspierane są: Windows x64, Mac ARM64 / x64, [Linux](https://twitter.com/rustdesk/status/1788905463678951787) oraz Android ARM64.
[Nagranie](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. Ręczna konfiguracja
W głównym panelu klienta RustDesk naciśnij na przycisk Menu [ &#8942; ] znajdujący się obok twojego ID. Następnie naciśnij na Sieć. Teraz możesz odblokować ustawienia używając podniesionych uprawnień i ustaw twoje `ID`, `Serwer przekaźnikowy`, `API` i `Klucz`. Istotne jest to, że `Klucz` to klucz publiczny używany do szyfrowania połączenia, nie jest to ten sam klucz, którego używałeś do aktywacji wersji Pro.
![](/docs/en/self-host/client-configuration/images/network-config.png)
Wprowadź adres serwera `hbbs` w polu tekstowym **Serwer ID**. Dwa inne adresy mogą być puste, RustDesk automatycznie je wydedukuje (jeżeli nie zostały wpisane). Serwer przekaźnikowy tyczy się serwera `hbbr` (port `21117`).
np.
```nolang
hbbs.przyklad.pl
```
lub
```nolang
hbbs.przyklad.pl:21116
```
### Ustaw `Klucz`
W celu ustanowienia szyfrowanego połączenia do twojego serwera, musisz wprowadzić jego klucz publiczny. Klucz ten jest zazwyczaj generowany przy pierwszym uruchomieniu programu `hbbs` i może zostać znaleziony w pliku `id_ed25519.pub` w katalogu roboczym / folderze "data".
Jako użytkownik `Pro` będziesz w stanie odczytać `Klucz` z [konsoli webowej](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/console/).
![](/docs/en/self-host/rustdesk-server-pro/console/images/console-home.png?v2)
### Ustaw `Serwer API`
Ta sekcja jest wyłącznie dla użytkowników `Pro`. W przypadku gdy możesz zalogować się do konsoli webowej, ale nie do klienta RustDeska, prawdopodobnie nieprawidłowo ustawiłeś wartość `Serwer API`.
Jeżeli twój serwer API nie jest uruchomiony na domyślnym porcie `21114` (nie potrzebujesz zezwalać na ruch do tego portu w firewallu, jeżeli używasz wersji open source), musisz wyraźnie wprowadzić wartość `Serwer API`.
Przykładowo: twój serwer API działa na domyślnym porcie HTTPS, w takim wypadku w `Serwer API` musisz wpisać `https://hbbs.przyklad.pl`.
Jeżeli dalej nie możesz stwierdzić wartości `Serwera API`, przejdź do strony powitalnej konsoli webowej. Wartość `Serwer API` będzie pokazana w powyższym zdjęciu (Pole tekstowe z etykietą `API:`).
## 3. Skonfiguruj używając importu albo eksportu
1. Użyj [powyższych](https://rustdesk.com/docs/pl/self-host/client-configuration/#ręczna-konfiguracja) kroków żeby skonfigurować klienta RustDeska na urządzeniu.
2. Korzystając z urządzenia przejdź do Ustawień - Sieć i odblokuj.
3. Naciśnij na `Eksportuj konfigurację serwera`.
4. Wklej skopiowany ciąg znaków w Notatnik (lub coś podobnego).
5. Przejdź do nowego klienta, skopiuj powyższy ciąg znaków do schowka.
6. Przejdź do Ustawień - Sieć w kliencie RustDeska, odblokuj i naciśnij `Importuj konfigurację serwera`.
7. Aplikacja automatycznie wklei ustawienia.
8. Naciśnij `Zatwierdź`.
## 4. Konfiguracja automatyczna
Najłatwiejszym sposobem na automatyczną konfigurację są skrypty wdrożeniowe możliwe do znalezienia [tutaj](https://rustdesk.com/docs/pl/self-host/client-deployment/).
## 5. Zaimportuj konfigurację z wersji `Pro` poprzez schowek
![](/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. Używając parametru linii poleceń `--config`
`rustdesk.exe --config <config-string>`
Możesz uzyskać ciąg konfiguracyjny z konsoli webowej (widoczny na powyższym obrazku) lub z klienta RustDesk w sekcji "Ustawienia → Sieć" ([tutaj](https://github.com/rustdesk/rustdesk/discussions/7118) znajduje się dyskusja na ten temat).

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

File diff suppressed because it is too large Load Diff

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

@ -0,0 +1,376 @@
---
title: Wdrażanie klientów
weight: 400
pre: "<b>2.4. </b>"
---
Najprostszym sposobem jest użycie niestandardowego klienta, https://twitter.com/rustdesk/status/1788905463678951787.
Możesz wdrożyć to na kilka sposobów, niektóre z nich opisano w sekcji [Konfiguracja klienta](https://rustdesk.com/docs/pl/self-host/client-configuration/).
Alternatywnie można użyć skryptów masowego wdrażania z RMM, Intune itp. ID i hasło są generowane przez skrypt. Należy je zebrać lub podzielić na różne skrypty, aby zebrać ID i hasło.
Stałe hasło można zmienić z losowego na preferowane, zmieniając zawartość wewnątrz `()` po `rustdesk_pw` na preferowane hasło dla PowerShella i odpowiednią linię dla każdej innej platformy.
## PowerShell
```powershell
$ErrorActionPreference= 'silentlycontinue'
# Przypisz wartość losowego hasła do zmiennej password
$rustdesk_pw=(-join ((65..90) + (97..122) | Get-Random -Count 12 | % {[char]$_}))
# Pobierz ciąg konfiguracyjny z portalu internetowego i wypełnij poniższe pola.
$rustdesk_cfg="stringkonfiguracyjny"
################################## Proszę nie edytować poniżej tej linii #########################################
# Uruchom jako administrator i pozostań w bieżącym katalogu
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;
}
}
# Ta funkcja zwróci najnowszą wersję i link do pobrania jako obiekt.
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)
}
# Aktualny przykładowy 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
# poprawka błędu - czasami trzeba zastąpić "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
}
# Utwórz obiekt do zwrócenia
$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 to najnowsza wersja."
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 "Instalowanie usługi"
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 "..............................................."
# Wyświetl wartość zmiennej ID
Write-Output "ID RustDeska: $rustdesk_id"
# Wyświetl wartość zmiennej Password
Write-Output "Hasło: $rustdesk_pw"
Write-Output "..............................................."
```
## Windows batch/cmd
```bat
@echo off
REM Przypisz wartość losowego hasła do zmiennej Password.
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 Pobierz string konfiguracyjny z portalu webowego i wypełnij poniższe pola.
set rustdesk_cfg="stringkonfiguracyjny"
REM ############################### Proszę nie edytować poniżej tej linii #########################################
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 Pokaż wartość zmiennej ID
echo ID RustDeska: %rustdesk_id%
REM Pokaż wartość zmiennej Password
echo Hasło: %rustdesk_pw%
echo ...............................................
```
## MSI
Można również użyć msi zamiast `rustdesk.exe --silent-install`.
https://rustdesk.com/docs/pl/client/windows/msi/
## Winget
można również wdrożyć za pomocą powershella z winget (instaluje się to za pomocą wersji apt firmy Microsoft — części najnowszych instalacji systemu Windows)
z okna powershella lub za pomocą skryptu (na przykład za pomocą GPO)
```
winget install --id=RustDesk.RustDesk -e
```
## macOS Bash
```sh
#!/bin/bash
# Przypisz wartość losowego hasła do zmiennej password
rustdesk_pw=$(openssl rand -hex 4)
# Pobierz string konfiguracyjny z portalu webowego i wypełnij poniższe pola.
rustdesk_cfg="stringkonfiguracyjny"
################################## Proszę nie edytować poniżej tej linii #########################################
# Żądanie hasła administratora w celu podwyższenia uprawnień
[ "$UID" -eq 0 ] || exec sudo bash "$0" "$@"
# Określ punkt montowania dla DMG (katalog tymczasowy)
mount_point="/Volumes/RustDesk"
# Pobierz plik rustdesk.dmg
echo "Pobieranie RustDeska"
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
# Zamontuj plik DMG w określonym punkcie montowania
hdiutil attach "$dmg_file" -mountpoint "$mount_point" &> /dev/null
# Sprawdź, czy montaż zakończył się powodzeniem.
if [ $? -eq 0 ]; then
# Przenieś zawartość zamontowanego pliku DMG do folderu /Applications.
cp -R "$mount_point/RustDesk.app" "/Applications/" &> /dev/null
# Odmontuj plik DMG
hdiutil detach "$mount_point" &> /dev/null
else
echo "Nie udało się zamontować pliku DMG RustDesk. Instalacja została przerwana."
exit 1
fi
# Uruchom polecenie rustdesk z opcją --get-id i zapisz wynik w zmiennej rustdesk_id.
cd /Applications/RustDesk.app/Contents/MacOS/
rustdesk_id=$(./RustDesk --get-id)
# Zastosuj nowe hasło do RustDeska
./RustDesk --server &
/Applications/RustDesk.app/Contents/MacOS/RustDesk --password $rustdesk_pw &> /dev/null
/Applications/RustDesk.app/Contents/MacOS/RustDesk --config $rustdesk_cfg
# Zakończ wszystkie procesy o nazwie RustDesk
rdpid=$(pgrep RustDesk)
kill $rdpid &> /dev/null
echo "..............................................."
# Sprawdź, czy rustdesk_id nie jest puste
if [ -n "$rustdesk_id" ]; then
echo "ID RustDeska: $rustdesk_id"
else
echo "Nie udało się uzyskać ID RustDeska"
fi
# Echo the value of the password variable
echo "Hasło: $rustdesk_pw"
echo "..............................................."
echo "Proszę zakończyć instalację w GUI, trwa uruchamianie RustDeska"
open -n /Applications/RustDesk.app
```
## Linux
```sh
#!/bin/bash
# Przypisz losową wartość do zmiennej password
rustdesk_pw=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 8 | head -n 1)
# Pobierz string konfiguracyjny z portalu webowego i wypełnij poniższe pola.
rustdesk_cfg="stringkonfiguracyjny"
################################## Proszę nie edytować poniżej tej linii #########################################
# Sprawdź, czy skrypt jest uruchamiany jako root
if [[ $EUID -ne 0 ]]; then
echo "This script must be run as root."
exit 1
fi
# Zidentyfikuj system operacyjny
if [ -f /etc/os-release ]; then
# freedesktop.org i systemd
. /etc/os-release
OS=$NAME
VER=$VERSION_ID
UPSTREAM_ID=${ID_LIKE,,}
# Jeśli identyfikator nie był 'ubuntu' ani 'debian', należy użyć ID_LIKE.
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
# W niektórych wersjach Debiana/Ubuntu bez polecenia lsb_release
. /etc/lsb-release
OS=$DISTRIB_ID
VER=$DISTRIB_RELEASE
elif [ -f /etc/debian_version ]; then
# Starsze Debiany, Ubuntu, itd.
OS=Debian
VER=$(cat /etc/debian_version)
elif [ -f /etc/SuSE-release ]; then
# Starszy SuSE itd.
OS=SuSE
VER=$(cat /etc/SuSE-release)
elif [ -f /etc/redhat-release ]; then
# Starsze Red Hat, CentOS, itd.
OS=RedHat
VER=$(cat /etc/redhat-release)
else
# Użyj uname, np. "Linux <wersja>", działa również w przypadku BSD itp.
OS=$(uname -s)
VER=$(uname -r)
fi
# Zainstaluj RustDeska
echo "Instalacja RustDeska"
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 "Niewspierany system operacyjny"
# tutaj można poprosić użytkownika o zgodę na próbę instalacji mimo wszystko
# jeśli użytkownik wyrazi zgodę, należy przeprowadzić instalację
# jeśli użytkownik odmówi, należy zamknąć skrypt
exit 1
fi
# Uruchom polecenie rustdesk z opcją --get-id i zapisz wynik w zmiennej rustdesk_id
rustdesk_id=$(rustdesk --get-id)
# Zastosuj nowe hasło do RustDeska
rustdesk --password $rustdesk_pw &> /dev/null
rustdesk --config $rustdesk_cfg
systemctl restart rustdesk
echo "..............................................."
# Sprawdź, czy rustdesk_id nie jest puste
if [ -n "$rustdesk_id" ]; then
echo "ID RustDeska: $rustdesk_id"
else
echo "Nie udało się uzyskać ID RustDeska."
fi
# Wyświetl wartość zmiennej "password"
echo "Hasło: $rustdesk_pw"
echo "..............................................."
```

133
content/self-host/nat-loopback-issues/_index.pl.md Normal file
View File

@ -0,0 +1,133 @@
---
title: Problemy z pętlą zwrotną NAT
weight: 500
pre: "<b>2.5. </b>"
---
{{% notice note %}}
To wyjaśnienie obejmuje złożoną wiedzę z zakresu sieci komputerowych, dlatego potrzebujemy pomocy, aby poprawić jego zrozumiałość.
{{% /notice %}}
Więcej szczegółowych informacji na temat pętli zwrotnej NAT można znaleźć na [Wikipedii](https://en.wikipedia.org/wiki/Network_address_translation#NAT_hairpinning) (_brak polskiej wersji_).
Podczas wdrażania serwera RustDesk w sieci domowej lub innym środowisku sieciowym znajdującym się za zaporą NAT, serwer RustDeska i klienci **MUSZĄ**:
A: Używać lokalnego adresu IP, aby uzyskać dostęp do siebie nawzajem LUB:
B: Skonfigurować zaporę sieciową, która obsługuje i ma włączoną funkcję pętli zwrotnej NAT.
Możesz zauważyć, że nie możesz połączyć się z serwerem za pomocą **publicznego adresu IP** lub **domeny** (która teoretycznie wskazuje na Twój publiczny adres IP).
## Problem
W tym przykładzie prześledzimy, co się dzieje, gdy urządzenia LAN próbują połączyć się z `rustdesk.przyklad.pl`. Załóżmy, że publiczny adres IP routera to `172.16.16.1`, adres IP serwera w sieci LAN to `192.168.11.20`, a żądana domena to `rustdesk.przyklad.pl`. Posiadasz klienta korzystającego z adresu `192.168.11.2`.
Po skonfigurowaniu serwera za NAT routera można dodać przekierowanie portów w routerze, aby wszystkie przychodzące wiadomości kierowane na PUBLICZNY adres IP 172.16.16.1 były przekazywane do serwera pod adresem 192.168.11.20.
Gdy urządzenie LAN chce uzyskać dostęp do Internetu, na przykład do serwera WWW pod adresem 8.8.8.8, wysyła żądanie jako pochodzące z adresu 192.168.11.2 i kieruje je do routera. Router przechwytuje to żądanie i przepisuje je na adres 8.8.8.8 jako pochodzące z adresu 172.16.16.1. Kiedy adres 8.8.8.8 odpowiada na adres 172.16.16.1, router sprawdza poprzednie połączenie i przekierowuje odpowiedź z powrotem na adres 192.168.11.2.
Jeśli użytkownik pod adresem 8.8.8.8 wyśle wiadomość do naszej sieci, używając adresu 172.16.16. 1, reguła przekierowania portów zmieni adres docelowy 172.16.16.1 na serwer pod adresem 192.168.11.20, pozostawiając źródło żądania jako 8.8.8.8, dzięki czemu serwer może odpowiedzieć (mniej więcej) bezpośrednio na adres 8.8.8.8.
Jeśli użytkownik pod adresem 8.8.8.8 zdecyduje się na próbę włamania do naszej sieci i twierdzi, że wysyła wiadomości z adresu 192.168.11.2, router wie, że ruch pochodzący z adresu 192.168.11.2 jest ważny tylko z urządzeń sieci LAN i zazwyczaj blokuje ten ruch.
Problem pojawia się, gdy próbujesz połączyć się z siecią LAN. Jeśli urządzenie LAN próbuje połączyć się z `rustdesk.przyklad.pl`, które będzie miało adres `172.16.16.1`. W tym momencie router ma wiele możliwości do wyboru. Właśnie wysłał wiadomość ze swojego portu LAN do portu WAN, pochodzącą z adresu 192.168.11.2 i kierowaną do adresu 172.16.16.1. Po dotarciu do portu WAN wiadomość ta jest nie do odróżnienia od powyższego przykładu, w którym ktoś z Internetu próbował włamać się do naszej sieci.
Funkcja pętli zwrotnej NAT skutecznie zmieni część adresu źródłowego "z 192.168.11.2" we wcześniejszym etapie procesu, aby wiedzieć, że musi użyć tabeli NAT do przesyłania wiadomości między serwerem a klientem.
Jeśli problem z połączeniem występuje tylko wtedy, gdy znajdujesz się w sieci LAN, ale działa ono poprawnie poza nią, może to być przyczyną twojego problemu.
## Rozwiązania
Istnieją trzy sposoby rozwiązania tego problemu.
### 1. Skonfiguruj NAT Loopback na routerze
Jeśli wiesz, jak to zrobić, możesz skonfigurować pętlę zwrotną NAT na swoim routerze, ale wymaga to wiedzy z zakresu sieci. Niektóre routery nie mają możliwości dostosowania tego ustawienia, więc nie jest to najlepsza opcja dla wszystkich.
{{% notice note %}}
Artykuł opublikowany przez [MikroTik](https://help.mikrotik.com/docs/display/ROS/NAT#NAT-HairpinNAT) bardzo dobrze wyjaśnia tę kwestię. Możesz zacząć naukę od tego miejsca.
{{% /notice %}}
### 2. Wdróż serwer DNS w sieci LAN.
Najpierw wybierz, który wolisz: [AdGuard Home](https://github.com/AdguardTeam/AdGuardHome/wiki/Docker) czy [Pi-hole](https://github.com/pi-hole/docker-pi-hole). Możesz to wdrożyć przez dockera albo na tym samym serwerze co serwer RustDeska. Poniższy przykład pokaże Ci kilka kroków, jak to zrobić.
Oba są blokerami reklam opartymi na DNS, ale można wyłączyć tę funkcję, jeśli nie chcesz blokować reklam.
Najpierw skieruj swoją `domenę` na adres IP sieci LAN serwera RustDesk (na przykład `192.168.11.20`). Następnie przejdź do ustawień `DHCP` routera (uwaga: NIE WAN) i ustaw `pierwszy` adres IP DNS na serwer, na którym wdrożyłeś AdGuard Home lub Pi-hole. `Drugim` adresem DNS może być DNS dostawcy usług internetowych lub inny publiczny DNS, np. `1.1.1.1` (Cloudflare) lub `8.8.8.8` (Google). Gotowe!
Oto przykład:
#### AdGuard Home
Blokowanie reklam może powodować problemy. Jeśli nie chcesz szukać rozwiązania i chcesz wyłączyć tę funkcję, kliknij przycisk "Wyłącz ochronę".
![](/docs/en/self-host/nat-loopback-issues/images/adguard_home_disable_protection.png)
<br>
Przejdź do ustawień "Przepisywanie DNS" (_DNS Rewrites_).
![](/docs/en/self-host/nat-loopback-issues/images/adguard_home_click_dns_rewrites.png)
<br>
Kliknij "Dodaj przepisywanie DNS", a następnie wpisz swoją `domenę` i `adres IP w sieci LAN` serwera w polu.
![](/docs/en/self-host/nat-loopback-issues/images/adguard_home_dns_rewrite_dialog.png)
Oto jak wygląda efekt końcowy.
![](/docs/en/self-host/nat-loopback-issues/images/adguard_home_dns_rewrite_final_result.png)
***Nie zapomnij przypisać AdGuard Home do DHCP sieci LAN routera!***
<hr>
#### Pi-hole
Blokowanie reklam może powodować problemy. Jeśli nie chcesz szukać rozwiązania i chcesz wyłączyć tę funkcję, kliknij przycisk "Na stałe" w podmenu "Wyłącz blokowanie".
![](/docs/en/self-host/nat-loopback-issues/images/pi_hole_disable_blocking.png)
Przejdź do "Lokalny DNS → Rekordy DNS".
Wpisz swoją `domenę` i adres `IP` w polu, a następnie kliknij "Dodaj".
Aby sprawdzić ostateczne wyniki, spójrz na żółte linie na tym zdjęciu.
![](/docs/en/self-host/nat-loopback-issues/images/pi_hole_local_dns_dns_records.png)
***Nie zapomnij przypisać swojego Pi-hole do DHCP sieci LAN routera!***
### 3. Dodaj reguły do pliku hosts
Ta metoda jest zalecana tylko w przypadku niewielkiej liczby urządzeń. Jeśli masz wiele urządzeń, preferowana jest metoda DNS. W przeciwnym razie musiałbyś wykonać tę czynność ręcznie na każdym urządzeniu, które wymaga dostępu do serwera.
{{% notice warning %}}
Jeśli ta metoda zostanie zastosowana na urządzeniu przenośnym, takim jak laptop, nie będzie ono mogło połączyć się z serwerem poza siecią LAN.
{{% /notice %}}
Ścieżka dla różnych systemów operacyjnych:
#### Windows
```text
C:\Windows\system32\drivers\etc\hosts
```
Możesz edytować ten plik z podwyższonymi uprawnieniami lub skopiować go na `Pulpit` i edytować tam. Po zakończeniu edycji skopiuj plik z powrotem do oryginalnej lokalizacji.
#### macOS
```text
/etc/hosts
```
Możesz użyć programu `vim`, który jest preinstalowany.
```sh
sudo vim /etc/hosts
```
#### Linux
```text
/etc/hosts
```
Możesz użyć `vim` lub `nano`.
```sh
sudo vim /etc/hosts
```
<hr>
Format jest taki sam we wszystkich trzech systemach operacyjnych. Najpierw `IP`, a następnie `domena`. Jedna pozycja w każdym wierszu.
Przykładowo:
```text
192.168.11.20 rustdesk.przyklad.pl
```

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

@ -0,0 +1,135 @@
---
title: Docker
weight: 7
---
> Tutaj jest inny dobry poradnik: [Tworzenie własnego rozwiązania zdalnego pulpitu: RustDesk hostowany samodzielnie w chmurze za pomocą Dockera (Hetzner)](https://www.linkedin.com/pulse/building-your-own-remote-desktop-solution-rustdesk-cloud-montinaro-bv94f)
## Zainstaluj twój własny serwer za pomocą Dockera
### Wymagania
Potrzebujesz zainstalowanego Dockera/Podmana aby uruchomić rustdesk-server jako kontener Dockerowy. W razie wątpliwości, zainstaluj Dockera przy użyciu tego [poradnika](https://docs.docker.com/engine/install) aby upewnić się, że wszystko jest aktulane.
Upewnij się, że zezwoliłeś na te porty w zaporze:
- `hbbs`:
- `21114` (TCP): używany do konsoli webowej, dostępnej wyłącznie w wersji `Pro`.
- `21115` (TCP): używany do testowania typu NAT.
- `21116` (TCP/UDP): **Zwróć uwagę, że `21116` powinien być zezwolony zarówno dla TCP jak i UDP.** `21116/UDP` jest używany do rejestracji ID i usługi heartbeat. `21116/TCP` jest używany do przebijania się przez NAT (TCP) i usługi połączeniowej.
- `21118` (TCP): używany do obsługi klientów webowych.
- `hbbr`:
- `21117` (TCP): używany do usług serwera przekaźnikowego.
- `21119` (TCP): używany do obsługi klientów webowych.
*Jeżeli nie potrzebujesz obsługi klientów webowych, porty `21118` i `21119` mogą zostać zablokowane.*
### Przykłady z Dockerem
```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` działa wyłącznie na **Linuxie** i sprawia, że `hbbs`/`hbbr` widzi prawdziwy przychodzący adres IP, a nie adres kontenera (172.17.0.1).
Jeżeli `--net=host` działa poprawnie, parametry `-p` nie są używany. Jeżeli działasz na Windowsie, nie używaj `sudo` ani `--net=host`.
**Usuń `--net=host` jeżeli masz problemy z połączeniem na twojej platformie.**
{{% /notice %}}
{{% notice note %}}
Jeżeli nie widzisz logów używając `-td`, możesz podejrzeć logi za pomocą `docker logs hbbs`. Możesz także uruchomić kontenery za pomocą `-it`, wtedy `hbbs/hbbr` nie zostaną uruchomione w trybie daemona.
{{% /notice %}}
### Przykłady z Docker Composem
Aby uruchomić pliki Docker z plikiem `compose.yml` zgodnie z opisem tutaj, musisz mieć zainstalowany [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
```
Jeśli chcesz wprowadzić zmiany w konfiguracji, np. ustawić ALWAYS_USE_RELAY=Y, możesz ustawić zmienne środowiskowe w pliku 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
```
### Przykłady z Podmanem Quadlet
Jeśli chcesz uruchomić kontenery za pomocą Podman jako usługę systemd, możesz skorzystać z poniższych przykładowych konfiguracji Podman Quadlet:
```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
```
or
```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.pl.md Executable file
View File

@ -0,0 +1,13 @@
---
title: Serwer RustDeska - open source
weight: 100
pre: "<b>2.1. </b>"
---
Dołącz do naszego [Discorda](https://discord.com/invite/nDceKgxnkV) jeżeli chciałbyś pogadać z nami o samodzielnym hostowaniu twojego [open sourcowego serwera RustDeska](https://github.com/rustdesk/rustdesk-server).
{{% notice note %}}
Jeżeli postawisz serwer w twoim domu/biurze i nie jesteś w stanie połączyć się przez publiczne IP/domenę, sprawdź [ten artykuł](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.pl.md Normal file
View File

@ -0,0 +1,52 @@
---
title: Instalacja
weight: 1
---
## Poradniki wideo
Na YouTubie znajduje się wiele poradników, https://github.com/rustdesk/rustdesk/wiki/FAQ#video-tutorials.
## Wymagania sprzętowe
Wymagania sprzętowe są bardzo niskie; wystarczy podstawowa konfiguracja serwera w chmurze, a wymagania dotyczące procesora i pamięci są minimalne. Można również użyć Raspberry Pi lub podobnego urządzenia. Jeśli chodzi o rozmiar sieci, w przypadku niepowodzenia bezpośredniego połączenia przebijania się przez NAT (TCP), użyty zostanie ruch przekaźnikowy. Ruch połączenia przekaźnikowego wynosi od 30 K/s do 3 M/s (ekran 1920x1080) w zależności od ustawień rozdzielczości i aktualizacji ekranu. Jeśli jest to tylko do celów pracy biurowej, ruch wynosi około 100 K/s.
## Zapora sieciowa
Jeśli masz zainstalowany program UFW, użyj następujących poleceń, aby skonfigurować zaporę sieciowa:
```
ufw allow 21114:21119/tcp
ufw allow 21116/udp
sudo ufw enable
```
## Instalacja
### Metoda 1.: Docker (zalecana)
```
bash <(wget -qO- https://get.docker.com)
wget rustdesk.com/oss.yml -O compose.yml
sudo docker compose up -d
```
Po więcej szczegółów, sprawdź [Docker](/docs/pl/self-host/rustdesk-server-oss/docker/).
### Metoda 2.: Zainstaluj własny serwer jako usługę systemd za pomocą prostego skryptu instalacyjnego
Skrypt jest hostowany na koncie [Techaholda](https://github.com/techahold/rustdeskinstall) i wspierany na naszym [Discordzie](https://discord.com/invite/nDceKgxnkV).
Obecnie skrypt pobiera i konfiguruje serwery przekaźnikowe i sygnałowe (hbbr i hbbs), generuje konfiguracje i umieszcza je na stronie internetowej chronionej hasłem, aby ułatwić wdrażanie u klientów.
Wykonaj następujące polecenia:
```
wget https://raw.githubusercontent.com/techahold/rustdeskinstall/master/install.sh
chmod +x install.sh
./install.sh
```
W repozytorium [Techaholda](https://github.com/techahold/rustdeskinstall) znajduje się również skrypt aktualizacyjny.
Następnie zapisz adres IP/DNS i klucz wyświetlone na końcu instalacji i wprowadź je odpowiednio w ustawieniach klienta > Sieć > Serwer identyfikacyjny/serwer przekaźnikowy w polach `Serwer ID` i `Klucz`, pozostawiając pozostałe pola puste (patrz uwaga poniżej).
### Metoda 3.: Zainstaluj własny serwer jako usługę systemd przy użyciu pliku deb dla dystrybucji Debiana
Musisz samodzielnie [pobrać](https://github.com/rustdesk/rustdesk-server/releases/latest) pliki deb i zainstalować je za pomocą polecenia `apt-get -f install <nazwa pliku>.deb` lub `dpkg -i <nazwa pliku>.deb`.
## Skonfiguruj klienta
Sprawdź ten [artykuł](/docs/pl/self-host/client-configuration/#2-ręczna-konfiguracja).

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

@ -0,0 +1,10 @@
---
title: Synology
weight: 22
---
Synology oferuje dwa rodzaje Dockerów: "Docker" i "Container Manager". Jeśli korzystasz z DSM 7.2 lub nowszej wersji, postępuj zgodnie z instrukcją dla DSM 7.2. Jeśli korzystasz ze starszej wersji systemu, postępuj zgodnie z instrukcją dla DSM 6.
Jeśli korzystasz z Synology z Portainerem, zapoznaj się z [tym samouczkiem](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.pl.md Normal file
View File

@ -0,0 +1,71 @@
---
title: Synology DSM 6
weight: 22
---
> Alternatywny, aktualny samouczek od strony trzeciej znajduje się [tutaj](https://mariushosting.com/how-to-install-rustdesk-on-your-synology-nas/).
Ten samouczek oparty jest na najnowszych wersjach DSM v6 i v7.
{{% notice note %}}
Po aktualizacji DSM 7.2 program Docker został zaktualizowany do nowej wersji „Container Manager”. Zapoznaj się z [tym artykułem](/docs/en/self-host/rustdesk-server-oss/synology/dsm-7).
{{% /notice %}}
## Zainstaluj Dockera
| Open Package Center | Zainstaluj Dockera |
| --- | --- |
| ![](/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) |
## Zainstaluj serwer RustDeska
| Wyszukaj rustdesk-server w rejestrze Docker i zainstaluj, klikając dwukrotnie | Po zainstalowaniu obrazu rustdesk-server, kliknij dwukrotnie, aby utworzyć kontener |
| --- | --- |
| ![](/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) |
## Stwórz kontener hbbs
Jak wspomniano powyżej, kliknij dwukrotnie obraz rustdesk-server, aby utworzyć nowy kontener, i nadaj mu nazwę `hbbs`.
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/hbbs.png)
Naciśnij na powyższe `Zaawansowane ustawienia`.
- Włącz `Włącz auto-restart`.
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/auto-restart.png)
- Włącz opcję `Użyj tej samej sieci co host Dockera`. Więcej informacji na temat sieci hosta można znaleźć [tutaj](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)
- Zamontuj katalog hosta (np. `/home/rustdesk/`) do `/root`, hbbs wygeneruje w tym katalogu kilka plików (bazy danych i pliki `key`), które muszą być zachowane po ponownym uruchomieniu systemu.
| Punkt montowania | Pliki wygenerowane w katalogu hosta |
| --- | --- |
| ![](/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) |
- Ustaw polecenie
{{% notice note %}}
System operacyjny Synology jest oparty na Debianie, więc host net (--net=host) działa poprawnie, nie musimy mapować portów za pomocą opcji `-p`.
{{% /notice %}}
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/hbbs-cmd.png?v3)
- Gotowe
## Create hbbr container
Please repeat above `hbbs` steps, but name the container `hbbr` and command (for Set Command Step) should be `hbbr`.
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/hbbr-config.png)
## Kontenery hbbr/hbbs
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-6/images/containers.png)
| Kliknij dwukrotnie na kontener i sprawdź logi | Sieć kontenerów |
| --- | --- |
| ![](/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) |
## Pobierz swój Klucz
Przed użyciem File Station przejdź do folderu setup, pobierz plik `id_ed25519.pub` i otwórz go w edytorze tekstowym, aby uzyskać dostęp do swojego klucza.

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

@ -0,0 +1,89 @@
---
title: Synology DSM 7.2
weight: 20
---
<!-- Dla tłumaczy: Tłumacząc elementy takie jak "przyciski", nie tłumaczcie ich po prostu, ale odwołajcie się do rzeczywistych nazw w interfejsie. -->
Po aktualizacji DSM 7.2 firma Synology zmieniła nazwę pakietu "Docker" na "Container Manager". Pakiet ten posiada nowy interfejs graficzny i zawiera narzędzie "docker-compose", które ułatwia tworzenie kontenerów Docker.
## Obsługiwane modele i wymagania
Container Manager zapewnia obsługę ARM64 dla niektórych modeli z niższej półki, takich jak seria J. Szczegółową listę obsługiwanych modeli można znaleźć na [stronie internetowej Synology](https://www.synology.com/en-us/dsm/packages/ContainerManager).
W większości przypadków nie ma potrzeby instalowania dodatkowej pamięci RAM w celu zainstalowania Dockera i serwra RustDeska.
## 1. Zainstaluj menedżera kontenerów (Docker)
Otwórz "Package Center", wyszukaj i zainstaluj "Container Manager".
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-7/images/dsm7_install_container_manager_though_package_center.png)
## 2. Stwórz folder
Po zainstalowaniu programu "Container Manager" zostanie utworzony folder współdzielony o nazwie `docker`. Umieśćmy w nim dane naszego serwera.
Otwórz File Station, utwórz folder o nazwie `rustdesk-server` (lub dowolnej innej). Następnie utwórz w nim folder o nazwie `data`, tak jak na obrazku.
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-7/images/dsm7_create_required_folders.png)
## 3. Stwórz kontener
Otwórz "Container Managera", przejdź do "Project" i naciśnij "Create".
Wpisz nazwę projektu `rustdesk-server` i zmień opcję "Source" z "Upload compose.ym" na "Create compose.yml", a następnie skopiuj poniższą treść do pola.
![](/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 # Jeśli chcesz zainstalować wersję Pro, zmień to na rustdesk/rustdesk-server-pro:latest.
command: hbbs
volumes:
- ./data:/root
network_mode: host
depends_on:
- hbbr
restart: always
hbbr:
container_name: hbbr
image: rustdesk/rustdesk-server:latest # Jeśli chcesz zainstalować wersję Pro, zmień to na rustdesk/rustdesk-server-pro:latest.
command: hbbr
volumes:
- ./data:/root
network_mode: host
restart: always
# Ponieważ używasz trybu hosta Docker
# Na wypadek, gdybyś zapomniał numery portów:
# 21114 TCP dla konsoli webowej, dostępny tylko w wersji Pro
# 21115 TCP dla testu typu NAT
# 21116 TCP dla funkcji przebijania przez NAT
# 21116 UDP dla serwera heartbeat/ID
# 21117 TCP dla przekaźnika
```
Pomiń `Web portal settings`, a następnie zakończ.
## 4. Sprawdź czy działa
Otwórz File Station, w folderze `docker/rustdesk-server/data` powinny znajdować się pliki `id_ed25519` i `id_ed25519.pub`. Możesz je pobrać i otworzyć w dowolnym edytorze tekstowym lub użyć [Synology Text Editor](https://www.synology.com/en-us/dsm/packages/TextEditor). Jest to klucz publiczny potrzebny do klienta RustDeska.
Klucz publiczny będzie wyglądał następująco:
![](/docs/en/self-host/rustdesk-server-oss/synology/dsm-7/images/dsm7_viewing_public_key_though_syno_text_editor.png)
Sprawdź [tutaj](/docs/pl/client), aby skonfigurować swojego klienta. Potrzebne są tylko `serwer ID` i `klucz`. `Serwer przekaźnikowy` nie jest potrzebny, ponieważ ustawiliśmy go w `hbbs`, a `hbbs` automatycznie dostarczy te informacje.
## 5. Skonfiguruj przekierowanie portów w routerze
Przejdź do strony administracyjnej routera, znajdź wszystko, co dotyczy `Przekierowania portów` – powinno to znajdować się w ustawieniach `WAN` lub `Zapora sieciowa`.
Jeśli nadal nie możesz znaleźć tego ustawienia, wyszukaj w Google `{marka routera} + przekierowanie portów` lub `{model routera} + przekierowanie portów`. Jeśli to urządzenie pochodzi od twojego dostawcy usług internetowych, zapytaj go o to.
Otwórz następujące wymagane porty:
* `21114` TCP dla konsoli webowej, dostępnej tylko w wersji Pro
* `21115` TCP dla testu typu NAT
* `21116` TCP przebijanie przez NAT (TCP)
* `21116` UDP heartbeat/serwer ID
* `21117` TCP serwer przekaźnikowy

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

@ -0,0 +1,122 @@
---
title: Windows & PM2 lub NSSM
weight: 20
---
{{% notice note %}}
Polityka bezpieczeństwa systemu Windows jest skomplikowana. Jeśli ten samouczek nie działa lub występują problemy z połączeniem, przejdź na serwer z systemem Linux.
{{% /notice %}}
{{% notice note %}}
Wersja GUI, `RustDeskServer.setup.exe`, nie jest już wspierana i nie jest zalecana.
{{% /notice %}}
## Wybór
Masz teraz dwie możliwości: możesz użyć PM2 (łatwiejsze) lub NSSM (nieco trudniejsze) do uruchomienia serwera RustDeska.
Korzystanie z NSSM ma kilka zalet:
- Kompatybilność wsteczna ze starszymi wersjami systemu Windows (Windows Server 2008 R2/Windows 7 i wcześniejsze, choć nie zostało to przetestowane).
- Idealne rozwiązanie dla systemu Windows Server.
- Automatyczne uruchamianie podczas startu systemu bez konieczności logowania (użytkownik, który utworzył wpis startowy, nie musi się logować, aby uruchomić program).
- Uruchamianie obu plików binarnych jako usług.
- Samodzielne działanie (brak zależności od Node.js).
Zalety PM2 obejmują:
- Dobry rozwiązanie, jeśli serwer działa na tym samym komputerze, co główny komputer roboczy
- Regularne logowanie się na konto użytkownika, który utworzył wpis startowy RustDeska
- Bardziej przyjazny dla użytkownika
## Instalacja za pomocą NSSM
### Instalacja NSSM
Proszę [pobrać](https://github.com/dkxce/NSSM/releases/download/v2.25/NSSM_v2.25.zip) i rozpakować NSSM, wybierając odpowiednią
architekturę dla systemu Windows (w przypadku x86 należy użyć zawartości folderu win32, a w przypadku x64 zawartości
folderu win64). Najlepszą praktyką jest również przeniesienie pliku binarnego NSSM do katalogu
`Pliki programów\NSSM` (po uruchomieniu NSSM jako usługi nie można go przenieść z katalogu, w którym został umieszczony,
dlatego najlepiej jest umieścić go w katalogu `Pliki programów`) na dysku instalacyjnym (zwykle dysk C:).
Zaleca się również dodanie ścieżki (np. `C:\Program Files\NSSM`) do zmiennej ścieżki.
### Czy NSSM jest poprawnie zainstalowany
Jeśli wszystko zostało wykonane poprawnie, folder `C:\Program Files\NSSM` (w tym przykładzie używam dysku C:,
ale można użyć dowolnego dysku, na którym zainstalowano system Windows, lub dowolnej ścieżki) powinien
zawierać tylko plik `nssm.exe`.
W tym przykładzie użyjemy `C:\Program Files\NSSM`.
Otwórz wiersz polecenia i uruchom `nssm`. Jeśli pojawi się strona pomocy, możesz przejść do następnego kroku.
### Uruchom hbbr i hbbs
Pobierz wersję [serwera RustDeska](https://github.com/rustdesk/rustdesk-server/releases) dla systemu Windows.
Rozpakuj program do katalogu `C:\Program Files\RustDesk Server` (lub dowolnego innego miejsca, ale upewnij się, że
nie ulegnie ono zmianie po zainstalowaniu usługi). Teraz wróć do wiersza poleceń.
W tym przykładzie będziemy używać `C:\Program Files\RustDesk Server`.
```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”
```
**Uwaga:**
- Możesz zmienić nazwę `RustDesk hbbs service` na dowolną nazwę usługi hbbs.
- Możesz zmienić nazwę `RustDesk hbbr service` na dowolną nazwę usługi hbbr.
- Możesz zmienić `C:\Program Files\RustDesk Server\hbbs.exe` na lokalizację, w której umieściłeś pliki binarne RustDeska.
- Możesz zmienić `C:\Program Files\RustDesk Server\hbbr.exe` na lokalizację, w której umieściłeś pliki binarne RustDeska.
**Szablony poleceń:**
Szablon polecenia, który można skopiować, wkleić i edytować.
```cmd
nssm install <Pożądana nazwa usługi hbbs> <Ścieżka do plików binarnych RustDesk hbbs> <Argumenty RustDesk hbbs>
nssm install <Pożądana nazwa usługi hbbr> <Ścieżka do plików binarnych RustDesk hbbr> <Argumenty RustDesk hbbr>
```
**Uruchom usługi**
Po pomyślnym zainstalowaniu usług należy je uruchomić.
```cmd
nssm start <Nazwa żądanej usługi hbbs>
nssm start <Nazwa żądanej usługi hbbr>
```
**Gotowe!**
(Powyższa metoda została przetestowana w systemie Windows Server Core 2022 Standard).
## lub
## Instalacja za pomocą PM2
### Zainstaluj Node.js
[Pobierz](https://nodejs.org/dist/v16.14.2/node-v16.14.2-x86.msi) i zainstaluj Node.js.
Node.js jest środowiskiem uruchomieniowym PM2, więc najpierw należy zainstalować Node.js.
### Zainstaluj PM2
Wpisz poniższe polecenia w `cmd.exe`, naciśnij klawisz <kbd>Enter</kbd> po każdym wierszu i uruchom je po kolei.
```cmd
npm install -g pm2
npm install pm2-windows-startup -g
pm2-startup install
```
### Uruchom hbbr i hbbs
Pobierz wersję [serwera RustDeska](https://github.com/rustdesk/rustdesk-server/releases) dla systemu Windows. Rozpakuj program na dysk C:. Uruchom następujące cztery polecenia:
```cmd
cd C:\rustdesk-server-windows-x64
pm2 start hbbs.exe
pm2 start hbbr.exe
pm2 save
```
### Wyświetl logi
```cmd
pm2 log hbbr
pm2 log hbbs
```
## Alternatywne poradniki
https://pedja.supurovic.net/setting-up-self-hosted-rustdesk-server-on-windows/?lang=lat

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

@ -0,0 +1,98 @@
---
title: 2FA
weight: 16
---
Po zalogowaniu się na swoje konto włączenie weryfikacji dwuskładnikowej (2FA) może poprawić bezpieczeństwo konta.
Nasza konsola webowa obsługuje obecnie dwa rodzaje uwierzytelniania dwuskładnikowego (2FA):
1. Weryfikacja emailowa
2. TOTP. Do wygenerowania kodu weryfikacyjnego wymagana jest aplikacja uwierzytelniająca, taka jak [Authy](https://authy.com), [Microsoft Authenticator](https://www.microsoft.com/en-us/security/mobile-authenticator-app/) albo [Google Authenticator](https://play.google.com/store/apps/details?id=com.google.android.apps.authenticator2).
Najpierw musisz przejść do strony ustawień konta.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/1-settings-account.png)
## Weryfikacja emailowa
Aby włączyć weryfikację emailową podczas logowania, potrzebujesz:
1. Ustawić adres e-mail.
2. Włącz opcję `Włącz weryfikację logowania za pomocą adresu e-mail`.
3. Naciśnij na `Zatwierdź`.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/2-2fa-email-1.png)
Kiedy zalogujesz się następnym razem, RustDesk wyśle ci emaila z kodem weryfikacyjnym, a strona internetowa przejdzie do strony weryfikacyjnej.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/2-2fa-email-2.png)
## TOTP
TOTP jest powszechnie stosowaną metodą uwierzytelniania dwuskładnikowego (2FA), dlatego w konsoli internetowej serwera RustDesk Pro termin 2FA odnosi się do weryfikacji TOTP.
### Przygotyuj aplikację uwierzytelniającą
Najpierw należy przygotować aplikację uwierzytelniającą.
Możesz wybrać jedną z następujących aplikacji uwierzytelniających: [Authy](https://authy.com), [Microsoft Authenticator](https://www.microsoft.com/en-us/security/mobile-authenticator-app/) albo [Google Authenticator](https://play.google.com/store/apps/details?id=com.google.android.apps.authenticator2).
### Włącz 2FA
Gdy na stronie ustawień wyświetla się przycisk `Włącz 2FA`, oznacza to, że funkcja 2FA nie jest obecnie włączona.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-1.png)
Kliknij przycisk, a pojawi się formularz umożliwiający włączenie uwierzytelniania dwuskładnikowego (2FA).
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-2.png)
Otwórz aplikację uwierzytelniającą i dodaj konto, skanując kod QR.
Jeśli nie możesz zeskanować kodu QR, możesz również wprowadzić kod ręcznie.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-3.png)
Po dodaniu konta w aplikacji uwierzytelniającej wprowadź kod weryfikacyjny w aplikacji uwierzytelniającej, aby włączyć 2FA.
Po pomyślnym włączeniu funkcji 2FA, serwer RustDeska zostanie również powiązany z 6 **kodami zapasowymi**. Dzięki temu będziesz mógł użyć tych **kodów zapasowych** do przejścia weryfikacji, nawet jeśli nie będziesz mógł skorzystać z aplikacji uwierzytelniającej.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-4.png)
{{% notice note %}}
1. Te kody zapasowe możesz wykorzystać tylko raz.
2. Przechowuj kody zapasowe w bezpiecznym miejscu.
{{% /notice %}}
### Weryfikacja logowania
Po włączeniu funkcji 2FA weryfikacja logowania za pomocą emailowa nie będzie już stosowana. Zamiast tego będziemy stosować weryfikację logowania za pomocą funkcji 2FA.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-login-5.png)
Po zalogowaniu zostaniesz przekierowany na stronę weryfikacyjną.
![](/docs/en/self-host/rustdesk-server-pro/2fa/images/3-2fa-enable-login-6.png)
### Modyfikacja ustawień
Po włączeniu funkcji 2FA modyfikacja ustawień konta wymaga dodatkowej weryfikacji 2FA.
![](/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)
### Stan 2FA
2FA ma łącznie 3 stany: nieaktywny, aktywny i wygasły.
![](/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 %}}
Po wygaśnięciu 2FA nadal można z niego normalnie korzystać. Oznacza to po prostu, że ustawienia 2FA nie były zmieniane przez dłuższy czas (domyślnie 180 dni). Ze względów bezpieczeństwa zalecamy ponowne włączenie 2FA, aby można było zaktualizować tajne dane.
{{% /notice %}}

103
content/self-host/rustdesk-server-pro/_index.pl.md Normal file
View File

@ -0,0 +1,103 @@
---
title: Serwer RustDeska Pro
weight: 200
pre: "<b>2.2. </b>"
---
Serwer RustDesk Pro oferuje więcej funkcji w porównaniu z wersją open source.
- Zarządzanie kontami
- [Konsola webowa](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/console/)
- [API](https://github.com/rustdesk/rustdesk/wiki/FAQ#api-of-rustdesk-server-pro)
- Integracje: [OIDC](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/oidc/), [LDAP](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/ldap/), [2FA](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/2fa/)
- Książka adresowa
- Zarządzanie logami (połączenia, transfer plików, alarmy itp.)
- Zarządzanie urządzeniami
- [Synchronizacja ustawień bezpieczeństwa](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/strategy/)
- [Kontrola dostępu](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/permissions/)
- [Wiele serwerów przekaźnikowych](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/relay/) (automatyczny wybór najbliższego)
- [Generator niestandardowego klienta](https://rustdesk.com/docs/pl/self-host/client-configuration/#1-generator-klientów-wyłącznie-wersja-Pro-z-planem-podstawowym-lub-dostosowanym)
- WebSocket
- Samodzielny hosting klienta webowego
{{% notice note %}}
Jeśli hostujesz serwer w domu/biurze i nie możesz go połączyć przez publiczny IP/domenę, sprawdź [ten artykuł](https://rustdesk.com/docs/pl/self-host/nat-loopback-issues/).
{{% /notice %}}
{{% notice note %}}
Zalecamy najpierw przeczytać: [Jak działa samodzielnie hostowany serwer?](/docs/pl/self-host/#jak-działa-samodzielnie-hostowany-serwer).
{{% /notice %}}
## Wymagania sprzętowe
Podstawowy VPS wystarczy do większości zastosowań. Oprogramowanie serwera nie jest wymagające pod względem CPU i pamięci. Nasz publiczny serwer ID hostowany na VPS 2 CPU/4 GB obsługuje ponad 1 milion punktów końcowych. Każde połączenie przekaźnikowe zużywa średnio 180 kb/s. 1 rdzeń CPU i 1 GB RAM wystarczą dla 1000 równoczesnych połączeń.
## Przewodniki krok po kroku
[Samodzielny hosting serwera RustDesk Pro w chmurze przez Docker](https://www.linkedin.com/pulse/step-by-step-guide-self-host-rustdesk-server-pro-cloud-montinaro-fwnmf/)
## Instrukcje wideo
[Poradnik dla początkujących](https://www.youtube.com/watch?v=MclmfYR3frk)
[Poradnik dla zaawansowanych](https://youtu.be/gMKFEziajmo)
## Licencja
Licencje dostępne są na https://rustdesk.com/pricing.html. Więcej szczegółów na [stronie licencji](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/license/).
## Rozpoczęcie pracy
### 1. Instalacja
```
bash <(wget -qO- https://get.docker.com)
wget rustdesk.com/pro.yml -O compose.yml
sudo docker compose up -d
```
Więcej szczegółów w dokumentacji [Dockera](/docs/pl/self-host/rustdesk-server-pro/installscript/docker/).
### 2. Wymagane porty
Należy otworzyć porty TCP `21114`-`21119` oraz UDP `21116`. Upewnij się, że są poprawnie skonfigurowane w zaporze sieciowej i mapowaniu portów Dockera.
Więcej informacji o portach [tutaj](/docs/pl/self-host/rustdesk-server-oss/install/#porty).
### 3. Konfiguracja licencji
Dostęp do konsoli webowej: `http://<adres IP serwera>:21114`. Domyślne dane logowania: `admin`/`test1234`. Instrukcja konfiguracji licencji [tutaj](/docs/pl/self-host/rustdesk-server-pro/license/#aktywacja-licencji).
### 4. Konfiguracja HTTPS dla konsoli webowej
> Możesz pominąć ten krok podczas okresu próbnego, ale pamiętaj o zmianie adresu API w kliencie po włączeniu HTTPS
Prosty przewodnik [ręcznej konfiguracji HTTPS](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/faq/#ręczna-konfiguracja-https-dla-konsoli-webowej).
### 5. Konfiguracja klienta
https://rustdesk.com/docs/en/self-host/client-configuration/
### 6. Konfiguracja WebSocket
Aby włączyć obsługę klienta webowego lub [desktop/mobilnego](/docs/pl/self-host/client-configuration/advanced-settings/#allow-websocket), dodaj następujące ustawienia do konfiguracji reverse proxy:
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
## Aktualizacja serwera
[Przewodnik aktualizacji](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/faq/#jak-zaktualizować-RustDesk-Server-Pro-do-nowej-wersji) dla różnych metod instalacji.
## Migracja i backup
Szczegółowy [samouczek migracji](https://github.com/rustdesk/rustdesk-server-pro/discussions/184).
## Migracja licencji
Instrukcje [tutaj](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/license/#faktury-odzyskiwanie-licencji-i-migracja).
## Rozszerzenie licencji
[Przewodnik](/docs/pl/self-host/rustdesk-server-pro/license/#odnawianierozszerzanie-licencji) dotyczący rozszerzenia licencji na więcej użytkowników i urządzeń.
## Bezpieczeństwo
https://github.com/rustdesk/rustdesk/discussions/9835

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

@ -0,0 +1,108 @@
---
title: Konsola webowa
weight: 10
---
Konsola webowa jest zintegrowana z serwerem RustDeska Pro i obsługiwana przez port `21114`.
Funkcje:
- Przeglądanie urządzeń
- Dodawanie/modyfikowanie użytkowników i grup użytkowników
- Modyfikowanie uprawnień dostępu do urządzeń
- Przeglądanie dzienników połączeń urządzeń i innych dzienników
- Aktualizowanie ustawień
- Zarządzanie strategiami synchronizacji ustawień klienta
- Zarządzanie współdzielonymi książkami adresowymi
- Generowanie niestandardowej kompilacji klienta
## Logowanie
Domyślny port konsoli webowej to 21114. Wpisz `http://<adres IP serwera>:21114` w przeglądarce, aby przejść do strony konsoli, jak pokazano na poniższym rysunku. Domyślna nazwa użytkownika/hasło administratora to `admin`/`test1234`:
![](/docs/en/self-host/rustdesk-server-pro/console/images/console-login.png)
Jeśli potrzebujesz obsługi protokołu HTTPS, zainstaluj serwer internetowy, taki jak `Nginx`, lub użyj `IIS` dla systemu Windows.
Po zalogowaniu się pamiętaj, aby zmienić hasło. Wybierz `Ustawienia` w menu konta w prawym górnym rogu, aby przejść do strony zmiany hasła, jak pokazano na poniższym rysunku. Możesz również utworzyć inne konto administratora i usunąć domyślne. Zaleca się włączenie emailowej weryfikacji logowania.
<a name=console-home></a>
![](/docs/en/self-host/rustdesk-server-pro/console/images/console-home.png?v2)
Użytkownicy niebędący administratorami mogą również zalogować się, aby przeglądać swoje urządzenia i logi oraz zmieniać ustawienia użytkownika.
## Automatyczne konfiguracje
Klikając na `Windows EXE`, uzyskasz konfiguracje dla swojego serwera RustDeska Pro, co pomoże Ci skonfigurować klientów.
W przypadku klientów Windows możesz pominąć niestandardową konfigurację serwera i umieścić informacje konfiguracyjne w pliku `rustdesk.exe`. Jak pokazano powyżej, przejdź do strony powitalnej konsoli i kliknij na `Windows EXE`. **Wymagana wersja klienta ≥ 1.1.9.**
Możesz użyć tego w połączeniu z [konfiguracją klienta](https://rustdesk.com/docs/pl/self-host/client-configuration/) i [skryptami wdrożeniowymi](https://rustdesk.com/docs/pl/self-host/client-deployment/), aby skonfigurować swoich klientów.
## Tworzenie nowego użytkownika innego niż domyślny użytkownik `admin`
{{% notice note %}}
Plan `Indywidualny` nie posiada tej funkcji.
{{% /notice %}}
1. Kliknij `Użytkownicy` w menu po lewej stronie.
2. Utwórz kolejne konto z włączoną opcją `administrator`.
3. Zaloguj się na nowe konto administracyjne.
4. Usuń `admin` na stronie `Użytkownicy`.
## Tworzenie nowego użytkownika
1. Kliknij opcję `Użytkownicy` w menu po lewej stronie.
2. Utwórz nowego użytkownika.
3. Wybierz grupę, do której ma on należeć (jeśli chcesz dodać nowe grupy, czytaj dalej).
## Dodawanie nowej grupy
1. Kliknij `Grupy` w menu po lewej stronie.
2. Utwórz nową grupę.
3. Po utworzeniu możesz zezwolić grupom na wzajemny dostęp. Kliknij `Edytuj`.
4. Wybierz odpowiednie grupy, do których chcesz uzyskać dostęp (zostaną one automatycznie dodane do odpowiedniej grupy).
## Konfigurowanie wielu serwerów przekaźnikowych
1. Przejdź do `Ustawienia` w menu po lewej stronie.
2. Kliknij `Przekaźnik` w podmenu.
3. Kliknij `+` obok `Serwery przekaźnikowe`.
4. Wprowadź adres DNS lub adres IP serwera przekaźnikowego w wyświetlonym polu i naciśnij <kbd>Enter</kbd>.
5. Jeśli masz więcej niż jeden serwer retransmisyjny, możesz kliknąć `+` i w razie potrzeby dostosować ustawienia geograficzne (zapamiętaj i skopiuj swój klucz do pozostałych serwerów).
## Ustaw lub zmień licencję
1. Przejdź do `Ustawień` w menu po lewej stronie.
2. Kliknij `Licencja` w podmenu.
3. Kliknij `Edytuj` i wklej kod licencji.
4. Kliknij `OK`.
## Wyświetlanie logów
Po lewej stronie kliknij `Logi`.
## Konfiguracja poczty e-mail
W tym przykładzie użyto Gmaila
1. Przejdź do `Ustawienia` w menu po lewej stronie.
2. Kliknij `SMTP` w podmenu.
3. Wprowadź adres SMTP `smtp.gmail.com`.
4. Wprowadź port 587 w polu `Port SMTP`.
5. Wprowadź adres konta Gmail, np. `mojserwerrustdeska@gmail.com`, w polu `Konto pocztowe`.
6. Wprowadź hasło (możesz potrzebować hasła aplikacji).
7. Wprowadź adres swojego konta Gmail, np. `mojserwerrustdeska@gmail.com`, w polu `Od`.
8. Kliknij `Sprawdź`, aby zapisać.
## Przypisywanie użytkowników/grup/strategii/grup urządzeń do urządzeń
Użytkownik to użytkownik RustDeska zalogowany na urządzeniu lub przypisany do niego poprzez kliknięcie `Edytuj` obok urządzenia, kliknięcie pola `Użytkownik` i wybranie użytkownika z listy rozwijanej. Spowoduje to automatyczne przypisanie grupy na podstawie grupy, do której użytkownik został przypisany.
Można to również zrobić za pomocą interfejsu API w wierszu poleceń podczas wdrażania lub później, wywołując plik wykonywalny RustDesk, a następnie poleceniem `--assign --token <wygenerowanytoken> --user_name <nazwa_użytkownika>`. Aby to zrobić, należy przejść do `Ustawienia → Tokeny → Utwórz` i najpierw utworzyć token z uprawnieniami urządzenia. Przykładem w systemie Windows jest `"C:\Program Files\RustDesk\rustdesk.exe" --assign --token <wygenerowanytoken> --user_name <nazwa_użytkownika>`.
Możesz również przypisać strategię w ten sposób, np. `--assign --token <wygenerowanytoken> --strategy_name <nazwastrategii>`.
Możesz również przypisać książkę adresową w ten sposób, np. `--assign --token <wygenerowanytoken> --address_book_name <nazwaksiążkiadresowej>` lub `--assign --token <wygenerowanytoken> --address_book_name <nazwaksiążkiadresowej> --address_book_tag <znacznikksiążkiadresowej> --address_book_alias <alias>`. `--address_book_alias` wymaga serwera RustDeska Pro w wersji 1.5.8 lub nowszej i klienta w wersji 1.4.1.
Możesz również przypisać nazwę grupy urządzeń w ten sposób, np. `--assign --token <wygenerowanytoken> --device_group_name <nazwagrupyurządzeń>`.
Wiersz poleceń w systemie Windows domyślnie nie wyświetla wyników. Aby uzyskać wynik, uruchom polecenie w następujący sposób: `"C:\Program Files\RustDesk\rustdesk.exe" <arg1> <arg2> ... | więcej` lub `"C:\Program Files\RustDesk\rustdesk.exe" <arg1> <arg2> ... | Out-String`, patrz [tutaj](https://github.com/rustdesk/rustdesk/discussions/6377#discussioncomment-8094952).
## Wyszukiwanie urządzenia
1. Przejdź do sekcji Urządzenia.
2. W polu wyszukiwania nazwy urządzenia wpisz nazwę i kliknij `Szukaj` lub naciśnij <kbd>Enter</kbd>.
3. Aby użyć symbolu wieloznacznego, dodaj `%` na początku, na końcu lub w obu miejscach wyszukiwanego terminu.

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

@ -0,0 +1,534 @@
---
title: FAQ
weight: 600
---
## Jak zainstalować za pomocą prostego skryptu instalacyjnego?
1. Uzyskaj licencję ze strony [https://rustdesk.com/pricing.html](https://rustdesk.com/pricing.html). Więcej szczegółów znajdziesz na stronie [licencji](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/license/).
2. Przygotuj VPS, serwer fizyczny lub maszynę wirtualną z systemem Linux.
3. Jeśli chcesz użyć DNS i SSL, utwórz nazwę DNS, np. `rustdesk.twojadomena.com`.
4. Przejdź na [tę stronę](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/installscript/#install).
5. Skopiuj i wklej polecenie do terminala Linux.
6. Postępuj zgodnie z instrukcjami wyświetlanymi podczas instalacji.
7. Po zakończeniu instalacji otwórz `https://rustdesk.twojadomena.com` lub `http://twoj.adres.ip:21114`.
8. Zaloguj się przy użyciu nazwy użytkownika `admin` i hasła `test1234`.
9. Wprowadź kod licencyjny zakupiony w kroku 1.
## Jak przekonwertować serwer RustDesk OSS na wersję Pro?
1. Uzyskaj licencję ze strony [https://rustdesk.com/pricing.html](https://rustdesk.com/pricing.html). Więcej szczegółów znajdziesz na stronie [licencji](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/license/).
2. Otwórz port TCP 21114.
3. Zaloguj się do swojego serwera RustDesk.
4. Jeśli nie używałeś DNS i chcesz skorzystać z SSL, utwórz nazwę DNS, np. `rustdesk.twojadomena.com`.
5. Przejdź na [tę stronę](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/installscript/#convert-from-open-source).
6. Skopiuj i wklej polecenie do terminala Linux.
7. Postępuj zgodnie z instrukcjami wyświetlanymi podczas instalacji.
8. Po zakończeniu instalacji otwórz `https://rustdesk.twojadomena.com` lub `http://twoj.adres.ip:21114`.
9. Zaloguj się przy użyciu nazwy użytkownika `admin` i hasła `test1234`.
10. Wprowadź kod licencyjny zakupiony w kroku 1.
## Jak zaktualizować RustDesk Server Pro do nowej wersji?
Zaleca się wcześniejsze wykonanie kopii zapasowej plików danych (np. plików sqlite3), https://github.com/rustdesk/rustdesk-server-pro/discussions/184#discussioncomment-8013375.
### Jeśli zainstalowano za pomocą skryptu (`install.sh`)
Uruchom [update.sh](/docs/en/self-host/rustdesk-server-pro/installscript/script/#upgrade).
- ### Docker Compose
```
sudo docker compose down
sudo docker compose pull
sudo docker compose up -d
```
Więcej informacji znajdziesz w [tej dyskusji](https://stackoverflow.com/questions/37685581/how-to-get-docker-compose-to-use-the-latest-image-from-repository).
- ### Docker
```
sudo docker ps
## możesz również użyć <NAZWA KONTENERA>, np. hbbs i hbbr, jeśli postępowałeś zgodnie z instrukcją.
sudo docker stop <ID KONTENERA>
sudo docker rm <ID KONTENERA>
sudo docker rmi <ID OBRAZU>
sudo docker run ..... # tak samo jak podczas instalacji
```
np.:
```
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
Untagged: rustdesk/rustdesk-server-pro@sha256:401b8344323addf777622d0463bd7b964dd18a01599e42e20d8b3818dae71ad2
Deleted: sha256:a3d9d43a3d1dd84b10c39fe0abf7767b18a87819ff0981443ce9e9a52604c889
Deleted: sha256:65ae79ecc0f8b1c8a21085d04af7c8d8f368dd5ad844982d4c7b3ac1f38ba33a
Deleted: sha256:9274a824aef10f2ef106d8f85fbd1905037169cf610951f63dc5109dae4b0825
Deleted: sha256:aa89ac8b57a49f49f041c01b9c0f016060e611cf282e3fda281bc6bebbabaf3f
Deleted: sha256:4af9839016f72586a46f915cae8a5ccf3380ba88a2f79532692d3b1d7020387e
Deleted: sha256:e900a7ffc2fc14fa432cc04823740dcbb78c0aa3508abbbe287ce8b274541ada
Deleted: sha256:503eeab76c11e8316a2a450ef0790d31c5af203309e9c5b44d1bf8a601e6e587
Deleted: sha256:825683356e7dbfcbaabcbf469c9aeb34d36ebeab0308170432b9553e28203116
Deleted: sha256:24a48d4af45bab05d8712fe22abec5761a7781283500e32e34bdff5798c09399
root@hz:~# sudo docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
rustdesk/makepkg latest 86a981e2e18f 2 months ago 2.23GB
root@hz:~# sudo docker run --name hbbs -v ./data:/root -td --net=host --restart unless-stopped rustdesk/rustdesk-server-pro hbbs
Unable to find image 'rustdesk/rustdesk-server-pro:latest' locally
latest: Pulling from rustdesk/rustdesk-server-pro
4ce000a43472: Pull complete
1543f88421d3: Pull complete
9b209c1f5a8d: Pull complete
d717f548a400: Pull complete
1e60b98f5660: Pull complete
a86960d9bced: Pull complete
acb361c4bbf6: Pull complete
4f4fb700ef54: Pull complete
Digest: sha256:401b8344323addf777622d0463bd7b964dd18a01599e42e20d8b3818dae71ad2
Status: Downloaded newer image for rustdesk/rustdesk-server-pro:latest
0cc5387efa8d2099c0d8bc657b10ed153a6b642cd7bbcc56a6c82790a6e49b04
root@hz:~# sudo docker run --name hbbr -v ./data:/root -td --net=host --restart unless-stopped rustdesk/rustdesk-server-pro hbbr
4eb9da2dc460810547f6371a1c40a9294750960ef2dbd84168079e267e8f371a
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
root@hz:~# sudo docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
rustdesk/rustdesk-server-pro latest a3d9d43a3d1d 5 days ago 193MB
rustdesk/makepkg latest 86a981e2e18f 2 months ago 2.23GB
```
Aby uzyskać więcej szczegółów, sprawdź [to](https://www.cherryservers.com/blog/how-to-update-docker-image).
## Zainstalowałem za pomocą skryptu, jak mogę uruchomić i zatrzymać usługi?
Usługi korzystają z systemd, więc można je uruchomić i zatrzymać za pomocą `sudo systemctl stop|start|restart rustdesk-hbbs|rustdesk-hbbr`, np. `sudo systemctl restart rustdesk-hbbs`.
## Zainstalowałem za pomocą skryptu, jak mogę wyświetlić logi w systemie Linux?
Logi są przechowywane w `/var/log/rustdesk-server`, można je wyświetlić za pomocą `tail /var/log/rustdesk-server/hbbs.log` lub `tail /var/log/rustdesk-server/hbbs.error`.
## Zainstalowałem za pomocą skryptu, jak mogę sprawdzić status usług RustDeska?
Aby sprawdzić status, użyj `sudo systemctl status rustdesk-hbbs|rustdesk-hbbr`, np. `sudo systemctl status rustdesk-hbbs`.
## Jak mogę zmienić hasło administratora?
1. Otwórz `https://rustdesk.yourdomena.com` lub `http://twojadresIP:21114`.
2. Zaloguj się z nazwą użytkownika `admin` i hasłem `test1234`.
3. Kliknij `admin` w prawym górnym rogu.
4. Kliknij `Ustawienia`.
5. Wprowadź nowe hasło w odpowiednich polach.
## Jak mogę przenieść moją licencję na nowy serwer?
Proszę sprawdzić [tutaj](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/license/#invoices-and-migration).
## E-maile nie działają z mojego VPS
Wiele dostawców VPS blokuje porty 465 i 25.
Prosty sposób na sprawdzenie to użycie telnet. Aby przetestować w terminalu Linuxa, wpisz `telnet twój.serwer.mailowy.com 25`. W systemie Windows użyj PowerShell z komendą `Test-NetConnection -ComputerName twój.serwer.mailowy.com -Port 25`.
Twój serwer mailowy może nie używać portu 25. Upewnij się, że używasz właściwych portów.
## Czy mogę wdrożyć RustDeska za pomocą PowerShell lub podobnego narzędzia?
Oczywiście, skrypty pomocne przy wdrażaniu znajdziesz [tutaj](https://rustdesk.com/docs/en/self-host/client-deployment/).
## Jak mogę zgłosić błąd?
Proszę zgłaszać przez [GitHuba](https://github.com/rustdesk/rustdesk-server-pro/issues).
## Dlaczego, jeśli hostuję samodzielnie, to nie jest to darmowe i open source?
1. RustDesk stał się pełnoetatową pracą dla wielu osób, które mają życie, żony, prace i dzieci, co wymaga czasu i kosztuje pieniądze!
2. Chcemy być tutaj i nadal robić postępy w nadchodzących latach.
3. Wersja open source nadal będzie open source i zachęcamy innych do rozwoju zgodnie z licencją AGPL.
## Nie mogę połączyć się z urządzeniami w różnych grupach, dlaczego?
To łatwo naprawić, musisz zezwolić na dostęp międzygrupowy.
1. Dodaj nowe grupy.
2. Kliknij `Edytuj`.
3. Wybierz odpowiednie grupy, do których chcesz mieć dostęp (automatycznie dodaje je do odpowiadającej grupy).
## Jak mogę automatycznie uzyskać konfiguracje?
Konfiguracje są generowane automatycznie.
1. Pobierz najnowszych klientów z [GitHuba](https://github.com/rustdesk/rustdesk/releases/latest).
2. Na głównej stronie konsoli webowej kliknij `Windows EXE`.
3. Wprowadź host i API (jeśli różnią się od twojej konfiguracji).
4. Kliknij `Wyślij`.
5. Zeskanuj kod QR na Androidzie i zmień nazwę pliku exe na wygenerowaną.
## Czy oferujecie hosting dla RustDesk Server Pro?
Proszę skontaktować się z naszym zespołem [sprzedaży](mailto://sales@rustdesk.com).
## Czy jest gdzieś dostępny przewodnik wideo?
Tak! Mamy [kanał YouTube](https://youtube.com/@RustDesk).
## Dlaczego moje logi/nazwy urządzeń są puste?
Upewnij się, że API jest poprawnie ustawione na kontrolowanym urządzeniu, https://github.com/rustdesk/rustdesk-server-pro/issues/21#issuecomment-1637935750.
## Jak mogę odinstalować serwer RustDeska Pro?
Uruchom następujące polecenia:
```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/
```
Jeśli skrypt zainstalował Nginx, usuń go za pomocą:
```sh
sudo apt remove nginx
```
## Jak mogę usunąć urządzenia z listy urządzeń w konsoli webowej?
Teraz dostępna będzie opcja wyłączenia, a następnie usunięcia.
## Jak mogę zaktualizować RustDeska za pomocą PowerShella?
```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
```
## Błąd `Key mismatch`
Skonfiguruj swojego klienta z [prawidłowym kluczem](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/relay/).
## Błąd `Failed to connect to relay server`
Upewnij się, że `hbbr` jest uruchomiony. Więcej informacji o `hbbr` znajdziesz [tutaj](https://rustdesk.com/docs/en/self-host/rustdesk-server-oss/install/).
Jeśli twój `hbbr` nie działa na tej samej maszynie co `hbbs`, masz wiele serwerów relay lub nie używasz domyślnego portu `21117`, musisz jawnie przekazać tę informację do `hbbs`. Sprawdź [tutaj](https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/relay/).
## Resetowanie MFA dla konta administratora
https://github.com/rustdesk/rustdesk/discussions/6576
## Ręczna konfiguracja HTTPS dla konsoli webowej
### 1. Kup nazwę domeny i przypisz ją do adresu IP swojego serwera.
* Kup nazwę domeny u rejestratora takiego jak GoDaddy, Namecheap lub Namesilo.
* Przypisz nazwę domeny do adresu IP swojego serwera poprzez:
- Panel kontrolny rejestratora domen (zalecane)
- [Dostawców DNS](https://en.wikipedia.org/wiki/List_of_managed_DNS_providers)
Na przykład, jeśli kupiłeś domenę `example.com` w `Namesilo`, a adres IP twojego serwera to `123.123.123.123`, i chcesz użyć subdomeny `rustdesk.example.com` jako adresu HTTPS konsoli webowej. Otwórz [link](https://www.namesilo.com/account_domains.php), kliknij przycisk z podpowiedzią `Manage dns for the domain`, dodaj rekord `A` z nazwą hosta `rustdesk` i adresem IP twojego serwera.
![](/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)
* Propagacja DNS może chwilę potrwać. Sprawdź na https://www.whatsmydns.net, czy domena została poprawnie przypisana do adresu IP serwera. Krok 6 wymaga poprawnego wyniku propagacji. W kolejnych krokach zastąp `YOUR_DOMAIN` swoją subdomeną, np. `rustdesk.example.com`.
### 2. Instalacja Nginx
* Debian/Ubuntu: `sudo apt-get install nginx`
* Fedora/CentOS: `sudo dnf install nginx` lub `sudo yum install nginx`
* Arch: `sudo pacman -S install nginx`
* openSUSE: `sudo zypper install nginx`
* Gentoo: `sudo emerge -av nginx`
* Alpine: `sudo apk add --no-cache nginx`
Uruchom `nginx -h`, aby sprawdzić, czy instalacja się powiodła.
### 3. Instalacja Certbot
* Metoda 1: Jeśli masz zainstalowany `snap`, uruchom `sudo snap install certbot --classic`.
* Metoda 2: Użyj `python3-certbot-nginx`, np. `sudo apt-get install python3-certbot-nginx` dla Ubuntu.
* Metoda 3: Jeśli powyższe metody zawiodą, spróbuj zainstalować `certbot-nginx`, np. `sudo yum install certbot-nginx` dla CentOS 7.
Uruchom `certbot -h`, aby sprawdzić, czy instalacja się powiodła.
### 4. Konfiguracja Nginx
Istnieją dwa sposoby:
* Jeśli istnieją katalogi `/etc/nginx/sites-available` i `/etc/nginx/sites-enabled`, zastąp `TWOJA_DOMENA` w poniższej komendzie swoją nazwą domeny i wykonaj ją.
```sh
cat > /etc/nginx/sites-available/rustdesk.conf << EOF
server {
server_name TWOJA_DOMENA;
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
```
Następnie uruchom polecenie `sudo ln -s /etc/nginx/sites-available/rustdesk.conf /etc/nginx/sites-enabled/rustdesk.conf`.
Uruchom polecenie `cat /etc/nginx/sites-available/rustdesk.conf`, aby upewnić się, że jego zawartość jest poprawna.
* Jeśli katalogi `/etc/nginx/sites-available` i `/etc/nginx/sites-enabled` nie istnieją, a katalog `/etc/nginx/conf.d` istnieje, zastąp `TWOJA_DOMENA` w poniższym poleceniu swoją nazwą domeny i uruchom je.
```sh
cat > /etc/nginx/conf.d/rustdesk.conf << EOF
server {
server_name TWOJA_DOMENA;
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
```
Uruchom polecenie `cat /etc/nginx/conf.d/rustdesk.conf`, aby upewnić się, że jego zawartość jest poprawna.
### 5. Włącz reguły zapory sieciowej dla domeny
Uruchom następujące polecenia:
```sh
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw --force enable
sudo ufw --force reload
```
### 6. Generate SSL certificate
Zastąp `$TWOJA_DOMENA` nazwą swojej domeny, a następnie uruchom
`sudo certbot --nginx --cert-name $TWOJA_DOMENA --key-type ecdsa --renew-by-default --no-eff-email --agree-tos --server https://acme-v02.api.letsencrypt.org/directory -d $TWOJA_DOMENA`.
Jeśli pojawi się monit "Wprowadź adres e-mail (używany do pilnych powiadomień o odnowieniu i bezpieczeństwie)", wprowadź swój adres e-mail.
Ostatecznie zawartość pliku `rustdesk.conf` powinna wyglądać następująco:
```
server {
server_name TWOJA_DOMENA;
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/;
}
listen 443 ssl; # managed by Certbot
ssl_certificate /etc/letsencrypt/live/TWOJA_DOMENA/fullchain.pem; # managed by Certbot
ssl_certificate_key /etc/letsencrypt/live/TWOJA_DOMENA/privkey.pem; # managed by Certbot
include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
}
server {
if ($host = TWOJA_DOMENA) {
return 301 https://$host$request_uri;
} # managed by Certbot
server_name TWOJA_DOMENA;
listen 80;
return 404; # managed by Certbot
}
```
Oto kilka typowych błędów:
* Konsola wyświetla komunikat `Successfully deployed certificate for TWOJA_DOMENA to /etc/nginx/.../default` zamiast `Successfully deployed certificate for TWOJA_DOMENA to /etc/nginx/.../rustdesk.conf`.
Przyczyną może być to, że Certbot nie znajduje pliku `rustdesk.conf`. Możesz spróbować jednego z poniższych rozwiązań:
- Sprawdź wynik kroku 5, uruchom `sudo service nginx restart`.
- Skopiuj konfiguracje serwera `server{...}`, które zawierają `TWOJA_DOMENA` do `rustdesk.conf` i zmień `location{...}` na poniższą treść.
```sh
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/;
}
```
* `too many certificates (5) already issued for this exact set of domains in the last 168 hours`
Rozwiązanie: Dodaj kolejną nazwę domeny do DNS i zmień `TWOJA_DOMENA` na nią, np. `rustdesk2.example.com`. Następnie powtórz kroki 1, 4 i 6.
* `Error getting validation data`
Rozwiązanie: Problem może być spowodowany zaporą sieciową, zapoznaj się z https://rustdesk.com/docs/en/self-host/rustdesk-server-pro/faq/#firewall
Uwaga: Uruchom `sudo service nginx restart`, jeśli ręcznie zmieniałeś plik `rustdesk.conf`.
### 7. Logowanie do strony internetowej
* Otwórz `https://TWOJA_DOMENA` w przeglądarce, zaloguj się przy użyciu domyślnej nazwy użytkownika "admin" i hasła "test1234", a następnie zmień hasło na własne.
### 8. Dodanie obsługi WebSocket Secure (WSS) dla serwera ID i serwera relay, aby umożliwić bezpieczną komunikację na wszystkich platformach.
Dodaj następującą konfigurację do pierwszej sekcji `server` w pliku `/etc/nginx/.../rustdesk.conf`, a następnie zrestartuj usługę `Nginx`.
Klient webowy będzie dostępny pod adresem `https://TWOJA_DOMENA/web`. Niestandardowi klienci mogą używać WebSocket, ustawiając `allow-websocket=Y` w opcjach zaawansowanych. Jeśli używasz niestandardowego klienta z włączonym WebSocket, nie będzie on wykorzystywał TCP/UDP i może łączyć się tylko przez relay (z wyjątkiem połączeń bezpośrednich przez IP). Jeśli używasz tylko tego klienta z WebSocket, serwer może zamknąć porty 21114-21119 i pozostawić otwarty tylko port 443.
```
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;
}
```
Pełna konfiguracja jest następująca:
```
server {
server_name TWOJA_DOMENA;
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/;
}
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;
}
listen 443 ssl; # managed by Certbot
ssl_certificate /etc/letsencrypt/live/YOUR_DOMAIN/fullchain.pem; # managed by Certbot
ssl_certificate_key /etc/letsencrypt/live/YOUR_DOMAIN/privkey.pem; # managed by Certbot
include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
}
server {
if ($host = TWOJA_DOMENA) {
return 301 https://$host$request_uri;
} # managed by Certbot
server_name TWOJA_DOMENA;
listen 80;
return 404; # managed by Certbot
}
```
{{% notice note %}}
Jeśli wcześniej wdrożyłeś aplikację dla klientów webowych i chcesz korzystać z niej na wszystkich platformach, musisz dodać `proxy_read_timeout`.
{{% /notice %}}
### 9. Omiń CORS, jeśli korzystasz z publicznego klienta internetowego RustDeska `https://rustdesk.com/web`
Aby ominąć ograniczenia CORS przeglądarek, należy dodać poniższy fragment w sekcji `location /` pliku `/etc/nginx/.../rustdesk.conf`. Pomiń ten krok, jeśli korzystasz z własnego klienta internetowego.
```
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
Jeśli podczas instalacji pojawi się komunikat `Waiting for RustDesk Relay service to become active...`, przyczyną może być SELinux. Możesz spróbować wykonać następujące polecenia:
```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
### Zapora chmury
Jeśli korzystasz z chmury AWS/Azure/Google/DigitalOcean, otwórz porty przychodzące UDP (21116) i TCP (21114-21119) w panelu dostawcy chmury.
- [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/
### Zapora serwera lokalnego
RustDesk konfiguruje zaporę za pomocą `ufw`. Może to nie działać na niektórych dystrybucjach jak CentOS 9, możesz spróbować z `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
```
Jeżeli używasz IP:
```sh
sudo firewall-cmd --permanent --add-port=21114/tcp
```
Jeżeli używasz DNS/domeny:
```sh
sudo firewall-cmd --permanent --add-port=80/tcp
sudo firewall-cmd --permanent --add-port=443/tcp
```
Po wykonaniu powyższych czynności uruchom `sudo firewall-cmd --reload`, aby przeładować zaporę.
## Po zmianie hasła administratora w konsoli webowej nie mogę się zalogować. Czy istnieje prosty sposób na zresetowanie hasła?
1. Upewnij się, że masz zainstalowane `rustdesk-utils`. Jeśli nie, możesz je pobrać [tutaj](https://github.com/rustdesk/rustdesk-server-pro). Polecenie należy wykonać z folderu, w którym znajduje się baza danych, czyli `/var/lib/rustdesk-server`.
2. Polecenie to `rustdesk-utils set_password nazwa_użytkownika hasło`. Jeśli zadziała, wyświetli się komunikat *Done*.
Dostępne są również inne polecenia: `genkeypair`, `validatekeypair [klucz publiczny] [klucz prywatny]`, `doctor [rustdesk-server]`, `reset_email_verification` oraz `reset_2fa_verification`, które można użyć z `rustdesk-utils`.
https://github.com/rustdesk/rustdesk-server-pro/discussions/183
## Dodanie certyfikatu głównego CA do kontenera Docker (dla problemów z TLS przy SMTP, OIDC itp.)
https://github.com/rustdesk/rustdesk-server-pro/issues/99#issuecomment-2235014703

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

@ -0,0 +1,77 @@
---
title: Docker
weight: 3
---
## Docker Compose (zalecane)
W przypadku Docker Compose MUSISZ użyć `network_mode: "host"`, aby zapewnić prawidłowe działanie licencji. Zainstaluj Docker, korzystając z tego [przewodnika](https://docs.docker.com/engine/install), aby mieć pewność, że będzie to najnowsza wersja!
Skopiuj poniższy tekst do pliku `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
```
Następnie uruchom `sudo docker compose up -d` lub `podman-compose up -d`
> `sudo apt install podman-compose` w celu zainstalowania `podman-compose`
{{% notice note %}}
[Jak ręcznie skonfigurować protokół HTTPS dla konsoli internetowej](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/faq/#ręczna-konfiguracja-https-dla-konsoli-webowej).
{{% /notice %}}
## Polecenia Dockera
Zainstaluj Docker zgodnie z tym [przewodnikiem](https://docs.docker.com/engine/install), aby mieć pewność, że jest on w najnowszej wersji!
Możesz też zainstalować Docker za pomocą tego polecenia.
```
bash <(wget -qO- https://get.docker.com)
```
Uruchom następujące polecenia (obraz s6 może wymagać `./data:/data` zamiast `./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 %}}
W powyższym przykładzie użyto poleceń `sudo` i `--net=host`. Nie będą one działać w systemie Windows. Proszę usunąć te polecenia. Jeśli usuniesz `--net=host`, sprawdź poniższe informacje.
{{% /notice %}}
```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 %}}
[Jak ręcznie skonfigurować protokół HTTPS dla konsoli internetowej](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/faq/#ręczna-konfiguracja-https-dla-konsoli-webowej).
{{% /notice %}}
> Jeśli masz problem z SELinux w systemie Fedora, sprawdź tę [kwestię](https://github.com/rustdesk/rustdesk-server/issues/230).

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

@ -0,0 +1,86 @@
---
title: install.sh
weight: 4
---
{{% notice note %}}
Nie zapomnij uzyskać licencji na [https://rustdesk.com/pricing/](https://rustdesk.com/pricing/). Więcej szczegółów znajdziesz na stronie [licencji](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/license/).
Przed wykonaniem tej prostej instalacji zaleca się zapoznanie z [instalacją OSS](https://rustdesk.com/docs/pl/self-host/rustdesk-server-oss/install/). Znajdziesz tam więcej szczegółów technicznych.
{{% /notice %}}
## Instalacja
Skopiuj i wklej poniższą komendę w terminalu Linuxa, aby zainstalować serwer RustDeska Pro.
`wget -qO- https://raw.githubusercontent.com/rustdesk/rustdesk-server-pro/main/install.sh | bash`
{{% notice note %}}
Zalecam użycie [obrazu Dockera](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/installscript/docker/#docker-compose), który znacznie upraszcza proces wdrażania i aktualizacji rozwiązania. Zużycie zasobów jest bardzo niskie.
Pamiętaj, aby uruchomić powyższą komendę w katalogu domowym, a nie w katalogu, w którym nie masz uprawnień do zapisu.
{{% /notice %}}
Co robi skrypt:
- Instaluje wymagane zależności
- Konfiguruje zaporę UFW (jeśli dostępna)
- Tworzy katalog roboczy `/var/lib/rustdesk-server` i katalog logów `/var/log/rustdesk-server`
- Instaluje pliki wykonywalne w `/usr/bin`
- Pobiera i wypakowuje usługi RustDeska Pro do powyższego katalogu
- Tworzy usługi systemd dla hbbs i hbbr (nazwy usług to `rustdesk-hbbs.service` i `rustdesk-hbbr.service`)
- W przypadku wybrania domeny instaluje Nginx i Certbot, umożliwiając dostęp do API na porcie `443` (HTTPS) oraz uzyskanie certyfikatu SSL przez port `80` (automatycznie odnawiany). Po skonfigurowaniu HTTPS należy korzystać z adresu `https://twojadomena.com` zamiast `https://twojadomena.com:21114`.
{{% notice note %}}
Jak [ręcznie skonfigurować HTTPS dla konsoli webowej](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/faq/#ręczna-konfiguracja-https-dla-konsoli-webowej).
{{% /notice %}}
{{% notice note %}}
Jeśli usługa systemd nie uruchamia się, problem może być związany z SELinux. Sprawdź [tę sekcję](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/faq/#selinux).
{{% /notice %}}
{{% notice note %}}
Jeśli klient nie może połączyć się z serwerem lub nie masz dostępu do konsoli webowej, sprawdź [tę sekcję](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/faq/#firewall).
{{% /notice %}}
## Aktualizacja
Skopiuj i wklej poniższą komendę w terminalu Linux, aby zaktualizować istniejącą instalację RustDesk Server Pro. Skrypt można też zapisać lokalnie i zaplanować przez cron.
`wget -qO- https://raw.githubusercontent.com/rustdesk/rustdesk-server-pro/main/update.sh | bash`
{{% notice note %}}
W przypadku problemów ze skryptem zaleca się przejrzenie go i wykonanie kroków ręcznie, jeden po drugim.
Pamiętaj, aby uruchomić powyższą komendę w katalogu domowym, a nie w katalogu, w którym nie masz uprawnień do zapisu.
{{% /notice %}}
Co robi skrypt:
- Sprawdza dostępność nowych wersji serwera RustDesk Pro
- W przypadku znalezienia nowej wersji usuwa pliki API i pobiera nowe pliki wykonywalne oraz API
## Konwersja z wersji open source
Skopiuj i wklej poniższą komendę w terminalu Linux, aby przekonwertować serwer RustDeska na serwer RustDeska Pro.
`wget -qO- https://raw.githubusercontent.com/rustdesk/rustdesk-server-pro/main/convertfromos.sh | bash`
{{% notice note %}}
Dodaj port TCP `21114` do swojej zapory - jest to dodatkowy port dla konsoli webowej i logowania użytkowników w kliencie RustDesk.
{{% /notice %}}
{{% notice note %}}
W przypadku problemów ze skryptem zaleca się przejście na instalację Dockerową lub ręczne wykonanie kroków ze skryptu.
{{% /notice %}}
Co robi skrypt:
- Wyłącza i usuwa stare usługi
- Instaluje wymagane zależności
- Konfiguruje zaporę UFW (jeśli dostępna)
- Tworzy folder `/var/lib/rustdesk-server` i kopiuje do niego certyfikaty
- Usuwa `/var/log/rustdesk` i tworzy `/var/log/rustdesk-server`
- Pobiera i wypakowuje usługi RustDeska Pro
- Tworzy usługi systemd dla hbbs i hbbr
- W przypadku wybrania domeny instaluje Nginx i Certbot w ramach obsługi HTTPS

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

@ -0,0 +1,30 @@
---
title: Instalacja
weight: 2
---
## Metoda 1: Docker (zalecana)
```
bash <(wget -qO- https://get.docker.com)
wget rustdesk.com/pro.yml -O compose.yml
sudo docker compose up -d
```
Więcej szczegółów znajdziesz w dokumentacji [Dockera](/docs/pl/self-host/rustdesk-server-pro/installscript/docker/).
## Metoda 2: install.sh
Jeśli jesteś biegły w systemie Linux, możesz użyć poniższego skryptu. W przeciwnym razie, w przypadku niepowodzenia, możesz napotkać poważne problemy, a ustalenie przyczyny może być trudne.
`bash <(wget -qO- https://raw.githubusercontent.com/rustdesk/rustdesk-server-pro/main/install.sh)`
Więcej szczegółów znajdziesz w dokumentacji [install.sh](/docs/pl/self-host/rustdesk-server-pro/installscript/script/).
## Konwersja z wersji open source
### Docker
Jeśli używasz wersji open source zainstalowanej przez Docker, nie ma bezpośredniej metody konwersji. Zamiast tego musisz uruchomić nowy kontener z obrazem Pro. Przed wykonaniem tej czynności wykonaj kopię zapasową klucza prywatnego (pliku `id_ed25519`, a nie `id_ed25519.pub`). Po skonfigurowaniu nowego kontenera skopiuj stary plik klucza prywatnego `id_ed25519` do katalogu roboczego nowego kontenera, a następnie zrestartuj kontener.
### install.sh
Jeśli używasz wersji open source zainstalowanej przez install.sh, postępuj zgodnie z [tymi instrukcjami](/docs/pl/self-host/rustdesk-server-pro/installscript/script/#konwersja-z-wersji-open-source).

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

@ -0,0 +1,62 @@
---
title: Instalacja na Windowsie (przestarzałe)
weight: 5
---
{{% notice note %}}
Polityka bezpieczeństwa Windows może być problematyczna. Jeśli ten poradnik nie działa lub występują niestabilne połączenia, zaleca się migrację na serwer Linux.
{{% /notice %}}
{{% notice note %}}
Wersja z GUI, `RustDeskServer.setup.exe`, nie jest już rozwijana i nie jest zalecana.
{{% /notice %}}
## Instalacja
Do działania RustDesk na Windowsie wymagane jest Microsoft Visual C++ Redistributable. Można je pobrać [tutaj](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist).
1. Uzyskaj licencję na [https://rustdesk.com/pricing.html](https://rustdesk.com/pricing.html). Więcej szczegółów na stronie [licencji](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/license/).
2. Pobierz instalator Windows z [GitHub](https://github.com/rustdesk/rustdesk-server-pro/releases/latest).
3. Wypakuj instalator.
4. Uruchom instalator i postępuj zgodnie z instrukcjami. Alternatywnie możesz zainstalować ręcznie używając [PM2 lub NSSM](https://rustdesk.com/docs/pl/self-host/rustdesk-server-oss/windows/).
5. Po zakończeniu instalacji otwórz RustDesk Server.
6. Postępuj zgodnie z wyświetlanymi instrukcjami.
7. Kliknij `Services`, a następnie `Start`.
8. Po zakończeniu instalacji przejdź do `http://twojadresip:21114`.
9. Zaloguj się używając nazwy użytkownika `admin` i hasła `test1234`.
10. Wprowadź kod licencji zakupiony w kroku 1.
## Użycie IIS jako proxy
Upewnij się, że `Dynamic Content Compression` jest zainstalowane (to funkcja IIS, którą można zainstalować przez Role serwera).
1. Otwórz IIS (lub zainstaluj go).
2. Utwórz nową witrynę dla RustDeska z powiązaniami (najlepiej 443) i odpowiednim certyfikatem. Podstawowe ustawienia powinny wskazywać na pusty folder.
3. W IIS zainstaluj [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. W panelu hosta IIS otwórz Application Request Routing.
2. Przejdź do Server Proxy Settings.
3. Włącz proxy i pozostaw domyślne ustawienia.
4. Zapisz ustawienia i przejdź do URL Rewrite.
## URL Rewrite
1. Otwórz witrynę w IIS i kliknij dwukrotnie URL Rewrite.
2. Kliknij `Add rules`.
3. Skonfiguruj nową regułę reverse proxy.
4. Ustaw lokalny adres (adres 21114) \
Reguła przychodząca - wewnętrzny adres RustDeska 21114 \
Reguły wychodzące - `From` to wewnętrzny adres RustDeska 21114, `To` to adres zewnętrzny. \
Uwaga: Nie dodawaj http/https przed adresami - są obsługiwane automatycznie. Upewnij się, że wszystkie adresy są dostępne zarówno wewnętrznie, jak i zewnętrznie.
## Kompresja
1. Wyłącz `Dynamic Content Compression`.
## Rozwiązywanie problemów
W przypadku błędu 500.52 dodaj wymienione zmienne: [IIS działający jako odwrotny serwer proxy: gdzie zaczynają się problemy](https://techcommunity.microsoft.com/t5/iis-support-blog/iis-acting-as-reverse-proxy-where-the-problems-start/ba-p/846259).
Może być konieczna zmiana ustawień SSL na "Require SSL → Ignore".

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

@ -0,0 +1,37 @@
---
title: LDAP
weight: 17
---
## Konfiguracja
Przejdź do strony ustawień `LDAP` jak pokazano poniżej.
![](/docs/en/self-host/rustdesk-server-pro/ldap/images/ldap.png)
- **Host LDAP:** Nazwa hosta lub adres IP serwera LDAP. Np. `ldap.przyklad.com` lub `192.0.2.1`.
- **Port LDAP:** Numer portu, na którym nasłuchuje serwer LDAP. Domyślny port dla LDAP to `389`, a dla LDAPS (LDAP przez SSL) to `636`.
- **DN bazowy:** Punkt początkowy dla wyszukiwania LDAP. Np. dc=przyklad,dc=com.
- **Zakres:** Określa zakres wyszukiwania w katalogu LDAP. Może to być one (tylko wpisy bezpośrednio pod DN bazowym) lub sub (wszystkie wpisy poniżej DN bazowego).
- **DN/Powierzanie użytkownika bind:** Nazwa użytkownika i hasło konta usługowego używane do uwierzytelniania innych użytkowników w LDAP. Zwykle w formacie DN, np. `cn=admin,dc=przyklad,dc=com`.
- **Filtr:** Filtr wyszukiwania dla zapytań LDAP. Np. `(objectClass=person)` lub `(&(wiek=28)(!(imie=Jan)))`.
- **Atrybut nazwy użytkownika:** Atrybut zawierający nazwę użytkownika. Np. `uid` lub `sAMAccountName`. Domyślnie używane są `uid` i `cn`. Więcej w [tej dyskusji](https://github.com/rustdesk/rustdesk-server-pro/issues/140#issuecomment-1916804393).
- **StartTLS:** Określa czy użyć StartTLS do zabezpieczenia połączenia.
- **NoTLSVerify:** Określa czy pominąć weryfikację certyfikatu TLS. Zaleca się pozostawienie false (weryfikacja włączona) chyba że wiesz co robisz.
## Jak to działa?
- Jak działają logowania przez LDAP? Czy trzeba najpierw utworzyć użytkownika?
> RustDesk tworzy użytkownika przy pierwszym logowaniu
- Jak sprawdzić czy LDAP działa (najlepiej jakieś polecenie do testowania)?
> Po przesłaniu konfiguracji, system połączy się z serwerem LDAP używając podanego binddn/hasła i zweryfikuje działanie.
- Jak zmienić lokalnych użytkowników na LDAP?
> Jeszcze nie
- Czy obsługiwane są grupy LDAP?
> Jeszcze nie

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

@ -0,0 +1,46 @@
---
title: Licencja
weight: 15
---
## Zakup licencji
Licencję można nabyć na stronie [https://rustdesk.com/pricing.html](https://rustdesk.com/pricing.html). W formularzu Stripe podaj poprawny adres e-mail. Licencja (oraz faktura w osobnej wiadomości) zostanie wysłana na podany adres e-mail po udanej płatności.
![](/docs/en/self-host/rustdesk-server-pro/license/images/stripe.jpg)
## Aktywacja licencji
Licencję należy wprowadzić w konsoli webowej (`http://<adres-ip-serwera-rustdeska-pro>:21114`) podczas pierwszej konfiguracji lub później.
| Ustawianie licencji | Zmiana licencji |
| --- | --- |
| ![](/docs/en/self-host/rustdesk-server-pro/license/images/set.png) | ![](/docs/en/self-host/rustdesk-server-pro/license/images/change.png) |
## Odnawianie/rozszerzanie licencji
Opcje odnawiania i rozszerzania licencji dostępne są w [portalu samoobsługowym](https://rustdesk.com/self-host/account/). Zaloguj się przy użyciu adresu e-mail użytego przy zakupie licencji.
| Strona licencji z opcjami | Okno rozszerzenia |
| --- | --- |
| ![](/docs/en/self-host/rustdesk-server-pro/license/images/renew.jpg?v2) | ![](/docs/en/self-host/rustdesk-server-pro/license/images/upgrade.png) |
Po dokonaniu płatności należy odświeżyć licencję [jak poniżej](/docs/pl/self-host/rustdesk-server-pro/license/#odświeżanie-licencji) aby ją aktywować.
### Odświeżanie licencji
Po płatności należy ręcznie aktywować licencję w konsoli webowej. Kliknij `Edytuj`, następnie `OK` - nie trzeba wprowadzać żadnych zmian, ponieważ klucz licencji pozostaje taki sam.
![](/docs/en/self-host/rustdesk-server-pro/license/images/updatelic.jpg)
## Faktury, odzyskiwanie licencji i migracja
Licencja może być używana tylko na jednej maszynie (dotyczy tylko hbbs, hbbr nie wymaga licencji). Aby zmigrować licencję na inną maszynę, odzyskać licencję lub pobrać faktury, odwiedź [https://rustdesk.com/self-host/account/](https://rustdesk.com/self-host/account/). Zaloguj się adresem e-mail użytym w Stripe, odłącz starą maszynę jak poniżej. Po wprowadzeniu licencji w nowym serwerze, licencja zostanie automatycznie przypisana.
![](/docs/en/self-host/rustdesk-server-pro/license/images/unbind.jpg)
## Proxy
Jeśli serwer nie ma bezpośredniego dostępu do internetu w celu weryfikacji licencji, można skonfigurować proxy, np. `proxy=http://użytkownik:hasło@przykład.com:8080 ./hbbs`.
Alternatywnie można dodać `proxy=http://użytkownik:hasło@przykład.com:8080` do pliku `.env` w katalogu roboczym (gdzie znajdują się pliki `id_ed25519` / `db.sqlite3`).
`http` można zastąpić `https` lub `socks5`. Jeśli nie ma `użytkownika` / `hasła` / `portu`, można użyć `proxy=http://przykład.com`.

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

@ -0,0 +1,10 @@
---
title: OIDC
weight: 16
---
- Korzystaj z istniejących kont `Google`, `Okta`, `Facebook`, `Azure`, `GitHub`, `GitLab` itd. aby łatwo tworzyć i logować się do konta `RustDeska Pro`.
- Specyfikacja dostępna w dokumencie [OpenID Connect Core 1.0 incorporating errata set 1](https://openid.net/specs/openid-connect-core-1_0.html).
# Przykłady
{{% children depth="4" showhidden="true" %}}

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

@ -0,0 +1,42 @@
---
title: Azure
weight: 16
---
## Instrukcja wideo
[https://www.youtube.com/watch?v=izGxSmifURI](https://www.youtube.com/watch?v=izGxSmifURI)
## Konfiguracja
1. Zaloguj się do [portalu Azure](https://portal.azure.com).
2. Wyszukaj i wybierz **Microsoft Entra ID**.
3. W lewym menu wybierz [**Rejestracje aplikacji**](https://portal.azure.com/#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/~/RegisteredApps), kliknij **Nowa rejestracja**.
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/1-Azure-NewRegistration.png)
4. W konsoli RustDeska Pro przejdź do strony **Ustawienia**, kliknij moduł **OIDC**. Skopiuj **URL zwrotny**. **Uwaga**: **URL zwrotny** nie jest edytowalny, część `Ścieżka` jest stała i wynosi `api/oidc/callback`, a część `Protokół://Host:Port` pochodzi z adresu aktualnej strony. Jeśli otworzyłeś konsolę przez `http://localhost:8000/<ścieżka>`, to **URL zwrotny** to `http://localhost:8000/api/oidc/callback`. Jeśli przez `https://192.168.0.1:8000/<ścieżka>`, to **URL zwrotny** to `https://192.168.0.1:8000/api/oidc/callback`. Ponieważ Azure wymaga `https://` lub `http://localhost`, wybierz odpowiedni adres do otwarcia konsoli RustDeska Pro.
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/12-RustDesk-Callback.png)
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/2-Azure-Register-RecirectURIs-Restrictions.png)
5. Wprowadź **Nazwę**, wybierz **Obsługiwane typy kont** i wklej **URI przekierowania** z RustDeska Pro.
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/2-Azure-Register.png)
6. W RustDeska Pro kliknij **Nowy dostawca uwierzytelniania**.
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/3-RustDesk-NewAuthProvider.png)
7. W Azure wybierz aplikację, kliknij **Przegląd** i skopiuj **Identyfikator aplikacji (klienta)**.
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/4-Azure-ClientID.png)
8. W RustDeska Pro wklej **Identyfikator klienta**.
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/5-RustDesk-ClientID.png)
9. W Azure przejdź do **Certyfikaty i wpisy tajne**, utwórz nowy lub wybierz istniejący wpis tajny klienta.
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/6-Azure-NewOrSelectClientSecret.png)
10. W Azure skopiuj wartość wpisu tajnego klienta. **Uwaga**: Ta wartość jest widoczna tylko podczas pierwszego tworzenia. Po opuszczeniu strony nie będzie już widoczna. Zachowaj tę wartość w bezpiecznym miejscu.
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/7-Azure-CopySecretValue.png)
11. W RustDeska Pro wklej wartość wpisu tajnego klienta.
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/8-RustDesk-FillClientSecret.png)
12. W RustDeska Pro wypełnij pole **Wystawca** wartością `https://login.microsoftonline.com/<Identyfikator katalogu (dzierżawy)>/v2.0`. Zastąp `Identyfikator katalogu (dzierżawy)` swoim **Identyfikatorem katalogu (dzierżawy)**. **Identyfikator katalogu (dzierżawy)** znajduje się w panelu **Przegląd** aplikacji w Azure.
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/9-RustDesk-Issuer.png)
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/10-Azure-TenantID.png)
13. W Azure wybierz menu **Uwierzytelnianie**. Skonfiguruj autoryzację, wybierając **Tokeny identyfikatorów (używane dla przepływów niejawnych i hybrydowych)**.
![](/docs/en/self-host/rustdesk-server-pro/oidc/azure/images/11-Azure-Auth.png)
## Materiały referencyjne
- [Konfiguracja dostawcy OpenID Connect z Azure AD](https://learn.microsoft.com/en-us/power-pages/security/authentication/openid-settings)
- [OpenID Connect na platformie tożsamości Microsoft](https://learn.microsoft.com/en-us/azure/active-directory/develop/v2-protocols-oidc)

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

@ -0,0 +1,59 @@
---
title: Kontrola dostępu
weight: 16
---
## Uprawnienia dostępu do urządzeń
Urządzenie może być przypisane do:
- pojedynczego użytkownika
- pojedynczej grupy urządzeń
- lub obu tych opcji jednocześnie
Gdy urządzenie jest przypisane do użytkownika, dostęp do niego mają:
- ten użytkownik
- grupa użytkowników
- osoby z odpowiednimi ustawieniami dostępu międzygrupowego
Gdy urządzenie jest przypisane do grupy urządzeń, dostęp regulują ustawienia dostępu między użytkownikami a grupami urządzeń.
### Sposoby przypisania urządzenia do użytkownika:
1. Przez stronę urządzeń w konsoli
2. Logowanie na kliencie przy użyciu przypisanego konta użytkownika
3. Polecenie wiersza poleceń
### Sposoby przypisania urządzenia do grupy urządzeń:
1. Przez stronę urządzeń w konsoli
2. Polecenie wiersza poleceń
### Sytuacje blokujące dostęp do urządzenia:
1. Ustawienie statusu "wyłączone" dla urządzenia w konsoli
2. Dezaktywacja użytkownika w konsoli
## Ustawienia dostępu między grupami użytkowników
W konsoli przejdź do strony grup i kliknij `Edytuj`, aby zmodyfikować ustawienia dostępu międzygrupowego.
Zmiany w polu `Dostęp do innych grup` obowiązują natychmiast, bez konieczności klikania `OK`.
Opcje `Może uzyskiwać dostęp do` i `Może być dostępny dla` pełnią podobną funkcję - istnieją dla wygody, ale mogą powodować pewne zamieszanie.
{{% notice note %}}
Użytkownik i grupa po stronie kontrolującej są określani przez osobę logującą się, a nie przez użytkownika przypisanego z konsoli. Wynika to z faktu, że niektóre urządzenia kontrolujące (np. klient iOS czy wersja webowa) nie mają ID urządzenia.
{{% /notice %}}
![](/docs/en/self-host/rustdesk-server-pro/permissions/images/crossgrp.png)
## Ustawienia dostępu dla grup urządzeń
Grupy urządzeń to alternatywny sposób zarządzania uprawnieniami. Kluczowe zasady:
1. Urządzenie może należeć tylko do jednej grupy urządzeń
2. Można ustawiać uprawnienia dostępu dla użytkowników/grup użytkowników do grup urządzeń. Uprawnienia te sumują się z uprawnieniami międzygrupowymi - dostęp jest przyznawany, jeśli pozwalają na to którekolwiek z ustawień
3. Gdy nieprzypisane urządzenie zostanie dodane do grupy, przestaje być uważane za "nieprzypisane"
{{% notice note %}}
Funkcja grup urządzeń wymaga:
- Klient RustDeska w wersji ≥ 1.3.8
- Serwer RustDeska Pro w wersji ≥ 1.5.0
{{% /notice %}}

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

@ -0,0 +1,155 @@
---
title: Konfiguracja serwerów przekaźnikowych
weight: 17
---
## RustDesk Pro - Instalacja dodatkowych serwerów relay z geolokalizacją przy użyciu Dockera
{{% notice note %}}
[Podstawowa instalacja](https://rustdesk.com/docs/pl/self-host/rustdesk-server-pro/installscript/) automatycznie tworzy serwer relay (proces `hbbr`) na tej samej maszynie - nie trzeba go konfigurować osobno.
Jeśli chcesz dodać kolejny serwer relay na innej maszynie, uruchom `hbbr` zgodnie z [instrukcją instalacji OSS](https://rustdesk.com/docs/pl/self-host/rustdesk-server-oss/install/). Plik `hbbr` znajdziesz w:
- `rustdesk-server-linux-amd64.tar.gz`
- `rustdesk-server-hbbr_<wersja>-<arch>.deb`
- `rustdesk-server-windows-x86_64.tar.gz`
- lub w obrazie Dockera (`sudo docker run ... rustdesk/rustdesk-server-pro hbbr`)
`hbbr` nie wymaga licencji i jest identyczny jak w wersji open source.
{{% /notice %}}
Możesz uruchomić wiele serwerów relay na całym świecie i wykorzystywać automatyczną geolokalizację, aby łączyć się z najbliższym serwerem - zapewnia to szybsze połączenia z zdalnymi komputerami. Proces `hbbs` automatycznie sprawdza dostępność serwerów relay co kilka sekund i wybiera tylko te aktywne.
{{% notice note %}}
Znany problem: https://github.com/rustdesk/rustdesk/discussions/7934
{{% /notice %}}
> Będziesz potrzebować pary kluczy prywatnych `id_ed25519` i `id_ed25519.pub`.
1 - Jeśli docker jest już zainstalowany, połącz się z serwerem przez SSH i utwórz wolumin dla hbbr.
```
# docker volume create hbbr
```
Wolumin hbbr powinien znajdować się w `/var/lib/docker/volumes/hbbr/_data`.
2 - Skopiuj parę kluczy prywatnych do lokalizacji woluminu. W tym przypadku użyjemy SCP do skopiowania plików.
Polecenie to `scp <ścieżka/nazwa pliku> nazwa użytkownika@serwer:</ścieżka docelowa>`.
```
# 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 - Wdróż kontener hbbr przy użyciu utworzonego wcześniej woluminu. Wolumin ten zawiera parę kluczy prywatnych niezbędnych do uruchomienia prywatnego serwera przekaźnikowego.
```
# sudo docker run --name hbbr -v hbbr:/root -td --net=host rustdesk/rustdesk-server hbbr -k _
```
4 - Sprawdź logi działania, aby upewnić się, że hbbr działa przy użyciu twojej pary kluczy.
```
# 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
```
W zależności od systemu operacyjnego możesz chcieć zablokować/zezwolić na adresy IP za pomocą zapory sieciowej.
W naszym przypadku, korzystając z systemu Ubuntu, chcemy zezwolić na wszystkie połączenia TCP z portami 21117 i 21119.
```
# sudo ufw allow proto tcp from any to any port 21117,21119
```
**Włącz zaporę sieciową**
```
# sudo ufw enable
```
**Sprawdź stan**
```
# ufw status
Status: active
To Action From
-- ------ ----
21117,21119/tcp ALLOW Anywhere
21117,21119/tcp (v6) ALLOW Anywhere (v6)
```
## Konfiguracja geolokalizacji w RustDesku Pro przez konsolę webową
### Rejestracja i pobranie bazy danych GeoLite2 City
Aby korzystać z geolokalizacji, hbbs wymaga dostępu do bazy danych MaxMind GeoLite2 City. Baza jest darmowa - wystarczy zarejestrować się, aby pobrać plik i uzyskać klucz API.
1. Załóż konto na [stronie MaxMind](https://www.maxmind.com/en/account/login) (jeśli go nie masz)
2. Przejdź do `Download Databases` i pobierz GeoLite2 City (wybierz plik gzip)
3. Po rozpakowaniu otrzymasz plik z rozszerzeniem `.mmdb`
<img width="500" alt="image" src="https://github.com/rustdesk/doc.rustdesk.com/assets/642149/e14318fb-ec52-463c-af77-d08c9479c1b5">
**Lokalizacja pliku:**
- Dla instalacji skryptem na Linux: `/var/lib/rustdesk-server/`
- Dla Dockera: w woluminie mapowanym do `/root`
### Automatyzacja aktualizacji (serwery Linux)
Bazę należy regularnie aktualizować. Można to zautomatyzować przez cron, wykorzystując klucz API:
1. W panelu MaxMind przejdź do `Manage License Keys`
2. Wygeneruj nowy klucz licencyjny
<img width="500" alt="image" src="https://github.com/rustdesk/doc.rustdesk.com/assets/642149/632aeb33-4f5d-4a31-9010-38e01c22d3c9">
<br>
<img width="500" alt="image" src="https://github.com/rustdesk/doc.rustdesk.com/assets/642149/3e178174-5fbf-46b7-a335-01f77125dfad">
Proces pobierania można zautomatyzować na kilka sposobów ([dokumentacja](https://dev.maxmind.com/geoip/updating-databases)). Poniższe polecenie można dodać do crontaba (zastąp `{Your Access Key}` swoim kluczem API):
```
/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'
```
### Zmiana ustawień w konsoli webowej RustDesk Pro
Dodaj adresy IP lub nazwy DNS swoich serwerów przekaźnikowych (DNS jest obsługiwane od wersji 1.1.11) w sekcji `Serwery przekaźnikowe`. **Port nie jest wymagany, jawnie używany jest port `21117`.** <br>
<img width="500" alt="image" src="https://github.com/rustdesk/doc.rustdesk.com/assets/642149/c4452ba4-5e1d-437a-ae1d-fc0070bfa26c">
Dodaj nadpisanie geolokalizacji, wprowadzając adres IP serwera oraz współrzędne, w których serwer jest zlokalizowany. <br>
<img width="500" alt="image" src="https://github.com/rustdesk/doc.rustdesk.com/assets/642149/41c558e3-423b-4296-90d3-cb0769f4a369">
Kliknij `Reload Geo`, a Twoja lista powinna wyglądać podobnie do tej. <br>
<img width="500" alt="image" src="https://github.com/rustdesk/doc.rustdesk.com/assets/642149/5a0d39a9-4fec-46b4-a7a2-7ed38b6baeb7">
Aby potwierdzić wyniki, sprawdź logi hbbs po kliknięciu `Reload Geo`. Powinieneś zobaczyć komunikat pokazujący adresy IP serwerów przekaźnikowych i ich współrzędne.
> Jeśli używasz RustDeska Pro na maszynie z systemem Linux, użyj polecenia `RUST_LOG=debug ./hbbs`, aby wyświetlić logi. Jeśli korzystasz z kontenera Dockerowego, użyj `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)))]
```
Możesz również potwierdzić żądania przekaźnika bezpośrednio na swoich instancjach hbbr, po prostu sprawdzając logi kontenera.
```
# 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.pl.md Normal file
View File

@ -0,0 +1,8 @@
---
title: SMTP
weight: 16
---
Konfiguracja SMTP umożliwia twojemu serwerowi wysyłanie powiadomień e-mail, takich jak zaproszenia użytkowników, weryfikacje logowania oraz alarmy połączeń.
[Instrukcja wideo](https://youtu.be/0LyQY1JS4Uc)

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

@ -0,0 +1,76 @@
---
title: Strategia
weight: 200
---
Strategia to narzędzie dla administratorów RustDesk umożliwiające masową aktualizację ustawień bezpieczeństwa na stronach konfiguracji klientów. Administratorzy mogą tworzyć różne strategie i stosować je do różnych urządzeń.
## Tworzenie strategii
Nową strategię można utworzyć, klikając przycisk `+`, a następnie wykonując różne akcje poprzez najechanie na strategię i kliknięcie menu.
W menu kontekstowym można wybrać opcje `Włącz` lub `Wyłącz` strategię, `Zmień nazwę`, `Duplikuj` lub `Usuń`. Dodatkowo można kliknąć `Edytuj urządzenia`, aby zmodyfikować urządzenia przypisane do danej strategii, lub `Edytuj użytkowników`, aby zmodyfikować przypisanych użytkowników.
Po prawej stronie menu strategii widoczna jest liczba urządzeń faktycznie przypisanych do strategii, uwzględniając jej priorytet.
![](/docs/en/self-host/rustdesk-server-pro/strategy/images/strategy_menu.png)
## Strategia urządzenia, strategia użytkownika i strategia grupy urządzeń
Strategie są stosowane według następującej kolejności priorytetów:
1. Strategia urządzenia (najwyższy priorytet)
2. Strategia użytkownika
3. Strategia grupy urządzeń (najniższy priorytet)
Każde urządzenie może być zarządzane tylko przez jedną strategię naraz. System priorytetów działa następująco:
- Strategie urządzeń mają pierwszeństwo przed strategiami użytkowników i grup urządzeń
- Strategie użytkowników mają pierwszeństwo przed strategiami grup urządzeń
- Strategie grup urządzeń dotyczą wszystkich urządzeń w grupie, które nie mają przypisanej strategii urządzenia ani użytkownika
## Edycja urządzeń
Po kliknięciu menu `Edytuj urządzenia` otworzy się okno dialogowe zawierające listę wszystkich urządzeń. Można zmieniać stan zaznaczenia pól wyboru, a następnie kliknąć przycisk `Zapisz`, aby zastosować zmiany na bieżącej stronie. Aby zmodyfikować urządzenia na innych stronach, należy do nich przejść. Można również użyć menu rozwijanego w prawym górnym rogu do filtrowania urządzeń.
Format kolumny strategii: strategia urządzenia/strategia użytkownika/strategia grupy urządzeń lub "-" dla strategii domyślnej.
Przykład okna dialogowego po kliknięciu `Edytuj urządzenia` w menu "demo1":
- Urządzenie "1981241962" przypisane do strategii "demo3"
- Urządzenie "1279471875" przypisane do strategii "demo2"
- Urządzenie "a123456" przypisane do strategii "demo1"
- Urządzenie "1227624460" przypisane do strategii domyślnej
![](/docs/en/self-host/rustdesk-server-pro/strategy/images/edit_devices.png)
## Edycja użytkowników
Po kliknięciu menu `Edytuj użytkowników` otworzy się okno dialogowe zawierające listę wszystkich użytkowników. Można zmieniać stan zaznaczenia pól wyboru, a następnie kliknąć przycisk `Zapisz`, aby zastosować zmiany na bieżącej stronie. Aby zmodyfikować użytkowników na innych stronach, należy do nich przejść. Można również użyć menu rozwijanego w prawym górnym rogu do filtrowania użytkowników.
Przykład okna dialogowego po kliknięciu `Edytuj użytkowników` w menu "demo2":
- Użytkownik "admin" przypisany do strategii "domyślna"
- Użytkownik "user1" przypisany do strategii "demo2"
- Użytkownik "user2" przypisany do strategii "demo3"
![](/docs/en/self-host/rustdesk-server-pro/strategy/images/edit_users.png)
## Edycja grup urządzeń
Po kliknięciu menu `Edytuj grupę urządzeń` otworzy się okno dialogowe zawierające listę wszystkich grup urządzeń. Można zmieniać stan zaznaczenia pól wyboru, a następnie kliknąć przycisk `Zapisz`, aby zastosować zmiany na bieżącej stronie. Aby zmodyfikować grupy na innych stronach, należy do nich przejść. Można również użyć menu rozwijanego w prawym górnym rogu do filtrowania grup.
Przykład okna dialogowego po kliknięciu `Edytuj grupę urządzeń` w menu "demo1":
- Grupa "device_group1" przypisana do strategii "demo1"
- Grupa "group2" przypisana do strategii "demo2"
- Grupa "group3" przypisana do strategii "domyślna"
![](/docs/en/self-host/rustdesk-server-pro/strategy/images/edit_device_groups.png)
## Synchronizacja strategii
Każde urządzenie może być zarządzane tylko przez jedną strategię. Jeśli strategia jest wyłączona, urządzenie nie będzie zarządzane przez żadną strategię. Podczas synchronizacji RustDesk porównuje znaczniki czasu strategii lokalnych i serwera, aby określić konieczność synchronizacji. Po zakończeniu synchronizacji:
* Jeśli użytkownik zmieni niektóre opcje, klient użyje opcji użytkownika
* Jeśli administrator zmieni zawartość strategii, opcje klienta zostaną zsynchronizowane
* Jeśli administrator zmieni strategię przypisaną do urządzenia, opcje klienta zostaną zsynchronizowane
## Modyfikacja strategii
Na dole strategii należy kliknąć `Edytuj`, wprowadzić zmiany i kliknąć `Zatwierdź`. Strategia zostanie zsynchronizowana z urządzeniami w ciągu 30 sekund.

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

@ -0,0 +1,14 @@
---
title: Samouczki wideo
weight: 50
---
## OSS
[NetworkChuck: Twój Zdalny Pulpit SSIE!! Wypróbuj zamiast tego to (DARMOWE + Open Source)](https://www.youtube.com/watch?v=EXL8mMUXs88)
[Instrukcja instalacji i obsługi](https://www.youtube.com/watch?v=9nzHm3xGz2I)
[Zabezpieczenia RustDeska](https://www.youtube.com/watch?v=EeFqj23jxMk)
## Pro
[Kanał YouTube](https://youtube.com/@rustdesk)

7
hugo.yaml
View File

@ -129,6 +129,13 @@ languages:
# params:
# landingPageName: "🏠 Домашняя страница"
pl:
title: "Dokumentacja RustDesk"
weight: 2
languageName: "Polski"
params:
landingPageName: "Strona główna"
pt:
title: "Documentação para RustDesk"
weight: 2