Commit 32a17cab authored by Eugen Rochko's avatar Eugen Rochko

Merge branch 'master' into 'master'

Polish translation

See merge request !1
parents 821bb8d8 6058bdf0
Pipeline #354 passed with stages
in 17 seconds
......@@ -13,6 +13,10 @@ enableGitInfo = true
contentDir = "content/en"
languageName = "English"
weight = 1
[languages.pl]
contentDir = "content/pl"
languageName = "Polski"
weight = 1
[menu]
[[menu.docs]]
......
---
title: Dokumentacja Mastodona
---
Witaj w dokumentacji Mastodona!
<div style="margin-bottom: 26px">
{{< youtube "IPSbNdBmWKE" >}}
</div>
**Wybierz swoją drogę:**
- [Dowiedz się jak korzystać z Mastodona]({{< relref "usage/basics.md" >}})
- [Dowiedz się jak zainstalować Mastodona]({{< relref "administration/installation.md" >}})
- [Dowiedz się jak napisać aplikację dla Mastodona]()
---
title: Konfigruacja
description: Omówienie opcji konfiguracji Mastodona
menu:
docs:
parent: administration
weight: 2
---
Mastodon używa zmiennych środowiskowych do konfiguracji.
Dla zwiększenia wygody, mogą one być odczytywane z pliku `.env.production` znajdującego się w katalogu Mastodona, ale mogą zostać zawsze nadpisane przez zewnętrzny proces. Dla przykładu, pliki usług systemd mogą odczytywać zmienne środowiskowe z `EnvironmentFile` lub definicji w `Environment`, więc możesz ustawić oddzielne parametry konfiguracji dla poszczególnych usług. Mogą też być określone podczas uruchamiania Mastodona z wiersza poleceń.
## Podstawowe
### Federacja
- `LOCAL_DOMAIN`
- `WEB_DOMAIN`
- `ALTERNATE_DOMAINS`
### Tajne klucze
- `SECRET_KEY_BASE`
- `OTP_SECRET`
- `VAPID_PRIVATE_KEY`
- `VAPID_PUBLIC_KEY`
### Deployment
- `RAILS_ENV`
- `RAILS_SERVE_STATIC_FILES`
- `RAILS_LOG_LEVEL`
- `TRUSTED_PROXY_IP`
- `SOCKET`
- `PORT`
- `NODE_ENV`
- `BIND`
### Opcje skalowania
- `WEB_CONCURRENCY`
- `MAX_THREADS`
- `PREPARED_STATEMENTS`
- `STREAMING_API_BASE_URL`
- `STREAMING_CLUSTER_NUM`
## Połączenie z bazą danych
### PostgreSQL
- `DB_HOST`
- `DB_USER`
- `DB_NAME`
- `DB_PASS`
- `DB_PORT`
- `DATABASE_URL`
### Redis
- `REDIS_HOST`
- `REDIS_PORT`
- `REDIS_URL`
- `REDIS_NAMESPACE`
- `CACHE_REDIS_HOST`
- `CACHE_REDIS_PORT`
- `CACHE_REDIS_URL`
- `CACHE_REDIS_NAMESPACE`
### ElasticSearch
- `ES_ENABLED`
- `ES_HOST`
- `ES_PORT`
- `ES_PREFIX`
### StatsD
- `STATSD_ADDR`
- `STATSD_NAMESPACE`
## Ograniczenia
- `SINGLE_USER_MODE`
- `EMAIL_DOMAIN_WHITELIST`
- `DEFAULT_LOCALE`
- `MAX_SESSION_ACTIVATIONS`
- `USER_ACTIVE_DAYS`
## E-mail
- `SMTP_SERVER`
- `SMTP_PORT`
- `SMTP_LOGIN`
- `SMTP_PASSWORD`
- `SMTP_FROM_ADDRESS`
- `SMTP_DOMAIN`
- `SMTP_DELIVERY_METHOD`
- `SMTP_AUTH_METHOD`
- `SMTP_CA_FILE`
- `SMTP_OPENSSL_VERIFY_MODE`
- `SMTP_ENABLE_STARTTLS_AUTO`
- `SMTP_TLS`
## Przechowywanie plików
- `CDN_HOST`
- `S3_ALIAS_HOST`
### Lokalne przechowywanie plików
- `PAPERCLIP_ROOT_PATH`
- `PAPERCLIP_ROOT_URL`
### Amazon S3 i kompatybilne
- `S3_ENABLED`
- `S3_BUCKET`
- `AWS_ACCESS_KEY_ID`
- `AWS_SECRET_ACCESS_KEY`
- `S3_REGION`
- `S3_PROTOCOL`
- `S3_HOSTNAME`
- `S3_ENDPOINT`
- `S3_SIGNATURE_VERSION`
### Swift
- `SWIFT_ENABLED`
- `SWIFT_USERNAME`
- `SWIFT_TENANT`
- `SWIFT_PASSWORD`
- `SWIFT_PROJECT_ID`
- `SWIFT_AUTH_URL`
- `SWIFT_CONTAINER`
- `SWIFT_OBJECT_URL`
- `SWIFT_REGION`
- `SWIFT_DOMAIN_NAME`
- `SWIFT_CACHE_TTL`
## Zewnętrzne uwierzytelnianie
- `OAUTH_REDIRECT_AT_SIGN_IN`
### LDAP
- `LDAP_ENABLED`
- `LDAP_HOST`
- `LDAP_PORT`
- `LDAP_METHOD`
- `LDAP_BASE`
- `LDAP_BIND_DN`
- `LDAP_PASSWORD`
- `LDAP_UID`
- `LDAP_SEARCH_FILTER`
### PAM
- `PAM_ENABLED`
- `PAM_EMAIL_DOMAIN`
- `PAM_DEFAULT_SERVICE`
- `PAM_CONTROLLED_SERVICE`
### CAS
- `CAS_ENABLED`
- `CAS_URL`
- `CAS_HOST`
- `CAS_PORT`
- `CAS_SSL`
- `CAS_VALIDATE_URL`
- `CAS_CALLBACK_URL`
- `CAS_LOGOUT_URL`
- `CAS_LOGIN_URL`
- `CAS_UID_FIELD`
- `CAS_CA_PATH`
- `CAS_DISABLE_SSL_VERIFICATION`
- `CAS_UID_KEY`
- `CAS_NAME_KEY`
- `CAS_EMAIL_KEY`
- `CAS_NICKNAME_KEY`
- `CAS_FIRST_NAME_KEY`
- `CAS_LAST_NAME_KEY`
- `CAS_LOCATION_KEY`
- `CAS_IMAGE_KEY`
- `CAS_PHONE_KEY`
### SAML
- `SAML_ENABLED`
- `SAML_ACS_URL`
- `SAML_ISSUER`
- `SAML_IDP_SSO_TARGET_URL`
- `SAML_IDP_CERT`
- `SAML_IDP_CERT_FINGERPRINT`
- `SAML_NAME_IDENTIFIER_FORMAT`
- `SAML_CERT`
- `SAML_PRIVATE_KEY`
- `SAML_SECURITY_WANT_ASSERTION_SIGNED`
- `SAML_SECURITY_WANT_ASSERTION_ENCRYPTED`
- `SAML_SECURITY_ASSUME_EMAIL_IS_VERIFIED`
- `SAML_ATTRIBUTES_STATEMENTS_UID`
- `SAML_ATTRIBUTES_STATEMENTS_EMAIL`
- `SAML_ATTRIBUTES_STATEMENTS_FULL_NAME`
- `SAML_ATTRIBUTES_STATEMENTS_FIRST_NAME`
- `SAML_ATTRIBUTES_STATEMENTS_LAST_NAME`
- `SAML_UID_ATTRIBUTE`
- `SAML_ATTRIBUTES_STATEMENTS_VERIFIED`
- `SAML_ATTRIBUTES_STATEMENTS_VERIFIED_EMAIL`
## Ukryte usługi
- `http_proxy`
- `ALLOW_ACCESS_TO_HIDDEN_SERVICE`
## Inne
- `SKIP_POST_DEPLOYMENT_MIGRATIONS`
---
title: Instalacja
description: Jak zainstalować Mastodona na serwerze z Ubuntu 18.04
menu:
docs:
parent: administration
weight: 1
---
<img src="/setup.png" alt="" style="margin: 0; box-shadow: none">
## Podstawowa konfiguracja serwera (nieobowiązkowa)
Jeżeli konfigurujesz nowe urządzenie, zalecane jest zabezpieczenie go. Załóżmy, że korzystasz z **Ubuntu 18.04**:
### Nie pozwól na logowanie przez SSH z użyciem hasła (tylko kluczem)
Na początek upewnij się, że jesteś zalogowany(-a) z użyciem klucza, nie hasła – w przeciwnym razie zostaniesz zablokowany(-a). Wielu dostawców hostingu daje możliwość wysłania klucza publicznego i automatycznie konfiguruje logowanie użytkownika root z użyciem klucza.
Edytuj `/etc/ssh/sshd_config` i znajdź `PasswordAuthentication`. Upewnij się, że nie jest ono skomentowane i jest ustawione na `no`. Po dokonaniu zmian uruchom ponownie sshd:
```sh
systemctl restart ssh
```
### Aktualizacja pakietów systemowych
```sh
apt update && apt upgrade -y
```
### Instalacja fail2ban, aby blokował po wielu nieudanych próbach logowania
```sh
apt install fail2ban
```
Edytuj `/etc/fail2ban/jail.local` i dodaj:
```ini
[DEFAULT]
destemail = twój@email.tutaj
sendername = Fail2Ban
[sshd]
enabled = true
port = 22
[sshd-ddos]
enabled = true
port = 22
```
Na koniec, uruchom ponownie fail2ban:
```sh
systemctl restart fail2ban
```
### Zainstaluj firewall i odblokuj tylko porty SSH, HTTP i HTTPS
Na początek, zainstaluj iptables-persistent. Podczas instalacji zostaniesz zapytany(-a), czy chcesz pozostawić obecne zasady – odmów.
```sh
apt install -y iptables-persistent
```
Edytuj `/etc/iptables/rules.v4` i dodaj:z
```
*filter
# Allow all loopback (lo0) traffic and drop all traffic to 127/8 that doesn't use lo0
-A INPUT -i lo -j ACCEPT
-A INPUT ! -i lo -d 127.0.0.0/8 -j REJECT
# Accept all established inbound connections
-A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
# Allow all outbound traffic - you can modify this to only allow certain traffic
-A OUTPUT -j ACCEPT
# Allow HTTP and HTTPS connections from anywhere (the normal ports for websites and SSL).
-A INPUT -p tcp --dport 80 -j ACCEPT
-A INPUT -p tcp --dport 443 -j ACCEPT
# Allow SSH connections
# The -dport number should be the same port number you set in sshd_config
-A INPUT -p tcp -m state --state NEW --dport 22 -j ACCEPT
# Allow ping
-A INPUT -p icmp -m icmp --icmp-type 8 -j ACCEPT
# Log iptables denied calls
-A INPUT -m limit --limit 5/min -j LOG --log-prefix "iptables denied: " --log-level 7
# Reject all other inbound - default deny unless explicitly allowed policy
-A INPUT -j REJECT
-A FORWARD -j REJECT
COMMIT
```
Dzięki iptables-persistent, ta konfiguracja będzie ładowana w trakcie uruchomienia systemu. Ponieważ nie zamierzamy go teraz uruchomić ponownie, załadujmy ją ręcznie:
```sh
iptables-restore < /etc/iptables/rules.v4
```
## Wymagania wstępne
- Urządzenie z systemem **Ubuntu 18.04** wraz z dostępem do roota
- **Domena** (lub subdomena) dla serwera Mastodona, np. `example.com`
- Usługa doręczania e-maili lub inny **serwer SMTP**
Wykonaj te polecenia jako root. Jeżeli nie jesteś obecnie na koncie roota, przełącz się na nie:
```sh
sudo -i
```
### Repozytoria systemu
Upewnij się, że curl jest zainstalowany:
```sh
apt install -y curl
```
#### Node.js
```sh
curl -sL https://deb.nodesource.com/setup_8.x | bash -
```
#### Yarn
```sh
curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
```
### Pakiety systemowe
```sh
apt update
apt install -y \
imagemagick ffmpeg libpq-dev libxml2-dev libxslt1-dev file git-core \
g++ libprotobuf-dev protobuf-compiler pkg-config nodejs gcc autoconf \
bison build-essential libssl-dev libyaml-dev libreadline6-dev \
zlib1g-dev libncurses5-dev libffi-dev libgdbm5 libgdbm-dev \
nginx redis-server redis-tools postgresql postgresql-contrib \
certbot yarn libidn11-dev libicu-dev libjemalloc-dev
```
### Instalacja Ruby
Będziemy korzystać z rbenv, aby zarządzać wersjami Ruby, ponieważ ułatwia to przejście na prawidłową wersję po pojawieniu się nowego wydania. rbenv musi zostać zainstalowany dla każdego użytkownika który będzie go używał osobno, więc zacznijmy od utworzenia użytkownika, na którym uruchomimy Mastodona:
```sh
adduser --disabled-login mastodon
```
Możemy teraz zalogować się na to konto:
```sh
su - mastodon
```
I przejść do instalacji rbenv i rbenv-build:
```sh
git clone https://github.com/rbenv/rbenv.git ~/.rbenv
cd ~/.rbenv && src/configure && make -C src
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec bash
git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build
```
Po zakończeniu, możemy zainstalować prawidłową wersję Ruby:
```sh
RUBY_CONFIGURE_OPTS=--with-jemalloc rbenv install 2.5.1
rbenv global 2.5.1
```
Musimy też zainstalować bundler:
```sh
gem install bundler --no-ri --no-rdoc
```
Wróćmy na konto root:
```sh
exit
```
## Konfiguracja
### Konfiguracja PostgreSQL
#### Ustawienia wydajności (nieobowiązkowe)
Aby zwiększyć wydajność, możesz skorzystać z [pgTune](https://pgtune.leopard.in.ua/#/), aby wygenerować odpowiednie ustawienia i zmienić odpowiednie wartości w `/etc/postgresql/9.6/main/postgresql.conf` przed ponownym uruchomieniem PostgreSQL poleceniem `systemctl restart postgresql`
#### Tworzenie użytkownika
Musisz utowrzyć użytkownika PostgreSQL, z którego będzie mógł korzystać Mastodon. Najprościej użyć uwierzytelniania „ident” w prostym ustawieniu, tzn. użytkownik PostgreSQL nie będzie miał oddzielnego hasła i będzie mógł z niego korzystać linuksowy użytkownik o tej samej nazwie.
Przejdź do powłoki:
```sh
sudo -u postgres psql
```
Wykonaj:
```
CREATE USER mastodon CREATEDB;
\q
```
Gotowe!
### Konfiguracja Mastodona
Pora pobrać kod Mastodona. Przełącz się na użytkownika mastodon:
```sh
su - mastodon
```
#### Pobieranie kodu
Użyj narzędzia git, aby pobrać najnowsze stabilne wydanie Mastodona:
```sh
git clone https://github.com/tootsuite/mastodon.git live && cd live
git checkout $(git tag -l | grep -v 'rc[0-9]*$' | sort -V | tail -n 1)
```
#### Instalacja ostatnich zależności
Pora na instalację zależności używających Ruby i JavaScript:
```sh
bundle install \
-j$(getconf _NPROCESSORS_ONLN) \
--deployment --without development test
yarn install --pure-lockfile
```
#### Generowanie konfiguracji
Uruchom interaktywny konfigurator:
```sh
RAILS_ENV=production bundle exec rake mastodon:setup
```
W ten sposób:
- utworzysz plik konfiguracyjny
- wykonasz prekompilację zasobów
- utworzysz schemat bazy danych
Plik konfiguracyjny zostanie zapisany jako `.env.production`. Możesz przejrzeć i edytować go według swoich potrzeb. Możesz odwołać się do [documentacji konfiguracji]({{< relref "configuration.md" >}}).
Możesz wrócić na użytkownika root:
```sh
exit
```
### Konfiguracja nginx
Skopiuj przykładową konfigurację nginx z katalogu Mastodona:
```sh
cp /home/mastodon/live/dist/nginx.conf /etc/nginx/sites-available/mastodon
ln -s /etc/nginx/sites-available/mastodon /etc/nginx/sites-enabled/mastodon
```
Zedytuj `/etc/nginx/sites-available/mastodon` u zamień `example.com` na swoją domenę i dokonaj niezbędnych zmian.
Załaduj ponownie nginx, aby wprowadzić zmiany:
```sh
systemctl reload nginx
```
### Uzyskanie certyfikatu SSL
Skorzystamy z Let's Encrypt, aby uzyskać bezpłatny certyfikat SSL:
```sh
certbot certonly --webroot -d example.com -w /home/mastodon/live/public/
```
Możesz teraz zedytować `/etc/nginx/sites-available/mastodon`, aby zmodyfikowac wiersze `ssl_certificate` i `ssl_certificate_key`.
Załaduj ponownie nginx, aby wprowadzić zmiany:
```sh
systemctl reload nginx
```
W tym momencie, po odwiedzeniu domeny w przeglądarce powinieneś(-aś) zobaczyć stronę z błędem przedstawiającą słonia uderzającego w ekran komputera. To dlatego, że nie uruchomiliśmy jeszcze Mastodona.
### Konfiguracja usług systemd
Skopiuj szablony usług systemd z katalogu Mastodona:
```sh
cp /home/mastodon/live/dist/mastodon-*.service /etc/systemd/system/
```
Zedytuj następujące pliki, aby upewnić się czy nazwa użytkownika i ścieżki są prawidłowe:
- `/etc/systemd/system/mastodon-web.service`
- `/etc/systemd/system/mastodon-sidekiq.service`
- `/etc/systemd/system/mastodon-streaming.service`
Na koniec, uruchom i aktywuj nowe usługi systemd:
```sh
systemctl start mastodon-web mastodon-sidekiq mastodon-streaming
systemctl enable mastodon-*
```
Będą one automatycznie uruchamiane wraz z systemem.
**Hurra! To wszystko. Możesz teraz odwiedzić swoją domenę w przeglądarce!**
---
title: Dodatkowe funkcje
description: Jak włączyć dodatkowe funkcje Mastodona
menu:
docs:
parent: administration
weight: 5
---
## Wyszukiwanie tekstu
TODO
## Ukryte usługi
TODO
## Logowanie z użyciem LDAP/PAM/CAS/SAML
TODO
---
title: Kroki po instalacji
description: Co zrobić po zakończeniu instalacji Mastodona
menu:
docs:
parent: administration
weight: 3
---
## Korzystanie z interfejsu wiersza poleceń
Interfejs wiersza poleceń Mastodona jest plikiem wykonywalnym o nazwie `tootctl` znajdującym się w katalogu `bin` wewnątrz głównego katalogu Mastodona. Musisz określić, którego środowiska chcesz używać określając zmienną środowiskową `RAILS_ENV`. Jeżeli nie jesteś programistą korzystającą z urządzenia lokalnie, musisz użyć `RAILS_ENV=production`. Jeżeli masz pewność, że nigdy nie będziesz potrzebować innego środowiska, możesz dodać je dla ułatwienia do pliku `.bashrc`, np.:
```bash
echo "export RAILS_ENV=production" >> ~/.bashrc
```
Jeżeli tak zrobisz, nie będziesz musiał(-a) uwzględniać go cały czas. W przeciwnym razie, wywołania `tootctl` będą wyglądały tak, zakładająć że kod Mastodona znajduje się w katalogu `/home/mastodon/live`:
```bash
cd /home/mastodon/live
RAILS_ENV=production bin/tootctl help
```
## Tworzenie konta administratora
### W przeglądarce
Po zarejestrowaniu się w przeglądarce, musisz użyć wiersza poleceń aby nadać nowo utworzonemu kontu prawa administratora. Załóżmy, że Twoja nazwa użytkownika to `alice`:
```bash
RAILS_ENV=production bin/tootctl accounts update alice --role admin
```
### W wierszu poleceń
Możesz utworzyć nowe konto używając interfejsu wiersza poleceń.
```bash
RAILS_ENV=production bin/tootctl accounts create \
alice \
--email alice@example.com \
--confirmed \
--role admin
```
W terminalu pojawi się wygenerowane losowo hasło.
## Wypełnianie informacji o serwerze
Po zalogowaniu się, przejdź na stronę **Ustawienia strony**. Mimo braku technicznego wymogu wypełnienia tych informacji, są one istotne dla użytkowników.
|Ustawienie|Opis|
|----------|----|
|Nazwa użytkownika do kontaktu|Twoja nazwa użytkownika, aby inni mogli wiedzieć, do kogo należy serwer|
|Służbowy adres e-mail|Twój adres e-mail, aby osoby które nie mogą się zalogować lub nie mają konta mogły się z Tobą skontaktować|
|Opis instancji|Dlaczego ten serwer powstał? Dla kogo jest on przeznaczony? Co czyni go wyjątkowym?|
|Niestandardowy opis strony|Możesz tu umieścić różnego rodzaju informacje, ale zalecane jest umieszczenie **zasad**|
Po wypełnieniu tych pól, naciśnij „Zapisz zmiany”.
## Ustawienie regularnych kopii zapasowych (nieobowiązkowe, choć nie do końca)
W przypadku rzeczywistego zastosowania, upewnij się że będziesz wykonywać kopie zapasowe serwera Mastodona.
For any real-world use, you should make sure to regularly backup your Mastodon server.
### Omówienie
Things that need to be backed up in order of importance:
1. Baza danych PostgreSQL
2. Tajne klucze aplikacji z pliku `.env.production` lub odpowiadającego mu
3. Pliki wysłane przez użytkowników
4. Baza danych Redis
### Tryby awaryjne
Istnieją dwa rodzaje niepowodzeń przed którymi większość osób choni się: awaria sprzętu, taka jak uszkodzenie danych na dysku i błąd oprogramowania lub człowieka, taki jak przypadkowe usunięcie części danych. W tej dokumentacji omówiony zostaje tylko pierwszy przypadek.
Utrata bazy danych PostgreSQL to najgorsza możliwość. Mastodon przechowuje tam wszystkie ważne dane. Jeżeli baza danych zniknie, wraz z nią znikną wszystkie konta i wpisy z Twojego serwera.
Jeżeli utracisz tajne klucze aplikacji, część funkcji Mastodona przestanie działać użytkownikom, zostaną wylogowani, uwierzytelnianie dwuetapowe nie będzie dostępne i subskrypcje Web Push API przestaną działać.
Jeżeli utracisz pliki wysłane przez użytkowników, znikną awatary, zdjęcia nagłówka i załączniki multimedialne, ale Mastodon wciąż *będzie* działać.
Utrata bazy danych Redis jest prawie bezbolesna: jedyne nieodwracalne dane to kolejki Sidekiq i zaplanowane ponowne próby nieudanych zadań. Strumienie list i osi czasu są przechowywane przez Redis, ale mogą zostać wygenerowane ponownie z użyciem tootctl.
Najlepsze kopie zapasowe to te na innym urządzeniu niż to, na którym uruchomiony jest Mastodon. Dla przykładu, jeżeli serwer spłonie, a dysk twardy wybuchnie, kopie zapasowe przechowywane na nim nie będą mogły zostać użyte…
### Kopia zapasowa tajnych kodów
Są one najprostsze do zabezpieczenia, ponieważ nigdy się nie zmieniają. Musisz tylko przechowywać `.env.production` w bezpiecznym miejscu.
### Kopia zapasowa PostgreSQL
PostgreSQL jest zagrożony utratą danych w wyniku utraty prądu, uszkodzeń dysku twardego i nieudanych migracji. Z tego powodu, zalecane jest tworzenie od czasu do czasu kopii zapasowej używając `pg_dump` lub `pg_dumpall`.
Gdy ważna jest dostępność w każdym momencie, możesz używać replikacji przez strumieniowanie, aby mieć drugi serwer PostgreSQL z zawsze aktualnymi danymi i móc przełączyć się na niego, jeżeli jeden serwer przestanie działać.
### Kopia zapasowa plików wysyłanych przez użytkowników
Jeżeli korzystasz z zewnętrznego dostawcy object storage takiego jak Amazon S3, Google Cloud lub Wasabi, nie musisz przejmować się tworzeniem kopii zapasowych. Te firmy są odpowiedzialne za radzenie sobie z awariami sprzętu.
Jeżeli przechowujesz pliki lokalnie, od Ciebie zależy, czy będziesz tworzyć kopie coraz większego katalogu `public/system`, gdzie domyślnie przechowywane są wysyłane pliki.
### Kopia zapasowa Redis
Tworzenie kopii zapasowej Redis jest proste. Redis regularnie zapisuje wszystko w `/var/lib/redis/dump.rdb`, jedynym pliku który powinieneś(-naś) gdzieś przechowywać.
---
title: Aktualizacja do nowego wydania
description: Jak zaktualizować Mastodona do nowszej wersji
menu:
docs:
parent: administration
weight: 5
---
Kiedy pojawia się nowa wersja Mastodona, możesz znaleźć ją na [stronie wydań na GitHubie](https://github.com/tootsuite/mastodon/releases). Pamiętaj, że korzystanie z niewydanego kodu z gałęzi `master` jest możliwe, choć nie jest zalecane.
Wydania Mastodona są przyporządkowanem tagom gita. Na początek, zaloguj się na użytkownika `mastodon`:
```sh
su - mastodon
```
Przejdź do głównego katalogu Mastodona:
```sh
cd /home/mastodon/live
```
Pobierz kod wydania, zakładając że nowa wersja nazywa się `v2.5.0`:
```sh
git fetch --tags
git checkout v2.5.0
```
Strona wydania zawiera listę zmian, a pod nią instrukcje aktualizacji. Dowiesz się, jak wykonać ją. Na przykład, jeżeli jest wspomniane, że musisz skompilować ponownie zasoby, powinieneś(-naś) wykonać:
```sh
RAILS_ENV=production bundle exec rails assets:precompile
```