PostgreSQL w Tailscale: bind i kolejność startu
Jak otworzyć PostgreSQL tylko dla tailnetu: bind na adres 100.x, wąski pg_hba albo tailscale serve. Plus wyścig przy restarcie i poprawka w systemd.
Jak wystawić PostgreSQL przez Tailscale, a nie do internetu
PostgreSQL przez Tailscale da się udostępnić na trzy sposoby. Pierwszy to bind na adres 100.x węzła. Drugi to nasłuch na wszystkich adresach z wąskim pg_hba.conf i regułą firewalla. Trzeci to zostawienie bazy na localhost i wystawienie jej poleceniem tailscale serve --tcp. Trzeci sposób w ogóle nie ma problemu z kolejnością startu. Pierwszy go ma: po restarcie serwera PostgreSQL może wystartować, zanim Tailscale ustawi adres 100.x, i wtedy baza nie nasłuchuje tam, gdzie się jej spodziewasz.
Ten poradnik zakłada, że Tailscale już działa na Twoim VPS-ie. Bazę chcesz otworzyć dla laptopa albo drugiego serwera w tym samym tailnecie (prywatnej sieci Tailscale). Port 5432 nie może być widoczny z publicznego internetu. Wszystkie polecenia uruchamiasz sam, na swoim serwerze. Przy każdym podaję, co powinieneś zobaczyć.
Od czego zaczynamy: Ubuntu 26.04, PostgreSQL 18, Tailscale 1.96+
Na Ubuntu 26.04 LTS pakiet postgresql instaluje PostgreSQL 18. W repozytorium resolute metapakiet ma wersję 18+290ubuntu1, a pakiet źródłowy postgresql-18 jest w wersji 18.6 (stan na 19 listopada 2026). Na Ubuntu 24.04 ten sam pakiet daje PostgreSQL 16, więc tam w ścieżkach i nazwach jednostek zamień 18 na 16. Sprawdź, co masz:
apt-cache policy postgresql
pg_lsclusterspg_lsclusters pokazuje wersję, nazwę klastra, port i status. Na świeżej instalacji powinieneś zobaczyć klaster 18 main na porcie 5432. Ubuntu trzyma pliki konfiguracyjne w /etc/postgresql/<wersja>/main, czyli tutaj w /etc/postgresql/18/main. Każdy klaster działa jako osobna usługa systemd o nazwie postgresql@<wersja>-<klaster>, czyli postgresql@18-main.service. Usługa postgresql.service jest nadrzędna. Uruchamia, zatrzymuje i przeładowuje wszystkie klastry naraz.
Teraz Tailscale:
tailscale version
tailscale ip -4tailscale ip -4 wypisuje tylko adres IPv4 węzła w tailnecie, na przykład 100.101.102.103. Zapisz go, bo będzie potrzebny w kilku miejscach. W przykładach poniżej serwer z bazą ma adres 100.101.102.103, a laptop 100.88.10.20.
Polecenie tailscale wait, z którego korzystam dalej, pojawiło się w Tailscale 1.96. W dzienniku zmian jest przy wersji 1.96.2 z 18 marca 2026. Najnowszy klient w dzienniku zmian to dziś 1.104.7. Jeśli tailscale version pokazuje coś starszego niż 1.96, zaktualizuj pakiet albo użyj wariantu z własną pętlą opisanego niżej. Gdy instalacja Tailscale na Ubuntu kończy się błędem, zajrzyj do poradnika o naprawie błędów instalacji Tailscale na Ubuntu.
Trzy sposoby w skrócie
- Sposób A.
listen_addresseswskazuje adres 100.x. Baza nasłuchuje tylko w tailnecie. Wymaga poprawnej kolejności startu, bo przed startem Tailscale tego adresu nie ma. - Sposób B.
listen_addresses = '*', do tego wąskie wpisy wpg_hba.confi reguła firewalla. W tym sposobie wyścigu przy starcie nie ma, ale port 5432 jest otwarty także na publicznym interfejsie. Całą ochronę przejmują firewall ipg_hba.conf. - Sposób C. PostgreSQL zostaje na
localhost, atailscale serve --tcpprzekazuje do niego ruch z tailnetu. Bazy nie da się źle zbindować, bolocalhostistnieje zawsze. - Wariant Docker Compose.
ports: "100.x.y.z:5432:5432"ma ten sam wyścig co sposób A, tylko po stronie Dockera.
Sposób A: listen_addresses na adres 100.x
Domyślnie listen_addresses ma wartość localhost. Ustawienie przyjmuje listę adresów IP lub nazw hostów rozdzieloną przecinkami. Otwórz /etc/postgresql/18/main/postgresql.conf i ustaw:
listen_addresses = 'localhost,100.101.102.103'localhost zostawiam celowo. Lokalne aplikacje i kopie zapasowe dalej łączą się przez pętlę zwrotną (loopback), nawet gdy coś stanie się z Tailscale. Połączenia przez gniazdo Unix działają niezależnie od tej listy.
Zmiana listen_addresses działa dopiero po restarcie serwera. Samo przeładowanie (reload) nie wystarczy:
sudo systemctl restart postgresql.service
sudo ss -ltnp | grep 5432Wynik ss powinien pokazać dwa gniazda w stanie LISTEN: 127.0.0.1:5432 i 100.101.102.103:5432. Jeśli widzisz coś innego, sprawdź, jaką wartość serwer naprawdę wczytał: sudo -u postgres psql -c 'SHOW listen_addresses;'. Inna wartość oznacza, że jakieś inne ustawienie nadpisuje Twoje albo że serwer nie został zrestartowany. Teraz dopisz klienta do /etc/postgresql/18/main/pg_hba.conf. O tym, jak wąski ma być ten wpis, piszę niżej w części o pg_hba.conf.
Dlaczego PostgreSQL startuje przed Tailscale
Po restarcie maszyny systemd uruchamia usługi równolegle. Kolejność wymusza tylko After= albo Before=. Dokumentacja systemd mówi to wprost: bez zależności porządkującej obie jednostki startują jednocześnie, bez żadnego opóźnienia. Sprawdź, po czym startuje Twój klaster:
systemctl show -p After postgresql@18-main.service
systemd-analyze critical-chain postgresql@18-main.serviceJeśli na liście After= nie ma tailscaled.service ani tailscale-online.target, nic nie każe bazie czekać na Tailscale. Sama usługa tailscaled.service z repozytorium Tailscale porządkuje się po network-pre.target, NetworkManager i systemd-resolved. Nie czeka na network-online.target. Adres 100.x nie istnieje, dopóki Tailscale go nie ustawi, a PostgreSQL może próbować się na nim zbindować wcześniej.
Co wtedy dzieje się z bazą, wynika z dokumentacji PostgreSQL. Gdy lista nie jest pusta, serwer startuje, jeśli uda mu się nasłuchiwać na co najmniej jednym adresie TCP/IP. Dla każdego adresu, którego nie da się otworzyć, zapisuje ostrzeżenie. To daje dwa różne objawy:
- Z
listen_addresses = 'localhost,100.101.102.103'baza wstaje, ale tylko na127.0.0.1. Do tailnetu nie wraca sama. Laptop dostaje odmowę połączenia, dopóki nie zrestartujesz PostgreSQL ręcznie. To cichszy i gorszy przypadek. - Z
listen_addresses = '100.101.102.103'żaden adres TCP się nie otwiera. Dokumentacja nie mówi tego słowami, ale wynika z niej, że serwer wtedy nie wystartuje.
Nie podaję tutaj dokładnej treści komunikatu, bo nie odtworzyłem tego wyścigu na prawdziwym restarcie. Sprawdź go u siebie. Po restarcie serwera uruchom:
journalctl -b -u postgresql@18-main.service
sudo ss -ltnp | grep 5432Szukaj ostrzeżenia o adresie, którego nie dało się otworzyć. Jeśli ss pokazuje tylko 127.0.0.1:5432, wyścig wystąpił, nawet gdy w dzienniku nic nie rzuca się w oczy. Na jednym serwerze może się to zdarzać co kilka restartów, na innym nigdy. Zależy to od tego, jak szybko Tailscale połączy się z serwerem koordynującym.
Naprawa: drop-in systemd z tailscale-online.target
tailscale wait czeka, aż zasoby Tailscale będą gotowe do bindowania. Według dokumentacji CLI od wersji 1.96 jedynym takim zasobem jest interfejs Tailscale i jego adresy. Polecenie zwraca kod 0, gdy się udało, i inny kod przy błędzie albo po przekroczeniu czasu. Dokumentacja Tailscale opisuje też cel tailscale-online.target dla systemd, który uruchamia właśnie tailscale wait. Najpierw sprawdź, czy Twój pakiet go dostarcza:
systemctl cat tailscale-online.target
systemctl cat tailscale-wait-online.serviceW repozytorium Tailscale cel tailscale-online.target wymaga usługi tailscale-wait-online.service i startuje po niej. Ta usługa jest typu oneshot, uruchamia /usr/bin/tailscale wait, ma RemainAfterExit=yes i sama startuje po tailscaled.service. Nie sprawdzałem, od której wersji pakietów te pliki trafiają do systemu, ani czy każdy pakiet dystrybucji je instaluje. Jeśli systemctl cat odpowiada No files found, przejdź do następnej sekcji.
Gdy cel istnieje, dodaj plik drop-in, czyli nakładkę na jednostkę, której nie edytujesz bezpośrednio. Według dokumentacji systemd drop-iny w /etc/ mają pierwszeństwo przed tymi z /run/ i /usr/lib/. Aktualizacja pakietu PostgreSQL nie zmienia Twojego pliku w /etc/systemd/system:
sudo mkdir -p /etc/systemd/system/postgresql@18-main.service.d
printf '[Unit]\nWants=tailscale-online.target\nAfter=tailscale-online.target\n' \
| sudo tee /etc/systemd/system/postgresql@18-main.service.d/10-tailscale.conf
sudo systemctl daemon-reload
systemctl show -p After -p Wants postgresql@18-main.serviceOstatnie polecenie powinno pokazać tailscale-online.target zarówno w After=, jak i w Wants=. Dwie linie robią dwie różne rzeczy. Wants= dociąga cel do startu systemu. After= każe na niego poczekać. Sama linia Wants= niczego nie porządkuje, bo według dokumentacji systemd zależności wymagające nie wpływają na kolejność startu.
Dlaczego Wants=, a nie Requires=? Z Requires= jednostka zostaje zatrzymana albo zrestartowana, gdy wymagana jednostka zostanie jawnie zatrzymana albo zrestartowana. Restart celu Tailscale restartowałby wtedy bazę danych. Z Wants= baza startuje nawet wtedy, gdy czekanie się nie powiedzie, więc lokalne aplikacje na localhost dalej działają. Więcej o tej różnicy znajdziesz w tekście o zależnościach i warunkach w systemd.
Jest jedna pułapka. Usługi typu oneshot w systemd domyślnie nie mają limitu czasu startu, a tailscale wait --timeout=0 czeka bez końca. Sprawdź domyślny limit w swojej wersji:
tailscale wait --helpJeśli Twój tailscale wait może czekać w nieskończoność, a Tailscale nie połączy się po restarcie, PostgreSQL też nigdy nie wystartuje. Wtedy dodaj limit na samą usługę czekającą:
sudo mkdir -p /etc/systemd/system/tailscale-wait-online.service.d
printf '[Service]\nTimeoutStartSec=90\n' \
| sudo tee /etc/systemd/system/tailscale-wait-online.service.d/10-timeout.conf
sudo systemctl daemon-reloadPo 90 sekundach systemd uzna czekanie za nieudane. PostgreSQL dzięki Wants= i tak wystartuje, przynajmniej na localhost.
Gdy nie masz tailscale-online.target: własna jednostka z pętlą
Na starszym pakiecie albo bez plików jednostek możesz zrobić to samo ręcznie. Poniższa jednostka to mój własny układ, a nie przepis z dokumentacji Tailscale. Działa jak tailscale-wait-online.service, ale zamiast tailscale wait sprawdza co sekundę, czy adres 100.x jest już przypisany do interfejsu w jądrze. Bind potrzebuje dokładnie tego warunku. Zapisz ją jako /etc/systemd/system/tailscale-addr-ready.service:
[Unit]
Description=Czekaj na adres Tailscale 100.101.102.103
Wants=tailscaled.service
After=tailscaled.service
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/bin/sh -c 'for i in $(seq 1 60); do ip -4 -o addr show | grep -qF "inet 100.101.102.103/" && exit 0; sleep 1; done; echo "brak adresu Tailscale po 60 s" >&2; exit 1'Pętla kończy się sama po 60 próbach, więc nie zależy od limitu czasu systemd. Wpisz swój adres z tailscale ip -4 w obu miejscach. Przetestuj jednostkę ręcznie, a potem podepnij do niej PostgreSQL:
sudo systemctl daemon-reload
sudo systemctl start tailscale-addr-ready.service
systemctl status tailscale-addr-ready.service
sudo mkdir -p /etc/systemd/system/postgresql@18-main.service.d
printf '[Unit]\nWants=tailscale-addr-ready.service\nAfter=tailscale-addr-ready.service\n' \
| sudo tee /etc/systemd/system/postgresql@18-main.service.d/10-tailscale.conf
sudo systemctl daemon-reloadsystemctl status powinien pokazać active (exited). Stan failed z napisem brak adresu Tailscale po 60 s w dzienniku oznacza, że adres w pliku nie zgadza się z adresem na interfejsie. Często spotkasz radę, żeby taką pętlę wpisać jako ExecStartPre= w samej usłudze PostgreSQL. Wybrałem osobną jednostkę, bo tę samą może wskazać także Docker, o czym niżej. Nie trzeba jej włączać przez enable. Wants= w drop-inie dociąga ją przy każdym starcie bazy.
Sposób B: nasłuch na wszystkim, wąski pg_hba i firewall
Z listen_addresses = '*' PostgreSQL nasłuchuje na wszystkich interfejsach. Bind na adres wieloznaczny nie wymaga istnienia konkretnego adresu, więc wyścigu przy starcie nie ma. Ceną jest to, że port 5432 odpowiada też na publicznym IP serwera. Odrzucenie obcego połączenia robią wtedy dwie warstwy: firewall i pg_hba.conf. Obie muszą być poprawne.
Firewall na Ubuntu to zwykle ufw. Najpierw sprawdź nazwę interfejsu Tailscale i politykę dla ruchu przychodzącego:
ip -br addr | grep '100\.'
sudo ufw status verboseW przykładzie interfejs nazywa się tailscale0. Jeśli u Ciebie jest inaczej, podmień nazwę. Przy polityce deny (incoming) dodaj jedną regułę, która wpuszcza 5432 tylko z interfejsu Tailscale:
sudo ufw allow in on tailscale0 to any port 5432 proto tcp
sudo ufw status numberedNie dodawaj ogólnego sudo ufw allow 5432/tcp. Taka reguła otworzyłaby port dla całego internetu. Jeśli dostawca VPS-a ma osobny firewall sieciowy w panelu, nie otwieraj w nim 5432 wcale. Ruch z tailnetu dociera do serwera tunelem Tailscale, a nie bezpośrednio na port 5432.
pg_hba.conf: dlaczego 100.64.0.0/10 to za dużo
Tailscale przydziela adresy z puli 100.64.0.0/10, czyli od 100.64.0.0 do 100.127.255.255. To przestrzeń CGNAT (carrier-grade NAT, czyli NAT po stronie operatora) z RFC 6598, zarezerwowana dla sieci dostawców internetu. To nie jest „Twój tailnet”. Wpis 100.64.0.0/10 w pg_hba.conf pasuje do każdego źródła z tej puli, nie tylko do Twoich urządzeń. Węższy i lepszy wybór to osobny wpis /32 dla każdego klienta. W notacji CIDR (classless inter-domain routing) /32 oznacza dokładnie jeden adres IPv4.
PostgreSQL czyta pg_hba.conf od góry. Używa pierwszego wpisu, który pasuje do typu połączenia, adresu klienta, bazy i użytkownika. Nie ma przejścia do kolejnych linii: jeśli wybrany wpis odrzuci hasło, następne nie są już sprawdzane. Jeśli nic nie pasuje, dostęp jest zabroniony. Dopisz klientów nad wszelkimi szerszymi liniami host:
# TYPE DATABASE USER ADDRESS METHOD
host appdb appuser 100.88.10.20/32 scram-sha-256
host appdb appuser 100.90.1.5/32 scram-sha-256Typ host pasuje do każdego połączenia TCP/IP, z SSL i bez. scram-sha-256 to uwierzytelnianie hasłem metodą SCRAM (salted challenge response authentication mechanism), w której hasło nie idzie przez sieć jawnym tekstem. Użytkownik musi więc mieć hasło. Ustaw je w psql, a potem przeładuj konfigurację. pg_hba.conf jest wczytywany przy starcie i po sygnale SIGHUP, więc restart nie jest potrzebny:
sudo -u postgres psql -c '\password appuser'
sudo systemctl reload postgresql.serviceZ laptopa sprawdź połączenie przez psql "host=100.101.102.103 dbname=appdb user=appuser". Komunikat no pg_hba.conf entry for host oznacza, że żaden wpis nie pasuje do adresu, z którego naprawdę przychodzi połączenie. Porównaj go z wynikiem tailscale ip -4 na kliencie.
Grant w Tailscale: tylko tcp:5432 i tylko do tagu
pg_hba.conf ogranicza, kto może się zalogować. Polityka tailnetu ogranicza, kto w ogóle dojdzie do portu. Tailscale zaleca do większości zastosowań reguły typu grant. Mogą one współistnieć ze starszymi regułami ACL w tym samym pliku polityki. Poniższy przykład składam z dwóch stron dokumentacji Tailscale i nie testowałem go na żywym tailnecie. Sprawdź go w edytorze polityki przed zapisem:
{
"tagOwners": {
"tag:db": []
},
"grants": [
{
"src": ["ty@example.com", "tag:app"],
"dst": ["tag:db"],
"ip": ["tcp:5432"]
}
]
}Pusta lista przy tag:db oznacza według dokumentacji, że właścicielem tagu jest autogroup:admin. Jako src możesz podać adres e-mail użytkownika (wtedy wszystkie jego urządzenia) albo inny tag, na przykład serwer aplikacji. Tag nadajesz serwerowi bazy tak:
sudo tailscale up --advertise-tags=tag:db --force-reauthZanim to zrobisz, zapamiętaj dwie rzeczy. Tag usuwa z urządzenia tożsamość użytkownika, a przy pierwszym otagowaniu wyłącza wygasanie klucza. Druga sprawa jest ważniejsza. Jeśli nie zdefiniowałeś żadnych reguł, Tailscale stosuje domyślną politykę, która pozwala wszystkim urządzeniom łączyć się ze wszystkimi. Nowy tailnet ma właśnie taką regułę w pliku. Wąski grant niczego nie ogranicza, dopóki ta szeroka reguła zostaje obok niego. Usuń ją albo zawęź, a potem sprawdź, czy inne urządzenia dalej mają dostęp tam, gdzie powinny.
Sposób C: Postgres na localhost i tailscale serve --tcp
Najprostszy sposób to w ogóle nie ruszać listen_addresses. PostgreSQL zostaje na domyślnym localhost, a Tailscale przekazuje do niego ruch TCP z tailnetu:
sudo tailscale serve --bg --tcp=5432 tcp://localhost:5432
tailscale serve statustailscale serve udostępnia usługę wewnątrz tailnetu. Do publicznego internetu wystawia usługi osobne polecenie, Funnel, którego tutaj nie używasz. Flaga --bg sprawia, że konfiguracja działa w tle i wraca po restarcie maszyny albo Tailscale. Bez niej trzeba ją uruchamiać ręcznie. Dokumentacja Serve nie ma gotowego przykładu z samym --tcp, a w jednym miejscu pisze -bg, w innym --bg. Sprawdź więc dokładną składnię w tailscale serve --help na swojej wersji. Przekazywanie portu nie wymaga roota. Root jest potrzebny tylko do serwowania pliku, katalogu albo gniazda Unix.
Wyścigu przy starcie tu nie ma, bo localhost istnieje od pierwszej sekundy, a Tailscale przekazuje ruch dopiero wtedy, gdy sam działa. Jest za to inny koszt. Przekaźnik Tailscale łączy się z localhost:5432. Sprawdź, jaki adres klienta widzi wtedy PostgreSQL:
sudo -u postgres psql -c 'SELECT client_addr, usename FROM pg_stat_activity WHERE client_addr IS NOT NULL;'Jeśli client_addr to 127.0.0.1 albo ::1, wpisy /32 dla klientów w pg_hba.conf nic nie dadzą. Potrzebujesz wpisu host dla 127.0.0.1/32 i ::1/128 z scram-sha-256. Kontrola tego, kto dochodzi do portu, przechodzi wtedy w całości na grant w Tailscale. Przy tym sposobie grant z poprzedniej sekcji jest więc jedyną warstwą, która rozróżnia klientów. Aby wyłączyć przekazywanie, powtórz polecenie z tymi samymi flagami i dopisz na końcu off. tailscale serve reset czyści całą konfigurację Serve.
Wariant Docker Compose: ten sam wyścig
Jeśli baza działa w kontenerze, Docker domyślnie publikuje porty na wszystkich adresach hosta. Wariant tylko dla tailnetu wygląda tak:
services:
db:
# obraz, wolumeny i zmienne bez zmian
restart: unless-stopped
ports:
- "100.101.102.103:5432:5432"Dokumentacja Compose każe zawsze pisać HOST:CONTAINER w cudzysłowie, bo YAML bez niego potrafi odczytać taką wartość jako liczbę. Problem jest ten sam co w sposobie A. Docker uruchamia kontenery z polityką restartu przy starcie demona, a sam docker.service nie musi być uporządkowany po Tailscale. Sprawdź to przez systemctl show -p After docker.service. Dokumentacja Dockera nie opisuje, co się dzieje, gdy adresu z mapowania portu jeszcze nie ma, więc nie zgaduję treści błędu. Po restarcie sprawdź docker compose ps i docker compose logs db. Kontener, który nie wstał albo nie ma opublikowanego portu, to objaw wyścigu. Jak Docker podnosi stosy po restarcie, opisuje osobny tekst o automatycznym starcie Docker Compose po restarcie.
Poprawka to ten sam drop-in, tylko na docker.service:
sudo mkdir -p /etc/systemd/system/docker.service.d
printf '[Unit]\nWants=tailscale-online.target\nAfter=tailscale-online.target\n' \
| sudo tee /etc/systemd/system/docker.service.d/10-tailscale.conf
sudo systemctl daemon-reloadBez tailscale-online.target wskaż tailscale-addr-ready.service z wcześniejszej sekcji. Pamiętaj, że teraz na Tailscale czeka cały Docker, czyli wszystkie kontenery na tej maszynie. Często lepiej przenieść bazę na sposób C. Opublikuj ją jako "127.0.0.1:5432:5432", a do tailnetu wystaw przez tailscale serve.
Druga uwaga dotyczy firewalla. Porty opublikowane przez Dockera omijają reguły ufw, bo Docker przekierowuje ruch w tabeli nat, zanim dotrze on do łańcuchów, których używa ufw. Szczegóły są w tekście dlaczego porty Dockera omijają ufw. Reguła ufw ze sposobu B nie chroni więc kontenera opublikowanego na 0.0.0.0. Jeśli zastanawiasz się, czy baza w ogóle powinna działać w kontenerze, zobacz porównanie bazy w Dockerze i na hoście.
Jak sprawdzić, że baza nie jest publiczna
Nie zakładaj, tylko sprawdź z zewnątrz. Z maszyny spoza tailnetu, na przykład z innego serwera, spróbuj połączyć się z publicznym IP VPS-a:
nc -vz -w 3 203.0.113.10 5432Zamiast 203.0.113.10 wpisz publiczny adres swojego serwera. Poprawny wynik to przekroczony czas albo odmowa połączenia. Komunikat o udanym połączeniu (jego treść zależy od wersji nc) oznacza, że 5432 jest otwarty dla świata. Wtedy wróć do firewalla albo do listen_addresses. Więcej metod znajdziesz w poradniku jak sprawdzić, czy port jest otwarty w Linuksie. Ten sam test z laptopa w tailnecie, na adres 100.x, powinien się udać.
Który sposób wybrać
Dla jednej bazy i kilku klientów polecam sposób C. Nie ma w nim wyścigu przy starcie, nie zmieniasz listen_addresses, a ruch kontroluje grant w Tailscale. Sposób A wybierz, gdy PostgreSQL ma widzieć prawdziwe adresy klientów, na przykład dla wpisów /32 w pg_hba.conf albo dla logów połączeń. Wtedy drop-in systemd jest obowiązkowy. Sposób B ma sens, gdy baza musi słuchać na kilku sieciach naraz i masz pewny firewall. Po każdej zmianie zrób jeden prawdziwy restart serwera i sprawdź ss -ltnp. Wyścig przy starcie widać tylko na prawdziwym restarcie.
FAQ
Dlaczego po restarcie serwera nie mogę połączyć się z PostgreSQL przez Tailscale?
Najczęściej PostgreSQL wystartował, zanim Tailscale ustawił adres 100.x. Z listen_addresses = 'localhost,100.x.y.z' baza działa wtedy tylko na 127.0.0.1 i zapisuje ostrzeżenie o adresie, którego nie dała rady otworzyć. Sprawdź sudo ss -ltnp | grep 5432 i journalctl -b -u postgresql@18-main.service. Naprawa to drop-in z Wants= i After= wskazującymi tailscale-online.target albo własną jednostkę, która czeka na adres.
Od której wersji Tailscale jest dostępne tailscale wait?
Według dziennika zmian i dokumentacji CLI Tailscale od wersji 1.96. Wpis jest przy wersji 1.96.2 z 18 marca 2026. Swoją wersję sprawdzisz przez tailscale version. Cel tailscale-online.target jest opisany w dokumentacji CLI, ale nie każdy pakiet musi go instalować. Sprawdź go przez systemctl cat tailscale-online.target.
Czy wpis 100.64.0.0/10 w pg_hba.conf jest bezpieczny?
Jest za szeroki. 100.64.0.0/10 to cała przestrzeń CGNAT, a nie tylko Twój tailnet. Dodaj osobny wpis /32 dla każdego klienta z metodą scram-sha-256, a w polityce Tailscale ogranicz dostęp do tcp:5432 na urządzeniu z tagiem bazy. Pamiętaj, że w pg_hba.conf wygrywa pierwsza pasująca linia.
Czy tailscale serve --tcp wystawia bazę do internetu?
Nie. tailscale serve udostępnia usługę tylko w tailnecie, a do publicznego internetu służy osobne polecenie Funnel. Dodaj --bg, żeby przekazywanie wracało po restarcie. Sprawdź w pg_stat_activity, jaki adres klienta widzi PostgreSQL. Jeśli to localhost, o tym, kto dochodzi do portu, decyduje grant w Tailscale.