Cara Install Moodle di Ubuntu

Moodle adalah aplikasi open source untuk e-learning berbasis web. Moodle telah banyak diimplementasikan di berbagai sekolah dan perguruan tinggi di Indonesia.

Tutorial instalasi Moodle ini menggunakan:

Install LAMP server

sudo apt-get updatesudo apt-get update

sudo apt-get install apache2 mysql-client mysql-server php7.0 libapache2-mod-php7.0 php7.0-pspell php7.0-curl php7.0-gd php7.0-intl php7.0-mysql php7.0-xml php7.0-xmlrpc php7.0-ldap php7.0-zip php7.0-soap php7.0-mbstring

Buat database

Download Moodle

Extract Moodle dan pindahkan ke /var/www/html

tar xzvf moodle-latest-34.tgz
sudo mv moodle /var/www/html/
cd /var/www/html
sudo chown -R :www-data moodle
sudo chmod -R 775 moodle

Buat direktori moodledata

cd /var/wwwcd /var/www

sudo mkdir moodledata

sudo chown -R :www-data moodledata

sudo chmod 775 moodledata

Akses http://localhost/moodle atau http://IP_SERVER/moodle
Pilih bahasa, setelah instalasi masih bisa diganti
cara install moodle di ubuntu

Konfirmasi direktori instalasi dan data
cara install moodle di ubuntu

Pilih database driver mysqli
cara install moodle di ubuntu

Database settings
cara install moodle di ubuntu

Konfirmasi lisensi
cara install moodle di ubuntu

Pengecekan kebutuhan server, extension PHP. Jika ada yang kurang, install extension dan restart apache. Misalnya kurang extension mbstring, curl, dan openssl cara installnya

sudo apt-get install php-mbstring php-curl php-openssl

Restart apache

Kemudian reload kembali halaman ini
cara install moodle di ubuntu

Jika semua environment sudah terpenuhi ditampilkan pesan Your server environment meets all minimum requirements..
cara install moodle di ubuntu

Proses instalasi dimulai. Cek semua statusnya apakah Success atau tidak
cara install moodle di ubuntu

Isi informasi General.
Password minimal 8 karakter, terdapat 1 karakter angka, 1 karakter huruf kapital, dan 1 karakter spesial seperti * atau #.
cara install moodle di ubuntu

Isi Front page settings
cara install moodle di ubuntu

Jika berhasil, langsung masuk ke Dashboard
cara install moodle di ubuntu

selamat mencoba 🙂




How setup my server

1. Check OS version

Check OS version    – centos : rpm –query centos-release

2. Install apache/http

– masuk super user : su – (input username & password)

– jalankan : sudo yum install httpd

– start apache/http : sudo service httpd start

– ubah port jika diperlukan, jalankan : vi /etc/httpd/conf/httpd.conf

– info :
3. Install mysql

– masuk super user : su – (input username & password)

– jalankan : sudo yum install mysql-server

– start mysql : sudo service mysqld start

– set config mysql : sudo /usr/bin/mysql_secure_installation

– info :
4. Install php

– masuk super user : su – (input username & password)

– jalankan : sudo yum install php php-mysql

– restart apache/http : sudo service httpd restart

– info :
5. Install git

– masuk super user : su

– (input username & password)

– update repo : yum update

– install : yum install git

– cek versi git : git –version

– regis : git config –global “mbwn”   git config –global “”

– info :
6. Install Phalcon

a. Check Versi Php : php -v

. Upgrade Php jika dibawah 5.6 harus upgrade Php

*. jika belum terinstall wget : yum install wget

*. jalankan : wget && rpm -Uvh epel-release-latest-6.noarch.rpm

*. jalankan : wget && rpm -Uvh remi-release-6*.rpm

*. set config : vi /etc/yum.repos.d/remi.repo

*. [remi] = enable=1   [remi-php56] = enable=1 :wq

*. upgrade : yum -y upgrade php*

*. cek kembali versi php : php -v

*. info :

b. Install

*. tambahkan repository : curl -s | sudo bash

*. Php 5.6 : sudo yum install php56u-phalcon

*. Php 7   : sudo yum install php70u-phalcon

*. package : sudo yum install php-devel pcre-devel gcc make

*. package : yum –enablerepo=remi,epel install php php-mysql gcc libtool

*. tambahkan extension : echo “” > /etc/php.d/phalcon.ini

*. chmod 777 /var/www/html/ : lakukan untuk permision folder

*. cek extension dan installasi, buat file info.php : <?php echo phpinfo(); ?> dan hit   c. Phalcon

*. dalam akses root pindah ke : cd /opt/

*. package : git clone     #SAMPE SINIH

*. cd cphalcon/build

*. sudo ./install

*. tambahkan extension : echo “” > /etc/php.d/phalcon.ini

*. restart apache/http : service httpd reload dan service httpd restart

*. info :

d. masalah Mod-Rewrite is not enabled

*. ubah : AllowOverride None to AllowOverride All pada : /etc/httpd/conf/httpd.conf

*. pastikan .htaccess dan .htrouter.php pada main folder

*. masalah -> Volt directory can’t be written : chmod -R a+w cache (biasanya ada difolder cache)   e. Gagal open Dr 2

*. delete dalam folder filesystem (engine) dan ubah permision filesystem menjadi 777 : chmod 777 /var/www/html/smsengine/filesystem/

7. Installasi CMS

a. copy semua file cms

b. ubah config db

c. ubah config base url

. Installasi Engine

a. copy semua file engine

b. ubah config db

c. ubah permision chache : chmod -R a+w /var/www/html/smsengine/cache

info :

d. ubah permision filesystem : chmod 777 /var/www/html/smsengine/filesystem

e. pada check engine, crontab ditambahkan sh pada awal untuk eksekusi file .sh

———————-Configurasi crontab -e

*/10 * * * * sh /var/www/html/smsengine/enginecheck/ >> /var/www/html/smsengine/log/engine_10minutes.log#*/30 * * * * sh /var/www/html/smsengine/enginecheck/ >> /var/www/html/smsengine/log/engine_30minutes.log
#30 12 * * * sh /var/www/html/smsengine/enginecheck/ >> /var/www/html/smsengine/log/engine_12oclock.log00 01 * * * sh /var/www/html/smsengine/enginecheck/ >> /var/www/html/smsengine/log/engine_day.log*/1 * * * * sh /var/www/html/smsengine/enginecheck/ >> /var/www/html/smsengine/log/engine_1minute.log*/1 * * * * sh /var/www/html/smsengine/enginecheck/ >> /var/www/html/smsengine/log/engine_telco.log*/1 * * * * sh /var/www/html/smsengine/enginecheck/ >> /var/www/html/smsengine/log/engine_app.log#00 07 * * * sh /var/www/html/smsengine/enginecheck/ >> /var/www/html/smsengine/log/engine_morning.log
00 */1 * * * sh /var/www/html/smsengine/enginecheck/ >> /var/www/html/smsengine/log/engine_1hour.log

SymptomsHow to set max_allowed_packet size to 16 MB for MySQL?
ResolutionFollow the steps below to achieve the same:
Connect to the server using SSH/RDP.Set the max_allowed_packet value in [mysqld] and [mysqldump] sections of my.cnf file:
[mysqld] max_allowed_packet=16M …. [mysqldump] max_allowed_packet=16M
Restart MySQL service:
# service mysqld restart mysql start/running, process 2496

How to Verify a CentOS Linux Server is 32 Bit or 64 Bit

To verify if a system is 32 bit versus 64 bit you can use the uname command. Below are examples of using the uname command from the CLI on a 32 bit system followed by using the uname command on a 64 bit system.

32 Bit CentOS Linux Server


[root@server ~]# uname -a

Linux 2.6.18-92.1.13.el5 #1 SMP Wed Sep 24 19:33:52 EDT 2008 i686 i686 i386 GNU/Linux

64 Bit CentOS Linux Server

[root@server ~]# uname -a
Linux 2.6.18-53.1.21.el5 #1 SMP Tue May 20 09:35:07 EDT 2008 x86_64 x86_64 x86_64 GNU/Linux

As you can see above the 64 bit server will show x86_64 numerous times after the install date and time. The 32 bit system will show i686 and i386 after the install date and time. So it is very easy to verify if a system is 32 bit versus 64 bit using the “uname -a” command from a shell.

ERROR 1045 (28000): Access denied for user ‘root’@’localhost’ (using password: NO)

The following steps are to reset the password for a user in case you forgot, this would also solve your mentioned error.

First, stop your MySQL:

sudo /etc/init.d/mysql stop


sudo service mysqld stop

Now start up MySQL in safe mode and skip the privileges table:

sudo mysqld_safe --skip-grant-tables &

and then Login with root:

mysql -uroot

And assign the DB that needs to be used:

use mysql;

Now all you have to do is reset your root password of the MySQL user and restart the MySQL service:

update user set password=PASSWORD("YOURPASSWORDHERE") where User='root';

flush privileges;

quit and restart MySQL:


sudo /etc/init.d/mysql stop sudo /etc/init.d/mysql start Now your root password should be working with the one you just set, check it with:

mysql -u root -p



it works!!!

Model could not be loaded while executing query [Phalcon Framework]

i get some trouble when using model query for execute in phalcon framework like this sample and the result :

$query = new Query(
“SELECT * FROM Campaign”,

Model ‘Campaign’ could not be loaded
#0 [internal function]: Phalcon\Mvc\Model\Manager->load(‘Campaign’, true)
#1 [internal function]: Phalcon\Mvc\Model\Query->_prepareSelect()
#2 [internal function]: Phalcon\Mvc\Model\Query->parse()
#3 /var/www/html/gamanads/app/controllers/AdspaceController.php(185): Phalcon\Mvc\Model\Query->execute()
#4 [internal function]: Vokuro\Controllers\AdspaceController->offerwallAction()
#5 [internal function]: Phalcon\Dispatcher->callActionMethod(Object(Vokuro\Controllers\AdspaceController), ‘offerwallAction’, Array)
#6 [internal function]: Phalcon\Dispatcher->_dispatch()
#7 [internal function]: Phalcon\Dispatcher->dispatch()
#8 /var/www/html/gamanads/public/index.php(41): Phalcon\Mvc\Application->handle()
#9 {main}

how i solve this problem is just, get full path for the model in models folder like this.

$query = new Query(
“SELECT * FROM Vokuro\Models\Campaign”,

and, taraaaaaa…. works very well.


Memulai Pembuatan Aplikasi Web dengan Express.js (1): Instalasi dan Pengenalan

Express.js adalah satu web framework paling populer di dunia Node.js. Dokumentasinya yang lengkap dan penggunaannya yang cukup mudah, dapat membuat kita mengembangkan berbagai produk seperti aplikasi web ataupun RESTful API. Express.js pun dapat digunakan menjadi pijakan untuk membangun web framework yang lebih kompleks seperti, Sails.js, MEAN (MongoDB, Express.js, Angular.js, Node.js) dan MERN (MongoDB, Express.js, React.js, Node.js). Express.js dibuat oleh TJ Holowaychuk dan sekarang dikelola oleh komunitas.

Beberapa keunggulan yang dimiliki oleh Express.js antara lain:

  • Dukungan pembuatan middleware
  • Dukungan terhadap berbagai HTTP verb seperti POST, GET, PUT, DELETE, OPTION, HEAD, dan lainnya
  • Sudah terpasang template engine Jade
  • manajemen file statik seperti CSS dan Javascript
  • Sangat bebas untuk dikostumisasi

Di tutorial bagian pertama ini, Anda akan mengenal bagaimana cara kita menggunakan Express.js yang paling dasar dan berbagai teknik dasar yang akan kita pelajari untuk membuat sebuah aplikasi web. Selamat menikmati tutorial ini :D.


Untuk menggunakan Express.js, pastikan Anda memasang Node.js terlebih dahulu dan pastikan NPM sudah dapat digunakan. Tutorial ini dibuat dengan menggunakan Node.js versi 5.10.1 dan NPM versi 3.8.5. Melalui konsol atau terminal silahkan eksekusi perintah berikut. Pastikan pilih folder yang Anda sukai:

$ npm install express -g
$ express demo
$ npm install
$ npm start

Sekarang mari kita lihat halaman pertama yang dihasilkan oleh Express.js di web browser. Silahkan akses URL http://localhost:3000/, bentuknya akan seperti ini:


Melihat Struktur Folder Express.js

Saat pertama kali dibuat, Express.js memiliki struktur folder seperti berikut:

  • bin, di dalamnya terdapat sebuah file yang bernama www dimana file tersebut akan dieksekusi saat menjalankan perintah “npm start”
  • node_modules, di dalamnya terdapat berbagai folder librarylibrary Node.js yang dipasang melalui node package manager atau NPM
  • public, kita dapat menaruh berbagai file CSS, Javascript, atau gambar di dalam folder ini.
  • routes, di dalamnya terdapat berbagai file yang berisi action yang diterima oleh routing yang kita definisikan. Dapat menerima request berupa GET, POST, PUT, DELETE, OPTION, dan HEAD
  • views, di dalamnya terdapat berbagai file jade atau html yang digunakan oleh routes untuk menampilkan halaman
  • app.js, file utama Express.js yang berisi penggunaan package utama dan konfigurasi utama
  • npm-debug.log, file yang berisi hasil debug atau error yang dicatat oleh Express.js selama running
  • package.json, berisi struktur JSON yang mendefinisikan profil proyek dan dependensi paket apa saja yang dibutuhkan aplikasi yang kita kembangkan. NPM akan melacak dependensi dengan melihat file ini

Melihat File – File Penting Express.js

Sekarang mari kita intip contoh isi file app.js. Di dalamnya Anda akan melihat penggunaan library tertentu dengan menggunakan require() kemudian memasangnya di Express.js dengan menggunakan use(), kemudian untuk mengatur variabel global digunakan set():

var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');

var routes = require('./routes/index');
var users = require('./routes/users');

var app = express();

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(express.static(path.join(__dirname, 'public')));

app.use('/', routes);
app.use('/users', users);

// catch 404 and forward to error handler
app.use(function(req, res, next) {
  var err = new Error('Not Found');
  err.status = 404;

// error handlers

// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
  app.use(function(err, req, res, next) {
    res.status(err.status || 500);
    res.render('error', {
      message: err.message,
      error: err

// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
  res.status(err.status || 500);
  res.render('error', {
    message: err.message,
    error: {}

module.exports = app;

Lanjut, kita lihat juga isi file dari package.json yang didalamnya terdapat konfigurasi file mana yang akan dieksekusi oleh “npm start”, kemudian ada juga daftar dependency yang digunakan oleh aplikasi yang kita kembangkan beserta versinya:

  "name": "demo",
  "version": "0.0.0",
  "private": true,
  "scripts": {
    "start": "node ./bin/www"
  "dependencies": {
    "body-parser": "~1.13.2",
    "cookie-parser": "~1.3.5",
    "debug": "~2.2.0",
    "express": "~4.13.1",
    "jade": "~1.11.0",
    "morgan": "~1.6.1",
    "serve-favicon": "~2.3.0"

Sedangkan file bin/www berisi kode untuk menjalankan aplikasi dengan default port dan konfigurasi informasi lainnya saat runtime:

#!/usr/bin/env node

 * Module dependencies.

var app = require('../app');
var debug = require('debug')('demo:server');
var http = require('http');

 * Get port from environment and store in Express.

var port = normalizePort(process.env.PORT || '3000');
app.set('port', port);

 * Create HTTP server.

var server = http.createServer(app);

 * Listen on provided port, on all network interfaces.

server.on('error', onError);
server.on('listening', onListening);

 * Normalize a port into a number, string, or false.

function normalizePort(val) {
  var port = parseInt(val, 10);

  if (isNaN(port)) {
    // named pipe
    return val;

  if (port >= 0) {
    // port number
    return port;

  return false;

 * Event listener for HTTP server "error" event.

function onError(error) {
  if (error.syscall !== 'listen') {
    throw error;

  var bind = typeof port === 'string'
    ? 'Pipe ' + port
    : 'Port ' + port;

  // handle specific listen errors with friendly messages
  switch (error.code) {
    case 'EACCES':
      console.error(bind + ' requires elevated privileges');
    case 'EADDRINUSE':
      console.error(bind + ' is already in use');
      throw error;

 * Event listener for HTTP server "listening" event.

function onListening() {
  var addr = server.address();
  var bind = typeof addr === 'string'
    ? 'pipe ' + addr
    : 'port ' + addr.port;
  debug('Listening on ' + bind);

Mengenal Template Engine Jade

Misal kita temukan sebuah file bernama layout.jade:

doctype html
    title= title
    link(rel='stylesheet', href='/stylesheets/style.css')
    block content

Kemudian layout tersebut digunakan oleh index.jade:

extends layout

block content
  h1= title
  p Welcome to #{title}

Maka bila kita bayangkan, hasilnya akan menjadi seperti ini namun tanpa harus mengetik ulang bagian tertentu di file berbeda yang menggunakan layout.jade:

doctype html
    title= title
    link(rel='stylesheet', href='/stylesheets/style.css')
    h1= title
    p Welcome to #{title}

Templating dengan menggunakan Jade mungkin agak aneh dan tidak lazim, karena kita tidak menggunakan penutup atau pembuka tag HTML. Untuk menyatakan bahwa sebuah elemen berada di dalam elemen lain, kita berikan dahulu satu tab dibawah elemen yang akan berisi elemen lain. Kemudian ada sintaks extends dan block yang berarti bahwa kita menggunakan template layout.jade sebagai wadah untuk index.jade. Lalu Jade akan mencari posisi block content dan mengisinya dengan elemen yang ada di index.jade.

Selain itu untuk mencetak variabel kita gunakan sintaks #{nama_variabel}. Sedangkan untuk menggunakan atribut HTML pada suatu elemen, kita gunakan tanda “(” dan “)” dengan mengisi atribut yang akan digunakan. Sebagai contoh mari kita lihat contoh berikut:

// contoh 1

<h1>Hello World</h1>


h1 Hello World

// contoh 2

<table id="table-mahasiswa" class="table table-hovered" border="1" style="display:inline-block;padding:50px;">


table(border="1", style="display:inline-block;padding:50px;")#table-mahasiswa.table.table-hovered
            td 1
            td hello
            td world

Untuk memudahkan pembuatan file Jade, Anda dapat menggunakan konverter tapi tentu saja hasil konversinya harus diperiksa dahulu, karena Jade sangat sensitif terhadap perbedaan penggunaan spasi dan tab. Jade mengharuskan kita hanya menggunakan salah satu jenis tab apakah hanya menggunakan spasi atau tab. Tidak boleh dicampur.

Routing di Express.js

OK, sekarang kita coba buka file index.js yang ada di folder routes:

var express = require('express');
var router = express.Router();

/* DEMO 0 - halaman index */
router.get('/', function(req, res, next) {
  res.render('index', { title: 'Express' });

module.exports = router;

Anda dapat melihat dalam setiap file routes harus menggunakan modul Express.js terlebih dahulu, kemudian membuat instance Router() dan barulah kita dapat mendefinisikan URL apa lalu ditangani oleh aksi apa. Aksi yang kita lewatkan ke dalam routes harus menerima variabel request, response, dan next. Anda dapat menampilkan template Jade yang ada di folder views dengan menggunakan render() yang dimiliki oleh objek response. Pada kode diatas, objek response ditangkap oleh parameter res, maka kita panggil render() melalui res.render() kemudian tentukan file* Jade mana yang akan kita tampilkan, dan kita dapat melewatkan beberapa variabel dengan diapit tanda “{” dan “}”.

Untuk route ini, file index.jade akan ditampilkan dan diberikan sebuah nilai berupa title yang berisi “Express”:

extends layout

block content
  h1= title
  p Welcome to #{title}

Bila kita akses url http://localhost:3000/ maka akan muncul tampilan berikut:


Mengirim Variabel ke Template

Masih di file index.js. Sekarang kita coba tambah parameter yang dilewatkan ke sebuah template bernama demo1.jade. Kita akan melewatkan sebuah pesan bernama message dan sebuah objek bernama user:

/* DEMO 1 - render template */
router.get('/demo1', function(req, res, next) {
                    message: 'Lorem ipsum sit dolor amet', 
                    user: {name:'suyono', email:'', website: ''} 

Seperti yang Anda lihat, kita lewatkan dua buah variabel dan variabel user memiliki struktur lebih detail di dalamnya. Bila akan kita tampilkan di demo1.jade maka kodenya akan seperti berikut:

extends layout

block content
  p message: #{message}
  p #{}
  p #{}
  p #{}

Bila kita akses url http://localhost:3000/demo1 maka akan muncul tampilan berikut:


Menerima Parameter URL

Masih di file index.js. Sekarang kita coba lagi teknik lainnya yang cukup penting. Kita akan menggunakan parameter URL dalam sebuah route. Untuk menandai bahwa sebuah segmen adalah parameter maka harus kita kurung dengan tanda “(:” dan “)” barulah didalamnya tulis nama parameternya. Untuk menangkapnya di dalam kode, Anda dapat memanggil req.params.nama_variabel sesuai dengan nama parameter yang ditentukan:

/* DEMO 2 - parameter di URL */
router.get('/demo2/(:id)/(:category)', function (req, res, next){
                            category: req.params.category, 

Sekarang akan kita tampilkan di file demo2.jade. Buat file tersebut di dalam folder views:

extends layout

block content
  p id: #{id}
  p category: #{category}

Bila kita akses url http://localhost:3000/demo2/1/food maka akan muncul tampilan berikut:


Menampilkan Response JSON

Masih di file index.js. Tidak berbeda jauh dengan menampilkan sebuah file template. Sekarang kita akan tampilkan langsung sebuah objek Javascript dan ditampilkan sebagai response JSON dengan menggunakan json():

/* DEMO 3 - menampilkan respon JSON */
router.get('/demo3', function(req, res, next) {
                message: 'Lorem ipsum sit dolor amet', 
                user: {name:'suyono', email:'', website: ''} 

Bila kita akses url http://localhost:3000/demo3 maka akan muncul tampilan berikut:


Menerima Request POST

Masih di file index.js. Sekarang kita akan mencoba menampilkan sebuah form dan mengirimnya melalui metode POST. Pertama kita buat dahulu route untuk menampilkan form. Kemudian buatlah route untuk menangkap hasil kiriman POST:

/* DEMO 4 - menerima request method POST dari form */
router.get('/demo4/', function (req, res, next){
});'/demo4/', function (req, res, next){
              message: "request POST is executed",
              data: { 
                username: req.param('username'), 
                email: req.param('email'), 
                website: req.param('website'), 
                phone: req.param('phone'), 

Pada kode diatas, untuk menangkap hasil kiriman POST, maka kita gunakan req.param(‘nama_variabel’), berbeda dengan cara menangkap kiriman GET dimana kita memanggil req.params.nama_variabel. Hati – hati jangan sampai tertukar yah.

Sekarang kita coba buat form nya dengan menggunakan template Jade. Silahkan buat sebuah file dengan nama demo4.jade di folder views:

extends layout

block content
    h3 Demo Form
    form(action='/demo4', method='post')
        input(type='text', name='username', placeholder='username')
        input(type='text', name='email', placeholder='email')
        input(type='text', name='website', placeholder='website')
        input(type='text', name='phone', placeholder='phone')
        input(type='submit', value='Submit')

Bila kita akses url http://localhost:3000/demo4 maka akan muncul tampilan berikut:



Menerima Request PUT

Berbeda dengan POST dan GET, kita akan mencoba metode PUT dalam Express.js, metode ini hanya dapat ditangkap oleh request yang membutuhkan metode PUT. Jadi bila diakses langsung dari web browser akan sulit dilakukan karena belum ada dukungan untuk metode ini. Namun kita dapat menggunakan Curl atau Postman untuk mencoba mengakses route yang bermetode PUT. Metode ini biasa digunakan untuk membangun RESTful API.

Sekarang mari kita buat route dengan URL /demo5 yang akan menampilkan sebuah JSON yang dikirimkan oleh client:

/* DEMO 5 - menerima request method PUT */
router.put('/demo5/', function (req, res, next){
              message: "request PUT is executed",
              data: { 
                username: req.param('username'), 
                email: req.param('email'), 
                website: req.param('website'), 
                phone: req.param('phone'), 

Bila kita gunakan POSTMAN untuk mengakses route tersebut maka akan muncul response seperti pada gambar:


Menerima Request DELETE

Kita akan mengerjakan bagian ini di file index.js. Hampir sama dengan PUT, DELETE pun saat ini belum didukung oleh web browser. Kita akan buat sebuah route bermetod DELETE dan mempunyai URL /demo6 yang akan menampilkan sebuah response JSON:

/* DEMO 6 - menerima request method DELETE */
router.delete('/demo6/', function (req, res, next){
              message: "request DELETE is executed"

Bila kita gunakan POSTMAN untuk mengakses route tersebut maka akan muncul response seperti pada gambar:


Melakukan Redirect ke URL lain

Masih di file yang sama, proses redirect tentu saja dibutuhkan bila kita sudah melakukan suatu proses, ingin dikembalikan ke halaman asal atau ke halaman tertentu. Kita akan membuat sebuah route dengan URL /demo7 yang akan melakukan redirect dengan menggunakan res.redirect() ke URL /demo7_result:

/* DEMO 7 - redirect url */
router.get('/demo7', function (req, res, next){

router.get('/demo7_result', function (req, res, next){

Berikut adalah views dari URL /demo7_result. Silahkan buat template berikut dengan nama demo7.jade dan simpan di folder views:

extends layout

block content
  p Hasil redirect dari /demo7

Bila kita akses url http://localhost:3000/demo7 maka akan muncul tampilan berikut:



Sebagai awalan, semoga tutorial ini dapat cukup dipahami untuk lanjut ke tutorial Express.js berikutnya yang akan mengenal lebih dalam bagaimana membuat aplikasi web dengan Express.js dan MongoDB. Untuk mempelajari Node.js dan Express.js ini, Anda memerlukan kemauan tinggi dan harus mencari resource sendiri. Karena masih sedikit perguruan tinggi atau SMK yang mau mengajarkan Node.js ataupun Express.js. Semoga bermanfaat :D.


credit :

Express : Fast, unopinionated, minimalist web framework for node.

var express = require(express)
var app = express()
app.get(/, function (req, res) {
  res.send(Hello World)


$ npm install express


  • Robust routing
  • Focus on high performance
  • Super-high test coverage
  • HTTP helpers (redirection, caching, etc)
  • View system supporting 14+ template engines
  • Content negotiation
  • Executable for generating applications quickly

Docs & Community

PROTIP Be sure to read Migrating from 3.x to 4.x as well as New features in 4.x.

Security Issues

If you discover a security vulnerability in Express, please see Security Policies and Procedures.

Quick Start

The quickest way to get started with express is to utilize the executable express(1) to generate an application as shown below:

Install the executable. The executable’s major version will match Express’s:

$ npm install -g express-generator@4

Create the app:

$ express /tmp/foo && cd /tmp/foo

Install dependencies:

$ npm install

Start the server:

$ npm start


The Express philosophy is to provide small, robust tooling for HTTP servers, making it a great solution for single page applications, web sites, hybrids, or public HTTP APIs.

Express does not force you to use any specific ORM or template engine. With support for over 14 template engines via Consolidate.js, you can quickly craft your perfect framework.


To view the examples, clone the Express repo and install the dependencies:

$ git clone git:// –depth 1
$ cd express
$ npm install

Then run whichever example you want:

$ node examples/content-negotiation


To run the test suite, first install the dependencies, then run npm test:

$ npm install
$ npm test