Uruchomienie aplikacji Ruby on Rails na serwerze linuxpl.com
Wielu początkujących programistów Ruby on Rails napotyka problem hostingu. Większość tanich firm hostingowych umożliwia uruchomienie aplikacji napisanych w PHP i niemożliwym jest uruchomienie tam aplikacji napisanej w Ruby. Własny serwer dedykowany to droga sprawa oraz trudno jest go skonfigurować początkującemu developerowi, a Heroku, mimo że jest darmowe w najprostszej wersji, to jest bardzo ograniczone.
W tym poście pokażę jak uruchomić aplikacje Ruby on Rails na najtańszym serwerze linuxpl, czyli za nie całe 50 zł rocznie.
Czego będziemy potrzebować aby zacząć?
- oczywiście konto na linuxpl. Może być testowe i w najprostszej wersji (darmowe na 14 dni)
- dostęp do SSH na tym serwerze(trzeba napisać email z prośbą o włączenie do [email protected]) (darmowe)
- konto na github.com (darmowe)
- terminal unixowy (najlepiej jest pracować na linuxie (nie jest dobrą praktyką używanie Windowsa do tworzenia aplikacji Ruby on Rails). Ja korzystam z Ubuntu. Można zainstalować maszynę wirtualną na Windowsie ewentualnie. Być może ten prosty tutorial da się zrobić używając Windowsa, ale jestem przekonany, że gdy będziesz musiał zrobić coś odrobinę trudniejszego, to zaczną się schody.
Zacznijmy!
Dodajemy nową domenę na serwerze linuxpl:
1. Logujemy się do panelu administracyjnego linuxpl.
2. Klikamy domenę, pod którą chcemy utworzyć subdomenę dla naszej nowej aplikacji Ruby on Rails.
3. Wybieramy zarządzanie domeną w sekcji Twoje konto.
4. Klikamy łączę: Dodaj dodatkową domenę.
5. Wpisujemy subdomenę. Moja domena to profiart.pl, więc wpisałem subdomenę: testujemy-rails.profiart.pl.
Tworzymy bazę danych postgres(pg) na linuxpl.
Następnym krokiem jest stworzenie bazy danych pg. Można oczywiście skorzystać z mysql, ale w tym tutorialu wykorzystamy bardziej popularnego w światku rubiowców postgresa.
Kopiujemy dane do bazy danych (nazwa, login, hasło) w bezpieczne miejsce, bo za chwilę będą nam potrzebne.
Tworzymy nową aplikację rails:
rails new testujemy_rails -d postgresql cd testujemy_rails rails server
i w przeglądarce otwieramy: http://localhost:3000/. Powinniśmy zobaczyć ekran powitalny frameworka Rails.
Jeśli działa prawidłowo, stwórzmy pierwszy commit do gita:
git add . && git commit -m "init"
Dodajmy teraz przykładowy kontroler z akcją index:
rails generate controller HelloLinuxpl index--no-helper --no-javascripts --no-stylesheets -no-test-framework
Ta komenda wygenerowała nam kontroler z akcją index, widok oraz dodała do routes odpowiednią linijkę dzięki której możemy zobaczyć wynik w przeglądarce.
Dodajmy do routes.rb również:
[code language=”ruby” light=”true”] root to: „hello_linuxpl#index” [/code]
aby utworzona akcja wskazywała również na stronę główną.
Terez uruchomimy serwer deweloperski lokalnie i zobaczymy wynik naszej pracy. Wpisujemy w konsoli:
rails server
I otwieramy w przęglądarce link: http://localhost:3000/
Konfiguracja deploymentu
Na tym zakończymy pracę nad aplikacją. Przejdźmy teraz do sedna tego wpisu, czyli deploymentu.
Baza danych
Otwieramy plik: testujemy_rails/config/database.yml
i ustawiamy nazwę i login poprzednio utworzonej bazy danych:
[code language=”ruby” light=”true”]
production:
<<: *default
database: profiart_tr
username: profiart_tr
password: <%= ENV[‚TESTUJEMY_RAILS_DATABASE_PASSWORD’] %>
host: 127.0.0.1
[/code]
Ze względów bezpieczeństwa, hasło będziemy pobierać ze zmiennych środowiskowych ENV serwera linuxpl.
Jak to zrobić wyjaśnimy w dalszej części tego artykułu.
Serwer github
Tworzymy nowe repozytorium na Github.com i spinamy je z naszą aplikacją rails.
Nie będę się rozpisywał na temat tworzenia konta na Github i nowych repozytoriów, bo na ten temat można znaleźć bardzo dużo materiałów w Internecie.
Za pomocą tej komendy spajamy nasze lokalne repozytorium git z repozytorium na serwerze:
git remote add origin [email protected]:blaszczakphoto/testujemy_rails.git
Wypychamy zmiany do serwera Github:
git push origin master
Jeśli wejdziemy na adres naszego repozytorium Github, to zobaczymy tę samą strukturę katalogów co lokalnie:
https://github.com/blaszczakphoto/testujemy_rails/
Reszta zmian lokalnych
Teraz żeby poprawnie uruchomić aplikacje na serwerze, musimy dokonać w niej kilka zmian.
W pliku: config/environments/production.rb ustawiamy:
[code language=”ruby” light=”true”]
config.public_file_server.enabled = true
[/code]
W config/secrets.yml zmieniamy klucz tablicy ENV na „TESTUJEMY_RAILS_SECRET”:
[code language=”ruby” light=”true”]
production:
secret_key_base: <%= ENV[„TESTUJEMY_RAILS_SECRET”] %>
[/code]
do Gemfile dodajemy gem mini_racer (potrzebny żeby uruchomić serwer bez nodejs):
[code language=”ruby” light=”true”]
gem ‚mini_racer’, platforms: :ruby
[/code]
i potem:
bundle install
Domyślnie node nie jest dostępny na serwerach linuxpl i trzeba dodatkowo za niego płacić. Więc kompilacje CSS i JavaScript trzeba robić lokalnie i zakomitwać do repozytorium git:
RAILS_ENV=production bundle exec rake assets:precompile
dodajemy wszystkie zmiany do gita i wypychamy na serwer Github:
git add . git commit -m "prepare for deployment" git push origin master
Ostatnią rzeczą, jaką musimy zrobić lokalnie to wygenerowanie secret tokenu rails:
rake secret
kopiujemy wynik tej komendy w bezpieczne miejsce. Za chwile będzie nam potrzebne podczas uruchamiania aplikacji na serwerze.
Ustawienie haseł jako zmiennych środowiskowych na serwerze linuxpl
teraz logujemy się do SSH na linuxpl:
ssh [email protected] -p 59184
W katalogu domowych tworzymy nowy folder w którym będziemy trzymać hasła i tokeny. Na przykład:
mkdir .secret_data
wchodzimy w świeżo utworzony katalog:
cd .secret_data
tworzymy plik o nazwie: .secret_data_testujemy_rails i otwieramy go w vim:
vim .secret_data_testujemy_rails
wklejamy:
[code language=”bash” light=”true”]
export TESTUJEMY_RAILS_DATABASE_PASSWORD=”HASLO”
export TESTUJEMY_RAILS_SECRET=”ABCD”
[/code]
gdzie:
w miejsce HASLO wpisujemy nasze hasło do stworzonej wcześniej bazy danych postgresql
a w miejsce ABCD wpisujemy chwile temu wygenerowany secret token.
zapisujemy plik i wychodzimy z niego.
Teraz wchodzimy do głównego katalogu naszego użytkownika:
cd ~
i otwieramy plik konfiguracyjny bash:
vim .bashrc
i odszukujemy linijkę:
[code language=”bash” light=”true”]
[ -z „$PS1″ ] &amp;amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp;amp; return
[/code]
i przed nią wklejamy:
[code language=”bash” light=”true”]
if [ -f ~/.secret_data/.secret_data_testujemy_rails ]; then
. ~/.secret_data/.secret_data_testujemy_rails
fi
zapisujemy i wychodzimy z edytora vim.
[/code]
odświeżamy terminal:
source ~/.bashrc
i sprawdzamy czy zmienne środowiskowe ENV zdefiniowane przed chwilą działają:
echo $TESTUJEMY_RAILS_DATABASE_PASSWORD
Sklonowanie plików aplikacji z serwera github do folderu na linuxpl
Teraz wchodzimy do katalogu pod który jest podpięta nasza domena. W moim przypadku jest to ~/domains/testujemy-rails.profiart.pl/public_html:
cd ~/domains/testujemy-rails.profiart.pl/public_html
usuwamy całą zawartość:
rm -rf *
Teraz wchodzimy na link do naszego repozytororium na Github. W moim przypadku:
https://github.com/blaszczakphoto/testujemy_rails
Klikamy zielony przycisk Clone or download i kopiujemy link HTTPS repozytorium do schowka:
https://github.com/blaszczakphoto/testujemy_rails.git
Wracamy do konsoli w której jest odpalone SSH. Powinniśmy wciąż być w katalogu ~/domains/testujemy-rails.profiart.pl/public_html
i wpisujemy komendę (oczywiście zamiast urla widocznego tutaj, trzeba wkleić url skopiowany przed chwilą ze strony github.com):
git clone https://github.com/blaszczakphoto/testujemy_rails.git .
Komenda ta klonuję repozytorium z serwera Github do katalogu public_html. Ważna jest kropka na końcu komendy. Bez niej, w katalogu public_html aplikacja sklonowałaby się do katalogu testujemy_rails. Dzięki kropce cała struktura plików stworzyła się bezpośrednio w katalogu public_html.
Sprawdzam czy wszystko dobrze się sklonowało:
ls -l
Teraz czas na konfigurację ruby i rvm na serwerze:
rvm user rubies; rvm user all; source $HOME/.rvmrc rvm autolibs disable rvm install 2.4.1
Na koniec sprawdzamy czy gemdir znajduje się w naszym folderze domowym:
rvm gemdir
w moim przypadku powinno wyświetlić się to:
/home/profiart/.rvm/gems/ruby-2.4.1
i dalej możemy sprawdzić jeszcze wersje ruby (czy wskazuje na 2.4.1):
ruby -v
Instalujemy bundler (musi być wersja < 1.12, a nie najnowsza ponieważ linuxpl ma problemy z wielowątkowością, która jest uruchamiana domyślnie w najnowszych wersjach bundlera):
gem install bundler -v '&amp;lt; 1.12' RAILS_ENV=production bundle install RAILS_ENV=production rake db:migrate
Teraz czas na uruchomienie serwera aplikacji:
ruby bin/rails server webrick -e production -p 3013 -d
-p 3013 to port na którym uruchomimy naszą aplikację rails. Musi być on wolny.
Email do administratora
Teraz piszemy email do [email protected]
Witam,
uruchomiłem aplikację rails na porcie 3013 na serwerze o IP http://144.76.189.18
Czy można prosić o przekierowanie jej na adres: testujemy-rails.profiart.pl?
Gdzie adres IP serwera można sprawdzić w panelu administratora linuxpl.
Pamiętajmy również o podaniu właściwego portu, takiego na jakim uruchomiliśmy aplikację.
Kiedy dostaniemy odpowiedź od administratora o dodaniu naszej aplikacji do vhosta, możemy sprawdzić efekt naszej pracy:
http://testujemy-rails.profiart.pl/
Kolejny deployment
Teraz, za każdym kolejnym razem gdy zrobimy zmianę lokalnie i chcemy ją sprawdzić na serwerze linuxpl wykonujemy:
Lokalnie:
RAILS_ENV=production bundle exec rake assets:precompile git add . &amp;amp; git commit -m "commit message for our changes" git push origin master
Na serwerze przez SSH w katalogu public_html:
git pull origin master RAILS_ENV=production bundle install RAILS_ENV=production rake db:migrate kill -9 $(cat tmp/pids/server.pid) && ruby bin/rails server webrick -e production -p 3013 -d
Podsumowanie
Trochę dużo kroków i to dość skomplikowanych. Ale myślę że warto się potrudzić. Komfort pracy z Rails jest tego wart! No i tą skomplikowana procedurę musimy wykonać tylko za pierwszym razem. Potem przy następnych zmianach już tylko kilka komend 🙂
Czekam na Wasze opinie w komentarzach.