Cara menginstal redmine di RHEL 8 / CentOS 8 Linux

Redmine adalah aplikasi web manajemen proyek open source yang populer. Ini mendukung database mayor seperti MySQL dan PostgreSQL sebagai backend, dan Anda juga dapat mengubah frontend ke Apache dari server web WEBrick (disarankan untuk penggunaan produksi) yang dikirimkan bersama instalasi. Pada artikel ini kita akan menginstal Redmine terbaru di RHEL 8 / CentOS 8, menggunakan PostgreSQL sebagai backend, tetapi kita akan membiarkan WEBrick default sebagai frontend, yang akan melayani pengujian kita dengan sempurna.

Jangan berharap proses ini mudah, atau bebas dari kesalahan. Bahkan mengikuti langkah-langkah ini ke surat itu, beberapa kesalahan pasti akan terjadi, pengaturan tampaknya menangani sudo langkah-langkahnya agak tidak konsisten – tetapi solusi juga disertakan yang akan memandu melalui kesalahan ini.

Dalam tutorial ini Anda akan mempelajari:

Cara menginstal paket sistem operasi yang diperlukan
Cara menyiapkan database
Cara instal aplikasi Redmine
Cara memulai dan login ke aplikasi

Halaman konfigurasi Redmine di RHEL 8.

Persyaratan dan Konvensi Perangkat Lunak yang Digunakan

Persyaratan Perangkat Lunak dan Konvensi Baris Perintah Linux
Kategori	Persyaratan, Konvensi, atau Versi Perangkat Lunak yang Digunakan
Sistem	RHEL 8 / CentOS 8
Perangkat Lunak	Redmine 4.0.3, PostgreSQL 10.5
Lainnya	Akses istimewa ke sistem Linux Anda sebagai root atau melalui `sudo` perintah.
Konvensi	# – membutuhkan perintah linux yang diberikan untuk dieksekusi dengan hak akses root baik secara langsung sebagai pengguna root atau dengan menggunakan `sudo` perintah $ – membutuhkan perintah linux yang diberikan untuk dieksekusi sebagai pengguna biasa yang tidak memiliki hak istimewa

Cara menginstal redmine di Redhat 8 petunjuk langkah demi langkah

Redmine adalah aplikasi Ruby. Untuk instalasi kita harus menggunakan rubygems dan bundler , dan kompilasi banyak dependensi, jadi itu akan memakan waktu cukup lama. Kami akan menggunakan repositori Red Hat yang tersedia setelah mengaktifkan manajemen langganan untuk menyelesaikan dependensi sistem operasi. Anda dapat merujuk ke panduan instalasi PostgreSQL di RHEL8 untuk pengaturan rinci database secara umum, dalam artikel ini kami hanya akan membahas langkah-langkah yang diperlukan untuk Redmine. Jika setup database baru, jangan lupa untuk melengkapi initdb langkah dalam panduan yang disebutkan, atau startup database akan gagal.

Kami akan membuat pengguna yang akan menjadi pemilik aplikasi, dan kami akan memberikannya sudo sementara mengakses. Kami dapat mencabut akses ini setelah penginstalan selesai.
```
# useradd redmine
```
Kita harus menetapkan kata sandi untuk pengguna baru, yang akan kita gunakan saat menggunakan sudo :
```
# passwd redmine
```
Pada distribusi berbasis RHEL, ada wheel grup pengguna, yang diizinkan menggunakan sudo untuk menjalankan perintah istimewa. Untuk memeriksa apakah grup ini diatur sebagai sudoer , kita dapat grep /etc/sudoers berkas:
```
# grep "%wheel" /etc/sudoers
%wheel  ALL=(ALL)       ALL
# %wheel        ALL=(ALL)       NOPASSWD: ALL
```
Baris kedua dengan opsi NOPASSWD dikomentari, yang akan sesuai dengan kebutuhan kita. Dengan konfigurasi di atas, yang perlu kita lakukan hanyalah menambahkan redmine pengguna ke wheel grup:
```
# usermod -a -G wheel redmine
```
Untuk menginstal paket yang akan disediakan oleh sistem operasi, kami akan menggunakan dnf :
```
# dnf install kernel-devel kernel-headers gcc postgresql-devel ruby ruby-devel rubygems
```
Untuk mendapatkan aplikasinya, kunjungi situs download resminya (yang berjalan di Redmine). Dari sini kita dapat mengunduh tarball yang dikompresi dengan wget ke sistem target:
```
# wget https://www.redmine.org/releases/redmine-4.0.3.tar.gz -O /opt/redmine-4.0.3.tar.gz
```
Seperti yang disarankan oleh perintah di atas, kita akan menginstal aplikasi di bawah /opt direktori. Kami akan beralih ke direktori ini, dan mengekstrak arsip:
```
# cd /opt
# tar -xzf redmine-4.0.3.tar.gz
```
Secara opsional, kami juga dapat membuat symlink untuk akses yang lebih mudah – dengan cara ini kita tidak perlu mengingat versi persisnya:
```
# ln -s /opt/redmine-4.0.3 /opt/redmine
```
Sekarang kita dapat mengatur redmine pengguna sebagai pemilik hierarki direktori yang diekstraksi, secara rekursif:
```
# chown -R redmine:redmine /opt/redmine*
```
Untuk menyiapkan database untuk koneksi aplikasi, kita harus memulainya jika belum berjalan:
```
# systemctl start postgresql
```
Kita harus membuat database kosong tempat aplikasi akan menyimpan datanya. Untuk melakukannya, kita akan beralih ke postgres pengguna sistem operasi dibuat secara default saat instalasi database:
```
# su - postgres
```
Kita akan login ke psql sebagai superuser database:
```
$ psql
psql (10.5)
Type "help" for help.

postgres=#
```
Kami akan membuat peran yang akan digunakan oleh aplikasi (catat nama pengguna dan kata sandi):
```
postgres=# CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD 'R3DM1N3' NOINHERIT VALID UNTIL 'infinity';
```
Kami juga membuat database baru dengan pemilik yang dibuat di atas:
```
postgres=# CREATE DATABASE rmdb WITH ENCODING='UTF8' OWNER=redmine;
```
Kami akan membutuhkan nama pengguna, kata sandi, penyandian, dan nama basis data di langkah selanjutnya.
Sekarang pengguna sudah siap, kita perlu mengizinkan login untuk itu di server database. Pengguna redmine akan terhubung secara lokal, jadi kami menambahkan baris berikut ke pg_hba.conf file, secara default terletak di /var/lib/pgsql/data secara default pada distribusi berbasis RHEL:
```
host    rmdb        redmine             127.0.0.1/32          md5
```
Periksa file konfigurasi Anda untuk hal berikut:
```
# IPv4 local connections:
host    all             all             127.0.0.1/32            ident
```
Jika Anda memiliki baris seperti itu, beri komentar, itu akan bertentangan dengan login yang kami rencanakan untuk disiapkan.
Dengan itu, kita perlu memulai ulang database agar pengaturan dapat diterapkan:
```
# systemctl restart postgresql
```
Sekarang kami memiliki semua informasi yang diperlukan untuk memberi tahu aplikasi di mana dan bagaimana menemukan database. Ada contoh file konfigurasi koneksi database dengan semua database yang didukung di config subdirektori dari arsip yang diekstraksi. Kita dapat membuat salinan dari file ini (menggunakan redmine pengguna):
```
$ cp config/database.yml.example config/database.yml
```
Kami dapat menghapus atau mengomentari semua contoh pengaturan selain yang terkait dengan PostgreSQL, atau hanya membuat file kosong dengan konfigurasi yang diperlukan (lebih sedikit sampah akan tetap ada di file seperti itu). Pada akhirnya, /opt/redmine/config/database.yml harus berisi sebagai berikut:
```
# PostgreSQL configuration
production:
  adapter: postgresql
  database: rmdb
  host: 127.0.0.1
  username: redmine
  password: "R3DM1N3"
```
Perhatikan bahwa kami menggunakan informasi koneksi database yang kami siapkan di dua langkah terakhir.
Untuk mengurangi jumlah kemungkinan masalah, kami akan menguji apakah kami dapat masuk ke rmdb database dengan kredensial yang disediakan dalam file konfigurasi. Lebih mudah untuk men-debug masalah koneksi dengan perangkat PostgreSQL daripada yang lain:
```
$ psql -d rmdb -U redmine -W
Password for user redmine: 
psql (10.5)
Type "help" for help.

rmdb=>
```
Di sinilah bagian yang mudah berakhir. Sekarang kita akan menginstal berbagai paket Ruby yang bergantung pada Redmine. Beberapa dari mereka membutuhkan root akses, beberapa akan menginstal atas nama redmine pengguna, dan kemudian beberapa mungkin perlu diperbaiki. Tidak bercanda. Pertama-tama, kita membutuhkan bundler :
```
# gem install bundler
Fetching: bundler-2.0.1.gem (100%)
Successfully installed bundler-2.0.1
1 gem installed
```
Kami akan menggunakan bundler dengan redmine pengguna, tetapi kami juga membutuhkan root untuk memasang atau memperbaiki Ruby gems , jadi saya sarankan untuk membuka terminal lain, alihkan ke redmine pengguna, dan navigasikan ke /opt/redmine direktori, sekaligus menjaga konsol root tetap terbuka.
Sebagai redmine pengguna, kami memulai instalasi di /opt/redmine direktori:
```
$ bundle install --without development test rmagick
```
Banyak dependensi akan diinstal, dan untuk beberapa penginstal meminta sudo kata sandi – yang merupakan kata sandi redmine pengguna. Tampaknya fungsi sudo ini entah bagaimana rusak sedikit, dan dapat menangani beberapa instalasi paket hak istimewa root, dan tidak dapat melanjutkan dengan yang lain. Yang gagal dapat diinstal pada konsol root, dan bundler di atas perintah dapat dieksekusi di konsol pengguna redmine lagi. Apa yang perlu diinstal dalam kasus saya dengan root adalah sebagai berikut:
```
# gem install nokogiri -v '1.10.2' --source 'https://rubygems.org/'
# gem install pg -v '1.1.4' --source 'https://rubygems.org/'
```
Ada juga beberapa paket yang mungkin rusak selama penginstalan. Ini dapat diperbaiki pada konsol root juga. Seperti langkah instalasi paket yang gagal di atas, output dari bundler perintah akan memberi tahu paket mana yang bermasalah, dan bagaimana menyelesaikannya. Dalam kasus saya, paket-paket berikut perlu diperbaiki:
```
# gem pristine nio4r --version 2.3.1
# gem pristine redcarpet --version 3.4.0
# gem pristine websocket-driver --version 0.7.0
```
Harap dicatat bahwa jika Anda menginstal Redmine versi lain, nomor versi paket kemungkinan akan berbeda. Setelah memperbaiki semua paket yang rusak dan hilang, bundler perintah harus selesai tanpa kesalahan, dengan akhir output berikut:
```
[...]
Installing roadie-rails 1.3.0
Fetching rouge 3.3.0
Installing rouge 3.3.0
Bundle complete! 26 Gemfile dependencies, 57 gems now installed.
Gems in the groups development, test and rmagick were not installed.
Use `bundle info [gemname]` to see where a bundled gem is installed.
```
Setelah bagian yang rumit selesai, kita perlu membuat token yang akan digunakan untuk mengkodekan cookie sesi:
```
$ bundle exec rake generate_secret_token
```

Selanjutnya kita generate objek database yang dibutuhkan oleh aplikasi:

$ RAILS_ENV=production bundle exec rake db:migrate

Selain membuat objek database yang diperlukan, langkah ini akan menghasilkan banyak output dengan mencatat semua langkah ke konsol. Kita akan melihat banyak entri yang mirip dengan berikut ini:

[...]

== 20180913072918 AddVerifyPeerToAuthSources: migrating =======================
-- change_table(:auth_sources)
   -> 0.0082s
== 20180913072918 AddVerifyPeerToAuthSources: migrated (0.0083s) ==============

== 20180923082945 ChangeSqliteBooleansTo0And1: migrating ======================
== 20180923082945 ChangeSqliteBooleansTo0And1: migrated (0.0000s) =============

Proses ini akan selesai dalam beberapa detik.

Kita dapat memeriksa database yang terisi dengan psql :

rmdb=> \dt
                       List of relations
 Schema |                Name                 | Type  |  Owner  
--------+-------------------------------------+-------+---------
 public | ar_internal_metadata                | table | redmine
 public | attachments                         | table | redmine
 public | auth_sources                        | table | redmine
 public | boards                              | table | redmine
 public | changes                             | table | redmine
[...]

Langkah terakhir dari instalasi adalah memuat data default ke dalam database. Dengan memberikan REDMINE_LANG parameter kita dapat menyelamatkan diri dari pertanyaan apa pun selama pemuatan awal.
```
$ RAILS_ENV=production REDMINE_LANG=en bundle exec rake redmine:load_default_data
Default configuration data loaded.
```

Instalasi selesai. Kita dapat memulai aplikasi:

$ bundle exec rails server webrick -e production
=> Booting WEBrick
=> Rails 5.2.2.1 application starting in production on http://0.0.0.0:3000
=> Run `rails server -h` for more startup options
[2019-04-14 18:39:12] INFO  WEBrick 1.4.2
[2019-04-14 18:39:12] INFO  ruby 2.5.1 (2018-03-29) [x86_64-linux]
[2019-04-14 18:39:12] INFO  WEBrick::HTTPServer#start: pid=30062 port=3000

Aplikasi sudah berjalan dan dapat diakses dengan browser. Dari output di atas kita dapat menebak bahwa itu dapat diakses pada port 3000 , jadi jika kita memiliki firewall yang berjalan di mesin target, kita perlu membuka port ini untuk mengakses layanan dari jarak jauh:
```
# firewall-cmd --zone=public --add-port=3000/tcp --permanent
# firewall-cmd --reload
```
Dengan membuka browser dan mengarahkannya ke alamat mesin dan port 3000 (http://192.168.1.14:3000 pada tangkapan layar di bawah), kami dapat mengakses antarmuka berbasis web dari instalasi Redmine baru kami yang baru.
Halaman login Redmine.
Kredensial default adalah admin untuk username, dan juga untuk password. Pada login pertama, aplikasi yang berperilaku baik akan meminta perubahan kata sandi untuk akun istimewa ini. Dari sana, layanan menjadi milik kami untuk diisi, dikonfigurasi, dan dinikmati.
Setelah instalasi selesai, kita dapat menghapus redmine pengguna dari wheel grup, menghilangkan lubang keamanan yang diperlukan selama proses:
```
# gpasswd -d redmine wheel
Removing user redmine from group wheel
# id redmine
uid=1008(redmine) gid=1008(redmine) groups=1008(redmine)
```