Membangun Aplikasi Manajemen Hubungan Pelanggan Menggunakan AngularJS dan Laravel

Ketika membuat aplikasi satu halaman kita harus menggunakan beberapa jenis framework untuk melakukan beberapa pekerjaan bagi kita, sehingga kita bisa fokus pada fungsi yang sebenarnya. AngularJS cocok untuk hal ini, karena fitur seperti injeksi ketergantungan dinamis dan data bi-directional sudah didukung olehnya. Kadang-kadang kita juga memerlukan beberapa jenis server. Jika Anda telah memilih PHP maka Laravel mungkin pilihan terbaik Anda, karena mudah untuk bekerja dengannya dan cukup kuat.


Perkenalan

Dalam tutorial ini Anda akan membuat sistem manajemen pelanggan / transaksi sederhana dengan kemampuan untuk menambah dan menghapus keduanya. Ini mungkin bukan jenis hal yang sering anda buat, tapi itu bisa menunjukkan bagaimana menggunakan fitur dari kedua framework itu.

Sebelum kita mulai Anda harus men-setup database MySQL yang akan kita gunakan (Laravel mendukung lebih banyak dari itu, tetapi ini masih yang paling populer). Anda tidak perlu server web karena kita akan menggunakan built-in php (tapi tolong diingat, bahwa solusi ini hanya untuk developmen dan tidak boleh digunakan dalam produksi – PHP tidak memiliki banyak fitur yang diperlukan untuk app Anda untuk bekerja dengan baik di depan umum). Untuk itu, kita akan membutuhkan setidaknya PHP versi 5.4.0.


Persiapan

Hal pertama yang harus kita lakukan adalah menginstal Laravel. Proses lengkap dijelaskan di Website Laravel itu. Setelah itu, Anda harus memiliki direktori proyek Anda yang dibuat dengan semua file Laravel di sana. Arahkan ke direktori tersebut dalam baris perintah dan jalankan perintah ini:

php artisan serve

Jika semua berjalan Lancar, Anda akan melihat bahwa server development dimulai pada locahost:8000. Buka browser Anda dan arahkan kesana, Anda akan melihat halaman selamat datang Laravel ini:

first_run

Sekarang kita bisa memproses aplikasi yang sebenarnya.


Migrasi dan Model

Model di laravel adalah seperti di kebanyakan framework MVC lainnya. Ia menggunakan Eloquent ORM untuk mempermudah pekerjaan kamu – kamu mungkin tidak perlu menulis query sql lagi (kecuali kamu menginginkan sesuatu yang belum didukung oleh Eloquent ORM). Menggunakan migrasi kemu bisa mengubah struktur basisdata dengan kemampuan untuk mengembalikan perubahan jika suatu kesalahan terjadi. Kamu bisa membaca tentang migrasi lebih lanjut di dokumentasi laravel.

Di aplikasi kita ini, kita akan menggunakan 2 model :

  • Custormer – Yang akan menangani data pelanggan
  • Transaction – yang akan menangani informasi transaksi

Mari mulai dengan membuat migrasi untuk mereka. Jika kamu belum melakukannya, matikan server yang kita jalankan sebelumnya (Ctrl + C).

Pelanggan

Pertama, jalankan perintah ini:

php artisan migrate:make create_customers_table

Ini akan membuat file migrasi dengan struktur dasar untukmu. Sekarang arahkan ke app/database/migrations. Disana seharusnya ada sebuah file yang namanya diawali dengan timestamp dan diakhiri dengan “create_customers_table“. Laravel otomatis membuat struktur dasar ini untukmu. Method up() dipanggil ketika migrasi diterapkan, dan method down() dipanggil ketika migrasi di roll back (dibatalkan).

Pertama panggil method Schema::create(). Ini akan memerlukan dua argumen – nama schema dan fungsi callback:

Schema::create('customers', function ($table) {

Callback dieksekusi ketika tabel dibuat. Objek tabel dilewatkan sebagai variabel $table dan kita memanipulasi strukturnya menggunakan objek ini. Mari kita tambahkan field id auto-increment:

   $table->increments('id');

Selanjutnya disini ada 3 field string untuk nama depan pelanggan, nama belakang pelanggan dan email:

   $table->string('first_name');
   $table->string('last_name');
   $table->string('email')->unique();

Kita membuat field email unik dengan memanggil method unique() padanya.

Method terakhir adalah untuk timestamps:

$table->timestamps();
});

Ini akan membuat dua field dalam schema:  <code>created_at</code> dan <code>updated_at</code>. Ini akan digunakan oleh Eloquent untuk menyimpan waktu ketika item dibuat dan diperbarui.

Akhirnya, kode tersebut seharusnya tampak seperti ini:


public function up() {
   Schema::create('customers', function ($table) {
      $table->increments('id');
      $table->string('first_name');
      $table->string('last_name');
      $table->string('email')->unique();
      $table->timestamps();
   });
}

Method down() lebih ringkas – ini hanya akan menghapus schema:

public function down() {
   Schema::drop('customers');
}

Transaksi

Kodenya disini akan mirip dengan kode customer sebelumnya. Pertama jalankan perintah ini:

php artisan migrate:make create_transactions_table

Sekarang arahkan ke file di dalam app/database/migrations dan bukalah file itu. Seperti sebelumnya, dimulai deri membuat schema:

Schema::create('transactions', function ($table) {

Sekarang tambahkan field id, nama transaksi, harga dan id pelanggan yang terkait dengannya:

$table->increments('id');
$table->string('name');
$table->float('amount');
$table->integer('customer_id');

dan tentu saja timestamp:

$table->timestamps();
});

Kode akhirnya akan tampak seperti ini:

public function up() {
   Schema::create('transactions', function ($table) {
      $table->increments('id');
      $table->string('name');
      $table->float('amount');
      $table->integer('customer_id');
      $table->timestamps();
   });
}

Dan sekarang method down():

public function down() {
Schema::drop('transactions');
}

Konfigurasi Database

Sekarang sebelum kamu menerapkan migrasinya kamu harus mengatur koneksi ke database. Buka file app/config/database.php dan pergilah ke baris 55. Disinilah konfigurasi data untuk MySQL (terdapat beberapa yang lain disini, contohnya kamu bisa menggunakan SQLite atau Postgres):

Setelah kamu mengisinya, kamu bisa melanjutkan. Pastikan kamu menyimpan file dan menjalankan perintah dari direktori utama aplikasi (dengan file <code>artisan</code> didalamnya):


php artisan migrate

Dan selesai. Jika tidak ada error, itu berarti tabel telah berhasil dibuat. Kamu bisa menghubungi database untuk menggunakannya, sebagai contoh, menggunakan phpMyAdmin untuk mengeceknya secara manual jika kamu memerlukannya.

Model

Di Laravel, membuat model setelah kemu mengkonfigurasi database menggunakan migrasi benar-benar cepat. Arahkan ke app/models dan hapus contoh didalamnya User.php. Sekarang buat dua file bernama Customer.php dan Transaction.php.

Mari mulai dengan Customer.php. Setiap model di Laravel telah meng-extend class Eloquent:

class Customer extends Eloquent {

Sekarang kita akan mendefinisikan hubungan antara pelanggan dan transaksi mereka. Hal ini dilakukan dengan mendefinisikan method public dalam model dengan nama properti yang ingin kita miliki di dalamnya (dalam hal ini transactions):

public function transactions() {

Sekarang didalam tubuh fungsi transactions hanya ada satu baris:

     return $this->hasMany('Transaction');
   }
}

Ini akan memberitahu Eloquent bahwa ia harus menyediakan semua transaksi dengan customer_id sebagai nama properti di tabel transactions yang mereferensi ke tabel customer.

Sekarang kita akan melakukan hal yang sama untuk transactions, tapi kita akan membalik hubungan agar pemilik transaksi bisa diakses melalui properti customer.

class Transaction extends Eloquent {
   public function customer() {
      return $this->belongsTo('Customer');
   }
}

Ini dilakukan menggunakan method $this->belongsTo() pada model.


Controller

Sekarang untuk benar-benar menggunakan model kita harus membuat kontroller untuknya. Silahkan menuju direktori app/controllers, hapus file HomeController.php – file BaseController.php penting sebagai kontroller yang akan kita extends darinya. Sekarang buatlah dua file: CustomerController.php dan TransactionController.php.

CustomerController

Kontroller ini akan menangani semua yang berhubungan dengan pelanggan - menambah, menghapus dan menampilkan daftar pelanggan. Mulailah dengan mendefinisikan classnya:

class CustomerController extends BaseController {

Kita akan menggunakan fitur Laravel bernama RESTful controllers itu. Ini membuat membuat rute lebih mudah karena kita hanya perlu menentukan basis URI dan Laravel akan menangani segala sesuatu bagi kita. Hal ini mengharuskan Anda untuk memulai nama fungsi dengan HTTP kata kerja yang sesuai dan kemudian melanjutkan dengan nama subroute (menggunakan CamelCase). Jadi misalnya, jika kita akan memiliki metode bernama getNames dan basis URI-nya /customers, maka metode ini akan dapat diakses di /customers/names .

getIndex(), postIndex(), deleteIndex() dan lain-lain. Method ini akan di route ke default route (dalam kasus ini /customers).

Sekaran mari kita buat route pertama - mendapatkan data pelanggan berdasarkan id-nya:

public function getIndex() {

Mari kita dapatkan id dari parameter query (Laravel menyediakan class Input untuk menangani ini, jadi kamu tidak perlu menggunakan $_GET, $_POST dan $_FILES):

$id = Input::get('id');

Dan cari pelanggan di database menggunakan id ini:

   return Customer::find($id);
}

Setiap method di kontroller mengembalikan nilai string atau memiliki method __toString(). Dalam kasus ini model Customer yang dikembalikan akan dikonversikan ke JSON sebelum dikirimkan.

Sekarang kembalikan semua data pelanggan (bisa diakses melalui /customers/all):

public function getAll() {
   return Customer::all();
}

Seperti yang kamu lihat, kita bisa mendapatkan semua pelanggan menggunakan method all() pada model. Sekarang, bagian yang paling panjang, menambahkan pelanggan baru:

public function postIndex() {

Pertama mari kita cek apakah semua informasi yang dibutuhkan telah disediakan. Kita bisa menggunakan method Input::has() :

if (Input::has('first_name', 'last_name', 'email')) {

Mari kita taruh semua field input di variabel $input agar tidak perlu memanggil Input::get() lagi dan lagi. Ini bisa dilakukan dengan menggunakan Input::all():

$input = Input::all();

Berikutnya kita cek jika ada input yang kosong. Jika ada, kita akan mengembalikan error HTTP 400 Bad Request dengan pesan yang lebih jelas:

if ($input['first_name'] == '' || $input['last_name'] == '' || $input['email'] == '') {
   return Response::make('You need to fill all of the input fields', 400);
}

Karena kami ingin mengembalikan kode status lainnya dari 200 bukan hanya mengembalikan pesan sebagai string, kita menggunakan Response::make(), yang mengambil data untuk dikirim sebagai parameter pertama dan status kode sebagai yang kedua. Lihatlah di docs jika Anda ingin tahu lebih banyak tentang respon.

Sekarang akhirnya kita membuat model Customer baru dan mengisinya dengan data yang disediakan:

$customer = new Customer;
$customer->first_name = $input['first_name'];
$customer->last_name = $input['last_name'];
$customer->email = $input['email'];

Setelah itu kita bisa menyimpan model yang baru saja dibuat dan memberikan respon untuk permintaan yang dibuat:

$customer->save();
 
return $customer;

Disini kita menangani kasus jika tidak semua input disediakan:

} else {
      return Response::make('You need to fill all of the input fields', 400);
   }
}

Akhirnya, kita juga membutuhkan kemampuan untuk menghapus data pelanggan. Yang satu ini sangat pendek:

public function deleteIndex() {

Kita memulainya dengan mendapatkan id pelanggan untuk menghapusnya:

$id = Input::get('id');

Selanjutnya, kita mencari dan menghapus data pelanggan:

$customer = Customer::find($id);
$customer->delete();

Setelah itu, kita merespon permintaan dengan id yang diberikan:


      return $id;
   }
}

Sekarang sebelum rute dapat diakses, kita harus menghubungkan mereka. Buka file app/routes.php, hapus semua dengan membuatnya sebagai komentar dan tambahkan baris ini di akhir file:

Route::controller('/customers', 'CustomerController');

Ini akan memberitahu Laravel untuk merute semua permintaan di /customers ke CustomerController. Sekarang Anda dapat menggunakan CURL untuk bermain dengannya. Pertama jalankan server dengan php artisan serve dan kemudian Anda dapat, misalnya, membuat pelanggan:

curl -X POST -d "first_name=Jane&last_name=Doe&email=jdoe@gmail.com<script type="text/javascript">
/* <![CDATA[ */
(function(){try{var s,a,i,j,r,c,l,b=document.getElementsByTagName("script");l=b[b.length-1].previousSibling;a=l.getAttribute('data-cfemail');if(a){s='';r=parseInt(a.substr(0,2),16);for(j=2;a.length-j;j+=2){c=parseInt(a.substr(j,2),16)^r;s+=String.fromCharCode(c);}s=document.createTextNode(s);l.parentNode.replaceChild(s,l);}}catch(e){}})();
/* ]]> */
</script>" http://localhost:8000/customers

Kemudian kamu bisa mendapatkan semua data pelanggan:

curl http://localhost:8000/customers/all

TransactionController

Ini, seperti model adalah mirip dengan CustomerController. Pertama buat class:

class TransactionController extends BaseController {

Kemudian mari definisikan method untuk mendapatkan semua transaksi dari pelanggan:

public function getIndex() {
   $id = Input::get('id');
   return User::find($id)->transactions;
}

Seperti yang Anda lihat kita menggunakan hubungan yang telah didefinisikan sebelumnya untuk mendapatkan transaksi (sekarang panggil ulang query yang telah kamu tulis untuk mendapatkan hal yang sama menggunakan php dan sql murni).

Hal berikutnya akan menambahkan transaksi:

public function postIndex() {

Seperti sebelumnya, kita mengecek semua informasi yang dibutuhkan apakah telah disediakan:

if (Input::has('name', 'amount')) {

Jika sudah, masukkan nilainya ke variabel $input:

$input = Input::all();
[\code]

Periksa jika ada nilai yang disediakan kosong dan jika memang ada kembalikan error:


if ($input['name'] == '' || $input['amount'] == '') {
   return Response::make('You need to fill all of the input fields', 400);
}

Sekarang kita buat transaksi dan isi dengan semua info yang disediakan:

$transaction = new Transaction;
$transaction->name = $input['name'];
$transaction->amount = $input['amount'];

Sekarang kita perlu menambahkannya ke pelanggan yang tepat. Mari kita menemukan mereka dengan id yang disediakan dan tambahkan $transaction ke daftar transaksi mereka:

$id = $input['customer_id'];
User::find($id)->transactions->save($transaction);

Hal ini dilakukan dengan menggunakan method transactions->save() yang disediakan oleh Laravel. Sekarang kita bisa merespon dengan transaksi yang dibuat:

return $transaction;

Dan tangani kasus dimana tidak ada atau tidak semua data telah disedikan:

   } else {
      return Response::make('You need to fill all of the input fields', 400);
   }
}

Setelah itu ada juga metode untuk menghapus transaksi dengan cara yang sama saat kita menghapus pelanggan:

    public function deleteIndex() {
      $id = Input::get('id');
      $transaction = Transaction::find($id);
      $transaction->delete();
      
      return $id;
   }
}

Dan sekarang tinggal tambahkan rute dan kamu bisa mengetes kontroller menggunkan CURL:

Route::controller('/transactions', 'TransactionController');

Kesimpulan

Baiklah, ini adalah akhir dari bagian pertama - di bagian kedua dari tutorial ini, kita akan membuat front-end menggunakan AngularJS. Jangan ragu untuk menambahkan lebih banyak fitur untuk aplikasi Anda (seperti mengedit pelanggan atau memfilter), jika Anda tidak menemukan informasi yang Anda cari, lihatlah dokumentasi Laravel.

diterjemahkan secara bebas dari : http://net.tutsplus.com/tutorials/php/building-a-customer-management-app-using-angularjs-and-laravel/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+nettuts+%28Nettuts%2B%29

Advertisements

Cara Mudah Berkontribusi pada Proyek Open-source

Ketika proyek jQuery dimulai, Saya ingat bagaimana bergairahnya tim untuk membantu developer menggunakan library javascript jQuery. Itu adalah tenaga kerja sukarela dengan kita semua memberikan waktu dalam jumlah jam yang tak terhitung, siang dan malam, untuk membantu mengembangkan proyek dan komunitas pengembang. Dan kami melakukannya secara gratis karena kita suka untuk melakukannya. Tetapi ketika proyek tumbuh, begitu pula harapan dari masyarakat dalam hal fitur dan dukungan. Dan ini adalah di mana sebagian besar upaya open source gagal untuk berkembang.

Saya pikir sebagian besar pengembang yang mengeluarkan software OSS melakukannya untuk alasan altruistik ingin memberikan sesuatu kembali kepada  masyarakat yang dapat memecahkan masalah kritis.

Ketika komunitas butuh untuk berkembang, Anda perlu menemukan cara untuk memiliki lebih banyak waktu untuk fokus pada fitur. Anda dapat melakukan ini dengan menumbuhkan tim Anda tapi itu tidak selalu menjadi solusi. Pada proyek jQuery, kami meningkatkan ukuran tim dan bekerja dengan cara didelegasikan tetapi meskipun demikian, menjadi upaya berbasis relawan berarti proyek itu bergantung pada ketersediaan orang lain. Dan dengan kita semua memiliki pekerjaan penuh waktu dan banyak tanggung jawab dengan keluarga, saya dapat mengatakan bahwa kami berhasil mencapai banyak dengan sangat sedikit ketersediaan.

Pilihan lain yang diwujudkan adalah kemampuan untuk mendanai waktu untuk fokus pada mengerjakan tugas-tugas tertentu. Hal ini biasanya datang dalam bentuk sponsorship dari perusahaan bermerek yang telah membuat investasi internal yang cukup besar ke jQuery dan ingin proyek ini berhasil. Ini benar-benar bekerja dengan baik karena memungkinkan anggota tim untuk dapat secara khusus berfokus pada pemenuhan kebutuhan masyarakat dan fokus kemampuan mereka pada bidang-bidang yang sulit yang membutuhkan banyak perhatian khusus.

Sekarang tolong jangan berpikir ini hanya muncul dalam semalam. Butuh waktu lama sebelum orang ingin berkontribusi pada proyek dan membuktikan nilai usahanya adalah komponen penting untuk hal itu. jQuery merupakan bagian penting dari banyak situs dan produk tetapi ia dikembangkan selama bertahun-tahun kerja keras dan konsistensi dan bukan norma untuk sebagian besar proyek OSS. Dan sebagian besar proyek OSS tidak akan pernah menikmati tingkat keberhasilan dan ketenaran jQuery hanya karena waktu atau bahkan menjadi “terlalu niche.

Dan benar-benar tidak ada yang salah dengan itu. Saya pikir sebagian besar pengembang yang mengeluarkan software OSS melakukannya untuk alasan altruistik ingin memberikan kembali sesuatu kepada masyarakat yang dapat memecahkan masalah kritis. Jadi bagaimana proyek ini mendapatkan kaki seperti yang telah dilakukan dalam proyek jQuery?

Mari kita menjelajahinya.


Konsumen OSS vs. Kontributor

Aku sudah tidak bertemu dengan seseorang (baik offline maupun online) yang belum menggunakan beberapa perangkat lunak opensource. Itu kesepakatan yang cukup besar karena menunjukkan bahwa OSS di mana-mana. Pengembang mengandalkannya untuk memulai ide bagus berikutnya. Perusahaan memanfaatkan itu untuk biaya yang lebih rendah. Dan pemerintah menggunakannya untuk memastikan pertemuan mereka dengan kebutuhan masyarakat.

Satu hal yang saya rasakan untuk waktu yang lama, meskipun, adalah bahwa ada ketidakseimbangan yang pasti antara konsumen dan kontributor. Kemudahan seseorang untuk mengambil bagian dari perangkat lunak OSS dan menjalankannya karena lisensi yang fleksibel dan sedikit atau tidak ada biaya membuatnya sangat mudah untuk melupakan bahwa seseorang di luar sana yang benar-benar menulis dan mendukung perangkat lunak tersebut. Jika Anda hanya mengkonsumsi tanpa mempertimbangkan waktu, tenaga dan biaya yang terlibat dalam perangkat lunak, ada kemungkinan kuat bahwa di jalan Anda akan terkena dampak ketika proyek gagal. Jalan menuju OSS dipenuhi dengan proyek-proyek gagal dan ditinggalkan oleh pengembang dengan semua niat yang benar tetapi hanya tidak memiliki sumber daya untuk menjaga itu terjadi.


Bagaimana Memberikan Imbal Balik

Ini bukan untuk mengatakan bahwa kamu perlu untuk secara total melakukan seperti apa yang dilakukan Facebook dengan PHP tetapi ada banyak cara untuk membantu proyek dari mana Anda telah mengambil sesuatu yang berharga untuk Anda dan bisnis Anda. Beberapa diantaranya adalah:

  • Kontribusi kode – Kebanyakan proyek menggunakan GitHub yang mana membuat request pull menjadi sangat-sangat mudah
  • Kontribusi waktu – Proyek selalu mencari orang untuk membantunya dalam dokumentasi, dukungan dan evangelism
  • Menulis di blog – Cukup mudah untuk menulis sesuatu yang memudahkan seseorang untuk memakai tools
  • Meminta pekerjamu untuk waktunya – Jika Anda menggunakan software OSS di tempat kerja, mintalah majikan Anda untuk meluangkan waktu perusahaan agar berkontribusi kembali
  • Meminta pekerjamu untuk mendonasikan ulang kodenya  – Sepanjang baris yang sama, jika Anda memperluas fungsi program maka pertimbakanlah untuk berkontribusi kembali di bawah lisensi yang sama dengan proyek.

Banyak pryek memiliki halaman yang sama dengan ini yang menjelaskan secara khusus bagaimana caranya untuk berkontribusi.

Jika untuk alasan apapun Anda tidak dapat menawarkan ini, Anda harus mempertimbangkan membantu mendanai beberapa upaya ini. Bagaimana?” Anda bertanya.


Donasi Online

Ada platform bermunculan yang dirancang untuk memecahkan masalah ini dan kita akan melihat pada dua yang paling populer.

Bountysource – Platform Pendanaan Proyek OSS

bountysource-logo

Baru-baru ini, saya datang di  pendanaan untuk RVM (Ruby Version Manager). Jika Anda pernah membuat kode dalam Ruby on Rails, maka saya cukup yakin Anda tahu betapa pentingnya RVM adalah. Sayangnyasponsor utama mengakhiri dukungan dan proyek membutuhkan untuk mencari sponsor lain sehingga mereka mengambil ke situs baru yang disebut Bountysource yang bertujuan untuk menyediakan platform pendanaan untuk perangkat lunak open source.

bounty-rvm

Saya menemukan ini benar-benar hebat karena benar-benar tidak ada sumber daya seperti ini untuk proyek jQuery (atau Mootools, Prototype, dan lainnya) yang dapat memungkinkan proyek untuk berputar ke atas halaman penggalangan dana dengan semua alat untuk mengumpulkan sumbangan. Dan tentu saja, hal itu memungkinkan individu untuk menjelajahi proyek yang ingin mereka bantu dengan donasi lewat PayPal atau Google Wallet.

Apa yang benar-benar mengesankan saya adalah fakta bahwa proyek bisa mendaftar hal-hal yang ingin mereka capai dan melalui crowdsourcing, masyarakat dapat membantu untuk mendanai penyelesaian fitur tertentu melalui pembayaran pengembang (disebut “bounty/karunia“). Jadi katakanlah bahwa anda benar-benar ingin fungsi $.Deferred di Zepto.js. Anda dapat berkontribusi pada permintaan fitur untuk menarik komunitas agar menerapkan dan setelah selesai, karunia itu akan dibayarkan kepada orang (s) yang melakukannya.

bounty-zepto

Layanan ini membahas kebutuhan proyek, bahkan ke titik pendaftaran semua karunia untuk tugas-tugas dan nilai-nilai tertentu, tetapi juga memungkinkan masyarakat untuk memutuskan apa yang penting dan mendanai pengembangan fitur itu. Ini seperti Kickstarter untuk open-source. Sangat keren.

Gittip – Crowdfunding Orang yang Menginspirasi Kamu

gittip-logo

Gittip adalah layanan yang saya tahu tentangnya karena John Resig. Dia menjadi pendukung nyata layanan ini dan itu mengatakan banyak hal.

gittip-home

Mengutip John:

Saya melihat kesempatan besar bagi tim pengembang di Khan Academy untuk memberikan kembali kepada komunitas Open Source dengan cara yang tidak hanya terkait kode.

Ini sangat berbeda dengan Bountysource bahwa hal itu dimaksudkan untuk menawarkan hadiah uang tunai mingguan kecil untuk individu yang Anda merasa telah menyediakan nilai bagi anda. Anda dapat memberikan jumlah yang Anda inginkan sampai $ 100 per minggu. Ini sebenarnya adalah sumber daya yang besar untuk proyek-proyekpria lajang di mana coder satunya adalah menambahkan fitur, menjawab email dukungan dan kerja masyarakat. Ini mungkin tampak tidak penting tapi bahkan menyumbangkan lima dolar per minggu untuk pengembang yang mana mungkin dia hanya perlu memastikan mereka tahu pekerjaan mereka dihargai.

Ada lebih dari 650 komunitas yang terdaftar di Gittip dan memilih salah satunya akan menampilkan semua pemberi dan penerima atasnya:

gittip-js

Hal ini juga memungkinkan Anda untuk masuk ke halaman profil individu untuk memungkinkan Anda untuk berkontribusi kepada beberapa orang yang menginspirasi Anda:

gittip-resig

Dan dalam menjaga inline dengan etos OSSnya, Gittip bahkan memungkinkan Anda untuk checkout kode sumbernya melalui Github repositorynya.


Lebih banyak “Lakukan” dari pada “Bagaimana”

Titik artikel ini adalah untuk mendorong pentingnya kontribusi kembali ke open source. Jika Anda seorang konsumen, maka Anda harus secara serius mengevaluasi betapa berharganya perpustakaan atau alat yang Anda gunakan dan mencari cara untuk mendukungnya. Jika proyek tidak ada pada Bountysource atau Gittip, mengapa tidak menjangkau pemilik proyek dan meminta mereka untuk bergabung sehingga Anda dapat menyumbangkannya.

Dan hanya karena Anda mungkin tidak tertarik dalam kontribusi kode tidak berarti Anda tidak dapat memanfaatkan keterampilan lain untuk membantu proyek tumbuh. Menurut pendapat saya, kebutuhan terbesar tunggal proyek open-source adalah orang-orang yang tahu bagaimana bekerja dengan masyarakat. Soft skill sangat penting dan dari pengalaman saya, sangat kurang.

Hal utama adalah bahwa benar-benar tidak ada alasan untuk tidak memberikan kontribusi kembali ketika Anda menemukan sesuatu yang berharga. Hanya karena itu bebas” tidak berarti bahwa banyak investasi tidak ditempatkan ke dalamnya dan jika Anda tidak mendukungnya, hal itu mungkin hanya berlalu beberapa hari.

Diterjemahkan bebas dari : http://net.tutsplus.com/articles/easy-ways-to-contribute-to-open-source-projects/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+nettuts+%28Nettuts%2B%29

Membangun Merek Pribadi Anda sebagai Programmer

 

Hanya karena Anda seorang pengembang perangkat lunak tidak berarti bahwa Anda tidak perlu khawatir tentang branding. Bahkan, jika Anda benar-benar ingin meningkatkan karir Anda, Anda akan secara aktif mengelolanya dengan menciptakan merek pribadi Anda sendiri.

Dalam posting ini dan saya akan membantu Anda membuat merek pribadi Anda sendiri dengan terlebih dahulu memberikan gambaran yang jelas tentang apa yang membuat sebuah merek. (Petunjuk, itu bukan hanya logo.) Saya juga akan menunjukkan kepada Anda bagaimana untuk membuat merek pribadi yang efektif dengan mendefinisikan niche Anda. Akhirnya, saya akan membawa Anda melalui 4 komponen penting untuk menciptakan merek pribadi Anda sendiri.

Apa itu Merek?

Sebelum kita dapat menciptakan personal brand, kita perlu memahami apa sebenarnya merek itu.

Kebanyakan orang memikirkan merek sebagai logo. Meskipun banyak merek memiliki logo, tapi merek bukan hanya logo. Sebuah logo hanya sebagian kecil dari apa yang membuat merek/brand.

Brand adalah benar-benar janji.

Sebuah merek adalah semua tentang harapan. Ketika Anda membuat sebuah merek, Anda sedang membangun satu set harapan tentang Anda atau perusahaan Anda dan Anda membuat janji untuk memenuhi harapan mereka.

Pikirkan tentang merek populer seperti Starbucks. Apa janji yang Starbucks buat?

Ketika Anda berjalan ke Starbucks, Anda segera memiliki beberapa harapan tentang apa yang akan ada di menu, bagaimana Anda akan diperlakukan dan bahkan jenis pencahayaan yang digunakan dalam lokasi seperti apa.

Sebuah logo mewah tidak membuat merek Starbucks menjadi sukses. Sebaliknya, janji unik yang dibuat Starbucks untuk Anda dan setiap pelanggan lainnya adalah apa yang membangun merek mereka.

Saya pikir sebuah merek memiliki empat komponen utama:

  • Pesan – Apa yang diwakili merek ini?
  • Visual – Bagaimana merek di tampilkan secara visual?
  • Konsistensiapakah pesan merek adalah memberikan yang sama dan salah satu yang saya bisa andalkan?
  • Paparan Berulangapakah merek muncul cukup sering bagi saya untuk mengenalinya?

Tanpa empat aspek tersebut, sebuah merek ditakdirkan untuk gagal. Sebuah merek harus memiliki pesan yang konsisten yang jelas, dan diakui secara visual beberapa kali dalam rangka untuk menjadi efektif.

Kami akan kembali dan memecah masing-masing empat komponen nanti, tapi sebelum kita lakukan itu, mari kita bicara tentang apa itu personal branding.

Personal branding

Lebih mudah untuk membayangkan apa itu personal branding adalah jika Anda dapat melihat diri Anda sebagai sebuah bisnis.

Hello-My-Name-Is

Alih-alih memikirkan karir Anda sebagai pekerjaan Anda saat ini, coba dan bayangkan diri Anda sebagai bisnis yang menyediakan jasa pengembangan perangkat lunak. Jika Anda bekerja untuk orang lain, Anda hanya kebetulan memiliki satu pelanggan sekarang.

Ketika, Anda berpikir menjadi sebuah bisnis, personal branding jauh lebih masuk akal. Ini adalah merek yang Anda terapkan pada bisnis Anda.

Sebuah merek pribadi adalah janji yang Anda buat dan harapan Anda membuat tentang layanan yang Anda berikan.

Dalam rangka untuk menciptakan merek pribadi yang baik, Anda harus memilih apa yang disebut niche. Niche adalah spesialisasi di pasar yang lebih besar.

Misalnya, Anda dapat memilih untuk membuat niche Anda menjadi ranah database NoSQL. Mungkin Anda ingin dikenal sebagai database Wizard NoSQL.

Atau mungkin Anda adalah guru JavaScript pembangunan berbasis testing,  yang mengkhususkan diri dalam mengajar pengembang JavaScript bagaimana menulis tes yang efektif untuk kode mereka.

Semakin Anda mendapatkan ceruk ke dalam pasar, merek Anda akan kuat berada di pasar tertentu. Ketika Anda menelepon tukang ledeng karena pembuangan sampah Anda rusak, Anda akan lebih mungkin untuk memanggil ABC Plumbing atau The Garbage Disposal Fix-it Man?

Anda akan memiliki lebih banyak kesuksesan dalam menciptakan merek pribadi jika Anda bisa memberikan spesialisasi dan sespesifik mungkin.
(Ngomong-ngomong, jika Anda mencari buku yang bagus mengenai personal branding, meskipun buku ini disebut Personal Branding for Dummies, saya menemukan itu menjadi sebuah buku yang sangat komprehensif.)

Membuat Pesan

Komponen utama dari merek Anda akan menjadi pesan Anda. Pesan Anda adalah apa yang mewakili merek Anda. Sebuah merek tanpa pesan tidak benar-benar melakukan apa-apa, karena tidak berusaha untuk mengkomunikasikan apapun.

Pesan Anda harus mengkomunikasikan merek Anda yaitu tentang dan kumpulan harapan dan janji-janji merek yang akan anda berikan.

Jika Anda memiliki kesulitan dalam memikirkan pesan untuk merek pribadi Anda, tempat pertama untuk memulai adalah dengan melihat nilai yang Anda berikan. Berapa nilai Anda sebagai pengembang perangkat lunak atau perusahaan pengembangan perangkat lunak sediakan?

Mengapa seseorang harus mempekerjakan Anda untuk pekerjaan itu?

Di balik pesan Anda harus memiliki nilai unik yang Anda berikan. Apakah Anda developer frontend terbaik yang bisa dibeli dengan uang? Anda bisa belajar teknologi baru lebih cepat daripada orang lain? Apakah value proposition yang unik yang Anda tawarkan yang harus memaksa seseorang untuk mempekerjakan Anda bukan orang lain?

Membuat Visualisasi

Meskipun logo bukanlah satu-satunya hal yang membuat sebuah merek, hal ini tentunya merupakan bagian penting dari sebagian besar merek. Sebuah merek yang baik memiliki visual yang baik, dan Anda juga harus begitu.

Jelas tempat pertama untuk memulai adalah dengan membuat logo Anda sendiri. Anda bisa menggunakan nama perusahaan atau membuat logo dari nama Anda sendiri. Saya telah melihat keduanya digunakan sangat efektif. Sebagai contoh, saya menggunakan Simple Programmer sebagai merek saya, dan saya sudah memiliki logo yang dibuat untuk merek itu.

Anda tidak perlu menghabiskan jumlah uang berlebihan untuk mendapatkan sebuah logo yang baik. Aku mendapatkan logo bagus yang dibuat untuk saya sebesar $5 di situs popular Fiverr. Anda juga dapat menemukan seseorang di oDesk dengan murah yang akan membuat logo yang sangat baik.

Anda juga ingin memiliki skema warna yang baik yang Anda gunakan dengan semua brand Anda. Saya akan merekomendasikan menggunakan skema warna yang sama pada profil online Anda dan blog Anda, jika Anda memiliki satu. (Dan Anda benar-benar harus memilikinya.)

Saya juga, merekomendasikan menggunakan stok foto untuk membantu membentuk pesan Anda. Jika Anda ingin sumber yang baik untuk stok foto periksa despositphotos.

Akhirnya, sejauh visual pergi, Anda ingin memiliki headshot yang baik yang dapat Anda gunakan di mana-mana Anda menempatkan gambar Anda secara online. Saya akan merekomendasikan untuk mendapatkan headshot profesional. Berikut adalah tip yang baik tentang cara untuk menyelesaikannya dengan murah: Lain kali Anda jika anda membuat foto keluarga, minta fotografer untuk melakukan beberapa headshots untuk Anda juga.

headshot

Tetap Konsisten

Setelah Anda punya pesan dan Anda punya beberapa visual yang bagus untuk melangkah dengannya, Anda harus konsisten menerapkan pesan dan visual secara baik agar benar-benar menciptakan sebuah merek.

Konsistensi adalah bagian besar dari membangun merek pribadi Anda. Anda tidak dapat menjadi Joe pria C++ pointer hari ini, dan Joe guru basis data besok. Anda harus memilih sesuatu dan tetap dengan itu cukup lama untuk menangkapnya.

Pikirkan tentang beberapa contoh merek pribadi Anda yang anda kenali. Apakah merek-merek pribadi berubah dari hari ke hari? Ketika Anda pergi ke situs web blogger teknologi favorit Anda, apakah Anda memiliki ide yang cukup baik dari apa yang Anda akan lihat dan seberapa sering Anda akan melihat konten baru?

Aku tidak akan berbohong, itu akan memerlukan beberapa waktu untuk membangun merek pribadi Anda, tetapi jika Anda konsisten dengan kegiatan yang Anda lakukan, visual yang Anda gunakan dan pesan yang Anda berikan, Anda akan membangun merek pribadi untuk diri sendiri dari waktu ke waktu.

Mamaparkan Merek

Anda dapat melakukan segala sesuatu yang lain dengan benar dan jika Anda tidak memiliki paparan berulang, Anda masih tidak akan memiliki banyak merek.

Jika Anda hanya melihat atau mendengar dari sebuah merek sekali atau dua kali, itu tidak akan menempel di kepala Anda dan tidak akan efektif.

Dalam rangka untuk membuat merek pribadi Anda menancap, Anda perlu memaparkan pesan dan visual yang sama  untuk orang yang sama atau sekelompok orang.

Ada banyak cara untuk memaparkan merekmu, termasuk:

  • Aktif membuat dan memaintain blog
  • Menulis artikel di majalah atau komentar di blog lainnya
  • Berbicara di komunitas atau konferensi
  • Muncul di podcast atau media lainnya
  • Menulis sebuah buku, mempublikasikan sendiri atau lewat publisher
  • Berkontribusi pada open source
  • Membuat video You Tube atau tutorial

Pada awalnya, Anda mungkin hanya dapat melakukan beberapa hal-hal ini, tetapi karena Anda membangun merek Anda, Anda akan mendapatkan lebih banyak kesempatan untuk berbuat lebih banyak dan lebih banyak hal di daftar ini dan bahkan beberapa hal yang tidak ada di daftar ini.

Yang penting adalah bahwa Anda mendapatkan diri Anda di luar sana dan memberikan nilai nyata bagi orang lain. Jika Anda memberikan nilai dan Anda melakukannya dengan cara yang konsisten yang memanfaatkan pesan dan visual merek Anda, Anda akan membangun pengenalan merek dan menciptakan peluang bagus untuk diri sendiri.

Kemana setelah ini

Aku hanya bisa membahas begitu banyak dalam posting blog singkat tentang personal branding. Aku punya lebih banyak informasi mendalam tentang topik yang dibahas dalam posting ini, yang mana saya bekerja untuk membuat sebuah paket tentang Pemasaran Diri sebagai Pengembang Software. Dalam paket itu, aku akan memiliki serangkaian video lengkap tentang membangun merek. Jika Anda ingin tahu kapan kursus dilaksanakan, pastikan Anda mendaftar disini. (Saya juga akan memberitahu Anda ketika saya memposting postingan blog mengenai meningkatkan karir Anda.)
diterjemahkan bebas dari : http://www.javacodegeeks.com/2014/02/building-your-personal-programmer-brand.html

Vagrant: Apa, Mengapa, dan Bagaimana

 

Artikel ini akan membantu anda menggunakan Vagrant untuk mengelola mesin virtual anda, dan menjelaskan bagaimana anda dapat mengambil keuntungan dari Puppet menentukan berbagai sumber daya, seperti PHP dan PostgreSQL.

Pengenalan

 Pengembang memiliki banyak cara untuk membangun lingkungan pengembangan web mereka.

Pengembang memiliki banyak cara untuk membangun lingkungan pengembangan web mereka. Anda dapat menggunakan pilihan “lokal, seperti menginstal pre-built server all-in-one”, seperti Zend Server, XAMPP, MAMP, WAMP, dll, atau Anda dapat menginstal komponen sendiri dari sumber, atau melalui sistem manajemen paket seperti Homebrew, Apt, dan Yum.

Hal ini dapat bertambah saat Anda bekerja pada berbagai proyek dengan: PHP 5.3 dan PHP 5.4, MySQL, SQLite, MongoDB, Postgres, PEAR, PHPUnit, Rails 3.1, memcached, Redis, gearman, NodeJS, dll. Jika Anda meng-upgrade komputer atau komputer anda mati , Anda harus mulai dari awal lagi.

Anda bisa memiliki “remotesetup, menggunakan server di jaringan dengan Samba untuk berbagi, atau server SSH yang dipasang dengan alat sepertiExpanDrive. Opsi terakhir dapat menyebabkan latency pada saat membaca/menulis file, hal yang sangat menjengkelkan. Anda bisa menggunakan SSH + Vim untuk segala sesuatu, yang cepat, tapi itu hanya bekerja jika Anda ingin menggunakan Vim untuk semuanya.

Pengembangan vs. Produksi

Meskipun Anda mungkin senang dengan bagaimana Anda melakukan hal yang benar sekarang, berapa banyak dari Anda pernah mendengar (atau berkata) Yah itu bekerja pada komputer saya“. Ini mengerikan dan itu terjadi ketika lingkungannya berbeda, bahkan untuk detail yang paling sepele.

Hal ini sangat penting untuk memastikan bahwa lingkungan pengembangan Anda identik dengan lingkungan produksi, dan sesuai dengan server pementasan/staging dan pengujian jika Anda memiliki orang-orang untuk itu juga.

Itu mungkin terdengar mudah jika Anda hanya berpikir tentang menginstal Apache, PHP dan beberapa salinan MySQL, tetapi ada satu juta faktor untuk dipikirkan. Jika Anda mengembangkan di OSX dan menyebarkan ke sistem Ubuntu, maka Anda akan melihat masalah dengan kapitalisasi berkas. Hal ini biasa terjadi di CodeIgniter, ketika seseorang memiliki library lowercase first letter. Ini akan berjalan baik pada OSX, tetapi akan pecah bila digunakan untuk produksi. Proses pembangunan Anda mungkin baru saja kehilangan beberapa urusan, semua karena beberapa perbedaan OS yang sepele yang tak dipikirkan sebelumnya sampai terlambat untuk diketahui kemudian.

Pengembangan = Produksi

Memaksa pengembang untuk menggunakan OS yang sama akan menyebabkan masalah.

Jadi apa solusinya? Memaksa semua pengembang Anda untuk membuang alat-alat mereka yang berbeda dan mengembangkannya pada model yang sama persis dari laptop? Jika pengembang Anda semua mendapatkan merek baru MacBook, maka Anda tidak mungkin mendapatkan terlalu banyak keluhan, tapi kemudian Anda akan perlu untuk menggunakan OSX Server untuk semuanya.

Anda bisa menggunakan Linux untuk semuanya, tapi kemudian Anda harus berjuang distribusi mana yang akan digunakan. Memaksa pengembang untuk menggunakan OS yang sama akan menyebabkan masalah, penurunan produktivitas dan mempromosikan kutupertempuran (nerd-fighting).

Virtualisasi adalah jawabannya dan itu bukan hal yang baru, tetapi ketika orang berpikir tentang virtualisasi mereka sering berpikir masalah kinerja dan fans mereka saat laptop mereka mati-matian mencoba untuk menjalankan dua sistem operasi.

Masih terjadi kasus untuk mencoba menjalankan Windows pada mesin bertenaga rendah, tapi hari ini, sebuah Mac rata-rata memiliki 4 GB RAM secara umum, yang lebih dari cukup untuk sebuah instalasi server Ubuntu berjalan dalam mode command line dan semua alat pengembangan biasa (IDE, browser, alat debugging, dll). Ada beberapa pilihan untuk virtualisasi, tapi aku lebih menyukai VirtualBox dari Oracle (yang gratis). Perangkat lunak ini menangani semua beban berat untuk virtualisasi, kemudian alat yang disebut Vagrant mengelola instansiasinya.

Step 1 – Menginstal VirtualBox

Pertama Download VirtualBox and instal. Pada sistem *nix (Mac OSX, Linux, dll), kamu harus mengubah .bash_profile (or .zsh_profile) kamu untuk memperluas variabel $PATH:

PATH=$PATH:/Applications/VirtualBox.app/Contents/MacOS/
export PATH

Ini akan memberitahu Vagrant dimana VirtualBox terinstal, dan akan, tentu saja, berbeda untuk tiap sistem operasi.

Step 2 – Menginstal Vagrant

Kamu bisa mendownload vagrant siap pakai untuk sistem operasi kamu, atau menginsalnya sebagai gem jika tidak tersedia satupun:

$ gem install vagrant

Step 3 – Membuat Instance

Buatlah di suatu tempat agar setup vagrant  bisa hidup:

mkdir -p ~/Vagrant/test
cd ~/Vagrant/test

Kami akan menggunakan Ubuntu 12.04 LTS (Precise Pangolin), yang sudah memiliki “box” yang telah disetup.

vagrant box add precise32 http://files.vagrantup.com/precise32.box

Anda lihat di sini argumen precise32″ yang merupakan nama panggilan untuk URL tersebut. Anda sekarang dapat membuat sebuah instance, yang akan mendownload box ini.

vagrant init precise32
vagrant up

Sekarang instance akan berjalan. Mudah! Jika Anda ingin masuk ke dalamnya, melalui SSH, gunakan perintah ini:

vagrant ssh

Step 5 – Konfigurasi

Anda akan memiliki file, disebut Vagrantfile, yang berisi konfigurasi untuk instance ini:

# -*- mode: ruby -*-
# vi: set ft=ruby :
Vagrant::Config.run do |config|
    config.vm.box = "precise32"
    config.vm.box_url = "http://files.vagrantup.com/precise32.box"
    # Assign this VM to a host-only network IP, allowing you to access it
    # via the IP. Host-only networks can talk to the host machine as well as
    # any other machines on the same network, but cannot be accessed (through this
    # network interface) by any external networks.
    config.vm.network :hostonly, "192.168.33.10"
    # Set the default project share to use nfs
    config.vm.share_folder("v-web", "/vagrant/www", "./www", :nfs => true)
    config.vm.share_folder("v-db", "/vagrant/db", "./db", :nfs => true)
    # Forward a port from the guest to the host, which allows for outside
    # computers to access the VM, whereas host only networking does not.
    config.vm.forward_port 80, 8080
    # Set the Timezone to something useful
    config.vm.provision :shell, :inline => "echo \"Europe/London\" | sudo tee /etc/timezone && dpkg-reconfigure --frontend noninteractive tzdata"
    # Update the server
    config.vm.provision :shell, :inline => "apt-get update --fix-missing"
    # Enable Puppet
    config.vm.provision :puppet do |puppet|
        puppet.facter = { "fqdn" => "local.pyrocms", "hostname" => "www" }
        puppet.manifests_path = "puppet/manifests"
        puppet.manifest_file  = "ubuntu-apache2-pgsql-php5.pp"
        puppet.module_path  = "puppet/modules"
    end
end

Ini, jika Anda tidak memperhatikan, adalah sintaks Ruby; sehingga Anda bisa lebih kreatif dengan file ini, tapi ini adalah dasar-dasarnya.

Ini akan menunjukkan nickname mana yang akan digunakan dan memiliki URL dalam kasus nickname tidak diatur secara lokal (bagus untuk dibagikan ke sekitar).

Baris share_folder benar-benar berguna untuk pemetaan folder dalam contoh ke folder lokal. Menggunakan nfs => true instance akan dapat menulis dan mengubah hak akses dari file, yang berguna jika Anda, misalnya, mencoba untuk menginstal CMS di sana.

Port forwarding memungkinkan Anda untuk mengakses instance Anda pada http://localhost:8080 dan, tentu saja, mengubahnya ke port yang berbeda jika terjadi konflik.

File konfigurasi ini juga akan mengatur zona waktu ke Eropa/London, kemudian jalankan aptget update, yang harus memaksa sistem anda menjadi up-to-date setiap kali boot. Jika Anda melewatkan konfigurasi ini, Anda mungkin menemukan beberapa paket menolak untuk diinstal sebab referensi sekarang telah usang.

Ketika kamu mengubah konfigurasi, kamu bisa meload ulang instance untuk menggunakannya:

vagrant reload

Sekarang server kami telah berjalan dan siap untuk langkah selanjutanya, kita perlu menginstal beberapa perangkat lunak. Kami tidak hanya akan menggunakan apt-get install untuk menginstal banyak paket melalui baris perintah, kita akan provision” server kita.

Step 4 – Provisioning

Server Provisioning bukanlah sesuatu yang banyak pengembang perlu memikirkannya.

Server Provisioning bukan sesuatu yang banyak pengembang perlu memikirkannya, karena biasanya diserahkan kepada sysadmin. Idenya adalah untuk membuat beberapa catatan tentang perangkat lunak apa dan konfigurasi apa saja yang telah dibuat pada server sehingga Anda dapat membuat lingkungan pengembangan baru, server pementasan baru yang meniru produksi, atau membuat server produksi lain untuk memuat keseimbangan antara keduanya.

Provisioning Cara Lama

Bagaimana sysadmin menangani hal ini bervariasi, tetapi segala macam solusi telah digunakan di masa lalu – dari menjaganya dengan wiki untuk perintah yang dijalankan (yang bisa besar dan usang dengan cepat) dan pendekatan menarik menggunakan “multiterminal”, di mana Anda mengetik perintah ke dalam satu jendela dan meniru perintah yang sama pada 7 server lain pada waktu yang sama. Metode ini semua adalah mengerikan.

Salah satu solusinya adalah dengan membangun sendiri file .box Anda, atau membuat backup .iso sehingga server baru hanya dapat didasarkan pada itu, tapi mempertahankan images tersebut menciptakan banyak pekerjaan tambahan, dan tidak peduli seberapa keras Anda mencoba, mesin-mesin pembangunan akan menjadi tidak sinkron seiring waktu.

Provisioning Cara Modern

Ada dua sistem populer saat ini, yang disebut Puppet dan Chef.

Ada dua sistem populer saat ini, yang disebut Puppet dan Chef. Keduanya telah ada selama bertahun-tahun, tapi sudah mulai menjadi jauh lebih populer dengan meningkatnya metode pengembangan DevOps . Ide-ide untuk keduanya sama dan Anda harus menyelidiki kedua sistem, tapi tutorial ini akan fokus secara eksklusif pada Puppet.

Pada dasarnya, alih-alih menjalankan sekelompok perintah dan berharap semuanya bekerja dengan baik, Anda membangun sebuah manifest untuk Puppet menjelaskan segala sesuatu yang Anda perlu memastikan telah dilakukan. Bila Anda menjalankan perintah di terminal, Anda pada dasarnya mengatakan kepada komputer:

“Install Apache”

Dengan Puppet, kita akan mengatakan:

“Ensure Apache is installed”

Atau, bukannya:

“Make a new folder, called /var/wwwand set permissions to www-data:www-data”

Dengan Puppet, kita berkata:

“Ensure /var/www exists and has permissions matching www-data:www-data”

Perbedaannya di sini adalah bahwa memanifestasikan ini dapat dijalankan beberapa kali (pada tugas cron per jam atau harian) untuk menjaga hal-hal up to date, dan tidak akan ada hasil yang tidak diharapkan dari sesuatu yang mencoba untuk menginstal dua kali.

Ini juga akan membantu Anda menguji bahwa semuanya berjalan seperti yang diharapkan, ketika salah satu dari aturan-aturan ini gagal akan melemparkan kesalahan yang lebih mudah untuk dilacak dari greping sejumlah besar hasil perintah bash. Puppet akan melemparkan kesalahan merah besar (big red errors) membiarkan Anda tahu bahwa PHP tidak terinstal, atau modul tertentu tidak dapat dikonfigurasi.

Manifest dan Module

Manifests sedikit membingungkan pada awalnya, tetapi, setelah beberapa saat, mereka mulai masuk akal.

Berikut contoh dasar manifest:

file {'testfile':
  path    => '/tmp/testfile',
  ensure  => present,
  mode    => 0640,
  content => "I'm a test file.",
}

Tidak perlu untuk menjelaskan apa yang terjadi di sini, kan?

File ini dapat kemudian dimaksud ke dalam manifest Anda sebagai testfile” yang berarti dapat terdaftar sebagai dependensi untuk tindakan lainnya.

Contoh lebih jauh, kita akan mengacu pada manifests Puppet di GitHub untuk PyroCMS.

include apache
$docroot = '/vagrant/www/pyrocms/'
$db_location = "/vagrant/db/pyrocms.sqlite"
# Apache setup
class {'apache::php': }
apache::vhost { 'local.pyrocms':
    priority => '20',
    port => '80',
    docroot => $docroot,
    configure_firewall => false,
}
a2mod { 'rewrite': ensure => present; }

Ini termasuk modul apache”, set up beberapa variabel, menjalankan manifest tambahan apache::phppada modul apache, membuat sebuah virtual host kemudian memastikan bahwa mod_rewrite” diaktifkan.

Semua kelas ini didefinisikan dalam modul Apache yang kami disertakan.

Selanjutnya, kami juga ingin menginstal PHP:

include php
php::module { ['xdebug', 'pgsql', 'curl', 'gd'] :
    notify => [ Service['httpd'], ],
}
php::conf { [ 'pdo', 'pdo_pgsql']:
    require => Package['php5-pgsql'],
    notify  => Service['httpd'],
}

Ini potongan menifest yang akan menginstal ekstensi PHP yang kita butuhkan, kemudian pilihan notify akan memberi tahu Apache bahwa Anda telah menginstal konfigurasi baru, yang berarti akan merestart apache.

include postgresql
class {'postgresql::server': }
postgresql::db { 'pyrocms':
    owner     => 'pyrocms',
    password => 'password',
}

Hal ini akan membuat server postgres, membuat database, yang disebut pyrocms” dan memastikan pengguna, yang disebut pyrocms” ada dengan password yang diberikan.

Hampir selesai! Langkah terakhir adalah untuk memastikan bahwa Anda memiliki file dan folder yang dapat ditulis dan diatur dengan benar:

file { $docroot:
    ensure  => 'directory',
}
file { "${docroot}system/cms/config/config.php":
    ensure  => "present",
    mode    => "0666",
    require => File[$docroot],
}
$writeable_dirs = ["${docroot}system/cms/cache/", "${docroot}system/cms/config/", "${docroot}addons/", "${docroot}assets/cache/", "${docroot}uploads/"]
file { $writeable_dirs:
    ensure => "directory",
    mode   => '0777',
    require => File[$docroot],
}

Ini akan memastikan bahwa dokumen root Apache ada, file konfigurasi diatur ke 0666, dan beberapa folder yang dapat ditulis diatur ke 777.

Inilah semua yang kita miliki!

Untuk menjalankan semua ini, hanya reboot Vagrant Anda, atau

vagrant provision

Jika semuanya telah bekerja dengan benar, Anda akan melihat banyak teks sinyal biru yang semuanya sedang diinstal, namun, jika terjadi kesalahan, Anda akan melihat warna merah. Google kesalahan-kesalahan itu dan coba lagi.

Modul yang digunakan di sini adalah: Apache, Postgres, PHP dan Anda dapat melihat semuanya dalam tindakan dengan kloning repo PyroCMS Vagrant:

git clone --recursive git://github.com/pyrocms/devops-vagrant.git ~/vagrant/pyrocms
cd ~/vagrant/pyrocms
vagrant up

Arahkan browser kamu ke http://localhost:8089/ dan kamu seharusnya akan melihat installer. Mudah kan?

Catatan: Ini akan menginstal dengan MySQL karena dukungan Postgres dan SQLite di PyroCMS masih dalam pengembangan, menunggu fitur PDO CodeIgniter untuk diselesaikan. Jika kamu tertarik, kamu bisa bereksperimen dengan manifest Vagranfile untuk digunakan ubuntu-apache2-pgsql-php5.pp, hancurkan instance, dan jalankan ulang. Submodul pyrocms juga perlu untuk di cek di feature/pdo.

Kesimpulan

Pada artikel ini, kami menggunakan vagrant, VirtualBox dan Puppet untuk tidak hanya satu server contoh bagi kita , tapi kami telah membuat test suite untuk server kami untuk memastikan bahwa semuanya berjalan, diinstal dan dikonfigurasi dengan benar.

Kami juga telah membuat checklist untuk persyaratan, dan akan, di masa depan, dapat membuat sejumlah server identik dalam hitungan menit, bukan jam!

diterjemahkan secara bebas dari : http://code.tutsplus.com/tutorials/vagrant-what-why-and-how–net-26500

10 Kemampuan yang Wajib Dimiliki Programmer Tetapi Tidak didapatkan Di Pendidikan Formal

shutterstock_150587633_techschool

Sudah menjadi cerita umum: Anda pergi ke sekolah selama bertahun-tahun dan lulus dengan ijazah yang baru dicetak, mendapatkan pekerjaan pertama Anda, dan segera dikejutkan oleh aturan tidak tertulis dan kompleksitas sehari-hari lainnya dimana tidak ada yang peduli untuk memperingatkan Anda tentang hal itu sebelumnya. Dan pemrograman juga tidak terkecuali.

Beberapa siswa 100% siap untuk pekerjaan pertama mereka. Dan gelar ilmu komputer semata-mata dirancang guna mempersiapkan siswa untuk pekerjaan menulis aplikasi perbankan. Tapi aku masih terus terkejut melihat berapa banyak lulusan baru-baru inidan bahkan beberapa programmer berpengalamanyang masih mengedit kode mereka di Notepad atau Pico dan tidak tahu bagaimana menggunakan kontrol versi.

Jika Anda tidak ingin menjadi orang itu” atau tidak ingin menjadi orang itu lagi luangkanlah waktu untuk belajar 10 keterampilan dasar ini:

1. Version control systems

Ini mungkin kelalaian terbesar dalam kurikulum ilmu komputer. Lembaga pendidikan tinggi mengajarkan cara membuat kode sumber untuk program, tetapi biasanya mengabaikan segala sesuatu tentang pengelolaan kode tersebut. Setiap programmer harus tahu cara membuat repositori, mengedit dan commit kode tersebut, dan branch dan menggabungkan secara efektif sebagai bagian dari alur kerja proyek menggunakan Git atau Subversion. Mengetahui tentang sistem kontrol versi juga berarti bahwa Anda akan tahu lebih baik daripada bekerja untuk organisasi yang tidak menggunakanya.

2. Bagaimana menulis kode program

Bekerja sebagai seorang programmer adalah lebih dari sekedar menulis dalam bahasa pemrograman. Anda juga harus menulis catatan rilis untuk proyek-proyek Anda. Anda menulis pesan komit untuk kontrol versi. Anda menulis tiket untuk bug dalam sistem. Semua ini dan banyak lagi membutuhkan komunikasi bahasa Inggris yang jelas, dan efektif  keterampilan dimana pada program ilmu komputer jarang ditekankan.

3. Regular expressions

Regexes adalah bahasa mereka sendiri, dan setiap programmer modern perlu mahir dalam penggunaannya. Setiap bahasa pemrograman mendukung regexes atau memiliki perpustakaan standar untuk bekerja dengan mereka. Jika bagian dari tugas kode Anda untuk memvalidasi bahwa sejumlah bagian adalah lima huruf, tanda hubung dan angka, Anda harus segera mampu mengekspresikannya sebagai  /^[A-Z]{5}-\d$/.

4. Menggunakan librari

Ini tahun 2014, dan tidak perlu menggunakan ekspresi reguler untuk mengekstrak nama host dari URL. Setiap bahasa pemrograman modern memasukkan perpustakaan standar untuk fungsi umum, atau memiliki perpustakaan standar yang mudah tersedia.

Programmer perlu memahami bahwa kode yang telah ditulis, diuji, dan debug akan menjadi kualitas yang lebih baik daripada kode baru yang dia ciptakan. Bahkan lebih penting, kode yang tidak harus ditulis dapat diimplementasikan lebih cepat.

5. SQL

Seseorang berkata kepada saya pada meetup baru-baru ini, Semua SQL yang saya tahu saya pelajari di tempat kerja. Mengapa database elektif? Apa yang tidak menggunakan database?

Era menyimpan data dalam file flat berakhir. Semuanya masuk ke dan keluar dari database, dan SQL adalah bahasa yang digunakan untuk mengambilnya. SQL juga merupakan bahasa deklaratif, bukan bahasa prosedural, sehingga membutuhkan belajar cara baru berpikir tentang pemecahan masalah. Tapi setiap programmer harus memahami dasar-dasar normalisasi database dan dapat melakukan SELECTs (termasuk dasar INNER dan OUTER JOINs), INSERT, UPDATE dan DELETE.

6. Penggunaan Tool: tool-tool IDE, editor, CLI

Seorang tukang kayu tidak akan pernah menyelesaikan pekerjaan hanya dengan mengetahui bagaimana menggunakan gergaji besi saja, jadi mengherankan bahwa sekolah Ilmu Komputer dapat meluluskan mahasiswanya yang hanya tahu Notepad atau pico. Ini adalah pekerjaan alat pemrograman untuk membantu memanipulasi kode sumber dan semua data lainnya di komputer untuk membuat hidup programmer lebih mudah Baris perintah Unix, shell scripting, find, grepdan sed harus menjadi bagian dari setiap pengetahuan programmer.

7. Debugging

Setiap programmer harus dapat men-debug dengan debugger interaktif atau dengan menaburkan pernyataan print secara bebas di seluruh kode. Kemampuan untuk melacak masalah melalui perbaikan bertahap terlalu penting untuk diserahkan kepada programmer yang hanya belajar dengan kursi mereka.

8. Pemrograman Defensif

Bahkan programmer rockstar tidak sempurna, sebagian besar dunia adalah di luar kendali kita, dan banyak hal akan menjadi salah. Pemrograman defensif adalah tentang memahami kebenaran yang sederhana. Jika hal-hal tidak salah, kita tidak perlu memeriksa file telah sukses dibuka, atau menyatakan bahwa ID pelanggan adalah bilangan bulat yang valid, atau untuk menguji kode untuk memastikan bahwa ia bekerja dengan baik.

Programmer perlu memahami bahwa peringatan compiler adalah alat yang membantu membuat hidup lebih mudah, bukan gangguan yang harus dihindari. Setiap programmer harus tahu mengapa setiap program PHP harus dimulai dengan error_reporting(E_ALL), atau masing-masing programmer Perl dengan use strict; use warnings;.

9. Kerja Tim

Sangat sedikit pekerjaan pemrograman memungkinkan Anda untuk bekerja sepenuhnya seorang diri dan mereka yang melakukan hal itu sering melumpuhkan intelektualnya dan menjadikan anda seorang programmer yang lebih buruk daripada ketika anda memulai. Kode Anda harus berinteraksi dengan kode yang ditulis oleh orang lain, atau sering bercampur dengan kode dari orang lain. Tidak peduli seberapa berbakat, seorang programmer yang tidak bisa berkolaborasi dalam proyek dengan orang lain memiliki produktivitas yang negatif, dan dengan cepat menjadi beban bagi organisasi.

10. Bekerja pada kode yang telah ada

Di sekolah, setiap tugas kelas selalu baru, proyek baru. Itu bukan cara kerja di dunia nyata. Hal pertama yang terjadi pada karyawan baru adalah mereka bisa ditugaskan untuk memperbaiki tiket #8347 dalam sistem pelacakan bug. Setelah itu, mereka harus menambahkan fitur pelengkap kecil baru ke sistem yang ada dengan basis kode yang ditetapkan. Merancang kode baru datang beberapa bulan kemudian, jika mereka beruntung.

Sumber : http://blog.newrelic.com/2014/06/03/10-secrets-learned-software-engineering-degree-probably-didnt/

Pemetaan Relasional Database dan SQL ke MongoDB

Database NoSQL telah muncul pesat dalam beberapa tahun terakhir karena struktur mereka kurang dibatasi, desain skema scalable, dan akses yang lebih cepat dibandingkan dengan database relasional tradisional (RDBMS / SQL).  MongoDB merupakan database NoSQL open source yang berorientasi dokumen  yang menyimpan data dalam bentuk objek JSON seperti. Ini telah muncul sebagai salah satu database terkemuka karena skema yang dinamis, skalabilitas tinggi, performa query yang optimal, mengindeks lebih cepat dan komunitas pengguna yang aktif.

Jika Anda berasal dari sebuah latar belakang RDBMS/SQL, pemahaman konsep NoSQL dan MongoDB  dapat sedikit sulit saat mulai karena kedua teknologi memiliki cara yang sangat berbeda dari representasi data. Artikel ini akan mendorong Anda untuk memahami bagaimana domain RDBMS / SQL , fungsinya, persyaratan dan bahasa query yang dipetakan database MongoDB. Dengan pemetaan, berarti bahwa jika kita memiliki sebuah konsep dalam RDBMS / SQL, kita akan melihat apa konsep yang ekuivalen dalam MongoDB.

Kita akan mulai dengan pemetaan konsep relasional dasar seperti tabel, baris, kolom, dll dan bergerak untuk membahas pengindeksan dan join. Kami kemudian akan memeriksa query SQL dan mendiskusikan sesuai query database MongoDB mereka. Artikel ini mengasumsikan bahwa Anda memahami konsep database relasional dasar dan SQL, karena seluruh artikel lebih banyak menekankan pada pemahaman bagaimana konsep-konsep ini dipetakan di MongoDB. Mari kita mulai.

Memetakan Tables, Rows dan Columns

Setiap database MongoDB terdiri dari koleksi yang setara dengan database RDBMS yang terdiri dari tabel SQL. Setiap collection menyimpan data dalam bentuk dokumen yang setara dengan tabel yang menyimpan data dalam baris. Sementara row menyimpan data di dalam kumpulan kolom, dokumen memiliki struktur seperti JSON (dikenal sebagai BSON di MongoDB). Terakhir, cara kita memiliki baris/rows di baris SQL, kita memiliki fields di MongoDB. Berikut adalah contoh dari sebuah dokumen (baca row) yang memiliki beberapa fields (baca columns) menyimpan data pengguna:

{
  "_id": ObjectId("5146bb52d8524270060001f3"),
  "age": 25,
  "city": "Los Angeles",
  "email": "mark@abc.com<script type="text/javascript">
  /* <![CDATA[ */
  (function(){try{var s,a,i,j,r,c,l,b=document.getElementsByTagName("script");l=b[b.length-1].previousSibling;a=l.getAttribute('data-cfemail');if(a){s='';r=parseInt(a.substr(0,2),16);for(j=2;a.length-j;j+=2){c=parseInt(a.substr(j,2),16)^r;s+=String.fromCharCode(c);}s=document.createTextNode(s);l.parentNode.replaceChild(s,l);}}catch(e){}})();
/* ]]> */
  </script>",
  "user_name": "Mark Hanks"
}

Dokumen ini setara dengan satu baris di RDBMS. Collection terdiri dari banyak dokumen seperti tabel terdiri dari banyak baris. Perhatikan bahwa setiap dokumen dalam Collection memiliki field _id yang unik, yang merupakan field 12byte yang berfungsi sebagai kunci utama untuk dokumen. Bidang ini otomatis dihasilkan pada penciptaan dokumen dan digunakan untuk secara unik mengidentifikasi setiap dokumen.

Untuk memahami pemetaan yang lebih baik, mari kita ambil contoh dari sebuah tabel SQL users dan struktur yang sesuai di MongoDB. Seperti ditunjukkan dalam Gambar 1, setiap baris dalam tabel SQL diubah ke document dan setiap kolom ke field di MongoDB.

Figure 1 Mapping Table to Collection (1)
Gambar 1

Skema Dinamis

Satu hal yang menarik untuk fokus di sini adalah bahwa dokumen-dokumen yang berbeda dalam koleksi dapat memiliki skema yang berbeda. Jadi, sangat mungkin di MongoDB untuk satu dokumen memiliki lima field dan dokumen lain untuk memiliki tujuh field. Field dapat dengan mudah ditambahkan, dihapus dan dimodifikasi kapan saja. Juga, tidak ada kendala pada jenis data field. Dengan demikian, pada satu instance dapat menyimpan tipe data int  dan pada contoh berikutnya dapat menyimpan array.

Konsep-konsep ini harus tampak sangat berbeda dengan pembaca yang datang dari latar belakang RDBMS dimana struktur tabel, kolom mereka, tipe data dan hubungan yang telah ditentukan. Fungsionalitas ini menggunakan skema dinamis memungkinkan kita untuk menghasilkan dokumen dinamis pada saat dijalankan.

Sebagai contoh, pertimbangkan dua dokumen berikut dalam koleksi yang sama tetapi memiliki skema yang berbeda (Gambar 2):

Figure 2 Documents in a Collection having different structure

Gambar 2

Dokumen pertama berisi kolom alamat dan tanggal lahir yang tidak hadir dalam dokumen kedua sedangkan dokumen kedua berisi field occupation dan gender yang tidak hadir dalam dokumen pertama. Bayangkan jika kita telah merancang hal ini di SQL, kita akan terus empat kolom tambahan untuk alamat, tanggal lahir, jenis kelamin dan pekerjaan, beberapa di antaranya akan menyimpan nilai-nilai kosong (atau null), dan karenanya menempati ruang yang tidak perlu.

Model skema dinamis adalah alasan mengapa database NosSQL sangat scalable dalam hal desain. Berbagai skema kompleks (hirarkis, struktur pohon, dll) yang akan membutuhkan sejumlah tabel RDBMS dapat dirancang secara efisien dengan menggunakan dokumen-dokumen tersebut. Sebuah contoh khas akan menyimpan posting pengguna, mereka suka, komentar dan informasi terkait lainnya dalam bentuk dokumen. Sebuah implementasi SQL yang sama idealnya akan memiliki tabel terpisah untuk menyimpan posting, komentar dan suka sementara dokumen MongoDB dapat menyimpan semua informasi ini dalam satu dokumen.

Memetakan Join dan Hubungan

Hubungan di RDBMS yang dicapai dengan menggunakan hubungan kunci primer dan asing dan query yang menggunakan join. Tidak ada pemetaan langsung seperti di MongoDB tetapi hubungan di sini dirancang menggunakan dokumen tertanam dan menghubungkannya.

Pertimbangkan contoh di mana kita perlu untuk menyimpan informasi pengguna dan informasi kontak yang sesuai. Sebuah desain SQL ideal akan memiliki dua tabel, katakanlah user_information dan contact_information, dengan kunci primer id dan contact_id seperti ditunjukkan pada Gambar 3. Tabel contact_information juga akan berisi kolom user_id yang akan menghubungkan kunci asing untuk field id dari tabel user_information.

Relationships in RDBMS are achieved using primary and foreign key relationships and querying those using joins. There is no such straightforward mapping in MongoDB but the relationships here are designed using embedded and linking documents.

Consider an example wherein we need to store user information and corresponding contact information. An ideal SQL design would have two tables, sayuser_information and contact_information, with primary keys id andcontact_id as shown in Fig 3. The contact_information table would also contain a column user_id which would be the foreign key linking to the id field of theuser_information table.

Figure 3
Gambar 3

Sekarang kita akan melihat bagaimana kita akan merancang hubungan tersebut dalam MongoDB menggunakan pendekatan Linking documents dan Embedded documents. Perhatikan bahwa dalam skema SQL, kita biasanya menambahkan kolom (seperti id dan contact_id dalam kasus kami) yang bertindak sebagai kolom utama untuk meja itu. Namun, dalam MongoDB, kita umumnya menggunakan field yang secara otomatis dihasilkan _id sebagai kunci utama untuk secara unik mengidentifikasi dokumen.

Linking Documents

Pendekatan ini akan menggunakan dua collectionsuser_information dan contact_information keduanya memiliki field unik _id mereka. Kita akan memiliki field user_id dalam dokumen contact_information yang berkaitan dengan field _id dari  dokumen user_information yang menunjukkan mana kontak pengguna yang sesuai dengannya. (Lihat Gambar 4) Perhatikan bahwa dalam MongoDB, hubungan dan operasi yang terkait harus diurus secara manual (misalnya, melalui kode) karena tidak ada batasan kunci asing dan aturan berlaku.

Figure 4 Linking Documents in MongoDB
Figure 4

Field  user_id dalam dokumen kita hanyalah sebuah field yang memegang beberapa data dan semua logika terkait dengan itu harus dilaksanakan oleh kita. Bahkan jika Anda akan memasukkan beberapa user_id dalam dokumen contact_information yang tidak ada dalam koleksi user_information, MongoDB tidak akan membuang kesalahan apapun yang mengatakan bahwa user_id yang sesuai tidak ditemukan di koleksi user_information (tidak seperti SQL di mana ini akan menjadi batasan kunci asing tidak valid).

Menanamkan Dokumen

Pendekatan kedua adalah dengan menanamkan dokumen contact_information dalam dokumen user_information seperti ini (Gambar 5):

Figure 5 Embedding Documents in MongoDB
Gambar 5

Dalam contoh di atas, kita telah menanamkan sebuah dokumen kecil informasi kontak dalam informasi pengguna. Dalam cara yang sama, dokumen kompleks yang besar dan data hirarkis dapat tertanam seperti ini untuk berhubungan badan.

Juga, pendekatan mana yang digunakan antara pendekatan Menghubungkan dan Menanamkan tergantung pada skenario tertentu. Jika data yang akan tertanam diperkirakan akan tumbuh lebih besar dalam ukuran, lebih baik menggunakan pendekatan Menghubungkan daripada pendekatan Menanamkan untuk menghindari dokumen menjadi terlalu besar. Pendekatan tertanam umumnya digunakan dalam kasus di mana jumlah informasi terbatas (seperti alamat pada contoh kita) harus tertanam.

Bagan Pemetaan

Untuk meringkas, tabel berikut (Gambar 6) merupakan hubungan umum yang telah kita bahas:

Figure 6 Mapping Chart
Gambar 6

Memetakan Query SQL ke MongoDB

Sekarang bahwa kita nyaman dengan pemetaan dasar antara RDBMS dan MongoDB, kita akan membahas bagaimana bahasa query yang digunakan untuk berinteraksi dengan database berbeda di antara mereka.

Untuk query MongoDB, mari kita asumsikan koleksi pengguna dengan struktur dokumen sebagai berikut:


{
     "_id": ObjectId("5146bb52d8524270060001f3"),
     "post_text":"This is a sample post" ,
     "user_name": "mark",
     "post_privacy": "public",
     "post_likes_count": 0
}

Untuk query SQL , kita mengasumsikan tabel users memiliki lima kolom dengan struktur dibawah ini:

Figure 7 Sample SQL Table
Gambar 7

Kita akan membahas query yang berkaitan dengan membuat dan mengubah koleksi (atau tabel), memasukkan, membaca, memperbarui dan menghapus dokumen (atau baris). Ada dua query untuk setiap titik, satu untuk SQL dan satu lagi untuk MongoDB. Saya akan menjelaskan query MongoDB hanya karena kita sudah familiar dengan query SQL. Query MongoDB disajikan di sini ditulis dalam Mongo JavaScript shell sedangkan query SQL yang ditulis dalam MySQL.

Create

Dalam MongoDB, tidak perlu secara eksplisit menciptakan struktur koleksi (seperti yang kita lakukan untuk tabel menggunakan query CREATE TABLE). Struktur dokumen secara otomatis dibuat ketika insert pertama terjadi dalam koleksi. Namun, Anda dapat membuat koleksi kosong menggunakan perintah createCollection.

SQL: CREATE TABLE `posts` (`id` int(11) NOT NULL AUTO_INCREMENT,`post_text` varchar(500) NOT NULL,`user_name` varchar(20) NOT NULL,`post_privacy` varchar(10) NOT NULL,`post_likes_count` int(11) NOT NULL,PRIMARY KEY (`id`))

MongoDB: db.createCollection("posts")

Insert

Untuk menyisipkan dokumen di MongoDB, kita menggunakan metode insert yang mengambil obyek dengan pasangan nilai kunci sebagai input. Dokumen yang dimasukkan akan berisi field _id yang otomatis dihasilkan oleh software. Namun, Anda juga dapat secara eksplisit memberikan nilai byte 12 sebagai _id bersama dengan field lainnya.

SQL: INSERT INTO `posts` (`id` ,`post_text` ,`user_name` ,`post_privacy` ,`post_likes_count`)VALUES (NULL ,  'This is a sample post',  'mark',  'public',  '0');

MongoDB:  db.posts.insert({user_name:"mark", post_text:"This is a sample post", post_privacy:"public", post_likes_count:0})

Tidak ada fungsi Alter Table di MongoDB untuk mengubah struktur dokumen. Sejak dokumennya dalam skema dinamis, skema berubah sebagaimana dan ketika informasi terbaru terjadi pada dokumen.

Read

MongoDB menggunakan metode find yang setara dengan perintah SELECT di SQL. Pernyataan berikut hanya membaca semua dokumen dari koleksi posts tersebut.

SQL: SELECT * FROM  `posts`

MongoDB: db.posts.find()

Query berikut melakukan pencarian bersyarat untuk dokumen yang memiliki field user_name sebagai mark. Semua kriteria untuk mengambil dokumen harus ditempatkan dalam tanda kurung {} dipisahkan dengan koma.

SQL: SELECT * FROM `posts` WHERE `user_name` =  'mark'

MongoDB: db.posts.find({user_name:"mark"})

Query berikut meminta kolom tertentupost_text dan post_likes_count seperti ditentukan pada kumpulan dalam tanda kurung {}.

SQL: SELECT  `post_text` ,  `post_likes_count` FROM  `posts`

MongoDB: db.posts.find({},{post_text:1,post_likes_count:1})
Perhatikan bahwa MongoDB secara default mengembalikan field _id dengan masing-masing pernyataan yang ditemukan. Jika kita tidak ingin field ini di hasil kembaliannya, kita harus menentukan kunci _id dengan nilai 0 dalam daftar kolom yang akan diambil. Nilai kunci 0 menunjukkan bahwa kita ingin mengecualikan field ini dari kumpulan data yang dihasilkan.
MongoDB: db.posts.find({},{post_text:1,post_likes_count:1,_id:0})

Query berikut meminta field tertentu berdasarkan kriteria yang mana user_name adalah mark.

SQL: SELECT  `post_text` , `post_likes_count` FROM `posts` WHERE `user_name` =  'mark'

MongoDB: db.posts.find({user_name:"mark"},{post_text:1,post_likes_count:1})

Sekarang kita akan menambahkan satu lagi kriteria untuk mengambil tulisan dengan jenis privasi sebagai publik. Bidang kriteria tertentu menggunakan koma mewakili kondisi logika AND. Dengan demikian, pernyataan ini akan mencari dokumen yang memiliki keduanya user_name sebagai mark dan post_privacy sebagai public.

SQL: SELECT  `post_text` ,  `post_likes_count` FROM  `posts` WHERE  `user_name` =  'mark' AND  `post_privacy` =  'public'

MongoDB: db.posts.find({user_name:"mark",post_privacy:"public"},{post_text:1,post_likes_count:1})

Untuk menggunakan logika OR antara kriteria dalam metode find, kita menggunakan operator $or.

SQL: SELECT  `post_text` ,  `post_likes_count` FROM  `posts` WHERE  `user_name` =  'mark' OR  `post_privacy` =  'public'

MongoDB: db.posts.find({$or:[{user_name:"mark"},{post_privacy:"public"}]},{post_text:1,post_likes_count:1})

Selanjutnya, kita akan menggunakan metode sort yang mengurutkan hasil dalam urutan menaik dari post_likes_count (ditandai dengan 1).

SQL: SELECT *  FROM `posts` WHERE `user_name` = 'mark' order by post_likes_count ASC

MongoDB: db.posts.find({user_name:"mark"}).sort({post_likes_count:1})

Untuk mengurutkan hasil dalam urutan menurun, kita tentukan -1 sebagai nilai field.

SQL: SELECT *  FROM `posts` WHERE `user_name` = 'mark' order by post_likes_count DESC

MongoDB: db.posts.find({user_name:"mark"}).sort({post_likes_count:-1})

Untuk membatasi jumlah dokumen yang harus dikembalikan, kami menggunakan metode limit yang menentukan jumlah dokumen.

SQL: SELECT *  FROM `posts` LIMIT 10

MongoDB: db.posts.find().limit(10)

Cara kita menggunakan offset dalam SQL untuk melewati beberapa jumlah record, kita menggunakan function skip di MongoDB. Sebagai contoh, pernyataan berikut akan mengambil sepuluh posting dengan melewatkan lima pertama.

SQL: SELECT *  FROM `posts` LIMIT 10 OFFSET  5

MongoDB: db.posts.find().limit(10).skip(5)

Update

Parameter pertama ke metode update menentukan kriteria untuk memilih dokumen. Parameter kedua menentukan operasi update yang sebenarnya yang akan dilakukan. Sebagai contoh, query berikut memilih semua dokumen with user_name sebagai mark dan menetapkan post_privacy mereka sebagai private.

Satu perbedaan di sini adalah bahwa secara default, query update MongoDB hanya mengupdate satu (dan yang pertama cocok) dokumen. Untuk memperbarui semua dokumen yang sesuai kita harus memberikan parameter ketiga menentukan multi sebagai true menunjukkan bahwa kita ingin memperbarui beberapa dokumen.

The first parameter to the update method specifies the criteria to select the documents. The second parameter specifies the actual update operation to be performed. For example, the following query selects all the documents withuser_name as mark and sets their post_privacy as private.

SQL: UPDATE posts SET post_privacy = "private" WHERE user_name='mark'

MongoDB: db.posts.update({user_name:"mark"},{$set:{post_privacy:"private"}},{multi:true})

Remove

Menghapus dokumen cukup sederhana dan mirip dengan SQL.

SQL: DELETE FROM posts WHERE user_name='mark'

MongoDB:  db.posts.remove({user_name:"mark"})

Mengindex

MongoDB memiliki indeks default dibuat pada field _id disetiap koleksi. Untuk membuat indeks baru pada field lain, kita menggunakan metode ensureIndex dengan menentukan fields dan urutannya ditunjukkan oleh 1 atau -1 (naik atau turun).
SQL: CREATE INDEX index_posts ON posts(user_name,post_likes_count DESC)

MongoDB: db.posts.ensureIndex({user_name:1,post_likes_count:-1})

Untuk melihat semua indeks hadir dalam koleksi mana saja, kita menggunakan metode getIndexes pada baris yang sama dengan query SHOW INDEX dari SQL.

SQL: SHOW INDEX FROM posts

MongoDB: db.posts.getIndexes()

Kesimpulan

Pada artikel ini, kami mengerti bagaimana konsep-konsep dasar dan istilah RDBMS / SQL berhubungan di MongoDB. Kami memandang cara merancang hubungan dalam MongoDB dan belajar bagaimana fungsi query SQL dasar dipetakan di MongoDB.

Setelah mendapatkan bahasan dari artikel ini, Anda dapat melanjutkan mencoba query kompleks termasuk agregasimap reduce dan query yang melibatkan beberapa koleksi. Anda juga dapat mengambil bantuan dari beberapa alat online untuk mengkonversi query SQL ke query MongoDB di awal. Anda dapat merancang sampel skema database MongoDB Anda sendiri. Salah satu contoh terbaik untuk melakukannya akan menjadi database untuk menyimpan posting pengguna, suka, komentar dan komentar sejenisnya. Ini akan memberi Anda pandangan praktis dari desain skema fleksibel yang ditawarkan MongoDB.

Jangan ragu untuk memberi komentar, saran, pertanyaan atau ide-ide Anda.

diterjemahkan secara bebas dari http://code.tutsplus.com/articles/mapping-relational-databases-and-sql-to-mongodb–net-35650?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+nettuts+%28Tuts%2B+Web+Development%29

Membangun Pemendek URL Sendiri

Sebagian besar dari kita akrab dengan melihat URL seperti bit.ly atau t.co pada feed Twitter atau Facebook kami. Ini adalah contoh dari URL singkat, yang merupakan alias atau pointer singkat ke link halaman lain yang lebih panjang. Sebagai contoh, saya bisa mengirimkan kamu URL yang diperpendek http://bit.ly/SaaYw5 yang akan mengarahkan kamu ke URL google yang sangat panjang dengan hasil pencarian bagaimana menyetrika kaus. Akan jauh lebih mudah menggunakan teks 20karakter URL bit.ly bagi anak anda yang ada di perguruan tinggi dan mempersiapkan diri untuk wawancara pekerjaan besar pertamanya.

Dalam artikel ini Anda akan belajar cara membuat pemendek URL yang berfungsi penuh untuk website Anda yang akan bekerja apakah Anda menggunakan front controller/framework atau tidak. Jika Anda menggunakan front controller, saya akan membahas cara mudah untuk mengintegrasikan URL shortener ini tanpa harus menggali ke dalam program controller.

Menjawab Beberapa Pertanyaan Umum

Jadi dengan bit.ly dan banyak penyingkat URL lainnya  seperti itu di luar sana dan tersedia secara bebas, mengapa kita harus repot-repot membangun sendiri? Sebagian besar dari layanan memperpendek ini bahkan memiliki API yang mudah digunakan sehingga kita dapat menghasilkan URL singkat yang telah diprogram, dan menggunakannya dalam skrip PHP kita.

Alasan yang terbaik adalah untuk kenyamanan, estetika dan pengenalan merek. Jika misalnya website Anda memiliki aplikasi yang menciptakan sejumlah besar laporan, sebuah blog yang sangat aktif atau album foto besar, akan ada banyak link. Sebuah URL shortener akan memungkinkan Anda untuk membuat pemrograman yang bersih, link sederhana yang bisa diemail ke pembaca atau dipublikasikan di website Anda. Keuntungan yang jelas untuk memilikinya sendiri adalah bahwa pembaca Anda memiliki pengenalan merek instan dengan situs web Anda.

Anda mungkin bertanya-tanya mengapa Anda selalu melihat huruf dicampur dengan angka di URL yang dipersingkat. Dengan memiliki lebih dari sepuluh pilihan (0-9) per digit, kita dapat memiliki kombinasi yang lebih dramatis sambil menjaga kodenya sesingkat mungkin.

Karakter kita akan menggunakan adalah angka 1-9 bersama dengan berbagai huruf besar / huruf kecil. Saya telah menghapus semua vokal untuk mencegah memiliki link yang dibuat menggunakan kata-kata buruk yang tidak diinginkan, dan saya telah menghapus karakter yang bisa membingungkan satu sama lain. Ini memberi kita daftar sekitar 50 karakter yang tersedia untuk setiap digit, yang berarti bahwa dengan dua karakter, kami memiliki 2.500 kemungkinan kombinasi, 125.000 kemungkinan dengan tiga karakter, dan 6,5 juta kombinasi dengan hanya empat karakter!

Mempersiapkan Database

Mari membuat tabel short_urls. Ini adalah tabel yang sederhana dan pernyataan untuk membuatnya adalah seperti dibawah ini:

CREATE TABLE IF NOT EXISTS short_urls (
  id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  long_url VARCHAR(255) NOT NULL,
  short_code VARBINARY(6) NOT NULL,
  date_created INTEGER UNSIGNED NOT NULL,
  counter INTEGER UNSIGNED NOT NULL DEFAULT '0',
  PRIMARY KEY (id),
  KEY short_code (short_code)
)
ENGINE=InnoDB;

 

Kita memiliki autoincrementing primary key standar dan kolom untuk URL lengkap, kode singkat untuk URL (diindeks untuk pencarian lebih cepat), penanda waktu ketika baris diciptakan, dan jumlah berapa kali URL pendek telah diakses.

Perhatikan bahwa field long_url memiliki panjang maksimum 255 karakter, yang harus cukup untuk sebagian besar aplikasi. Jika Anda perlu untuk menyimpan URL yang lebih panjang maka Anda harus mengubah definisi menjadi TEXT.

Sekarang dengan PHP!

Membuat Kode Pemendek URL

Kode untuk membuat dan mengurai URL pendek akan berada dalam kelas bernama ShortUrl. Pertama, mari kita lihat kode yang bertanggung jawab untuk menciptakan kode yang diperpendek:

 

<!--?php
class ShortUrl
{
    protected static $chars = "123456789bcdfghjkmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ";
    protected static $table = "short_urls";
    protected static $checkUrlExists = true;
    protected $pdo;
    protected $timestamp;
    public function __construct(PDO $pdo) {
        $this->pdo = $pdo;
        $this->timestamp = $_SERVER["REQUEST_TIME"];
    }
    public function urlToShortCode($url) {
        if (empty($url)) {
            throw new Exception("No URL was supplied.");
        }
        if ($this->validateUrlFormat($url) == false) {
            throw new Exception(
                "URL does not have a valid format.");
        }
        if (self::$checkUrlExists) {
            if (!$this->verifyUrlExists($url)) {
                throw new Exception(
                    "URL does not appear to exist.");
            }
        }
        $shortCode = $this->urlExistsInDb($url);
        if ($shortCode == false) {
            $shortCode = $this->createShortCode($url);
        }
        return $shortCode;
    }
    protected function validateUrlFormat($url) {
        return filter_var($url, FILTER_VALIDATE_URL,
            FILTER_FLAG_HOST_REQUIRED);
    }
    protected function verifyUrlExists($url) {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_NOBODY, true);
        curl_setopt($ch,  CURLOPT_RETURNTRANSFER, true);
        curl_exec($ch);
        $response = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
        return (!empty($response) && $response != 404);
    }
    protected function urlExistsInDb($url) {
        $query = "SELECT short_code FROM " . self::$table .
            " WHERE long_url = :long_url LIMIT 1";
        $stmt = $this->pdo->prepare($query);
        $params = array(
            "long_url" => $url
        );
        $stmt->execute($params);
        $result = $stmt->fetch();
        return (empty($result)) ? false : $result["short_code"];
    }
    protected function createShortCode($url) {
        $id = $this->insertUrlInDb($url);
        $shortCode = $this->convertIntToShortCode($id);
        $this->insertShortCodeInDb($id, $shortCode);
        return $shortCode;
    }
    protected function insertUrlInDb($url) {
        $query = "INSERT INTO " . self::$table .
            " (long_url, date_created) " .
            " VALUES (:long_url, :timestamp)";
        $stmnt = $this->pdo->prepare($query);
        $params = array(
            "long_url" => $url,
            "timestamp" => $this->timestamp
        );
        $stmnt->execute($params);
        return $this->pdo->lastInsertId();
    }
    protected function convertIntToShortCode($id) {
        $id = intval($id);
        if ($id < 1) {
            throw new Exception(
                "The ID is not a valid integer");
        }
        $length = strlen(self::$chars);
        // make sure length of available characters is at
        // least a reasonable minimum - there should be at
        // least 10 characters
        if ($length < 10) {
            throw new Exception("Length of chars is too small");
        }
        $code = "";
        while ($id > $length - 1) {
            // determine the value of the next higher character
            // in the short code should be and prepend
            $code = self::$chars[fmod($id, $length)] .
                $code;
            // reset $id to remaining value to be converted
            $id = floor($id / $length);
        }
        // remaining value of $id is less than the length of
        // self::$chars
        $code = self::$chars[$id] . $code;
        return $code;
    }
    protected function insertShortCodeInDb($id, $code) {
        if ($id == null || $code == null) {
            throw new Exception("Input parameter(s) invalid.");
        }
        $query = "UPDATE " . self::$table .
            " SET short_code = :short_code WHERE id = :id";
        $stmnt = $this->pdo->prepare($query);
        $params = array(
            "short_code" => $code,
            "id" => $id
        );
        $stmnt->execute($params);
        if ($stmnt->rowCount() < 1) {
            throw new Exception(
                "Row was not updated with short code.");
        }
        return true;
    }
...

 

Ketika kita menginstansiasi class ShortUrl, kita akan melewatkan objek PDO kita. Konstruktor menyimpan referensi ini dan menetapkan nilai $timestamp.

Kita memanggil metode urlToShortCode () melewatkan URL panjang yang kita ingin dipersingkat. Metode ini membungkus segala sesuatu yang diperlukan untuk membuat kode URL pendek, yang akan ditambahkan ke nama domain kita.

urlToShortCode() memanggil validateUrlFormat() yang hanya menggunakan filter PHP untuk memastikan bahwa URL diformat dengan benar. Lalu, apakah variabel statis $checkUrlExists bernilai benar, verifyUrlExists() akan dipanggil menggunakan cURL untuk menghubungi URL dan memastikan bahwa hal itu tidak mengembalikan error 404 (Not Found). Sebagai alternatif anda dapat memeriksa status 200 (OK), tapi ini bisa menyebabkan masalah jika halaman tiba-tiba mengembalikan kode respon 301 (Dipindah) atau 401 (sah).

Adalah tidak masuk akal untuk memiliki entri ganda, sehingga kode memeriksanya dengan urlExistsInDb() yang meng-query database untuk URL yang panjang. Jika menemukan URL itu, ia akan mengembalikan kode pendek yang sesuai, jika tidak maka mengembalikan false jadi kita tahu bahwa kita perlu untuk menciptakannya. Perhatikan bahwa http://www.example.com dan http://example.com adalah URL yang berbeda, jadi jika Anda ingin mencegah duplikasi semacam ini maka Anda harus menambahkan beberapa kalimat biasa.

createShortCode() menujuk tugas-tugas dibawah ini kepada method khusus:

  1. insertUrlInDb() untuk memasukkan URL yang panjang ke dalam database dan mengembalikan ID baris yang baru.
  2. convertIntToShortCode() untuk mengubah ID baris baru ke skema nomor basis50 kita.
  3. insertShortCodeInDb()untuk memperbarui baris dengan kode pendek yang baru dibuat.

Ketika kita ingin membuat URL pendek, yang harus kita lakukan adalah menginstansiasi kelas, melewati PDO ke konstruktor, memanggil method urlToShortCode() tersebut dengan URL panjang yang ingin kita persingkat, dan menambahkan kode pendek kembali ke domain dan menyebarkannya kembali ke controller yang memintanya.


<!--?php
include "../include/config.php";
include "../include/ShortUrl.php";
try {
    $pdo = new PDO(DB_PDODRIVER . ":host=" . DB_HOST .
        ";dbname=" . DB_DATABASE,
        DB_USERNAME, DB_PASSWORD);
}
catch (PDOException $e) {
    trigger_error("Error: Failed to establish connection to database.");
    exit;
}
$shortUrl = new ShortUrl($pdo);
try {
    $code = $shortUrl->urlToShortCode($_POST["url"]);
    printf('<p><strong>Short URL:</strong> <a href="%s">%1$s</a></p>',
        SHORTURL_PREFIX . $code);
    exit;
}
catch (Exception $e) {
    // log exception and then redirect to error page.
    header("Location: /error");
    exit;
}

Menguraikan Kode Pendek

Kode untuk memecahkan kode pendek dan mendapatkan URL panjang adalah bagian dari kelas ShortUrl juga. Kami menyebutnya metode shortCodeToUrl() dan melewatkan kode singkat kami yang telah diekstrak dari URIshortCodeToUrl()juga menerima parameter opsional, $increment, yang defaultnya adalah TRUE. Kemudian menugaskan berikut:

  1. validateShortCodeFormat() memastikan bahwa kode singkat yang disediakan hanya berisi huruf dan angka.
  2. getUrlFromDb() query ke database dengan kode pendek yang diberikan dan mengembalikan id, long_url, dan counter.
  3. Jika parameter $increment bernilai true, incrementCounter() dipanggil untuk menambahkan nilai kolom counter.

Ini adalah sisa kode untuk class tersebut:


...
    public function shortCodeToUrl($code, $increment = true) {
        if (empty($code)) {
            throw new Exception("No short code was supplied.");
        }
        if ($this->validateShortCode($code) == false) {
            throw new Exception(
                "Short code does not have a valid format.");
        }
        $urlRow = $this->getUrlFromDb($code);
        if (empty($urlRow)) {
            throw new Exception(
                "Short code does not appear to exist.");
        }
        if ($increment == true) {
            $this->incrementCounter($urlRow["id"]);
        }
        return $urlRow["long_url"];
    }
    protected function validateShortCode($code) {
        return preg_match("|[" . self::$chars . "]+|", $code);
    }
    protected function getUrlFromDb($code) {
        $query = "SELECT id, long_url FROM " . self::$table .
            " WHERE short_code = :short_code LIMIT 1";
        $stmt = $this->pdo->prepare($query);
        $params=array(
            "short_code" => $code
        );
        $stmt->execute($params);
        $result = $stmt->fetch();
        return (empty($result)) ? false : $result;
    }
    protected function incrementCounter($id) {
        $query = "UPDATE " . self::$table .
            " SET counter = counter + 1 WHERE id = :id";
        $stmt = $this->pdo->prepare($query);
        $params = array(
            "id" => $id
        );
        $stmt->execute($params);
    }
}

Membawa Semuanya

Membangun/mengubah front controller atau menyesuaikan paket ini ke framework yang ada di luar lingkup artikel ini, dan jadi aku memilih untuk memasukkan logika decoding kami dalam sebuah file bernama r.php (r singkatan untuk redirect). Kita bisa menulis URL disingkat kita sebagai http://example.com/r/X4c mana r.php (atau r / index.php tergantung pada desain Anda) akan menjadi controller. Format ini akan mudah untuk mengintegrasikannya ke dalam hampir kerangka apapun tanpa menyentuh front controller yang ada.

Pada catatan terkait, jika Anda ingin belajar bagaimana membangun front controller Anda sendiri, periksa seri yang sangat baik An Introduction to the Front Controller Pattern.

Salah satu keuntungan dari desain ini adalah bahwa, jika Anda ingin, Anda dapat memiliki kontroler terpisah untuk bagian yang berbeda dari situs Anda menggunakan tabel yang berbeda untuk menjaga kode pendek terorganisir dan sesingkat mungkin. http://example.com/b/ bisa untuk posting blog, dan http://example.com/i/ bisa untuk gambar.

Tapi bagaimana kalau saya tidak menggunakan front controller atau framework?” Anda bertanya, Apakah aku hanya membaca artikel ini secara keseluruhan untuk hal yang sia-sia?” Meskipun itu tidak cukup, Anda dapat menggunakan format http://example.com/ r? c = X4c mana r / index.php berisi script decoding.

Ini adalah isi dari file r.php:


<?php
include "../include/config.php";
include "../include/ShortUrl.php";
// How are you getting your short code?
// from framework or front controller using a URL format like
// http://.example.com/r/X4c
// $code = $uri_data[1];
// from the query string using a URL format like
// http://example.com/r?c=X4c where this file is index.php in the
// directory http_root/r/index.php
$code = $_GET["c"];
try {
    $pdo = new PDO(DB_PDODRIVER . ":host=" . DB_HOST .
        ";dbname=" . DB_DATABASE,
        DB_USERNAME, DB_PASSWORD);
}
catch (PDOException $e) {
    trigger_error("Error: Failed to establish connection to database.");
    exit;
}
$shortUrl = new ShortUrl($pdo);
try {
    $url = $shortUrl->shortCodeToUrl($code);
    header("Location: " . $url);
    exit;
}
catch (Exception $e) {
    // log exception and then redirect to error page.
    header("Location: /error");
    exit;
}

Tergantung pada bagaimana Anda mendapatkan kode pendek, variabel $code diatur bersama dengan pengaturan konfigurasi lain. Kami membuat sambungan PDO kami, menginstansiasi sebuah instance dari class ShortUrl, dan memanggil shortCodeToUrl() melewatkan kode pendek dan meninggalkan counter ke pengaturan nilai default. Jika kode pendek berlaku, Anda akan memiliki URL yang panjang dimana Anda dapat mengarahkan pengguna kepadanya.

Penutup

Jadi di sanalah Anda memilikinyapemendek URL anda sendiri yang sangat mudah untuk ditambahkan ke situs yang ada. Tentu saja, ada banyak cara paket ini dapat ditingkatkan, seperti:

  • Abstrak interaksi database Anda untuk menghapus kode berlebihan.
  • Tambahkan cara untuk mengcache permintaan URL singkat.
  • Tambahkan beberapa analisis ke URL pendek yang diminta di luar field counter.
  • Tambahkan cara untuk menyaring halaman berbahaya.

Aku ingin mengambil kesempatan ini untuk mengucapkan terima kasih Timothy Boronczyk atas sarannya selama proses penulisan saya. Itu adalah suatu kehormatan untuk menulis artikel ini untuk SitePoint dan bekerja sama dengannya.

Silahkan fork  contoh kode artikel ini di GitHub dan bagikan kontribusi dan peningkatan kamu.

Terima kasih telah membaca dan selamat ber-PHP ria!

diterjemahkan dari http://www.sitepoint.com/building-your-own-url-shortener/

Google App Engine dan PHP: Cara Memulainya

Sudah lama sejak Google mengumumkan dukungan PHP pada Google App Engine. Artikel seri ini akan membawa Anda melalui semua langkah yang diperlukan agar aplikasi Anda dapat berjalan pada GAE. Untuk tutorial ini, kita akan menggunakan PhpStorm yang mendukung proyek GAE, tetapi Anda dapat menggunakan IDE pilihan Anda.Mulailah dengan menghormati prasyarat untuk platform Anda. Hal ini diperlukan karena Google App Engine SDK memerlukan software tertentu untuk bisa dijalankan secara lokal, yaitu Python yang menjalankan server”.Jika misalnya PhpStorm Anda tidak memiliki plugin GAE untuk beberapa alasan, pergilah ke Preferences dan temukan di plugin browser ini tersedia untuk didownload dan diinstal melalui repositori Plugin.

Mendaftarkan aplikasi pada GAE

Untuk mengembangkan sebuah aplikasi untuk GAE, Anda harus terlebih dahulu mendaftar dan mengambil ID aplikasi. Pergilah ke https://appengine.google.com/ dan log in dengan akun Google Anda. Setelah selesai, klik tombol “Create Application” di dashboard dan masukkan informasi yang diperlukan ke dalam formulir.

Memulai Proyek

Untuk memulai sebuah proyek PHP baru di GAE, cukup pilih dari menu drop-down dan mengisi data yang dibutuhkan.

Setelah Anda menerimanya, IDE secara otomatis akan menciptakan dua file: app.yaml dan main.php. Jika Anda tidak menggunakan PhpStorm, Anda dapat membuat sendiri ini.

app.yaml:

application: sitepoint-test
version: 1
runtime: php
api_version: 1
threadsafe: true

handlers:
- url: .*
  script: main.php

main.php:

<?php

echo 'Hello, world!';

Mari kita jelaskan atribut YAML.

threadsafe mengacu pada keselamatan thread PHP, isu yang sangat diperdebatkan dengan kebanyakan orang yang skeptis terhadap hal itu dan masih meragukan bahwa PHP sebenarnya mendukung thread. Untuk informasi lebih lanjut, baca dua pertanyaan StackOverflow ini.

Nilai ini tampaknya opsional tapi aku biasanya cenderung mempercayai Google dan Jetbrains untuk mengetahui apa yang mereka lakukan dan melihat karena tidak ada dokumentasi yang tepat pada kata properti, mari kita biarkan apa adanya.

handlers adalah seperangkat nilai-nilai yang mendefinisikan skrip yang menangani  pola URL. Pola URL adalah ekspresi reguler, dan ini bagian dari file YAML dapat digunakan untuk menentukan rute.

Pada titik ini, anda dapat memasukkan Pengaturan Proyek di PhpStorm, dan di bawah Google App Engine PHP Anda dapat memasukkan nama pengguna dan sandi Akun Google Anda, sehingga Anda tidak akan diminta ketika mendeploying mereka.

Mengetes aplikasi

Kita memiliki dua cara untuk mengetes aplikasi kita.

  1. Menjalankan dari terminal
  2. Menjalankan dari PhpStorm

Menjalankan aplikasi dari terminal

Untuk menjalankan server dari terminal, masukkan perintah berikut ini:

{google_appengine folder}/dev_appserver.py {project folder}

atau, dalam kasus saya ketika tanda {} dihilangkan dengan nilai sebenarnya:

google_appengine/dev_appserver.py gae01/

Ini akan menjalankan server aplikasi dan menunjuk pada folder yang disediakan sebagai parameter pertama. Dua hal terjadi ketika Anda melakukan hal ini: sebuah konsol administrasi dijalankan di http://localhost:8000 dan aplikasi itu sendiri dijalankan di http://localhost:8080. Jika Anda mengunjungi konsol admin, Anda akan melihat sejumlah besar informasi yang berguna dari isi memcache hingga cronjobs dan banyak lagi:

 

Mengarahkan URL ke http://localhost:8080 akan menampilkan “Hello World” di browser

Catat bahwa ketika kamu mendapati pesan eror The path specified with the --php_executable_path flag () does not exist.  ketika menjalankan aplikasi, ini berarti server aplikasi tidak mengetahui dimana lokasi php-cgi, makanya ia tidak dapat menjalankannya. Cukup tambahkan ini di baris perintahnya:

google_appengine/dev_appserver.py --php_executable_path=/usr/bin/php-cgi gae01/

Menemukan dimana lokasi php-cgi kamu adalah cukup mudah – ketikkan whereis php-cgi dan jika ia ada di variabel $PATH kamu, lokasinya akan ditunjukkan di terminal.

Menjalankan aplikasi dari PhpStorm

Untuk menjalankan aplikasi dari PhpStorm, klik pilihan “Edit Configurations” di menu “Select Run/Debug Configuration”:

Sebagian besar informasi dalam dialog yang muncul akan sudah diisi. Satu-satunya nilai yang hilang adalah  “Path to php-cgi executable” yang dapat Anda temukan dengan mengetik whereis php-cgi di terminal Anda. Pada Linux, punya saya berada di /usr/bin/phpcgi.

Setelah menekan Apply dan OK, klik panah hijau di sebelah menu Select Run/Debug Configurationi” , atau hanya tekan Shift + F10 sebagai shortcut ke perintah “Run default”. Konsol PhpStorm seharusnya menampilkan informasi tentang server yang baru saja dijalankan dan http://localhost:8000 dan http://localhost:8080 sekarang keduanya dapat diakses, dengan yang terakhir menghasilkan output Hello World”  ketika dikunjungi di browser .

Menjalankan melalui PhpStorm memiliki keuntungan tambahan untuk dapat mengatur breakpoints dan melakukan langkah demi langkah debugging. Cukup klik di dekat nomor baris dalam kode Anda (dalam selokan dari jendela editor) dan sebuah bola merah akan muncul. Itu breakpoint. Saat menjalankan aplikasi Anda, server akan berhenti secepat itu saat mencapai titik ini, memungkinkan Anda untuk memeriksa variabel yang ditetapkan saat ini, pemakaian memori, dan banyak lagi.

Deployment

Terdapat tiga cara untuk mendeploy aplikasi ke GAE:

  1. Melalui terminal/command line
  2. Melalui PhpStorm
  3. Melalui Git

Deployment Melalui terminal

Mengupload aplikasi melalui terminal adalah simpel dengan memanggil {google_appengine}/appcfg.py update {project folder} atau dalam kasus saya google_appengine/appcfg.py gae01/.

Deployment melalui PhpStorm

Untuk mendeploy dari PhpStorm, pergilah ke Tools -> Google App Engine for PHP -> Upload App Engine PHP app…

Jika Anda telah memasukkan kredensial Anda dalam Pengaturan Proyek, proses akan dilanjutkan secara otomatis tanpa pertanyaan. Jika tidak, Anda akan diminta untuk memasukkan username dan password, dan plugin akan memanggil perintah yang sama dengan ketika Anda memanggil secara manual ketika deploying melalui terminal.

Deployment melalui Git (Push-to-Deploy)

Push-to-deploy masih dalam keadaan eksperimental sekarang, tapi akan lebih baik jika meluangkan waktu dan usaha untuk menguasainya.

Untuk mengatur PTD, kamu perlu masuk ke cloud console dan menemukan aplikasimu disini.

Klik pada nama aplikasi Anda, gulir ke “Cloud Development” di menu sebelah kiri, dan klik “Create a New Repo”.

Simpan URL repo dan klik “Get Password”. Ini seharusnya menghasilkan string tidak seperti machine code.google.com login {user} password {pass} with {user} and {pass} ganti dengan data Anda sendiri. Salin string ini ke sebuah file yang bernama .netrc yang harus Anda buat dalam folder home Anda. Jika Anda berada di Windows, file yang harus dibuat adalah _netrc. Windows juga perlu memiliki variabel HOME yang telah didefinisikan, yang dapat Anda lakukan dengan memanggil setx HOME %USERPROFILE%.

Yang perlu Anda lakukan sekarang adalah menghubungkan url remote ke repo yang Anda miliki di komputer lokal Anda (baik add remote atau clone secara langsung dari URL repo cloud console yang diberikan padamu sebelumnya) dan push agar hidup. Karena app kita buat dalam artikel ini sudah ada, mari kita membuat repo Git di atasnya dan menambahkan url remote untuk itu. Untuk mencegah file sampah dari IDE yang diupload bersama berkas kita, tambahkan file .gitignore ini Ke folder.

cd gae01
git init
git add .
git commit -am 'Initial commit'
git remote add appengine REPO_URL

Ganti REPO_URL dengan url repo konsol awan Anda. Perintah terakhir yang dilakukan adalah menambahkan link remote ke repo lokal yang mengikat ke repo remote. Link ini disebut appengine” appengine hanya label, Anda dapat memilih sendiri, tapi tidak ada gunanya menggunakan sesuatu selain default standar yang ditunjukkan di sini.

Setiap kali Anda membuat perubahan, gunakan repo seperti yang Anda biasanya akan gunakan. Anda bahkan dapat mengatur repo Github di samping, dan menambahkan link remote lain ke repositori lokal ini. Ini akan memungkinkan Anda untuk memiliki kontrol versi di Github jika Anda terbiasa untuk itu dari pada Google Code, sementara masih menyebarkan ke GAE melalui PTD ketika Anda menarik/pull perubahan dari Github dan mendorongnya/push ke link appengine.

Untuk mendorong aplikasi agar online saat ini, panggil saja

git push appengine master

Perhatikan bahwa Anda dapat memiliki banyak cabang yang Anda inginkan, seperti dalam repo Git, tetapi hanya mendorong cabang master yang benar-benar akan menyebar ke lingkungan server yang hidup. Selain itu, kode sumber Anda dilindungi dari mencongkel mata, repo yang tidak umum dan hanya dapat dilihat oleh admin dan kontributor. Namun, jika pengguna menonaktifkan PTD dan menghidupkannya lagi, repo yang dibuang dan yang baru dibuat tidak ada cara untuk mengembalikan yang lama. Hati-hati tentang pada siapa Anda memberikan izin untuk itu.

Mengunjungi URL yang sesuai sekarang ( your-app-id.appspot.com ) seharusnya memberikan pesan Hello World, dan mengklik pada nama repo di konsol awan akan memberi Anda daftar versi sejarah dan gambaran dari kode sumber.

Kesimpulan

Google App Engine adalah cara terbaik untuk menyebarkan aplikasi dengan lalu lintas tinggi agar mudah diperluas. Kuota gratis mereka memungkinkan untuk 5 juta views per bulan, cukup mudah untuk aplikasi apapun, dan memperluasnya melewati kuota yang lama hanya dibutuhkan beberapa klik mouse.

Dalam artikel ini kita telah membahas penyebaran dasar dengan dan tanpa IDE, dan menjelaskan mekanisme Push-To-Deploy.

diterjemahkan bebas dari http://www.sitepoint.com/google-app-engine-php-getting-started/

Stored Procedures di MySQL dan PHP

Sederhananya, sebuah Stored Prosedure (“SP”) adalah prosedur (ditulis dalam SQL dan pernyataan kontrol lainnya) disimpan dalam database yang dapat dipanggil oleh mesin database dan terhubung dengan bahasa pemrograman.

Dalam tutorial ini, kita akan melihat cara membuat SP di MySQL dan jalankan di server MySQL dan PHP.

Catatan: Kita tidak akan membahas semua aspek dari SP disini,  We are not going to cover the full aspect of the SP here. Dokumen MySQL resmi selalu menjadi referensi Terbaik.

SP juga tersedia di server database umum lainnya (Postgre misalnya) sehingga apa yang akan kita bahas di sini dapat diterapkan untuk mereka juga.

Mengapa direkomendasikan untuk menggunakan

Sebagian besar dari kita sudah familiar dengan setup yang normal untuk membangun aplikasi database: membuat database, membuat tabel, mengatur indeks, CRUD data, melakukan query dari sisi klien dan melakukan proses lebih lanjut jika diperlukan.

Alur kerja tersebut bekerja dengan baik dalam banyak kasus tapi ada satu aspek penting dari pemrograman database hilang: Stored Procedure.

Setidaknya ada empat keuntungan yang saya ketahui dengan menggunakan SP dalam aplikasi database.

Pertama, mengurangi lalu lintas jaringan dan overhead. Dalam database PHP aplikasi web yang khas, ada empat lapisan:

  • Layer klien, yang mana normalnya adalah browser web. Ia menerima interaksi user dan menampilkan data di user interface.
  • Layer web server, yang menangani dan memilah permintaan user dan mengirim balik response yang diberikan ke layer klien.
  • Layer PHP, yang menangani semua interpretasi PHP, melakukan logika aplikasi, dan menghasilkan response dari PHP.
  • Layer Database, yang menangani semua query database, termasuk tidak terbatas pada sebuah query SELECT, pernyataan INSERT, dan seterusnya.

Dalam lingkungan yang khas, lapisan ini akan kemungkinan besar tidak berada pada satu mesin tunggal, bahkan mungkin tidak dalam satu jaringan, untuk aplikasi yang lebih besar.

Meskipun kecepatan jaringan telah sangat meningkat dalam beberapa tahun terakhir, masih paling lambat dan paling tidak dapat diandalkan dibandingkan dengan cara lain untuk mentransfer data (CPU cache, memori, hard disk, dll). Jadi, untuk menghemat bandwidth dan meningkatkan ketahanan, kadang-kadang ide yang baik untuk memiliki lebih banyak pengolahan dan logika yang dilakukan pada sisi server (khususnya, server MySQL) dan memiliki sedikit data yang ditransfer melalui jaringan.

Kedua, meningkatkan kinerja. SP disimpan dan dijalankan langsung di server MySQL. Hal ini dapat menjadi pra-kompilasi dan dianalisa oleh database server. Ini sangat berbeda dari mengeluarkan permintaan yang sama dari sisi client, di mana permintaan akan diurai oleh database driver, dianalisis dan dioptimalkan (jika mungkin) pada setiap kali pernyataan query disebut. Hal ini entah bagaimana mirip eksekusi bahasa dengan interpreter  (pada akhir client) dan eksekusi bahasa terkompilasi (pada akhir database server). Dan kita tahu program yang dikompilasi akan berjalan lebih cepat.

Ketiga, Tulis sekali dan Jalankan dan mana saja. SQL adalah standar dan murni 100% platform independen. Hanya mengandalkan pada server database. Pertimbangkan berapa banyak berbeda bahasa / libs ada yang bisa kita gunakan untuk menangani database. Hal ini meningkatkan efisiensi dengan menempatkan penerimaan dan pengolahan data pada akhir server daripada menulis logika pengolahan yang sama dalam sintaks yang berbeda yang disediakan oleh semua bahasa / libs, jika logika pengolahan datanya sangat umum digunakan.

Terakhir, SP merupakan aspek fundamental dari keamanan database.

Mari kita mempertimbangkan setup database sederhana. Dalam sistem informasi sumber daya manusia (HRIS), adalah wajar untuk mengasumsikan bahwa ada sebuah tabel yang memegang informasi gaji masing-masing karyawan. Seorang karyawan HR harus memiliki hak untuk mengambil beberapa angka dari tabel ini: Jumlah gaji, gaji rata-rata, dll tapi karyawan ini seharusnya tidak melihat gaji rinci dari setiap karyawan karena informasi ini akan terlalu sensitif dan seharusnya hanya tersedia untuk beberapa .

Kita tahu MySQL memiliki kontrol hak istimewa yang komprehensif. Dalam hal ini, jelas bahwa kita bahkan tidak bisa memberikan hak istimewa SELECT pada karyawan HR ini (yang, jika kita lakukan, berarti dia / dia bisa melihat gaji rinci semua orang). Tapi jika dia / dia tidak dapat mengakses tabel gaji, bagaimana karyawan ini bisa mendapatkan informasi agregasi berkaitan dengan gaji? Bagaimana kita bisa memungkinkan karyawan untuk mengambil informasi yang tanpa mengorbankan kebijakan HR?

Jawabannya adalah menggunakan Stored Prosedur yang mengembalikan informasi yang diperlukan dan memberikan karyawan yang berhak dengan hak akses Execute. (Untuk daftar rinci dan penjelasan tentang hak akses pada MySQL, silakan berkonsultasi di dokumentasi resmi. Link di sini adalah untuk MySQL 5.6. Silakan ganti 5.6 dengan versi yang Anda gunakan.)

SP sekarang adalah jembatan, menjembatani user (karyawan HR) dan tabel (gaji), yang mana pengguna tidak memiliki akses langsung.

Itu saja! Dengan SP, kita bisa mendapatkan pengguna untuk menyelesaikan tugas tanpa mengorbankan keamanan database (dan kebijakan SDM)!

Kerugian menggunakan Stored Procedures

Setelah menguraikan semua keuntungan dari menggunakan SP, kita harus jelas tentang beberapa kelemahan dan melihat apakah ada cara untuk memperbaikinya.

  • Tidak ada kontrol versi di SP itu sendiri . Ketika SP dimodifikasi , hal itu diubah , tidak ada jejak sejarah dapat disimpan di sisi server . Ini mungkin membuat beberapa frustrasi ketika pengguna ingin merollback perubahan. Saran saya adalah untuk menulis SP di sisi klien Anda dan meletakkannya di bawah kontrol versi . Ketika SP sudah siap , mudah untuk menyalin kode ke , katakanlah MySQL Workbench dan menciptakan itu pada sisi server . Dengan demikian , kita dapat memiliki beberapa tingkat kontrol versi .
  • Tidak ada cara mudah untuk melakukan “sinkronisasi ” perubahan yang diterapkan dan memaksa semua orang untuk menggunakan versi terbaru , khususnya, ketika masing-masing anggota tim memiliki database lokalnya sendiri untuk tujuan pengembangan dan pengujian . Versi kontrol dapat menjadi solusi namun masih membutuhkan intervensi manual dengan memperbarui salinan lokal dari SP di server db lokal . Cara lain adalah dengan menggunakan “mocking” . Anggota tim dapat dibagi sehingga setidaknya satu orang akan fokus pada pemeliharaan SP dan pelaksanaan panggilan kepada SP dalam kode . Semua orang lain yang membutuhkan hasil dari SP dapat mengembangkan dan menguji bagian mereka menggunakan objek mocking, yaitu , selalu dengan asumsi  panggilan “palsu” pada SP akan mengembalikan hasil yang diinginkan . Dalam tahap selanjutnya, penggabungan dapat dilakukan dengan membuang kode mocking.
  • Sulit untuk membackup/mengekspornya. SP adalah pada sisi server . Pengembang reguler hanya akan memiliki hak dasar ( SELECT , Execute , dll ) dan tidak ada hak admin untuk membackup dan mengekspor . Di satu sisi , saya tidak akan menyebutnya kelemahan melainkan aspek fundamental dari keamanan db. Tidak ada cara, dan tidak dianjurkan di area ini . Disarankan bahwa, dalam sebuah tim , DB admin khusus akan ditunjuk untuk melakukan pekerjaan tersebut . Sebuah backup db biasa juga dapat melayani tujuan backup/ekspor ( dan impor ) .

Membuat Stored Procedure di MySQL

Karena SP disimpan dalam server, dianjurkan untuk membuat SP langsung di server, yaitu, tidak dengan menggunakan PHP atau bahasa pemrograman lain untuk mengeluarkan perintah SQL untuk melakukannya.

Mari kita lihat bagaimana membuat SP di MySQL server, membuat user dan menerapkan hak dan menjalankannya (sebagai user tersebut) SP untuk melihat apakah hasilnya benar. Dalam lingkungan kerja saya, saya menggunakan MySQL Workbench. Alat-alat lain yang tersedia (PHPMyAdmin misalnya) sehingga merasa bebas untuk menggunakan alat-alat yang paling sesuai dengan Anda.

Asumsikan kita memiliki tabel seperti ini:

CREATE TABLE `salary` (
  `empid` int(11) NOT NULL,
  `sal` int(11) DEFAULT NULL,
  PRIMARY KEY (`empid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Dan untuk karyawan HR yang perlu mendapatkan informasi yang dikumpulkan di gaji (rata-rata, max, min, dll) dari tabel itu, pertama-tama kita membuat user ‘tr’ seperti ini:

CREATE USER 'tr'@'localhost' IDENTIFIED BY 'mypass';

and for this user, we only grant EXECUTE privilege to the schema where the salary table resides:

grant execute on hris.*  to tr@`%`

Kita dapat memverifikasi hak istimewa yang diperlukan, semata dengan mengunjungi “Pengguna dan Privileges” di MySQL Bench:

Sekarang kita bikin SP seperti berikut ini:

DELIMITER $$

CREATE PROCEDURE `avg_sal`(out avg_sal decimal)
BEGIN
    select avg(sal) into avg_sal from salary;

END

Catatan: Semua operasi di atas akan membutuhkan peran admin di server MySQL.

Setelah mengeluarkan perintah di MySQL Workbench, SP avg_sal  akan dibuat dan siap untuk dipanggil. Ini akan mengembalikan gaji rata-rata dari tabel gaji.

Untuk menguji apakah pengguna tr benar-benar dapat menjalankan SP tapi tidak harus dapat mengakses tabel gaji, kita dapat beralih peran dengan login ke server MySQL menggunakan pengguna tr. Hal ini dapat dilakukan dengan menciptakan koneksi lain di MySQL Workbench menggunakan sepasang user / password yang berbeda.

Setelah log in sebagai tr, hal pertama yang akan kita perhatikan adalah bahwa pengguna tidak akan dapat melihat tabel dan hanya bisa melihat SP:

Hal ini jelas bahwa pengguna tr tidak akan dapat mendapatkan apa pun dari setiap tabel (sehingga tidak dapat melihat jumlah gaji rinci tabel gaji) tetapi dia mampu mengeksekusi SP yang baru kita buat dan mendapatkan gaji rata-rata perusahaan:

call avg_sal(@out);
select @out;

Gaji rata-rata akan ditampilkan.

Kami sejauh ini melakukan semua persiapan untuk membuat user, memberikan hak istimewa, membuat SP dan menguji menjalankan SP. Selanjutnya kita akan menunjukkan bagaimana memanggil SP yang dari dalam PHP.

Memanggil Stored Procedure dari PHP

Dengan PDO, memanggil SP sangatlah mudah. Kode PHPnya adalah sebagai berikut:

$dbms = 'mysql';

//Replace the below connection parameters to fit your environment
$host = '192.168.1.8';
$db = 'hris';
$user = 'tr';
$pass = 'mypass';
$dsn = "$dbms:host=$host;dbname=$db";

$cn=new PDO($dsn, $user, $pass);

$q=$cn-&gt;exec('call avg_sal(@out)');
$res=$cn-&gt;query('select @out')-&gt;fetchAll();
print_r($res);

$res akan berisi gaji rata-rata dari tabel gaji. Pengguna dapat memproses lebih lanjut outputnya dengan PHP sekarang.

Kesimpulan

Pada artikel ini, kami meninjau komponen lama yang terlupakan dalam database MySQL: Stored Procedures. Keuntungan untuk menggunakan SP yang jelas dan biarkan aku kembali menekankan:. Stored Procedures memungkinkan kita untuk menerapkan kontrol akses database secara kuat ke data tertentu agar sesuai dengan kebutuhan bisnis

Kami juga menggambarkan langkah-langkah dasar untuk membuat stored procedure, membuat pengguna dan menetapkan hak istimewa, dan bagaimana untuk menyebutnya dalam PHP.

Artikel ini tidak mencakup secara penuh mengenai Stored Procedures. Beberapa aspek penting seperti parameter input/output, pernyataan kontrol, kursor, sintaks lengkap, dll tidak dibahas dalam artikel singkat ini.

Jika Anda merasa tertarik, silakan tinggalkan komentar Anda di sini dan kami akan senang untuk membawa lebih banyak artikel mendalam tentang aspek yang berguna dan kuat ini dari MySQL.

http://www.sitepoint.com/stored-procedures-mysql-php/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+PHPMaster_feed+%28PHPMaster%29

Membuat Kontrol Hak Akses di PHP Berdasarkan Peran Pengguna

Ada beberapa pendekatan yang berbeda untuk mengelola hak akses pengguna, dan masing-masing memiliki sisi positif dan negatif sendiri. Misalnya, menggunakan bit masking sangat efisien tetapi juga membatasi Anda dengan izin  32 atau 64 (jumlah bit dalam 32 atau 64 bit integer). Pendekatan lain adalah dengan menggunakan Access Control List (ACL), namun Anda hanya bisa memberikan izin tersebut pada objek bukan pada operasi tertentu.

Pada artikel ini saya akan membahas pendekatan favorit pribadi saya: akses kontrol berbasis peran (RBAC). RBAC adalah model di mana peran diciptakan untuk berbagai fungsi pekerjaan, dan izin untuk melakukan operasi tertentu kemudian diikat dengan peran. Seorang pengguna dapat diberikan satu atau beberapa peran yang membatasi akses mereka ke sistem hak akses dimana mereka telah diizinkan.

Kelemahan menggunakan RBAC adalah bahwa jika tidak dikelola dengan baik, peran dan hak akses dapat dengan mudah menjadi kekacauan. Dalam lingkungan bisnis yang berubah dengan cepat, itu bisa menjadi pekerjaan sendiri untuk melacak menempatkan peran yang tepat untuk karyawan baru dan menghapus mereka pada waktu yang tepat dari mantan karyawan atau mereka yang berganti posisi. Selain itu, mengidentifikasi peran baru untuk tugas pekerjaan yang unik dan merevisi atau menghapus peran tertentu memerlukan tinjauan rutin. Kegagalan  mengelola peran dapat membuka pintu ke banyak risiko keamanan.

Saya akan mulai dengan membahas tabel database yang diperlukan, maka saya akan membuat dua file kelas: (Role.php) yang akan melakukan beberapa tugas khusus untuk peran, dan (PrivilegedUser.php) yang akan memperluas kelas pengguna yang ada. Akhirnya saya akan berjalan melalui beberapa contoh bagaimana Anda dapat mengintegrasikan kodenya ke dalam aplikasi Anda. manajemen peran  dan manajemen pengguna berjalan beriringan, sehingga dalam artikel ini saya akan berasumsi bahwa Anda sudah memiliki beberapa jenis sistem otentikasi pengguna.

Database

Anda perlu empat tabel untuk menyimpan informasi peran dan izin : tabel roles menyimpan ID peran dan nama peran, tabel permissions menyimpan ID izin dan deskripsi, tabel role_perm menghubungkan izin mana saja yang dimasukkan ke peran tertentu, dan tabel  user_role menghubungkan peran mana saja yang ditugaskan ke seorang pengguna.

Menggunakan skema ini, Anda dapat memiliki jumlah yang tidak terbatas peran dan hak akses dan setiap pengguna dapat diberikan peran ganda.

Ini adalah pernyataan CREATE TABLE untuk databasenya:

CREATE TABLE roles (
  role_id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  role_name VARCHAR(50) NOT NULL,

  PRIMARY KEY (role_id)
);

CREATE TABLE permissions (
  perm_id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  perm_desc VARCHAR(50) NOT NULL,

  PRIMARY KEY (perm_id)
);

CREATE TABLE role_perm (
  role_id INTEGER UNSIGNED NOT NULL,
  perm_id INTEGER UNSIGNED NOT NULL,

  FOREIGN KEY (role_id) REFERENCES roles(role_id),
  FOREIGN KEY (perm_id) REFERENCES permissions(perm_id)
);

CREATE TABLE user_role (
  user_id INTEGER UNSIGNED NOT NULL,
  role_id INTEGER UNSIGNED NOT NULL,

  FOREIGN KEY (user_id) REFERENCES users(user_id),
  FOREIGN KEY (role_id) REFERENCES roles(role_id)
);

Catatan akhir tabel, user_role, referensi tabel pengguna yang belum saya definisikan di sini. Ini mengasumsikan bahwa user_id adalah kunci utama dari tabel pengguna Anda.

Anda tidak perlu membuat modifikasi pada tabel pengguna Anda untuk menyimpan informasi peran sebagai informasi yang disimpan secara terpisah dalam tabel baru ini. Bertentangan dengan beberapa sistem RBAC lain, pengguna di sini tidak diperlukan untuk memiliki peran secara default, melainkan, pengguna hanya tidak akan memiliki hak istimewa sampai peran telah secara khusus ditugaskan. Atau, akan ada kemungkinan di kelas PrivilegedUser untuk mendeteksi peran kosong dan merespon dengan peran unprivileged default ketika diperlukan, atau Anda bisa memilih untuk menulis naskah SQL singkat untuk menyalin ID pengguna dan menginisialisasi mereka dengan menetapkan peran unprivileged default.

Kelas Role

Fokus utama dari kelas Role adalah untuk mengembalikan objek peran yang diisi dengan masing-masing peran hak akses yang sesuai. Ini akan memungkinkan Anda untuk dengan mudah memeriksa apakah izin tersebut tersedia tanpa harus melakukan query SQL berlebihan dengan setiap permintaan.

Gunakan kode berikut untuk membuat Role.php:

<?php
class Role
{
    protected $permissions;

    protected function __construct() {
        $this->permissions = array();
    }

    // return a role object with associated permissions
    public static function getRolePerms($role_id) {
        $role = new Role();
        $sql = "SELECT t2.perm_desc FROM role_perm as t1
                JOIN permissions as t2 ON t1.perm_id = t2.perm_id
                WHERE t1.role_id = :role_id";
        $sth = $GLOBALS["DB"]->prepare($sql);
        $sth->execute(array(":role_id" => $role_id));

        while($row = $sth->fetch(PDO::FETCH_ASSOC)) {
            $role->permissions[$row["perm_desc"]] = true;
        }
        return $role;
    }

    // check if a permission is set
    public function hasPerm($permission) {
        return isset($this->permissions[$permission]);
    }
}

Metode getRolePerms() membuat objek Peran baru berdasarkan ID peran tertentu, dan kemudian menggunakan klausa JOIN untuk menggabungkan role_perm dan perm_desc tabel. Untuk setiap izin yang terkait dengan peran yang diberikan, deskripsi disimpan sebagai kunci dan nilainya diatur ke true. metode hasPerm ()  menerima keterangan izin dan mengembalikan nilai berdasarkan objek saat ini.

Kelas Privileged User

Dengan menciptakan kelas baru yang pemperluas/extend kelas pengguna yang ada, Anda dapat menggunakan kembali kode logika yang ada untuk mengelola pengguna dan kemudian menambahkan beberapa metode tambahan di atas yang diarahkan secara khusus supaya bekerja dengan hak istimewa.

Gunakan kode berikut untuk membuat file PrivilegedUser.php:

<?php
class PrivilegedUser extends User
{
    private $roles;

    public function __construct() {
        parent::__construct();
    }

    // override User method
    public static function getByUsername($username) {
        $sql = "SELECT * FROM users WHERE username = :username";
        $sth = $GLOBALS["DB"]->prepare($sql);
        $sth->execute(array(":username" => $username));
        $result = $sth->fetchAll();

        if (!empty($result)) {
            $privUser = new PrivilegedUser();
            $privUser->user_id = $result[0]["user_id"];
            $privUser->username = $username;
            $privUser->password = $result[0]["password"];
            $privUser->email_addr = $result[0]["email_addr"];
            $privUser->initRoles();
            return $privUser;
        } else {
            return false;
        }
    }

    // populate roles with their associated permissions
    protected function initRoles() {
        $this->roles = array();
        $sql = "SELECT t1.role_id, t2.role_name FROM user_role as t1
                JOIN roles as t2 ON t1.role_id = t2.role_id
                WHERE t1.user_id = :user_id";
        $sth = $GLOBALS["DB"]->prepare($sql);
        $sth->execute(array(":user_id" => $this->user_id));

        while($row = $sth->fetch(PDO::FETCH_ASSOC)) {
            $this->roles[$row["role_name"]] = Role::getRolePerms($row["role_id"]);
        }
    }

    // check if user has a specific privilege
    public function hasPrivilege($perm) {
        foreach ($this->roles as $role) {
            if ($role->hasPerm($perm)) {
                return true;
            }
        }
        return false;
    }
}

Metode pertama, getByUsername (), mengembalikan sebuah objek yang terisi dengan informasi tentang pengguna tertentu. Sebuah metode yang hampir sama dengan ini kemungkinan sudah ada di kelas pengguna Anda, tetapi Anda perlu menimpanya di sini sehingga metode-metode yang ada pada PrivilegedUser bisa dipanggil dengan objek yang sesuai. Jika Anda mencoba untuk memanggil metode dari PrivilegedUser pada objek pengguna, Anda akan mendapatkan kesalahan yang menyatakan bahwa metode ini tidak ada.

Metode kedua, initRoles (), menggunakan JOIN untuk menggabungkan user_role dan role  untuk mengumpulkan peran yang terkait dengan ID pengguna saat ini. Setiap peran kemudian diisi dengan izin yang sesuai dengan panggilan ke metode pada kelas Role yang dibuat sebelumnya, Role :: getRolePerms ().

Metode terakhir, hasPrivilege (), menerima penjelasan izin dan mengembalikan nilai true dari pengguna yang memiliki izin atau false jika sebaliknya.

Dengan dua kelas sebelumnya, memeriksa apakah pengguna memiliki hak istimewa tertentu menjadi sederhana seperti berikut:

<?php
require_once "Role.php";
require_once "PrivilegedUser.php";

// connect to database...
// ...

session_start();

if (isset($_SESSION["loggedin"])) {
    $u = PrivilegedUser::getByUsername($_SESSION["loggedin"]);
}

if ($u->hasPrivilege("thisPermission")) {
    // do something
}

Username berikut disimpan dalam session yang aktif dan objek PrivilegedUser baru dibuat untuk pengguna itu yang mana metode hasPrivilege() dapat dipanggil. Tergantung pada informasi dalam database Anda, keluaran objek Anda akan terlihat mirip dengan berikut ini:

object(PrivilegedUser)#3 (2) {

  ["roles":"PrivilegedUser":private]=>
  array(1) {
    ["Admin"]=>
    object(Role)#5 (1) {
      ["permissions":protected]=>
      array(4) {
        ["addUser"]=>bool(true)
        ["editUser"]=>bool(true)
        ["deleteUser"]=>bool(true)
        ["editRoles"]=>bool(true)
      }
    }
  }
  ["fields":"User":private]=>
  array(4) {
    ["user_id"]=>string(1) "2"
    ["username"]=>string(7) "mpsinas"
    ["password"]=>bool(false)
    ["email_addr"]=>string(0) ""
  }
}

Menjaga Semua Terorganisir

Salah satu dari banyak manfaat menggunakan pendekatan OOP dengan RBAC adalah bahwa hal itu memungkinkan Anda untuk memisahkan kode logika dan validasi dari objek tugas tertentu. Misalnya, Anda dapat menambahkan metode berikut pada kelas Role Anda untuk membantu mengelola peran operasi tertentu seperti memasukkan peran baru, menghapus peran dan seterusnya:

// insert a new role
public static function insertRole($role_name) {
    $sql = "INSERT INTO roles (role_name) VALUES (:role_name)";
    $sth = $GLOBALS["DB"]->prepare($sql);
    return $sth->execute(array(":role_name" => $role_name));
}

// insert array of roles for specified user id
public static function insertUserRoles($user_id, $roles) {
    $sql = "INSERT INTO user_role (user_id, role_id) VALUES (:user_id, :role_id)";
    $sth = $GLOBALS["DB"]->prepare($sql);
    $sth->bindParam(":user_id", $user_id, PDO::PARAM_STR);
    $sth->bindParam(":role_id", $role_id, PDO::PARAM_INT);
    foreach ($roles as $role_id) {
        $sth->execute();
    }
    return true;
}

// delete array of roles, and all associations
public static function deleteRoles($roles) {
    $sql = "DELETE t1, t2, t3 FROM roles as t1
            JOIN user_role as t2 on t1.role_id = t2.role_id
            JOIN role_perm as t3 on t1.role_id = t3.role_id
            WHERE t1.role_id = :role_id";
    $sth = $GLOBALS["DB"]->prepare($sql);
    $sth->bindParam(":role_id", $role_id, PDO::PARAM_INT);
    foreach ($roles as $role_id) {
        $sth->execute();
    }
    return true;
}

// delete ALL roles for specified user id
public static function deleteUserRoles($user_id) {
    $sql = "DELETE FROM user_role WHERE user_id = :user_id";
    $sth = $GLOBALS["DB"]->prepare($sql);
    return $sth->execute(array(":user_id" => $user_id));
}

Demikian juga, Anda bisa menambahkan pada kelas PrivilegedUser dengan metode yang serupa:

// check if a user has a specific role
public function hasRole($role_name) {
    return isset($this->roles[$role_name]);
}

// insert a new role permission association
public static function insertPerm($role_id, $perm_id) {
    $sql = "INSERT INTO role_perm (role_id, perm_id) VALUES (:role_id, :perm_id)";
    $sth = $GLOBALS["DB"]->prepare($sql);
    return $sth->execute(array(":role_id" => $role_id, ":perm_id" => $perm_id));
}

// delete ALL role permissions
public static function deletePerms() {
    $sql = "TRUNCATE role_perm";
    $sth = $GLOBALS["DB"]->prepare($sql);
    return $sth->execute();
}

Karena izin terikat langsung ke kode program yang mendasari logika aplikasi, izin baru harus dimasukkan secara manual atau dihapus dari database sesuai kebutuhan. Peran di sisi lain dapat dengan mudah dibuat, diubah atau dihapus melalui antarmuka administrasi.

Semakin banyak peran dan izin yang kamu miliki akan lebih sulit untuk dikelola, menjaga daftar tersebut seminimal mungkin adalah penting, tapi kadang-kadang hal yang sebaliknya tidak dapat dihindari. Saya hanya dapat menyarankan bahwa Anda menggunakan penilaian terbaik Anda dan mencoba untuk tidak terbawa arus.

Ringkasan

Anda sekarang memiliki pemahaman tentang akses kontrol  berbasis peran dan bagaimana menerapkan peran dan hak akses ke aplikasi yang sudah ada. Selain itu, Anda telah belajar beberapa tips untuk membantu mengelola peran Anda dan untuk menjaga hal-hal terorganisir dengan baik. Seperti biasa, saya mendorong Anda untuk bereksperimen dan bertanya jika Anda terjebak. Kami semua di sini untuk belajar dari satu sama lain dan saya senang untuk membantu ketika saya bisa!

translated from http://www.sitepoint.com/role-based-access-control-in-php/