Cara Menginstal Hadoop di Ubuntu

Pengantar

Hadoop merupakan salah satu framework yang banyak digunakan untuk mengolah dan menyimpan data dalam jumlah besar. Hadoop dirancang untuk menjalankan proses pemrosesan data secara terdistribusi sehingga pekerjaan yang sebelumnya membutuhkan satu server dengan sumber daya besar dapat dibagi ke beberapa komputer atau server.

Hadoop banyak digunakan dalam kebutuhan Big Data, analisis data, data engineering, hingga pengembangan sistem pemrosesan data terdistribusi. Salah satu kelebihannya adalah Hadoop dapat berjalan pada server Linux dan mendukung pengelolaan data berukuran besar menggunakan beberapa komponen yang saling terintegrasi.

Bagi yang ingin belajar Hadoop, Ubuntu dapat menjadi pilihan yang cukup praktis karena proses instalasi paket, Java, SSH, dan konfigurasi sistem relatif mudah dilakukan.

Pada tutorial ini, kita akan membahas cara menginstal Hadoop di Ubuntu menggunakan mode Pseudo-Distributed, yaitu Hadoop berjalan pada satu server tetapi komponen Hadoop tetap dikonfigurasi secara terpisah seperti pada lingkungan terdistribusi.

Tutorial ini cocok untuk kebutuhan belajar, pengujian, dan memahami dasar administrasi Hadoop sebelum diterapkan pada cluster yang terdiri dari beberapa server.

Persiapan Instalasi Hadoop di Ubuntu

Spesifikasi minimum yang disarankan untuk lingkungan belajar:

Ubuntu Server 22.04 atau 24.04.
Minimal 2 GB RAM.
Minimal 20 GB ruang penyimpanan.
User dengan akses sudo.
Koneksi internet.
Java.
SSH Server.

Pada tutorial ini, Hadoop akan dikonfigurasi menggunakan satu server.

Instalasi dan Konfigurasi Hadoop

Update Sistem Ubuntu
- Perbarui repository dan paket Ubuntu:
```
sudo apt update && sudo apt upgrade -y
```
- Periksa versi Ubuntu:
```
lsb_release -a
```
- Pastikan sistem dapat berjalan dengan normal sebelum melanjutkan.
Instal Java
Hadoop membutuhkan Java untuk menjalankan berbagai komponennya. Pada tutorial ini digunakan OpenJDK 11.
- Install OpenJDK 11:
```
sudo apt install openjdk-11-jdk -y
```
- Periksa versi Java:
```
java -version
```
  Contoh output:
```
openjdk version "11.x.x"
```
- Periksa lokasi Java:
```
readlink -f $(which java)
```
  Pada Ubuntu 24.04, lokasi Java yang digunakan pada tutorial ini adalah:
```
/usr/lib/jvm/java-11-openjdk-amd64/bin/java
```
- Lokasi tersebut nantinya digunakan sebagai nilai JAVA_HOME.
Membuat User Hadoop
Sebaiknya Hadoop dijalankan menggunakan user khusus agar tidak menggunakan user root.
- Buat user hadoop:
```
sudo adduser hadoop
```
  Masukkan password ketika diminta.
- Tambahkan user hadoop ke grup sudo:
```
sudo usermod -aG sudo hadoop
```
- Masuk sebagai user hadoop:
```
su - hadoop
```
- Periksa user yang sedang digunakan:
```
whoami
```
  Output:
```
hadoop
```
Konfigurasi SSH
Hadoop membutuhkan SSH untuk komunikasi antarproses. Walaupun tutorial ini menggunakan satu server, SSH tetap perlu dikonfigurasi agar script Hadoop dapat menjalankan proses pada server.
- Install OpenSSH Server dan Client:
```
sudo apt install openssh-server openssh-client -y
```
- Aktifkan service SSH:
```
sudo systemctl enable --now ssh
```
- Buat SSH key sebagai user hadoop:
```
ssh-keygen -t rsa -P ""
```
  Tekan Enter sampai proses pembuatan key selesai.
- Tambahkan public key ke authorized_keys:
```
cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
```
- Atur permission SSH:
```
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
chmod 600 ~/.ssh/id_rsa
chmod 644 ~/.ssh/id_rsa.pub
```
- Pastikan ownership file SSH sesuai dengan user hadoop:
```
chown -R hadoop:hadoop ~/.ssh
```
- Uji koneksi SSH ke server sendiri:
```
ssh localhost
```
  Jika berhasil masuk tanpa meminta password, konfigurasi SSH sudah berjalan dengan baik.
- Keluar dari koneksi SSH:
```
exit
```
Download dan Instal Hadoop
Pada tutorial ini digunakan Hadoop 3.4.1.
- Download paket Hadoop:
```
wget https://downloads.apache.org/hadoop/common/hadoop-3.4.1/hadoop-3.4.1.tar.gz
```
- Ekstrak file:
```
tar -xzf hadoop-3.4.1.tar.gz
```
- Pindahkan Hadoop ke direktori /usr/local:
```
sudo mv hadoop-3.4.1 /usr/local/hadoop
```
- Atur ownership direktori Hadoop:
```
sudo chown -R hadoop:hadoop /usr/local/hadoop
```
- Periksa isi direktori:
```
ls -lah /usr/local/hadoop
```
- Jika berhasil, akan terdapat direktori seperti:
```
bin
etc
include
lib
libexec
sbin
share
```
- Periksa versi Hadoop:
```
hadoop version
```
- Jika instalasi berhasil, versi Hadoop akan ditampilkan, misalnya:
```
Hadoop 3.4.1
```

Mengatur Environment Variable
Atur environment variable Java dan Hadoop pada user hadoop.

Edit file .bashrc:
```
nano ~/.bashrc
```

Tambahkan konfigurasi:

export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
export HADOOP_HOME=/usr/local/hadoop
export HADOOP_HDFS_HOME=$HADOOP_HOME
export HADOOP_MAPRED_HOME=$HADOOP_HOME
export YARN_HOME=$HADOOP_HOME
export HADOOP_COMMON_HOME=$HADOOP_HOME
export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin

Terapkan konfigurasi:
```
source ~/.bashrc
```

Periksa JAVA_HOME:

echo $JAVA_HOME

Output:

/usr/lib/jvm/java-11-openjdk-amd64

Periksa HADOOP_HOME:
```
echo $HADOOP_HOME
```
Output:
```
/usr/local/hadoop
```

Mengatur Java untuk Hadoop
- Edit file konfigurasi environment Hadoop:
```
nano /usr/local/hadoop/etc/hadoop/hadoop-env.sh
```
- Cari konfigurasi:
```
export JAVA_HOME=
```
- Ubah menjadi:
```
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
```
- Konfigurasi ini memastikan Hadoop menggunakan Java yang sudah diinstal pada server.
Konfigurasi core-site.xml
File core-site.xml digunakan untuk menentukan konfigurasi dasar Hadoop, termasuk alamat filesystem utama HDFS.
- Edit file:
```
nano /usr/local/hadoop/etc/hadoop/core-site.xml
```
- Isi dengan:
```
    
        fs.defaultFS
        hdfs://localhost:9000
    
```
- Pada konfigurasi ini, HDFS menggunakan localhost dengan port 9000.

Konfigurasi hdfs-site.xml
File hdfs-site.xml digunakan untuk menentukan konfigurasi HDFS, termasuk jumlah replikasi dan lokasi penyimpanan NameNode serta DataNode.

Edit file:

nano /usr/local/hadoop/etc/hadoop/hdfs-site.xml

Isi dengan:


    
        dfs.replication
        1
    

    
        dfs.namenode.name.dir
        file:///usr/local/hadoop/data/namenode
    

    
        dfs.datanode.data.dir
        file:///usr/local/hadoop/data/datanode

Buat direktori NameNode dan DataNode:

mkdir -p /usr/local/hadoop/data/namenode
mkdir -p /usr/local/hadoop/data/datanode

Pastikan ownership direktori Hadoop sesuai:

sudo chown -R hadoop:hadoop /usr/local/hadoop

Nilai dfs.replication menggunakan 1 karena tutorial ini menggunakan satu DataNode.

Konfigurasi MapReduce
Pada Hadoop 3.4.1 yang digunakan dalam tutorial ini, file mapred-site.xml.template tidak tersedia sehingga file mapred-site.xml dibuat secara manual.

Buat file:

nano /usr/local/hadoop/etc/hadoop/mapred-site.xml

Isi dengan:

    
        mapreduce.framework.name
        yarn
    

    
        mapreduce.application.classpath
        $HADOOP_MAPRED_HOME/share/hadoop/mapreduce/*:$HADOOP_MAPRED_HOME/share/hadoop/mapreduce/lib/*
    

    
        yarn.app.mapreduce.am.env
        HADOOP_MAPRED_HOME=/usr/local/hadoop
    

    
        mapreduce.map.env
        HADOOP_MAPRED_HOME=/usr/local/hadoop
    

    
        mapreduce.reduce.env
        HADOOP_MAPRED_HOME=/usr/local/hadoop

Konfigurasi HADOOP_MAPRED_HOME diperlukan agar komponen MapReduce yang dijalankan melalui YARN dapat menemukan library Hadoop MapReduce.

Tanpa konfigurasi tersebut, proses MapReduce dapat mengalami error seperti:

Could not find or load main class
org.apache.hadoop.mapreduce.v2.app.MRAppMaster

Konfigurasi YARN
YARN digunakan untuk mengelola resource dan menjalankan pekerjaan MapReduce.
- Edit file:
```
nano /usr/local/hadoop/etc/hadoop/yarn-site.xml
```
- Isi dengan:
```
    
        yarn.nodemanager.aux-services
        mapreduce_shuffle
    
```
- Dengan konfigurasi tersebut, YARN dapat digunakan sebagai resource manager untuk menjalankan pekerjaan MapReduce.
Format NameNode
Sebelum HDFS digunakan, NameNode harus diformat terlebih dahulu.
- Jalankan:
```
hdfs namenode -format
```
- Jika berhasil, Hadoop akan membuat metadata awal NameNode.
Peringatan:
Jangan menjalankan perintah hdfs namenode -format kembali pada cluster yang sudah digunakan dan memiliki data penting karena proses tersebut dapat membuat metadata HDFS sebelumnya tidak dapat digunakan.
Menjalankan HDFS
- Jalankan HDFS:
```
start-dfs.sh
```
- Periksa proses Hadoop:
```
jps
```
- Pada konfigurasi single-node, akan muncul proses seperti:
```
NameNode
DataNode
SecondaryNameNode
Jps
```
- Periksa status DataNode:
```
hdfs dfsadmin -report
```
- Pastikan terdapat:
```
Live datanodes (1)
```
- Jika DataNode terdeteksi, HDFS sudah berjalan dengan baik.
Menjalankan YARN
- Jalankan YARN:
```
start-yarn.sh
```
- Periksa kembali proses Hadoop:
```
jps
```
- Pada kondisi normal akan terlihat:
```
NameNode
DataNode
SecondaryNameNode
ResourceManager
NodeManager
Jps
```
- ResourceManager merupakan komponen utama YARN untuk mengelola resource cluster, sedangkan NodeManager menjalankan container pada node.

Menguji HDFS

Menguji Penyimpanan File pada HDFS
Setelah HDFS dan YARN berjalan, lakukan pengujian penyimpanan file menggunakan HDFS.
- Periksa isi root HDFS:
```
hdfs dfs -ls /
```
- Buat direktori pengujian:
```
hdfs dfs -mkdir /data
```
- Periksa kembali isi root HDFS:
```
hdfs dfs -ls /
```
- Buat file sederhana pada server:
```
echo "Belajar Hadoop di Ubuntu 24.04" > test.txt
```
- Upload file ke HDFS:
```
hdfs dfs -put test.txt /data/
```
- Periksa file yang sudah di-upload:
```
hdfs dfs -ls /data
```
- Baca isi file dari HDFS:
```
hdfs dfs -cat /data/test.txt
```
- Jika output menampilkan:
```
Belajar Hadoop di Ubuntu 24.04
```
  berarti HDFS sudah berhasil digunakan untuk menyimpan dan membaca data.

Menguji MapReduce dengan WordCount

Menguji MapReduce dengan WordCount
Selain HDFS, pengujian juga perlu dilakukan pada MapReduce untuk memastikan Hadoop dapat menjalankan pekerjaan melalui YARN.
- Buat direktori input pada HDFS:
```
hdfs dfs -mkdir -p /input
```
- Buat dua file contoh:
```
echo "hadoop ubuntu hdfs" > file1.txt
echo "hadoop yarn mapreduce" > file2.txt
```
- Upload kedua file ke HDFS:
```
hdfs dfs -put file1.txt /input/
hdfs dfs -put file2.txt /input/
```
- Periksa file input:
```
hdfs dfs -ls /input
```
- Jalankan contoh WordCount dari Hadoop:
```
hadoop jar /usr/local/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.4.1.jar wordcount /input /output
```
- Jika berhasil, proses akan menunjukkan progres Map dan Reduce, misalnya:
```
map 100% reduce 0%
map 100% reduce 100%
```
- Pada akhir proses akan muncul pesan seperti:
```
Job ... completed successfully
```
- Periksa direktori hasil:
```
hdfs dfs -ls /output
```
  Biasanya akan terdapat:
```
/output/_SUCCESS
/output/part-r-00000
```
- Baca hasil WordCount:
```
hdfs dfs -cat /output/part-r-00000
```
- Hasilnya kurang lebih:
```
hadoop  2
hdfs  1
mapreduce  1
ubuntu  1
yarn  1
```
- Jika hasil tersebut muncul, berarti Hadoop berhasil menjalankan pekerjaan MapReduce melalui YARN dan menyimpan hasilnya ke HDFS.

Mengakses Dashboard Hadoop

Mengakses Web UI Hadoop
Hadoop menyediakan Web UI untuk memantau kondisi HDFS dan YARN.
- Dashboard NameNode
  
  Dashboard NameNode dapat diakses melalui:
```
http://IP-SERVER:9870
```
  Ganti IP-SERVER dengan alamat IP server Ubuntu.
  
  Dashboard ini digunakan untuk melihat informasi seperti:
  - Status NameNode.
  - DataNode.
  - Kapasitas HDFS.
  - Penggunaan storage.
  - Filesystem HDFS.
  - Informasi cluster.
  Catatan:
  Pada konfigurasi pseudo-distributed sederhana seperti tutorial ini, Web UI NameNode tidak menyediakan halaman login bawaan. Halaman tersebut berfungsi sebagai dashboard monitoring dan administrasi.
- Dashboard ResourceManager
  
  Dashboard YARN ResourceManager dapat diakses melalui:
```
http://IP-SERVER:8088
```
  Dashboard ini digunakan untuk melihat:
  - Aplikasi YARN.
  - Pekerjaan MapReduce.
  - NodeManager.
  - Penggunaan resource.
  - Scheduler.
  - Status aplikasi.
  Setelah menjalankan pengujian WordCount, aplikasi dengan tipe berikut akan terlihat pada halaman Applications ResourceManager:
```
MAPREDUCE
```
  Status aplikasi yang berhasil akan menjadi:
```
FINISHED
```
- Mengizinkan Akses Web UI melalui UFW
  
  Jika menggunakan UFW dan dashboard perlu diakses dari jaringan tertentu, port dapat diizinkan:
```
sudo ufw allow 9870/tcp
sudo ufw allow 8088/tcp
```
  Peringatan:
  Untuk server produksi, sebaiknya dashboard Hadoop tidak dibuka bebas ke internet. Gunakan firewall, VPN, reverse proxy dengan autentikasi, atau pembatasan jaringan sesuai kebutuhan.

Menghentikan Hadoop

Menghentikan Hadoop
Jika Hadoop sudah tidak digunakan, hentikan YARN terlebih dahulu.
- Hentikan YARN:
```
stop-yarn.sh
```
- Kemudian hentikan HDFS:
```
stop-dfs.sh
```
- Periksa kembali proses Hadoop:
```
jps
```
- Proses Hadoop seperti berikut seharusnya sudah tidak berjalan:
```
NameNode
DataNode
SecondaryNameNode
ResourceManager
NodeManager
```

Tips dan Catatan Penting

Hal yang Perlu Diperhatikan

Gunakan Pseudo-Distributed untuk belajar dan pengujian, bukan cluster produksi.
Jangan menjalankan hdfs namenode -format pada cluster yang sudah memiliki data penting.
Gunakan dfs.replication = 1 karena tutorial hanya menggunakan satu DataNode.
Pastikan SSH tanpa password dengan ssh localhost.
Pastikan ownership Hadoop sesuai dengan user hadoop:
```
sudo chown -R hadoop:hadoop /usr/local/hadoop
```
Peringatan NativeCodeLoader bukan berarti Hadoop gagal berjalan.
Batasi akses Web UI port 9870 dan 8088 pada server produksi.
Uji HDFS dan WordCount setelah konfigurasi selesai.

Kesimpulan

Instalasi Hadoop di Ubuntu dilakukan dengan menyiapkan Java, user Hadoop, SSH, serta konfigurasi HDFS, MapReduce, dan YARN.

Pada mode Pseudo-Distributed, seluruh komponen Hadoop berjalan pada satu server dengan proses seperti NameNode, DataNode, ResourceManager, dan NodeManager.

Setelah konfigurasi selesai, HDFS dapat diuji dengan menyimpan dan membaca file, sedangkan MapReduce dapat diuji menggunakan WordCount.

Web UI NameNode pada port 9870 digunakan untuk memantau HDFS, sedangkan ResourceManager pada port 8088 digunakan untuk memantau aplikasi dan resource YARN.