Transformasi STB HG680-P Menjadi Mini Server Linux dengan Bash Script

Sebelumnya kita juga sudah membuat instalasi dari awal sampai dengan selesai pada SetTopBox (STB) HG680-P, tetapi dilakukan secara manual dengan menginstal tahap demi tahap. Pada kali ini kita akan membahas bagaimana jika semua yang sudah dilakukan tersebut dapat diinstal hanya dengan satu tahap saja.

Dalam penerapannya, kita ketahui bahwa terdapat beberapa layanan pada STB HG680-P, seperti Docker, CasaOS, dan Portainer. Selain itu, terdapat juga perangkat lunak yang berguna untuk monitoring seperti Prometheus, Node Exporter, cAdvisor, dan Grafana untuk membantu memantau kondisi serta penggunaan sumber daya server.

Pada artikel ini, kita akan membuat cara untuk mempermudah proses instalasi dan konfigurasi sehingga pekerjaan yang sebelumnya dilakukan secara bertahap dapat dilakukan menjadi satu tahap yang lebih teratur dan efisien. Tahapan tersebut dibuat lebih terstruktur melalui Bash Script. Dengan proses ini, mulai dari instalasi, konfigurasi layanan, serta penerapan pengaturan pada perangkat dapat dilakukan secara lebih konsisten dan efisien.

Catatan: Pada artikel ini alamat IP, hostname maupun username yang dicantumkan merupakan contoh yang digunakan untuk kebutuhan dokumentasi saja. Jika diterapkan pada STB masing-masing, pastikan untuk menyesuaikan informasi tersebut agar tidak terjadi kesalahan. Informasi jaringan dan identitas asli perangkat tidak ditampilkan untuk menjaga keamanan konfigurasi.

Mempersiapkan STB HG680-P sebagai Server

Langkah pertama yang dilakukan adalah memastikan STB HG680-P telah menggunakan sistem operasi berbasis Linux. Pada implementasi ini, sistem operasi yang digunakan adalah Armbian.

Pastikan sistem operasi Armbian sudah terinstal sebelum melakukan langkah ini. Setelah Armbian berhasil melakukan proses booting pada STB, koneksi jaringan dapat diperiksa menggunakan perintah berikut:

ip a

Perintah tersebut berfungsi untuk melihat jaringan dan alamat IP yang diperoleh STB setelah melakukan instalasi sistem operasi Armbian.

Sebagai contoh, perangkat dapat memiliki alamat IP:

192.168.10.100

Alamat IP tersebut akan digunakan untuk mengakses beberapa layanan yang disebutkan di atas melalui browser. Setelah koneksi jaringan dipastikan berjalan, proses instalasi dapat dilanjutkan.

Mengotomatisasi Instalasi dengan Bash

Langkah kedua adalah mengotomatisasi instalasi beberapa layanan yang sebelumnya dilakukan secara manual dengan menjalankan banyak perintah secara bertahap. Cara tersebut cukup merepotkan apabila proses yang sama perlu diterapkan kembali pada perangkat lain.

Maka dari itu, untuk mengatasi hal tersebut, kita akan membuat sebuah Bash Script bernama install.sh.

Script ini menangani beberapa proses sekaligus, yaitu:

• pemeriksaan sistem;
• instalasi Docker;
• instalasi Docker Compose;
• instalasi CasaOS;
• instalasi Portainer;
• pembuatan konfigurasi monitoring;
• pembuatan password bcrypt untuk autentikasi Prometheus;
• menjalankan seluruh container monitoring.

File install.sh yang digunakan dalam implementasi ini adalah sebagai berikut:

#!/bin/bash

set -e

# Monitoring credentials
MONITORING_USER="admin"

read -rsp "Enter monitoring password: " MONITORING_PASSWORD
echo

if [ -z "$MONITORING_PASSWORD" ]; then
    echo "Monitoring password cannot be empty."
    exit 1
fi

export MONITORING_PASSWORD

generate_monitoring_hash() {
    echo
    echo "[CHECK] Preparing bcrypt for monitoring authentication..."

    if ! python3 -c "import bcrypt" >/dev/null 2>&1; then
        echo "Python bcrypt module is not installed."
        echo "Installing python3-bcrypt..."
        apt-get update
        apt-get install -y python3-bcrypt
    fi

    MONITORING_PASSWORD_HASH=$(python3 -c \
    'import bcrypt, os; print(bcrypt.hashpw(
    os.environ["MONITORING_PASSWORD"].encode(),
    bcrypt.gensalt()).decode())')

    export MONITORING_PASSWORD_HASH

    echo "Monitoring bcrypt hash generated successfully."
}

echo "=========================================="
echo " STB Automation Installer"
echo "=========================================="

check_system() {
    echo
    echo "[CHECK] Checking system..."

    if [ "$EUID" -ne 0 ]; then
        echo "Please run this script with sudo."
        exit 1
    fi

    . /etc/os-release

    echo "User         : $(whoami)"
    echo "Hostname     : $(hostname)"
    echo "OS           : $PRETTY_NAME"
    echo "Architecture : $(dpkg --print-architecture)"

    if [ "$ID" != "ubuntu" ]; then
        echo "Warning: This script is designed for Ubuntu/Armbian based on Ubuntu."
    fi

    echo
    echo "System check completed."
}

install_docker() {
    echo
    echo "[1/4] Installing Docker..."

    if command -v docker >/dev/null 2>&1 &&
       docker compose version >/dev/null 2>&1; then

        echo "Docker and Docker Compose are already installed."
        systemctl enable --now docker

        docker --version
        docker compose version
        return
    fi

    echo "Docker is not installed. Installing Docker..."

    apt-get update
    apt-get install -y ca-certificates curl

    install -m 0755 -d /etc/apt/keyrings

    curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
        -o /etc/apt/keyrings/docker.asc

    chmod a+r /etc/apt/keyrings/docker.asc

    . /etc/os-release

    cat > /etc/apt/sources.list.d/docker.sources <<DOCKER_REPO
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: ${VERSION_CODENAME}
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
DOCKER_REPO

    apt-get update

    apt-get install -y \
        docker-ce \
        docker-ce-cli \
        containerd.io \
        docker-buildx-plugin \
        docker-compose-plugin

    systemctl enable --now docker

    echo
    echo "Docker installation completed."

    docker --version
    docker compose version
}

install_casaos() {
    echo
    echo "[2/4] Installing CasaOS..."

    if systemctl is-active --quiet casaos; then
        echo "CasaOS is already installed and running."
        systemctl status casaos --no-pager
        return
    fi

    if [ -x /usr/bin/casaos ]; then
        echo "CasaOS binary already exists."
        echo "Starting CasaOS services..."
        systemctl enable --now casaos
        return
    fi

    echo "CasaOS is not installed."
    echo "Installing CasaOS using the official installer..."

    if ! command -v curl >/dev/null 2>&1; then
        echo "curl is not installed. Installing curl..."
        apt-get update
        apt-get install -y curl
    fi

    curl -fsSL https://get.casaos.io | bash

    echo
    echo "CasaOS installation completed."
    systemctl status casaos --no-pager
}

install_portainer() {
    echo
    echo "[3/4] Installing Portainer..."

    if docker ps --format '{{.Names}}' |
       grep -qx "portainer"; then

        echo "Portainer is already running."
        docker ps --filter "name=^portainer$"
        return
    fi

    echo "Preparing Portainer directory..."

    mkdir -p /opt/portainer/portainer_data

    cat > /opt/portainer/docker-compose.yml <<'COMPOSE'
services:
  portainer:
    container_name: portainer
    image: portainer/portainer-ce:lts
    restart: always
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./portainer_data:/data
    ports:
      - "9443:9443"
      - "8000:8000"

networks:
  default:
    name: portainer_network
COMPOSE

    echo "Starting Portainer..."

    cd /opt/portainer
    docker compose up -d

    echo
    echo "Portainer installation completed."

    docker ps --filter "name=^portainer$"
}

install_monitoring() {
    echo
    echo "[4/4] Installing Monitoring..."

    mkdir -p /opt/monitoring/monitoring-data/config
    mkdir -p /opt/monitoring/monitoring-data/prometheus_data
    mkdir -p /opt/monitoring/monitoring-data/grafana_data

    cat > /opt/monitoring/docker-compose.yml <<'COMPOSE'
services:
  cadvisor:
    container_name: monitoring-cadvisor
    image: gcr.io/cadvisor/cadvisor:v0.47.1
    restart: always
    devices:
      - "/dev/kmsg:/dev/kmsg"
    volumes:
      - "/:/rootfs:ro"
      - "/sys:/sys:ro"
      - "/sys/fs/cgroup:/sys/fs/cgroup:ro"
      - "/var/lib/docker:/var/lib/docker:ro"
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
      - "/dev/disk:/dev/disk:ro"
    privileged: true
    ports:
      - "8080:8080"

  node-exporter:
    container_name: monitoring-node-exporter
    image: prom/node-exporter:v1.7.0
    restart: always
    command:
      - "--path.rootfs=/host"
    volumes:
      - "/:/host:ro"
    ports:
      - "9100:9100"

  prometheus:
    container_name: monitoring-prometheus
    image: prom/prometheus:v3.0.0
    user: root
    restart: always
    volumes:
      - "./monitoring-data/config/prometheus.yml:/etc/prometheus/prometheus.yml"
      - "./monitoring-data/config/web-config.yml:/etc/prometheus/web-config.yml"
      - "./monitoring-data/prometheus_data:/prometheus"
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--storage.tsdb.path=/prometheus"
      - "--storage.tsdb.retention.time=3d"
      - "--web.config.file=/etc/prometheus/web-config.yml"
    ports:
      - "9090:9090"
    depends_on:
      - cadvisor
      - node-exporter

  grafana:
    container_name: monitoring-grafana
    image: grafana/grafana:11.5.0
    user: root
    restart: always
    volumes:
      - "./monitoring-data/config/datasources.yml:/etc/grafana/provisioning/datasources/datasources.yml"
      - "./monitoring-data/grafana_data:/var/lib/grafana"
    ports:
      - "3000:3000"
    depends_on:
      - prometheus
COMPOSE

    cat > /opt/monitoring/monitoring-data/config/prometheus.yml <<PROMETHEUS
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets:
          - localhost:9090
    basic_auth:
      username: ${MONITORING_USER}
      password: ${MONITORING_PASSWORD}

  - job_name: "cadvisor"
    static_configs:
      - targets:
          - cadvisor:8080

  - job_name: "VM-STB"
    static_configs:
      - targets:
          - node-exporter:9100
PROMETHEUS

    cat > /opt/monitoring/monitoring-data/config/web-config.yml <<WEBCONFIG
basic_auth_users:
  ${MONITORING_USER}: "${MONITORING_PASSWORD_HASH}"
WEBCONFIG

    cat > /opt/monitoring/monitoring-data/config/datasources.yml <<DATASOURCE
apiVersion: 1

datasources:
  - name: prometheus
    type: prometheus
    url: http://prometheus:9090
    access: proxy
    isDefault: true
    basicAuth: true
    basicAuthUser: ${MONITORING_USER}
    secureJsonData:
      basicAuthPassword: "${MONITORING_PASSWORD}"
DATASOURCE

    echo "Starting monitoring services..."

    cd /opt/monitoring
    docker compose up -d

    echo
    echo "Monitoring installation completed."

    docker ps --filter "name=monitoring-"
}

check_system
install_docker
install_casaos
install_portainer
generate_monitoring_hash
install_monitoring

echo
echo "=========================================="
echo " Installation process completed."
echo "=========================================="

Di atas tersebut adalah bagian yang menunjukkan isi Bash Script yang telah dibuat dengan tujuan agar proses instalasi dan konfigurasi dapat dilakukan hanya dalam satu tahap.

Ketika script dijalankan di terminal, berbagai kebutuhan yang diperlukan pada STB seperti Docker dan layanan lainnya akan dipasang atau dikonfigurasi secara otomatis sehingga prosesnya tidak perlu dilakukan dalam banyak tahap atau secara manual.

Untuk menjaga keamanan konfigurasi, informasi yang bersifat sensitif seperti password, alamat IP, dan data jaringan asli tidak ditampilkan dalam dokumentasi ini. Password yang digunakan untuk layanan monitoring juga tidak disimpan secara langsung di dalam script, melainkan diminta secara interaktif ketika proses eksekusi berlangsung.

Untuk menjalankan script tersebut, gunakan perintah berikut:

sudo bash install.sh

Dengan metode ini, informasi password tetap berada di luar file script sehingga tidak tercantum secara langsung pada kode yang digunakan. Dalam proses autentikasi Prometheus, script memanfaatkan bcrypt untuk melakukan proses hashing terhadap password. Nilai hash yang diperoleh kemudian digunakan oleh sistem sebagai bagian dari mekanisme autentikasi dan tidak perlu dicantumkan dalam dokumentasi.

Menjalankan Docker pada STB

Setelah seluruh proses pada STB selesai, tahap pertama adalah menyiapkan Docker pada STB. Docker berfungsi sebagai platform untuk menjalankan dan mengelola aplikasi di dalam container.

Untuk memasangnya, script terlebih dahulu mengatur repository Docker sebagai sumber paket instalasi. Selanjutnya, komponen yang dibutuhkan, meliputi Docker Engine, Docker CLI, Containerd, Buildx, dan Docker Compose Plugin, akan dipasang secara otomatis.

Setelah instalasi berhasil, layanan Docker diatur agar dapat aktif secara otomatis setiap kali STB dinyalakan.

Status instalasi Docker dapat diperiksa menggunakan perintah:

docker --version
docker compose version

Kemudian container yang sedang berjalan dapat diperiksa dengan:

docker ps

Jika Docker berhasil dipasang, maka perintah tersebut akan menampilkan container yang telah dijalankan oleh script.

Mengelola Server dengan CasaOS

Setelah proses Docker selesai, selanjutnya adalah tahapan memasang CasaOS melalui script yang telah dibuat.

CasaOS berfungsi sebagai antarmuka berbasis web yang memudahkan proses pengelolaan server Linux tanpa harus selalu menggunakan terminal. Sementara itu, Portainer lebih ditujukan untuk pengelolaan lingkungan dan container Docker.

Dengan adanya CasaOS, pengelolaan perangkat serta aplikasi yang berjalan pada STB dapat dilakukan melalui tampilan web yang lebih sederhana dan mudah digunakan.

CasaOS dipasang menggunakan installer resminya dengan perintah:

curl -fsSL https://get.casaos.io | bash

Setelah proses instalasi selesai, CasaOS dapat dibuka melalui browser menggunakan alamat IP STB:

http://IP-STB

Jika instalasi berhasil, halaman CasaOS akan menampilkan dashboard server.

Mengelola Container dengan Portainer

Selain CasaOS, Portainer juga digunakan sebagai pengelola container Docker. Script membuat direktori:

/opt/portainer

Kemudian file docker-compose.yml dibuat secara otomatis. Container Portainer menggunakan image:

portainer/portainer-ce:lts

Port yang digunakan adalah:

9443
8000

Setelah container dijalankan, Portainer dapat diakses melalui:

https://IP-STB:9443

Portainer menyediakan antarmuka untuk melihat container, image, volume, network, dan resource Docker.

Dengan demikian, pengelolaan Docker pada STB tidak hanya dilakukan melalui terminal, tetapi juga dapat dilakukan melalui antarmuka web.

Menambahkan Sistem Monitoring

Setelah seluruh proses instalasi berbagai layanan utama pada STB disiapkan, proses selanjutnya adalah memasang sistem monitoring.

Sistem ini berfungsi untuk memantau kondisi perangkat sekaligus aktivitas container yang sedang berjalan. Pada implementasi ini, pemantauan server dibangun menggunakan empat komponen utama, yaitu:

• Node Exporter untuk menyediakan metric sistem;
• cAdvisor untuk menyediakan metric container;
• Prometheus untuk mengumpulkan dan menyimpan metric;
• Grafana untuk menampilkan metric dalam bentuk dashboard.

Keempat komponen tersebut dijalankan menggunakan Docker Compose.

Node Exporter menggunakan port:

9100

cAdvisor menggunakan port:

8080

Prometheus menggunakan port:

9090

Sedangkan Grafana menggunakan port:

3000

Memeriksa Prometheus

Pertama, Prometheus berfungsi sebagai pusat pengumpulan metric dari Node Exporter dan cAdvisor. Konfigurasi yang dibuat oleh script mendefinisikan beberapa target.

Berikut merupakan bagian konfigurasi scrape_configs yang digunakan:

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets:
          - localhost:9090

  - job_name: "cadvisor"
    static_configs:
      - targets:
          - cadvisor:8080

  - job_name: "STB"
    static_configs:
      - targets:
          - node-exporter:9100

Setelah service monitoring berjalan, Prometheus dapat dibuka melalui:

http://IP-STB:9090

Pada menu Status → Target, target monitoring dapat diperiksa.

Jika konfigurasi berhasil, maka target seperti cAdvisor dan STB akan menunjukkan status UP. Hal ini membuktikan bahwa Prometheus berhasil terhubung dengan sumber metric yang telah dikonfigurasi.

Menampilkan Monitoring dengan Grafana

Kedua, Grafana digunakan untuk menampilkan metric yang dikumpulkan oleh Prometheus dalam bentuk dashboard. Grafana dapat dikatakan sebagai visualisasi monitoring sehingga informasi seperti penggunaan CPU, memory, storage, dan aktivitas container dapat dipantau dengan lebih mudah.

Grafana menggunakan port:

3000

Sehingga dapat diakses melalui:

http://IP-STB:3000

Konfigurasi datasource Grafana dibuat otomatis oleh script. Berikut bagian konfigurasi datasource yang digunakan:

apiVersion: 1

datasources:
  - name: prometheus
    type: prometheus
    url: http://prometheus:9090
    access: proxy
    isDefault: true
    basicAuth: true
    basicAuthUser: ${MONITORING_USER}
    secureJsonData:
      basicAuthPassword: "${MONITORING_PASSWORD}"

Dengan konfigurasi di atas, Grafana secara otomatis menggunakan Prometheus sebagai datasource.

Dengan selesainya tahapan tersebut, STB sudah dilengkapi dengan sistem monitoring yang memungkinkan kondisi server serta container yang sedang berjalan dipantau melalui tampilan visual.

Kesimpulan

Pada artikel ini, proses instalasi dan konfigurasi STB HG680-P sebagai mini server Linux telah dilakukan menggunakan Bash Script. Metode ini digunakan untuk mengurangi proses instalasi yang sebelumnya dilakukan secara manual dan bertahap menjadi lebih otomatis dan terstruktur.

Bash Script yang dibuat mampu membantu melakukan pemeriksaan sistem serta menginstal dan menjalankan beberapa layanan, seperti Docker, Docker Compose, CasaOS, Portainer, Prometheus, Node Exporter, cAdvisor, dan Grafana. Selain itu, script juga menangani pembuatan konfigurasi monitoring dan autentikasi Prometheus menggunakan bcrypt.

Dengan adanya otomatisasi tersebut, proses menyiapkan STB sebagai mini server menjadi lebih cepat, konsisten, dan mudah diterapkan kembali pada perangkat lain.

Metode Bash ini juga menjadi dasar untuk pengembangan otomatisasi yang lebih terstruktur menggunakan Ansible, yang akan dibahas pada artikel selanjutnya.