Menggunakan MySQL Database Server tidak jarang kita temui error yang entah kenapa itu terjadi misalnya seperti MySQL 1045 Error Access Denied. Yang menjadi alasan sulit diatasi mungkin karena pesan yang tidak kita perhatikan secara detail sehingga menjadi sulit untuk diatasi.

MySQL menggunakan kode unik untuk merujuk pada error tertentu, jadi sebenarnya bisa kita lihat langsung didokumentasi resminya. Seperti contoh di atas kode 1045 mungkin kalian pernah alami atau saat ini mengalaminya. Mari kita lihat beberapa hal pemicu error tersebut.

1. Terhubung ke Host yang salah

[dev@server]# mysql -u root -p12345
mysql: [Warning] Using a password on the command line interface can be insecure.
ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: YES)

Jika tidak secara spesifik terhubung ke host tertentu (-h flag), MySQL client akan mencoba akses ke localhost yang mungkin sebenarnya kita ingin akses ke host lain. Jadi perlu kita cek kembali akses yang ingin kita gunakan.

[dev@server]# mysql -u root -p12345 -h -P 3306

2. User tidak ditemukan

[dev@server]# mysql -u newuser -p12345 -h localhost
mysql: [Warning] Using a password on the command line interface can be insecure.
ERROR 1045 (28000): Access denied for user 'newuser'@'localhost' (using password: YES)

Pastikan user yang digunakan ada tersimpan didalam tabel user. Jika tidak ditemukan, bisa kita buat dulu user tersebut. Bisa dibilang menggunakan non-root user adalah best practice dan jangan dibiasakan menggunakan root user.

mysql> SELECT User FROM mysql.user WHERE User='newuser';
Empty set (0.00 sec)

mysql> CREATE USER 'newuser'@'localhost' IDENTIFIED BY 'sekret';
Query OK, 0 rows affected (0.00 sec)

3. Client tidak ada permission access

[dev@server]# mysql -u newuser -p12345
mysql: [Warning] Using a password on the command line interface can be insecure.
ERROR 1045 (28000): Access denied for user 'newuser'@'localhost' (using password: YES)

Bisa kita cek informasinya melalui perintah berikut ini:

dsini

mysql> SELECT Host, User FROM mysql.user WHERE User='newuser';
+-------------+-------------+
| Host        | User        |
+-------------+-------------+
| 172.17.0.1 | newuser     |
+-------------+-------------+
1 row in set (0.00 sec)

Lalu kita bisa lihat dari IP mana client mencoba akses ke database.

[dev@server]# ip address | grep inet | grep -v inet6
inet 127.0.0.1/8 scope host lo
inet 172.17.0.20/24 brd 172.17.0.255 scope global dynamic wlp3s0

Untuk mengatasi ini cukup tentukan IP yang kita gunakan di client, atau cara yang paling mudah adalah dengan menggunakan tanda '%' yang otomatis akan memperbolehkan akses dari segala IP.

mysql> CREATE USER 'newuser'@'%' IDENTIFIED BY '12345';
Query OK, 0 rows affected (0.00 sec)

4. Password salah

Hal ini mungkin saja terjadi, kita lupa password atau kita sudah ganti password dan tidak mengingat password yang baru. Cara mengeceknya cukup mudah, pastikan kolom forgotten sama dengan kolom authentication_string, dan pastikan juga password yang kita gunakan sudah benar untuk user dan host yang sesuai.

mysql> SELECT authentication_string, PASSWORD('123456') FROM mysql.user WHERE User='newuser';
+-------------------------------------------+---------------------------+
| authentication_string             | PASSWORD('123456')                |
+-------------------------------------------+---------------------------+
| *827CCB0EEA8A706C4C34A16891F84E7B | *E10ADC3949BA59ABBE56E057F20F883E |
| *827CCB0EEA8A706C4C34A16891F84E7B | *E10ADC3949BA59ABBE56E057F20F883E |
+-------------+-------------+-------------------------------------------+
2 rows in set, 1 warning (0.00 sec)

Mudahnya, kita bisa ganti password langsung dengan perintah berikut:

mysql> set password for 'newuser'@'%' = 'abc123';
Empty set (0.00 sec)

5. Symbol pada password di Convert

Ini pernah saya alami, ternyata kendala ada di terminal yang digunakan, password otomatis dikonversi oleh Bash. Untuk mengatasinya, gunakan passwrod dalam tanda petik (').

[dev@server]# mysql -u newuser -pstrong!pas$word
mysql: [Warning] Using a password on the command line interface can be insecure.
ERROR 1045 (28000): Access denied for user 'nonexistant'@'localhost' (using password: YES)

[dev@server]# mysql -u newuser -p'strong!pas$word'
mysql: [Warning] Using a password on the command line interface can be insecure
...
mysql>

Jika kalian tidak punya akses sama sekali ke dalam MySQL shell, berikut ini beberapa langkah yang bisa digunakan untuk mengatasinya.

• Matikan service MySQL
• Modifikasi my.cnf dan tambahkan skip-grant-tables dibawah [mysqld]. Pada MySQL versi 8.x, efek dari config tersebut sudah otomatis berjalan (hanya berlaku untuk localhost)
• Nyalakan kembali service MySQL
• Akses dengan user root: mysql -u root -h localhost
• Ganti password dengan yang baru: UPDATE mysql.user SET authentication_string=PASSWORD(‘abc123’) WHERE User=’root’ and Host=’localhost’;
• Matikan service MySQL
• Hapus skip-grant-tables dari [mysqld] (jika kalian tambahkan sebelumnya)
• Nyalakan kembali MySQL

Dengan begitu kita sudah bisa kembali mendapatkan akses ke MySQL dengan user root. Itulah beberapa kendala dan cara menangani masalah yang terkait dengan MySQL 1045 Error Access Denied. Semoga dapat membantu kalian, selamat mencoba dan jangan lupa berikan komentar jika masih terkendala.

Sumber: percona

Headline image: kinsta

Saat ini, topik seperti cloud computing, serverless, stateless dan teknologi sumber data mutakhir lainnya sebagai penyalur data perangkat seluler seperti RESTful web service yang banyak digunakan sebagai penyalur data telah meninggalkan kesan bahwa REST (Representational State Transfer) merupakan teknologi baru, tapi faktanya REST ditemukan pada akhir abad ke 20.

Pada artikel ini saya akan menjelaskan sejarah singkat tentang REST (berdasarkan buku) dan mengulas sedikit bagaimana REST bekerja dalam protokol HTTP. Ada beberapa dasar acuan yang perlu diperhatikan ketika ingin mengubah sebuah aplikasi HTTP menjadi aplikasi RESTful service.

Di tahun 1999, ketika sebuah komentar definisi diajukan ke Internet Engineering Task Force (IETF: http://www.ietf.org) melalui RFC 2616: "Hypertext Transfer Protocol - HTTP/1.1." salah satu penulisnya, Roy Fielding yang mendefinisikan sebuah prinsip yang dibangun berdasarkan standar lingkungan HTTP dan URI yang kemudian melahirkan REST yang dikenal sekarang (disertasi lengkap mengenai informasi REST yang dibuat oleh Roy Fielding dapat dilihat melalui link publikasi berikut: http://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm).

Seperti keterangan diatas, prinsip yang dibuat berdasarkan standar linkungan HTTP dan URI. Mari kita lihat dasar utama seputar standar HTTP dan URI, tetap berkaitan dengan cara mengubah sebuah aplikasi HTTP menjadi aplikasi RESTful service.

- resource adalah segalanya

Untuk memahami prinsip ini, kita harus memahami gagasan dari represenstasi adalah dengan format tertentu dan bukan berdasarkan file. Setiap data yang tersedia di internet memiliki sebuah format yang dapat dideskripsikan dengan content-type. Misalnya, text document; JPEG Images; MPEG videos; xml, html, text document; dan binary data yang semuanya adalah resource dengan jenis content-type berikut: image/jpeg, video/mpeg, text/html, text/xml, application/json dan application/octet-stream.

- setiap resource dapat diidentifikasi oleh unique identifier

Karena internet mengandung banyak resource berbeda, semua resource itu harus bisa diakses melalui URI dan harus diidentifikasi secara unik. Selanjutnya, URI bisa dalam format yang mudah dibaca manusia (sebagian orang memang mewajibkannya) terlepas dari kenyataan bahwa penggunanya adalah programmer dan bukan manusia pada umumnya (bukan berprofesi sebagai programmer).

URI menyimpan data secara self-descriptive dan memudahkan pengembangan lebih lanjut. Selain itu, menggunakan URI yang dapat dibaca manusia dapat membantu mengurasi resiko kesalah logis dalam program seminimalis mungkin. Berikut ini beberapa contoh URI:

- http://www.example.com/images/party/2017/newyear

- http://www.example.com/videos/party/2017/newyear

- http://www.example.com/data/documents/outcome?format-xml

- http://www.example.com/data/archives/2015

Pada URI diatas telah mengekspos berbagai jenis resource yang cukup jelas yaitu berupa images, videos, XML document dan binary archive document. Itulah contoh dari URI yang memang harusnya dapat dengan mudah dipahami manusia.

- menggunakan standar metode HTTP

Protokol asli HTTP (RFC2616) mendefinisikan 8 action atau dikenal dengan verb yaitu: GET, POST, PUT, DELETE, HEAD, OPTIONS, TRACE, CONNECT. Urutan 4 verbs awal terasa sudah dapat dikenali dalam konteks resource, terutama ketika mendefinisikan aksi manipulasi data resource yaitu CRUD. Jika secara relative dibandingkan dengan operasi CRUD database SQL, dengan cara yang sama saat menerapkan prinsip REST dengan tepat, HTTP verb dapat digambarkan seperti berikut:

Namun ada pengecualian dalam menggunakan verb. Seperti contoh POST yang digunakan untuk membuat resource. Tapi ketika resource harus dibuat berdasarkan URI tertentu, maka PUT adalah verb yang sesuai (menyisipkan tanggal kedalam bagian URI).

PUT /data/documents/outcome/13082017 HTTP/1.1

Content-Type: text/xml
Host: www.example.com


<?xml version="1.0" encoding="utf-8"?>
<outcome date="outcome">
<Item>Sample item</Item>
<price currency="IDR">3500000</price>
</outcome>

HTTP/1.1 201 Created
Content-Type: text/xml
Location: /data/documents/outcome/13082017

Bagaimanapun juga, dalam aplikasi yang kita punya, mungkin kita ingin menyerahkan ke aplikasi REST dalam menentukan lokasi untuk menempatkan resource yang baru dibuat dan dengan demikian membuatnya berada dilokasi yang sesuai namun masih belum diketahui ataupun tidak temukan.

Misalnya, kita contohkan kita ingin server membuat bagian tanggal pada URI berdasarkan tanggal sekarang. Dalam kasus seperti itu, sangat tepat untuk menggunakan verb POST ke resource utama URI dan membiarkan server merespon dengan lokasi resource yang baru dibuat (outcome date akan terisi otomatis).

POST /data/documents/outcome HTTP/1.1

Content-Type: text/xml
Host: www.example.com

<?xml version="1.0" encoding="utf-8"?>
<outcome date="13082017">
<Item>Sample item</Item>
<price currency="IDR">3500000</price>
</outcome>

HTTP/1.1 201 Created
Content-Type: text/xml
Location: /data/documents/outcome

- resource dapat memiliki banyak jenis representasi

Fitur kunci dari sebuah resource adalah resource dapat direpresentasikan dalam bentuk yang berbeda dari yang disimpan. Jadi resource dalam proses request dan posting bisa dalam berbagai macam jenis representasi, selama format yang ditentukan didukung. Pada contoh sebelumnya, kita telah membuat resource dengan representasi XML, tetapi jika server mendukung format JSON, proses dari representasi berikut tetap dapat diterima.

POST /data/documents/balance HTTP/1.1

Content-Type: application/json
Host: www.mydatastore.com

{
 "balance": {
  "date": ""22082014"",
  "Item": "Sample item",
  "price": {
   "-currency": "IDR",
   "#text": "3500000"
  }
 }
}

HTTP/1.1 201 Created
Content-Type: application/json
Location: /data/documents/balance

Dengan memahami dasar protokol HTTP dapat dengan mudah untuk mengerti cara kerja RESTful service. Jadi untuk itu sebagai pelengkap dalam memahami RESTful service bisa terlebih dahulu membaca cara kerja protokol HTTP yang kemudian merujuk pada HTTP verb yang disebutkan diatas.

Itulah sedikit penjelasan mengenai RESTful service, jika mungkin ada yang kurang jelas ataupun salah dalam penjelasan saya mohon kiranya berikan komentar pada kolom dibawah. Dan untuk artikel selanjutnya saya akan coba berikan contoh membuat RESTful service dengan NodeJS.

Image source: javabeat.

Create, read, update dan delete (CRUD) dasar interaksi yang selalu dilakukan saat menggunakan sebuah database. Setelah sebelumnya kita mengenal dasar-dasar MongoDB, kali ini kita mulai untuk ke bagian penting yaitu CRUD dalam MongoDB yang tersedia dengan beberapa metode.

Membuat document (Insert)

Dalam hal membuat document (istilah pengganti record table dalam NoSQL) MongoDB menyediakan beberapa cara yang diantaranya yaitu:

- membuat document menggunakan insert()

Cara yang paling umum untuk membuat data document baru adalah dengan metode insert(). Metode ini memerlukan 1 argument yang merepresentasikan data baru sebuah document. Contohnya yaitu sebagai berikut:

> db.people.insert({ "firstname": "Jim", "lastname": "Doe", "address": "20 Main St." })

- membuat document menggunakan update()

Metode update() biasanya digunakan untuk mengubah sebuah data. Tetapi dalam MongoDB kita dapat menggunakannya untuk membuat document baru dengan syarat jika tidak ada document yang sama dengan query document dan juga perlu menambahkan "upsert" flag. Contohnya sebagai berikut:

> db.people.update({
... "firstname": "Jim"
... },
... {
... "firstname": "Jim",
... "lastname": "Doe",
... "address": "555 Main St."
... },
... {
... upsert: true
... })
WriteResult({ "nMatched" : 0, "nUpserted" : 1, "nModified" : 0, "_id" : ObjectId("58e34c04002c40a5718b63af")

Contoh query diatas akan membuat MongoDB mencari "firstname" Jim dan mencoba untuk mengubah datanya, tapi nyatanya collection "people" tidak memiliki "firstname" Jim dan karena kita menggunakan "upsert" flag dan MongoDB tidak menemukan data yang sesuai untuk di update maka sebagai gantinya document baru akan dibuat.

- membuat document menggunakan save()

Cara lain untuk membuat document baru adalah dengan menggunakan metode save(). Berikut ini contoh menggunakan save():

> db.people.save({
... "firstname": "John",
... "lastname": "Doe",
... "address": "555 Main St."
... })
WriteResult({ "nInserted" : 1 })

Cukup sederhana cara kerjanya yaitu dengan memasukkan langsung document baru tanpa menyertakan key "_id", atau bisa juga dengan menyertakan key "_id" yang kemudian MongoDB akan memeriksa apakah "_id" itu ada. Efeknya mirip seperti metode update() yang akan langsung membuat document baru jika data yang dicari tidak ditemukan.

Mengubah Dokumen (Update)

Semua proses update membutuhkan paling tidak 2 argument. Argument pertama menspesifikasikan field document dengan nilai apa yang mau diubah dan argument kedua mendefinisikan nilai baru document yang akan diubah. Perlu untuk diketahui kalau secara default fungsi update() cuma mengubah sebuah document (single document), meskipun sebenarnya dapat dioperasikan untuk mengubah banyak document dan bahkan seluruh collection.

Ada 2 tipe umum dari update yaitu perbedaan antara maksud penggunaannya. Tipe pertama yaitu melakukan modifikasi terhadap sebuah document, dan tipe kedua yaitu melakukan replace document lama dengan yang baru. Contoh dari tipe pertama adalah sebagai berikut:

> db.people.update(
... {firstname: "John"},
... {$set: {lastname: "Smith"}}
... )

Proses dari operasi diatas yaitu mencari sebuah document dimana memiliki firstname "John" dan kemudian mengganti nilai field lastname menjadi "Smith". Dan juga kita menggunakan $set operator yang berguna untuk menentukan nilai spesifik sebuah field.

Kemudian untuk cara kedua cukup membingungkan, coba perhatikan operasi berikut ini:

> db.people.update(
... {firstname: "John"},
... {lastname: "Smith"}
... )

Hasil contoh diatas, document akan di-replace hanya pada yang memiliki field lastname, dan field firstname akan dihapus karena document pertama digunakan hanya untuk pencocokan(sebagai argument pertama) dan document kedua digunakan untuk me-replace document yang telah cocok dengan hasil pencarian berdasarkan document pertama.

Jadi intinya, menggunakan teknik replace cukup beresiko karena dapat menghapus field jika tidak digunakan dengan tepat, oleh karena itu harus hati-hati dalam penggunaanya dan lebih disarankan untuk menggunakan $set operator untuk mengupdate document.

Menghapus Document (Delete)

Kita sudah tahu dasar dari operasi create, read, dan update dalam MongoDB. Selanjutnya adalah operasi terakhir yang sederhana yaitu menghapus data.

Dalam penggunaannya, jika tidak ada parameter yang diberikan, operasi remove() akan menghapus semua collection dari document-nya, misalnya:

> db.people.remove()

Hasilnya sudah pasti akan menghapus seluruh data yang ada. Setidaknya kita butuh menghapus data tertentu dari sebuah document, dan untuk itu dibutuhkan parameter ataupun query selector kedalam fungsi remove().

Ada contoh yang misalnya kita ingin menghapus semua nama orang yang memiliki lastname "Smith", jadi bentuk query yang dibuat yaitu:

> db.people.remove(
... {lastname: "Smith"}
... )

Perlu diingat kalau fungsi remove() tidak akan menghapus collection melainkan hanya menghapus document, bisa disamakan dengan klausa DELETE dalam SQL. Dan untuk menghapus collection kita gunakan fungsi drop().

> db.people.drop()

Part 1: Tutorial MongoDB: Pengenalan MongoDB - Part 1
Part 2: Tutorial MongoDB: Mengoperasikan MongoDB - Part 2
Part 3: Tutorial MongoDB: Tipe Data MongoDB - Part 3
Part 4: Tutorial MongoDB: Tipe Data MongoDB (Tambahan) - Part 4
Part 5: Tutorial MongoDB: Dasar MongoDB Shell - Part 5
Part 6: Tutorial MongoDB: Operasi CRUD - Part 6

Itulah dasar dalam menggunakan operasi CRUD di MongoDB. Untuk perbandingan lebih jelas dapat dilihat pada MongoDB CRUD Operations yang telah menyediakan tabel perbanding antara query SQL dan NoSQL.

Pada part ini kita akan mulai menggunakan MongoDB Shell untuk lebih mengenal MongoDB dalam penggunaannya, terlebih dalam pengoperasian fungsi query NoSQL database.

Untuk memulai menggunakan MongoDB Shell, pastikan terlebih dahulu service MongoDB sudah dijalankan. Untuk dapat mengakses server secara kustom, seperti hostname/IP server, port dan database, gunakan perintah berikut dari terminal:

mongo host_server:27017/myDB <== 27017 port default MongoDB

Contoh di atas diasumsikan kita sudah mempunyai database yang akan diakses, namun bila kita belum punya database maka gunakan perintah berikut:

mongo
> help <== untuk melihat kumpulan perintah shell
> show dbs <== menampilkan nama database
> use myDB <== gunakan database myDB atau buat db myDB
> exit <== keluar dari shell

Contoh perintah di atas adalah untuk kasus memulai akses database, bila nantinya kita sudah punya database yang akan dihandle maka saya pribadi lebih senang menggunakan cara berikut ini:

mongo --nodb
> conn = new Mongo("host_server:27017")
> db = conn.getDB("myDB")

Cukup sederhana dan tentunya lebih terlihat terstruktur, akan tetapi bukan berarti harus menggunakannya, mungkin ada cara lain yang lebih bagus yang bisa ditemukan di internet.

Seperti yang kita tahu sebelumnya kalau "mongo" sederhananya adalah JavaScript shell, dengan begitu kita bisa melihat JavaScript dokumentasi sebagai referensi. Untuk fungsi MongoDB secara spesific, sudah terdapat fungsi built-in yang dapat dilihat dengan perintah "help" seperti contoh sebelumnya di atas.

Untuk tingkatan level tersedia melalui parameter masing-masing, misalnya level database (berada dalam shell database yang digunakan) yaitu "db.help()" dan untuk level collection yaitu "db.nmcollection.help()"

Ada hal yang mungkin bisa dikatakan unik dalam MongoDB shell, misalkan kita ingin mengetahui seperti apa sebuah fungsi bekerja dalam mengolah data, dalam hal ini kita ingin mengetahui bagaimana fungsi update bekerja, maka cukup lakukan perintah berikut melalui shell:

> db.books.update

Dari hasil diatas maka akan tampak barisan kode JavaScript yang menghandle fungsi tersebut. Perlu diketahui, pada contoh tersebut kita tidak menggunakan tanda kurung "()" pada akhir nama fungsi, hal ini bertujuan untuk menguak isi dari fungsi tersebut, tetapi bisa kita menggunakan tanda kurung "()" pada nama fungsi tersebut "update()" maka berarti fungsi akan dieksekusi.

Part 1: Tutorial MongoDB: Pengenalan MongoDB - Part 1
Part 2: Tutorial MongoDB: Mengoperasikan MongoDB - Part 2
Part 3: Tutorial MongoDB: Tipe Data MongoDB - Part 3
Part 4: Tutorial MongoDB: Tipe Data MongoDB (Tambahan) - Part 4
Part 5: Tutorial MongoDB: Dasar MongoDB Shell - Part 5
Part 6: Tutorial MongoDB: Operasi CRUD - Part 6

Itulah sedikit dasar dalam menggunakan MongoDB shell, jika ada yang salah ataupun ada hal yang ingin ditanyakan silakan isi komentar dibawah, dan jangan lupa tetap kunjungi blog ini ataupun bookmark label tag mongodb untuk update part selanjutnya.

Dalam part ini, saya akan membahas sedikit lebih lanjut mengenai beberapa tipe data yang sudah dijelaskan sebelumnya.

Dates

Di JavaScript, class Date digunakan untuk tipe data date MongoDB. Ketika membuat object Date baru, selalu panggil new Date(....), bukan hanya Date(....). Perlu diperhatikan dalam penggunaannya karena proses pemanggilan menggunakan kata kunci new dan tanpa new itu berbeda (dalam hal ini dikenal istilah konstruktor). Untuk penjelasan lebih lengkap mengenai class Date dalam JavaScript dan format yang bisa diterapkan untuk sebuah konstruktor bisa dilihat langsung melalui Ecmascript ataupun referensi yang lainnya.

Array

Untuk pengertian array sendiri masih sama seperti array pada umumnya. Sebuah array dapat menampung nilai lists, stacks, ataupun queues. Dalam MongoDB sendiri kedudukan array dalam sebuah document cukup membantu karena sebuah key dapat memiliki nilai yang beragam. 

Misalnya ada sebuah document yang mempunyai key "tes" dan mempunyai nilai array:

{"tes" : ["pi", 3.14]}

Dari contoh tersebut, nilai array dapat memuat atau berisikan tipe data yang berbeda sebagai nilanya (pada contoh diatas, terdapat sebuah string dan floating-point number).

Array dalam document bisa mengandung array lainnya atau biasa dikenal dengan istilah "nested arrays". Satu hal yang mungkin bisa dikatakan sebagai keunggulan tentang array dalam sebuah document yaitu MongoDB mengerti struktur mereka dan tahu bagaimana membaca hingga kedalam nilai nested arrays sekalipun. Jadi hal ini memungkinkan kita untuk membuat sebuah index menggunakan key terkait untuk meningkatkan query speed.

Embedded Documents

Selain menampung sebuah konten, document sendiri bisa menampung document lain dalam sebuah key, ini dikenal dengan sebutan embedded document. Embedded document bisa digunakan untuk mengorganisir data  menjadi lebih natural ketimbang hanya dengan struktur yang flat untuk pasangan key/value.

Untuk contohnya, jika kita punya document yang meresepresentasikan seseorang dan ingin menyimpan alamatnya, kita bisa mengumpulkan informasinya ke dalam embedded "alamat" document:

{
    "nama" : "John Doe",
    "alamat" : {
        "jalan" : "Jl. Beringin",
        "kota" : "Jogja",
        "provinsi" : "DIY"
    }
}

Contoh diatas merupakan contoh kecil dari embedded document, mungkin ada banyak contoh lainnya di internet yang lebih dalam strukturnya. Jadi sederhananya untuk penggunaan embedded document lebih kurang seperti contoh diatas.

_id dan ObjectId

Setiap document yang tersimpan di MongoDB harus memiliki "_id" key. Pada part 2 kita sudah melihat proses post data ke dalam document yang mana key "_id" otomatis muncul dan memiliki nilainya sendiri. Nilai key "_id" bisa dengan berbagai tipe data, tetapi secara default adalah tipe data ObjectId. Dalam sebuah collection, setiap document harus memiliki nilai yang unik untuk "_id", yang memastikan bahwa setiap document dalam sebuah collection dapat diidentifikasi secara unik.

ObjectId

ObjectId adalah tipe default untuk "_id" dan merupakan sebuah Class yang di desain untuk menjadi ringan (lightweight). Desain ini menghasilkan kemudahan saat proses generate terhadap mesin yang berbeda. MongoDB mempunyai alasan utama kenapa mereka menggunakan ObjectId daripada menggunakan bentuk tradisional seperti autoincrement primary key adalah "karena sulit dan memakan waktu untuk sinkronisasi autoincrement primary key antar multiple server". Karena MongoDB didesain untuk menjadi database terdistribusi, hal tersebut menjadi penting untuk dapat menghasilkan identifikasi unik dalam sharded environment (multiple server).

Lalu muncul pertanyaan kenapa meng-insert document baru yang tidak ada memuat "_id" key secara otomatis tersimpan sendiri dalam document itu ? 

Jawabannya adalah terletak pada sisi client. MongoDB meng-handle hal tersebut melalui driver yang ada pada client, dan juga nilai ObjectId yang dihasilkan merupakan 12 bytes yang merupakan generate langsung dari mesin. Untuk lebih jelasnya bisa langsung mengunjungi official site MongoDB ataupun referensi lainnya.

Itulah sedikit tambahan penjelasan khusus terhadap tipe data diatas, jika ada yang salah ataupun ada pertanyaan mohon kiranya memberikan komentar pada kolom dibawah.

Part 1: Tutorial MongoDB: Pengenalan MongoDB - Part 1
Part 2: Tutorial MongoDB: Mengoperasikan MongoDB - Part 2
Part 3: Tutorial MongoDB: Tipe Data MongoDB - Part 3

Part 4: Tutorial MongoDB: Tipe Data MongoDB (Tambahan) - Part 4
Part 5: Tutorial MongoDB: Dasar MongoDB Shell - Part 5
Part 6: Tutorial MongoDB: Operasi CRUD - Part 6

Pada part sebelumnya kita sudah sedikit mengetahui fitur-fitur ataupun unsur yang ada dalam MongoDB. Pada part ini kita akan mulai mempelajari tipe data yang ada pada MongoDB.

Document didalam MongoDB dapat dianggap sebagai "JSON" karena secara konseptual mirip dengan object pada JavaScript. Perlu untuk diketahui bahwa JSON memiliki keterbatasan dalam hal dukungan tipe data yang diantaranya hanyalah: null, boolean, numeric, string, array, dan object. 

Dalam hal ini, MongoDB tersedia dengan dukungan tambahan terhadap tipe data dengan tetap membawa sifat dasar dari JSON itu sendiri. Berikut ini daftar tipe data yang umum dalam merepresentasikan sebuah document dalam MongoDB yaitu:

• null

          Null dapat digunakan untuk merepresentasikan sebuah nilai null dan nonexistent field:

{"x" : null}

• boolean

          Tipe data boolean dapat digunakan nilai dengan kondisi true dan false:

{"x" : true}

• number

          Dalam shell MongoDB secara default menggunakan 64-bit floating point numbers. Jadi, nomor berikut ini akan terlihat

          normal dalam shell:

{"x" : 3.14} OR {"x" : 3}

         Untuk Integer, bisa menggunakan class numberInt() atau numberLong():

{"x" : NumberInt("3")}
{"x" : NumberLong("3")}

• String

         Untuk setiap yang dari karakter UTF-8 bisa direpresentasikan dengan tipe string:

{"x" : "foobar"}

• Date

         Tipe data date disimpan sebagai milliseconds since the epoch (saya tidak tahu arti yang tepat dalam bahasa indonesia),
         dan time zone sendiri tidak tersimpan:

{"x" : new Date()}

• regular expression

         Mungkin bisa dibilang tipe data ini menarik karena menggunakan sintak regular expression JavaScript dan tentunya
         berfungsi dengan baik:

{"x" : /foobar/i}

• array

         Membuat field yang mengandung daftar atau kumpulan suatu nilai bisa menggunakan tipe data array:

{"x" : ["a", "b", "c"]}

• embedded document

         Document dapat juga mengandung nilai yang berupa documents dan tipe data dari embedded document itu 
         akan menyesuaikan: 

{"x" : {"foo" : "bar"}}

• object id

         Sebelumnya kita tahu pada part sebelumnya saat proses insert secara otomatis field _id akan muncul dengan tipe data
         object id. Object id sendiri ialah sebuah 12-byte ID untuk document (detailnya akan saya jelaskan pada part berikutnya): 

{"x" : ObjectId()}

• code

         Query dan document dalam MongoDB juga dapat memuat nilai arbitrary JavaScript code:

{"x" : function() { /* ... */ }}

Itulah penjelasan mengenai tipe data yang umum ditemukan dalam penggunaan database MongoDB. Mungkin penjelasan diatas belum begitu detail, jadi jika ada yang ingin ditanyakan bisa langsung mengisi kolom komentar dibawah, dan jangan lupa terus kunjungi blog saya untuk part selanjutnya. 

Part 1: Tutorial MongoDB: Pengenalan MongoDB - Part 1
Part 2: Tutorial MongoDB: Mengoperasikan MongoDB - Part 2
Part 3: Tutorial MongoDB: Tipe Data MongoDB - Part 3
Part 4: Tutorial MongoDB: Tipe Data MongoDB (Tambahan) - Part 4
Part 5: Tutorial MongoDB: Dasar MongoDB Shell - Part 5
Part 6: Tutorial MongoDB: Operasi CRUD - Part 6

Langkah awal yang diperlukan sebelum memulai menggunakan MongoDB yaitu mendownload dan menginstallnya. Dalam hal ini saya menggunakan Linux Debian sebagai wadahnya dan menginstallnya langsung dari repository dengan perintah "sudo apt-get install mongodb". Namun jika anda ingin memilih versi tertentu bisa langsung mengunjungi download center MongoDB.

Lakukan proses installasi hingga selesai kemudian ketikkan perintah berikut pada terminal untuk menjalankan MongoDB:

$ sudo mkdir -p /data/db; sudo chown `id -u` /data/db
$ mongod

Atau bisa juga langsung menggunakan perintah:

$ sudo systemctl start mongodb

Dari semua langkah diatas, bila tidak ada error berarti MongoDB sukses dijalankan.

MongoDB Shell

MongoDB datang dengan JavaScript shell yang memungkinkan interaksi dengan operasi atau perintah-perintah dari MongoDB. Untuk masuk kedalam shell cukup mudah, ketikkan perintah "mongo" maka kita akan langsung masuk kedalam shell, seperti contoh gambar berikut.

Karena MongoDB shell didukung full-feature JavaScript interpreter (penerjemah bahasa javascript), kita dapat melakukan coding langsung didalam shell, semisal saya membuat sebuah fungsi sederhana dengan JavaScript dan menjalankannya seperti gambar berikut.

Operasi dasar dengan Shell

Kita bisa menggunakan 4 dasar operasi seperti create, read, update, delete (CRUD) untuk memanipulasi dan melihat data didalam shell. Perlu untuk diketahui bahwa tidak ada penggunaan query relational database dalam NoSQL, melainkan menggunakan metode untuk menggantikannya.

Create

Merupakan fungsi insert document ke dalam collection. Semisal kita ingin membuat blog post, pertama kita buat lokal variabel "post" yang merupakan JavaScript object dengan berisikan data sebagai berikut:

> use blog <== secara otomatis membuat dan masuk kedalam database blog
> post = {
... "title" : "Judul Postingan",
... "content" : "Isi paragraf",
... "date" : new Date()} [tekan enter]

Kemudian kita bisa menyimpan data tersebut dengan menggunakan metode insert()  dan melihat data yang sudah tersimpan metode find(). Jika berhasil maka hasilnya akan terlihat seperti gambar berikut.

Dari gambar diatas terlihat bahwa data berhasil tersimpan, dan juga terdapat data baru berupa _id yang merupakan special key. Mengenai special key akan saya jelaskan dibagian lain.

Read

Fungsi read dalam MongoDB bisa menggunakan 2 metode yaitu find() dan findOne(). Cara penggunaannya sama dengan contoh sebelumnya, cukup mengganti nama metode yang digunakan.

Update

Untuk melakukan modifikasi dalam collection, kita perlu menggunakan metode update(). Dalam penggunaannya, metode update membutuhkan 2 parameter berupa document yang mau diupdate dan data baru yang akan dimasukkan. Contohnya masih menggunakan data sebelumnya, kita akan coba menambahkan key baru dengan nama comments dan menampung nilainya dalam array. Dalam JavaScript object dikenal istilah pasangan key/value dengan bentuk seperti:

{ key : "value" }

Kita akan memodifikasi variabel post dan menambahkan key dengan nama comments:

> post.comments = [] [tekan enter]

Kemudian kita lakukan update untuk postingan dengan title "Judul Postingan" dengan data document baru dengan perintah:

> db.blog.update({title: "Judul Postingan"}, post)

Kemudian periksa dengan metode find() jika berhasil maka akan ada key baru didalam document tersebut.

Delete

Menghapus document cukup menggunakan metode remove(). Untuk menghapus seluruh document dari collection cukup panggil tanpa menggunakan parameter, tetapi jika ingin menghapus document tertentu maka gunakan parameter. Seperti contoh berikut saya akan menghapus document dengan title "Judul Postingan".

> db.blog.remove({title: "Judul Postingan"})

Itulah beberapa operasi dasar dalam menggunakan MongoDB, bisa dibilang jauh berbeda dengan database yang umum kita gunakan. Meskipun begitu sangat menarik untuk mempelajari teknologi baru untuk menambah wawasan. Selamat mencoba dan silakan baca bagian lainnya.

Part 1: Tutorial MongoDB: Pengenalan MongoDB - Part 1
Part 2: Tutorial MongoDB: Mengoperasikan MongoDB - Part 2
Part 3: Tutorial MongoDB: Tipe Data MongoDB - Part 3
Part 4: Tutorial MongoDB: Tipe Data MongoDB (Tambahan) - Part 4
Part 5: Tutorial MongoDB: Dasar MongoDB Shell - Part 5
Part 6: Tutorial MongoDB: Operasi CRUD - Part 6

MongoDB adalah document-oriented database, dan bukan merupakan relational database atau biasa dikenal dengan nama NoSQL. Sebuah document-oriented database yang dimaksud ialah database yang menggantikan konsep "row" dengan model yang lebih fleksibel yaitu "document".

MongoDB dibuat dengan tujuan untuk digunakan sebagai database pada umumnya, jadi selain fitur umum seperti create, read, update, dan delete data tersedia juga fitur unik yang tersedia diantaranya yaitu: Indexing, Aggregation, Special collection types, File storage.

Dalam tiap-tiap bagian tutorial yang akan saya buat kita akan mengenal konsep dasar dari MongoDB. Untuk langkah awal kita akan mengenal dasar seperti:

• Sebuah document adalah sama dengan row dari relational database
• Sebuah collection adalah sama dengan table 
• Database collection

Document

Document bisa dikatakan sebagai jantungnya MongoDB. Representasi dari dari sebuah document bervariasi untuk setiap bahasa pemrograman. Untuk contohnya, dalam JavaScript sebuah document direpresentasikan sebagai object:

{"show" : "Hello, world!"}

Contoh object diatas berisi sebuah key, "show" dengan nilai yaitu "Hello, world!". Dari contoh object diatas hanya memiliki single key/value, tentunya kita bisa memiliki banyak pasangan key/value dengan memisahkannya menggunakan tanda koma (,):

{"show" : "Hello, world!", "foo" : 3}

Perlu untuk diketahui bahwa document-object disini bersifat case-sensitive jadi perlu untuk lebih teliti saat membuatnya.

Collection

Collection adalah grup dari kumpulan document. Jika sebuah document MongoDB dianalogikan sebagai sebuah "row" dalam relasional database, maka collection dapat juga dianalogikan sebagai table dalam relasional database.

Collection memiliki dynamic schema, yang berarti kalau document dalam sebuah collection dapat memiliki bentuk yang berbeda, misalnya:

{"greeting" : "Hello, world!"} {"foo" : 5}

Document diatas dapat disimpan dalam sebuah collection, dan juga document tersebut bisa memiliki type data yang berbeda pula seperti contoh diatas yang terdiri dari string dan integer. Disamping itu, Collection mendukung format Subcollection yang dapat menjadikan data collection lebih terstruktur.

Database

MongoDB mengelompokkan collection ke dalam database. Sebuah database memiliki "permission" tersendiri dan setiap database disimpan menjadi bentuk file didalam disk. MongoDB sudah memiliki beberapa database yang telah tersedia secara default sehingga kita tidak bisa membuat nama database yang sama yaitu: admin, local, config. Ketiga database itu bisa dikatakan sebagai database special karena berisikan informasi dari pengoperasian MongoDB.

Itulah beberapa penjelasan dari dasar MongoDB. Masih banyak lagi fitur yang bisa diketahui dengan langsung mencobanya ataupun memeriksa berbagai macam fitur dan fungsi melalui official documentasi dari MongoDB.

Part 1: Tutorial MongoDB: Pengenalan MongoDB - Part 1
Part 2: Tutorial MongoDB: Mengoperasikan MongoDB - Part 2
Part 3: Tutorial MongoDB: Tipe Data MongoDB - Part 3
Part 4: Tutorial MongoDB: Tipe Data MongoDB (Tambahan) - Part 4
Part 5: Tutorial MongoDB: Dasar MongoDB Shell - Part 5
Part 6: Tutorial MongoDB: Operasi CRUD - Part 6

Apache adalah salah satu web server populer dan paling banyak digunakan didunia, dan mencakup hampir 40% server didunia. Jika anda adalah seorang webmaster atau administrator yang menggunakan apache server, penting untuk anda tahu bagaimana mengamankan Apache dan mencegah dari tindakan peretasan. Pada artikel ini saya akan mendeskripsikan beberapa tips dan triks sederhana yang dapat anda gunakan untuk mengamankan apache server anda.

Note: saya menggunakan ubuntu 14.04 LTS

Install dan update apache

Pertama, anda perlu untuk mengupdate dan meninstall apache ke dalam komputer anda. Untuk melakukan hal ini dapat mengikuti perintah berikut:

$ sudo apt-get update
$ sudo apt-get install apache2

Jika berhasil terinstall maka saat anda mengakses localhost ataupun alamat IP melalui browser akan tampak halaman Apache seperti yang tampak dibawah ini.

Hide apache version

Secara default, apache menampilkan versi dari apache server yang terinstall pada komputer dengan nama dari sistem operasi server yang anda gunakan. 

Pada gambar diatas anda dapat melihat versi apache dan sistem operasi yang terinstall pada komputer server anda. Ini bisa menjadi masalah keamanan utama untuk web server anda. Untuk menyembunyikan informasi ini, anda perlu mengedit file konfigurasi utama Apache (“/etc/apache2/conf-enabled/security.conf”).

$ sudo nano /etc/apache2/conf-enabled/security.conf
ServerSignature Off
ServerTokens Prod
$ sudo service apache2 restart

Berikut hasil yang didapatkan, tampak berbeda dari gambar sebelumnya.

Menonaktifkan akses direktori dan symbolic links

Daftar direktori telah aktif dalam Apache server secara default. Daftar direktori menampilkan seluruh direktori dengan filenya yang ada di apache server. Jika ini diaktifkan, seorang attacker dapat dengan mudah melihat macam-macam file, menganalisanya dan mencuri informasi sensitif dari aplikasi yang digunakan. Anda dapat melihat contoh daftar direktori yang tertampil pada gambar dibawah.

Anda dapat menonaktifkannya dengan mengedit file konfigurasi apache.

$ sudo nano /etc/apache2/apache2.conf Options -FollowSymLinks AllowOverride None Require all granted

Note: kode diatas mengasumsikan kalau halaman web anda berasal dari folder "/var/www/html". jika anda telah mengubah lokasi sesuai yang anda tentukan, ubah path direktori dalam kode diatas.

Baris Options -FollowSymLinks juga menonaktifkan symbolic links. Jika anda ingin untuk tetap mengaktifkan symbolic links, hapus tanda "-" didepan FollowSymLinks, sehingga menjadi Options FollowSymLinks.

Simpan dan restart apache server. Setelah itu coba kembali mengakses web server melalui browser, anda akan mendapatkan error seperti gambar dibawah.

Menonaktifkan modul yang tidak diperlukan

Apache terinstall dengan beberapa modul aktif yang tidak diperlukan untuk penggunaan normal. Sangat direkomendasikan untuk menonaktifkan modul-modul yang tidak perlukan itu. Anda dapat melihat daftar modul aktif yang digunakan pada server anda dengan perintah berikut:

$ sudo ls /etc/apache2/mods-enabled/

Untuk dapat menonaktifkan modul-modul tersebut menggunakan perintah berikut, contohnya:

$ sudo a2dismod autoindex status$ sudo /etc/init.d/apach2 restart

Memanfaatkan ModSecurity

Mod security adalah modul apache gratis yang digunakan untuk melindungi web server anda dari berbagai macam serangan seperti SQL injection, cross site scripting, session hijacking, brute force dan jenis exploit lainnya. Dengan ini anda juga dapat memonitor trafik dengan basis real-time.

Anda dapat menginstall mod security dengan perintah berikut:

$ sudo apt-get install libapache2-modsecurity

Untuk mengecek apakah mod_security modul sudah berjalan, gunakan perintah berikut:

$ sudo apachectl -M | grep --color security

Gambar yang tertampil dibawah mengindikasikan kalau modul sudah dimuat dalam apache.

Untuk mengaktifkan mod_security rules, anda perlu untuk mengubah nama dan mengedit file mod security yang direkomendasikan dan menyetel opsi SecRuleEngine menjadi On. Lakukan dengan perintah berikut.

$ sudo mv /etc/modsecurity/modsecurity.conf-recommended /etc/modsecurity/modsecurity.conf
$ sudo nano /etc/modsecurity/modsecurity.conf
SecRuleEngine On

Simpan dan restart untuk melihat hasilnya.

Ada banyak security rules yang dimiliki ModSecurity (dikenal dengan Core Rule Set) yang berada pada direktori "/usr/share/modesecurity-crs". Sekarang anda perlu untuk mengaktifkan rule-rule ini untuk dapat bekerja dengan apache. Lakukan dengan perintah berikut.

$ sudo nano /etc/apache2/mods-enabled/security2.conf
IncludeOptional /etc/modsecurity/*.conf
IncludeOptional "/usr/share/modsecurity-crs/*.conf"
IncludeOptional "/usr/share/modsecurity-crs/base_rules/*.conf

Simpan dan restart apache. 

Menonaktifkan server side includes dan CGI execution

Disarankan untuk menonaktifkan server side includes dan CGI execution jika tidak diperlukan. Untuk melakukan hal ini anda perlu mengedit file konfigfurasi utama apache

$ sudo nano /etc/apache2/apache2.conf Options -FollowSymLinks -Includes -ExecCGI AllowOverride None Require all granted

Anda juga dapat melakukan hal ini untuk direktori tertentu, misalnya untuk menonaktifkan server side includes dan cgi file execution untuk direktori "/var/www/html/webdir1".

Options -Includes -ExecCGI

Simpan dan restart apache.

Membatasi besaran request

Apache tidak memiliki batasan size dari HTTP request secara defaultnya. Ini akan membebaskan seorang attacker mengirim jumlah data yang besar. Apache memiliki beberapa intruksi yang memperbolehkan anda untuk mengatur request size. Ini akan dapan melindungi web server anda dari serangan DDoS.

Anda dapat memasang nilai dari 0 (unlimited) hingga 2147483647 (2GB) dalam konfigurasi utama apache. Misalnya membatasi request size untuk direktori "/var/www/html/webdir1" menjadi 200K.

$ sudo nano /etc/apache2/apache2.conf
LimitRequestBody 204800

Simpan dan restart apache.

Menolak akses diluar document root

Direkomendasikan untuk apache dapat diakses hanya dari direktori document root. Anda bisa mengamankan direktori root (/) dengan pengaturan berikut.

$ sudo nano /etc/apache2/apache2.conf Options None Order deny,allow Deny from all

Keterangan:
- Options None: Ini akan menonaktifkan semua opsi
- Order deny, allow: Urutan di mana membolehkan dan menolak perintah diterapkan.
- Deny from all: ini akan menolak sebuah request dari semua ke direktori root

Simpan dan restart apache.

Beberapa langkah diatas adalah merupakan konfigurasi yang sangat sederhana dalam penggunakan Apache Web Server. Masih banyak macam konfigurasi yang bisa digunakan tentunya sesuai dengan kebutuhan yang diinginkan. Selamat mencoba.

Umumnya tidaklah aman memberikan akses remote ke server dengan root login, bahkan meskipun menggunakan password untuk otentikasinya juga masih belum cukup aman. Pada artikel ini saya akan memberikan sedikit dasar pengaturan untuk meningkatkan keamanan SSH login.

Mengamankan SSH Login

Dalam prosesnya, meningkatkan keamanan SSH login dapat dilakukan dengan menggunakan Public Key Authentication, jadi pada tahap ini saya akan membuat sebuah public key. Langkah yang dilakukan  juga cukup sederhana.

Karena kita ingin melakukan akses ke server secara aman, perlu membuat key terlebih dahulu dari komputer client (komputer yang anda gunakan untuk mengakses server). 

$ ssh-keygen -t rsa <=== (lakukan perintah ini dari client)

Dengan perintah di atas maka akan muncul output sebagai berikut:

Generating public/private rsa key pair.
Enter file in which to save the key (/home/user/.ssh/id_rsa):
Created directory '/home/user/.ssh'.
Enter passphrase (empty for no passphrase): <=== (tekan enter)
Enter same passphrase again: <=== (tekan enter
Your identification has been saved in /home/user/.ssh/id_rsa.
Your public key has been saved in /home/user/.ssh/id_rsa.pub.
The key fingerprint is:
3d:4f:08:79:3f:9d:96:3c:5a:ae:d5:38:35:ba:39:d3

Dari hasil output tersebut kita telah mendapatkan public ssh key yang kita akan gunakan. Untuk penggunaan perintah ssh-keygen dapat dilihat informasi selanjutnya dengan man ssh-keygen agar mengetahui pilihan lain yang bisa diterapkan semisal ssh-keygen -t rsa -b 2048 yang akan menghasilkan key dengan bit 2048.

Setelah mendapatkan public ssh key, selanjutnya kita masukan ssh key tersebut ke dalam server sebagai authorized_keys yang berguna sebagai tanda pengenal saat proses login berlangsung (sederhananya bisa dikatakan demikian). 

# scp ~/.ssh/id_rsa.pub userServer@10.20.30.10:.ssh/authorized_keys

Dengan demikian tahap pembuatan ssh key telah selesai. Selanjutnya kita perlu melakukan sedikit konfigurasi SSH didalam server. Masuk terlebih dahulu ke dalam server, contoh:

# ssh userServer@10.20.30.10

Dan bila sudah berhasil masuk, edit file konfigurasi SSH:

# nano /etc/ssh/sshd_configport 8399 <=== (ubah password default sesuai yang anda inginkan)
RSAAuthentication yes
PubkeyAuthentication yes
# /etc/init.d/ssh restart

Setelah itu coba login kembali untuk mengecek apakah kita berhasil login dengan pubilc ssh key yang telah ada didalam server dan port yang telah diubah. Jika berhasil maka lanjutkan edit file yang sama, sesuai yang saya katakan sebelumnya penggunaan akses root login tidaklah aman, oleh karena itu kita harus menonaktifkannya, cari dan sesuaikan isi file tersebut dengan baris dibawah ini:

PermitRootLogin no
PasswordAuthentication no

Simpan konfigurasinya, dan restart kembali SSH. Karena root sudah tidak bisa lagi diakses secara remote dengan konfigurasi diatas, maka untuk mengaksesnya bisa melalui user biasa, lakukan dengan langkah berikut:

# visudo
xxxx ALL=(ALL) NOPASSWD:ALL <=== (ganti xxxx dengan nama user anda)

Coba logout dari server dan lakukan login kembali dengan menggunakan root, semestinya kita tidak bisa lagi login menggunakan root. Dan untuk dapat kembali mengakses root login lah menggunakan user biasa sesuai dengan nama user yang telah diletakan dalam konfigurasi visudo.

$ ssh xxxx@10.20.30.10 -p 8399
$ sudo su -

Dengan perintah diatas kita bisa kembali mengakses root. Tentunya dengan cara ini akan lebih aman akses SSH yang dilakukan karena proses login berjalan dengan key yang telah dienkripsi dan juga akan sulit untuk bagi pihak lain yang mencoba mengakses server kita melalui SSH dari komputer miliknya tanpa adanya public ssh key yang telah kita berikan di dalam server. Selamant mencoba dan semoga bermanfaat.

tu Pada saat ini kita hidup dijaman yang segala sesuatunya berada di cloud. Tren ini sendiri memiliki kelebihan dan kekurangan. Kelebihan terbesar yang kita rasakan yaitu kita dapat mengakses data dimanapun, kapanpun dan dari perangkat apapun. Disisi lain kekurangan terbesarnya yaitu kita kehilangan kontrol terhadap hal milik kita.

Dengan bersadarkan hal tersebut, terdapat pilihan yang bisa kita lakukan yaitu membangun infrastruktur cloud kita sendiri. Kali ini saya akan memberikan contoh sederhana cara membangun sistem cloud. Cloud yang saya rekomendasikan yaitu ownCloud karena memiliki fitur yang bagus, tetapi pada artikel ini saya akan fokuskan dalam membangun layanan streaming menggunakan Emby. Emby server memiliki fitur yang otomatis mengkonversi media untuk dapat diputar pada perangkat apapun.

Installasi Emby

Proses installasi cukup mudah, dan juga emby support banyak ragam distro seperti Debian, CentOS, Arch Linux, Fedora, Ubuntu. Pada contoh ini saya akan menggunakan Ubuntu 14.04 server VM yang sudah terinstall. Langkah installasi yang dilakukan yaitu:

# wget -qO - http://download.opensuse.org/repositories/home:emby/xUbuntu_14.04/Release.key | apt-key add -
# sh -c "echo 'deb http://download.opensuse.org/repositories/home:/emby/xUbuntu_14.04/ /' >> /etc/apt/sources.list.d/emby-server.list"
# apt-get update
# apt-get install mono-runtime mediainfo libsqlite3-dev imagemagick-6.q8 libmagickwand-6.q8-2 libmagickcore-6.q8-2
# apt-get install emby-server

Pada saat proses installasi, akan terdapat peringatan untuk menentukan user. Default user yang terinstall yaitu "emby", tetapi bila memang ingin menggunkan user default tersebut perlu untuk memperhatikan hak aksesnya terhadap direktori dan file, tetapi bila ingin menggunakan user lain silakan diganti pada saat proses installasi. Seperti contoh gambar dibawah ini, kita dapat mengganti user sesuai yang kita inginkan.

Setelah proses installasi selesai, kita dapat langsung mengaksesnya melalui web browser dengan http://localhost:8096/web/wizardstart.html untuk masuk ke proses konfigurasi. Konfigurasi yang perlu dilakukan diantaranya yaitu:

- Menentukan bahasa

- Membuat user yang akan mengakses media

- Mempersiapkan media library

- Menentukan bahasa utk metadata (samakan dgn pilihan pertama)

- Skip TV Tuner

- Accept the terms of service

Halaman Konfigurasi

Halaman Setup media library

Halaman akses user ke server

Setelah selesai kita dapat langsung masuk ke dalam Emby media server untuk menentukan media library lebih lengkap dan konfigurasi lain yang diperlukan.

Sistem media server seperti ini sangat cocok digunakan pada local network, seperti jika kita mempunya Wi-Fi router, kita dapat memberikan informasi mengenai media server yang sudah kita buat pada halaman login Wi-Fi, tetapi terlebih dahulu kita perlu mengedit halaman login tersebut.

Sistem seperti ini memang sangat menarik jika diterapkan seperti cara tersebut sehingga user dapat mendapatkan pengalaman yang lebih menarik selain kegiatan internetan. Jika tertarik bisa langsung mencobanya sendiri dan silakan share pengalaman anda setelah menggunakannya.

Pada artikel ini saya akan memberikan contoh bagaimana mengelola server ataupun VPS dengan melalui Control panel. Sebelumnya saya juga telah membuat artikel mengenai VPS Control Panel Terbaik yang terdiri dari banyak user yang menggunakannya dan mendapatkan review yang baik.

Saya akan menggunakan Webmin/Virtualmin Control Panel. Control panel ini sudah tidak asing lagi bagi yang sudah sering mengelola server. Kegunaan control panel akan memudahkan admin sebagai pengelola dalam menangani server melalui interface (antarmuka) yang berbasis web.

Umumnya server tidak memiliki interface, jadi hanya berupa shell saja sehingga mungkin bagi sebagian orang hal itu sedikit menyulitkan. Namun dengan adanya control panel kita mendapatkan pengalaman yang baru dalam mengelola server dengan interface yang interaktif.

Untuk menginstall Webmin/Virtualmin dapat di download melalui official site webmin. Dan saya akan menggunakan Debian sebagai server dan sudah terdapat beberapa service yang telah terinstall didalamnya seperti MySQL, Nginx web server.

Install Webmin/Virtualmin

Masuk terlebih dahulu kedalam server, kemudian download package webmin.

#wget http://skylineservers.dl.sourceforge.net/project/webadmin/webmin/1.760/webmin_1.760_all.deb

Install dependensi yang dibutuhkan yaitu:

# apt-get install libauthen-pam-perl libio-pty-perl apt-show-versions libapt-pkg-perl libnet-ssleay-perl
# dpkg -i webmin_1.760_all.deb

Tunggu proses installasi selesai. Ketika berhasil menginstall webmin maka kita dapat langsung menjalankannya melalui web browser.

Menjalankan Webmin Control Panel

Untuk menjalankan webmin control panel dapat diakses melalui https://localhost:10000. Secara default webmin menginstall SSL untuk akses kedalam control panel sehingga kita harus mengaksesnya melalui protokol HTTPS, localhost dapat diganti dengan alamat IP server. Berikut ini halaman awal webmin control panel.

Mengkases control panel memerlukan user. User yang dimaksud ialah user sistem Linux, sebagai contoh gunakan user root untuk masuk ke dalam control panel. Berikut ini tampilan menu dalam webmin control panel

Pada sisi kiri terdapat daftar menu yang sudah disediakan oleh webmin, dan juga dapat dilihat terdapat service yang sudah terinstall dalam server saya yaitu MySQL dan Nginx web server. Saya dapat langsung melakukan konfigurasi terhadap service-service tersebut melalui control panel.

Selain melakukan konfigurasi terhadap service yang ada, juga masih tersedia banyak menu pilihan yang dapat kita konfigurasi sesuai dengan kebutuhan kita. Jadi tidak perlu lagi kita menggunakan terminal untuk melakukan konfigurasi karena dengan control panel kita bisa lebih mudah mengelola server yang kita punya dengan melalui interface berbasi web yang menarik.

Masih ada banyak control panel lainnya, silakan baca disini. Dan saya sendiri lebih senang menggunakan webmin karena lebih simple dan sudah terbiasa dalam penggunaannya, tetapi terkadang saya juga sering mencoba control panel lainnya untuk melihat perbedaan dan mencari pengalaman yang baru. Jadi selamat mencoba dan semoga bermanfaat.

Kita mungkin telah mengenal dengan istilah synchronize yang bekerja dengan menyinkronkan sebuah file dari satu tempat ke tempat lain. Umumnya proses synchronization berada pada background data yang ditangani langsung oleh server. Kali ini saya akan mencoba membuat syncronization pada 2 buah server dengan menggunakan Unison.

Unison adalah merupakan tool file-synchronization yang mirip dengan rsync, tetapi yang membedakannya yaitu Unison akan menyinkronkan segala perubahan yang terjadi langsung pada kedua object file (istilah yang dikenal replikasi), misalnya file yang diubah pada server1 akan direplikasi pada server2 dan begitu sebaliknya.

Pada proses yang saya lakukan ini akan saya gunakan 2 Debian server:

- server1 = 10.20.30.10

- server2 = 10.20.30.11

Saya akan mencoba melakukan sinkronisasi pada direktori /var/www.

Install Unison

Proses installasi dilakukan pada kedua server dengan perintah sebagai berikut:

# apt-get install unison

Membuat Private/Public Key

Private/public key kita buat pada server1 dengan perintah berikut:

# ssh-keygen -t dsa

**saat proses muncul, tekan saja ENTER hingga selesai jangan isikan apapun.

Proses akan muncul dan meminta passphrase, jangan diisi karena proses replikasi tidak akan berjalan jika tidak ada interaksi terhadap user/admin untuk mengetikkan passphrase tersebut.

Selanjutnya copy private/public key yang sudah kita buat ke server2:

# ssh-copy-id -i $HOME/.ssh/id_dsa.pub root@10.20.30.11 <== lakukan dari server1

**saat proses muncul, pertama ketik "yes" dan kemudian isikan password server2

Setelah berhasil kita dapat memeriksa apakah key file tersebut sudah berhasil masuk pada server2, lakukan dengan perintah berikut ini di server2:

# cat $HOME/.ssh/authorized_keys

Menjalankan Unison

Lakukan terlebih dahulu pada server1, seperti yang sebelumnya saya katakan akan menyinkronkan direktori /var/www pada kedua server.

# unison /var/www ssh://10.20.30.11//var/www <== dari server1

output yang muncul yaitu:

Press return to continue.[] <== tekan ENTER
Waiting for changes from serverReconciling changes
local debianhos...dir ----> / [f] <== tekan ENTER
Proceed with propagating updates? [] y <== tekan huruf "y"
Propagating updates
### tunggu proses hingga selesai akan muncul seperti dibawah ini ###
[END] Copying UNISON 2.40.65 finished propagating changes at 08:57:57.54 on 02 Oct 2015Saving synchronizer
stateSynchronization complete at 08:57:57 (1 item transferred, 0 skipped, 0 failed)

Setelah proses selesai, dapat langsung memeriksa direktori /var/www pada kedua server, pastinya akan terdapat isi yang sama dengan size file yang sama pula.

Proses diatas kita lakukan dengan interaksi langsung oleh user/admin, jika kita ingin melakukan proses tersebut tanpa interaksi langsung dapat dibuat konfigurasi terhadap unison, seperti contoh berikut:

# Roots of the synchronization
# nano /root/.unison/default.prf
root = /var/www
root = ssh://192.168.1.102//var/www
# Paths to synchronize
#path = current
#path = common
#path = .netscape/bookmarks.html
# Some regexps specifying names and paths to ignore
#ignore = Path stats ## ignores /var/www/stats
#ignore = Path stats/* ## ignores /var/www/stats/*
#ignore = Path */stats ## ignores /var/www/somedir/stats, but not /var/www/a/b/c/stats
#ignore = Name *stats ## ignores all files/directories that end with "stats"
#ignore = Name stats* ## ignores all files/directories that begin with "stats"
#ignore = Name *.tmp ## ignores all files with the extension .tmp
auto=true
batch=true
confirmbigdel=true
fastcheck=true
group=true
owner=true
prefer=newer
silent=true
times=true

Contoh diatas terdapat bagian tanda "#" dengan perintah path, itu bukanlah untuk membuat komentar tapi memang seperti itulah isi konfigurasi untuk path pada unison. Path dibuat untuk menspesifikasikan direktori root (contoh diatas: root=/var/www dengan path=current akan menjadi /var/www/current) dengan begitu hanya direktori yang sudah ditentukan yang akan disinkronisasi, jika tidak menspesifikasikan path maka seluruh direktori root akan dianggap sebagai file yang akan disinkron. Untuk lebih lanjut mengenai konfigurasi ini dapat dilihat langsung melalui man unison.

Jika telah membuat konfigurasi diatas, maka perintah untuk menjalankan unison cukup seperti berikut ini:

# unison

Tidak ada argumen yang mengikuti perintah tersebut karena semua telah berada dalam konfigurasi.

Membuat Cron Job Untuk Unison

Cron job dibuat agar proses sinkronisasi berjalan otomati dibelakang layar, dan untuk melakukan ini tentunya harus menentukan dulu dimana server utama, dalam kasus ini server1 adalah server utama yang akan menyinkron ke server2, sehingga cron job dilakukan pada server1. Berikut cara untuk membuat cron job:

# crontab -e
*/1 * * * * /usr/bin/unison &> /dev/null

Cron job diatas akan berjalan untuk setiap 1 menit, dan /usr/bin/unison merupakan path aplikasi unison pada komputer saya jadi kemungkinan berbeda dengan yang lain, untuk memeriksanya lakukan dengan perintah:

# which unison

Jika ingin lebih lanjut mengetahui cara membuat cron job, silakan baca cara menggunakan crontab di linux yang sudah pernah saya buat sebelumnya.

Uji Coba Unison Cron Job

Saya akan melakukan uji coba sinkronisasi yang kedua setelah konfigurasi yang dilakukan dan pembuatan cron job untuk mengetahui apakah unison sudah bejalan dengan baik.

Pertama lakukan pada server1 untuk membuat sebuah file, semisal file sinkronisasi dengan isi file tulisan "sinkron berhasil":

# echo "sinkron berhasil" > /var/www/sinkronisasi.txt

Selanjutnya kita menunggu cron job bekerja selama satu menit sesuai waktu yang sudah kita tentukan sebelumnya. Dan setelah berjalan 1 menit periksa pada server2, jika berhasil maka akan tampak file sinkronisasi dengan isi file tulisan "sinkron berhasil".

Tampak dari gambar diatas, proses sinkronisasi yang dilakukan telah berhasil. Melakukan hal semacam ini memang perlu apalagi jika mengelola sebuah server kita harus menentukan cara dan langkah yang tepat untuk mengelolanya baik salah satunya dengan sinkronisasi seperti cara diatas yang memudahkan kita untuk menyinkronkan file antara server1 dengan server2 tanpat harus berinteraksi langsung dalam proses sinkronnya. Selamat mencoba dan semoga bermanfaat.