Otomatisasi STB HG680-P Menjadi Mini Server Linux dengan Ansible

Sebelumnya kita juga sudah membuat instalasi dari awal sampai dengan selesai pada SetTopBox (STB) HG680-P dengan menggunakan metode Bash Script, sehingga proses instalasi dan konfigurasi dapat dilakukan secara otomatis dalam satu tahap. Dalam penerapannya, terdapat beberapa layanan pada STB HG680-P, seperti Docker, CasaOS, dan Portainer dan sebagainya. Selain itu ada juga beberapa perangkat yang berguna untuk monitoring seperti Prometheus, Node Exporter, cAdvisor, dan Grafana untuk membantu memantau kondisi serta penggunaan sumber daya server.

Lantas pada artikel ini, kita akan membahas bagaimana jika proses instalasi dan konfigurasi tersebut tidak hanya diterapkan pada satu perangkat saja, tetapi juga dapat diterapkan pada beberapa perangkat secara bersamaan. Untuk mengatasi hal tersebut, proses otomatisasi dapat dikembangkan menggunakan Ansible. Dengan Ansible, proses instalasi dan konfigurasi tidak perlu dilakukan secara berulang pada setiap STB, karena proses tersebut dapat dijalankan dari satu mesin pengendali menuju perangkat target melalui jaringan. Dengan proses ini juga, mulai dari instalasi, konfigurasi layanan, serta penerapan pengaturan pada perangkat dapat dilakukan secara lebih terstruktur, 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 menyesuaikan informasi tersebut dengan konfigurasi perangkat agar tidak terjadi kesalahan. Informasi jaringan dan identitas asli perangkat tidak ditampilkan untuk menjaga keamanan konfigurasi.

Mengotomatisasi Deployment dengan Ansible

Pada bagian Ansible, jika Bash Script dimanfaatkan untuk mempercepat proses instalasi dan konfigurasi pada satu perangkat STB, bagaimana jika melibatkan beberapa perangkat? Pendekatan tersebut dapat dikembangkan dengan menggunakan Ansible. Berbeda dengan Bash yang dijalankan secara langsung pada perangkat, Ansible memungkinkan proses konfigurasi dilakukan dari satu mesin pengendali ke sejumlah perangkat target melalui jaringan. Dengan cara ini, pekerjaan yang sebelumnya harus dilakukan secara berulang dapat dijalankan dengan lebih teratur, konsisten, dan efisien.

Pada implementasi ini, konfigurasi Ansible disimpan dalam direktori:

~/ansible

Struktur sederhananya adalah:

ansible/
├── inventory.ini
└── install.yml

Dalam konfigurasi Ansible, terdapat dua file utama yang digunakan seperti pada struktur di atas. File inventory.ini berfungsi sebagai daftar perangkat yang menjadi sasaran pengelolaan, termasuk informasi host yang akan dikonfigurasi. Sementara itu, install.yml berisi rangkaian tugas yang menentukan proses instalasi serta pengaturan layanan pada perangkat target.

Menentukan Target pada Inventory Ansible

Pertama, konfigurasi Ansible diawali dengan membuat file inventory.ini yang digunakan untuk menentukan perangkat yang menjadi target pengelolaan. Untuk menjaga keamanan dokumentasi, alamat IP yang digunakan pada konfigurasi asli tidak ditampilkan dan diganti dengan alamat IP contoh. Berikut contoh konfigurasi inventory.ini:

[targets]

stb-server ansible_host=192.168.10.100 ansible_user=user

Keterangan:

• targets merupakan nama grup host yang digunakan oleh Ansible.
• stb-server merupakan nama host yang digunakan sebagai identitas perangkat target.
• ansible_host berisi alamat IP perangkat yang akan dikonfigurasi.
• ansible_user berisi username Linux yang digunakan Ansible untuk terhubung ke perangkat target.

Dengan konfigurasi tersebut, Ansible dapat mengetahui perangkat yang menjadi target dan menggunakan informasi koneksi yang telah ditentukan untuk menjalankan proses konfigurasi.

Membuat Playbook Ansible

Kedua, setelah inventory dibuat, konfigurasi utama disimpan dalam install.yml.

Playbook berikut mengotomatisasi instalasi Docker, CasaOS, Portainer, serta komponen monitoring.

---
- name: STB Automation
  hosts: targets
  become: true

  vars_prompt:
    - name: monitoring_password
      prompt: "Enter monitoring password"
      private: true

  tasks:

    - name: Update APT cache
      apt:
        update_cache: true
        cache_valid_time: 3600

    - name: Install required packages
      apt:
        name:
          - ca-certificates
          - curl
          - gnupg
          - python3
          - python3-bcrypt
        state: present

    - name: Create Docker keyring directory
      file:
        path: /etc/apt/keyrings
        state: directory
        mode: '0755'

    - name: Add Docker GPG key
      get_url:
        url: https://download.docker.com/linux/ubuntu/gpg
        dest: /etc/apt/keyrings/docker.asc
        mode: '0644'

    - name: Add Docker repository
      apt_repository:
        repo: >
          deb [arch={{
          ansible_architecture |
          replace('x86_64', 'amd64') |
          replace('aarch64', 'arm64')
          }}
          signed-by=/etc/apt/keyrings/docker.asc]
          https://download.docker.com/linux/ubuntu
          {{ ansible_distribution_release }} stable
        filename: docker
        state: present

    - name: Install Docker
      apt:
        name:
          - docker-ce
          - docker-ce-cli
          - containerd.io
          - docker-buildx-plugin
          - docker-compose-plugin
        state: present
        update_cache: true

    - name: Enable Docker
      service:
        name: docker
        state: started
        enabled: true

    - name: Check CasaOS
      stat:
        path: /usr/bin/casaos
      register: casaos_binary

    - name: Install CasaOS
      shell: curl -fsSL https://get.casaos.io | bash
      when: not casaos_binary.stat.exists

    - name: Create Portainer directory
      file:
        path: /opt/portainer
        state: directory
        mode: '0755'

    - name: Create Portainer compose file
      copy:
        dest: /opt/portainer/docker-compose.yml
        mode: '0644'
        content: |
          services:
            portainer:
              image: portainer/portainer-ce:lts
              container_name: portainer
              restart: unless-stopped
              ports:
                - "9443:9443"
                - "8000:8000"
              volumes:
                - /var/run/docker.sock:/var/run/docker.sock
                - ./portainer_data:/data

    - name: Start Portainer
      command:
        cmd: docker compose up -d
        chdir: /opt/portainer

    - name: Generate Prometheus bcrypt password
      shell: |
        python3 -c "import bcrypt, os; print(
        bcrypt.hashpw(
        os.environ['PASSWORD'].encode(),
        bcrypt.gensalt()
        ).decode())"
      environment:
        PASSWORD: "{{ monitoring_password }}"
      register: prometheus_password_hash
      changed_when: false
      no_log: true

    - name: Create monitoring directory
      file:
        path: /opt/monitoring
        state: directory
        mode: '0755'

    - name: Create Prometheus data directory
      file:
        path: /opt/monitoring/monitoring-data/prometheus_data
        state: directory
        owner: '65534'
        group: '65534'
        mode: '0755'

    - name: Create Prometheus config
      copy:
        dest: /opt/monitoring/prometheus.yml
        mode: '0644'
        content: |
          global:
            scrape_interval: 15s

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

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

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

    - name: Create Prometheus web config
      copy:
        dest: /opt/monitoring/web-config.yml
        mode: '0644'
        content: |
          basic_auth_users:
            monitor: "{{ prometheus_password_hash.stdout }}"

    - name: Create Grafana provisioning directory
      file:
        path: /opt/monitoring/grafana/provisioning/datasources
        state: directory
        mode: '0755'

    - name: Create Grafana datasource
      copy:
        dest: /opt/monitoring/grafana/provisioning/datasources/prometheus.yml
        mode: '0644'
        content: |
          apiVersion: 1
          datasources:
            - name: Prometheus
              type: prometheus
              access: proxy
              url: http://prometheus:9090
              basicAuth: true
              basicAuthUser: monitor
              basicAuthPassword: "{{ monitoring_password }}"
              isDefault: true

    - name: Create monitoring compose file
      copy:
        dest: /opt/monitoring/docker-compose.yml
        mode: '0644'
        content: |
          services:
            cadvisor:
              image: gcr.io/cadvisor/cadvisor:v0.47.1
              container_name: cadvisor
              restart: unless-stopped
              ports:
                - "8080:8080"
              volumes:
                - /:/rootfs:ro
                - /var/run:/var/run:ro
                - /sys:/sys:ro
                - /var/lib/docker:/var/lib/docker:ro

            node-exporter:
              image: prom/node-exporter:v1.7.0
              container_name: node-exporter
              restart: unless-stopped
              ports:
                - "9100:9100"

            prometheus:
              image: prom/prometheus:v3.0.0
              container_name: prometheus
              restart: unless-stopped
              ports:
                - "9090:9090"

            grafana:
              image: grafana/grafana:11.5.0
              container_name: grafana
              restart: unless-stopped
              ports:
                - "3000:3000"
              environment:
                GF_SECURITY_ADMIN_USER: monitor
                GF_SECURITY_ADMIN_PASSWORD: "{{ monitoring_password }}"
              volumes:
                - ./grafana/provisioning:/etc/grafana/provisioning
                - grafana_data:/var/lib/grafana

          volumes:
            grafana_data:

    - name: Start Monitoring
      command:
        cmd: docker compose up -d
        chdir: /opt/monitoring

Pada playbook tersebut, password monitoring diminta ketika playbook dijalankan:

vars_prompt:
  - name: monitoring_password
    prompt: "Enter monitoring password"
    private: true

Dengan private: true, password tidak ditampilkan ketika diketik.

Password kemudian digunakan untuk menghasilkan bcrypt melalui task:

- name: Generate Prometheus bcrypt password
  shell: |
    python3 -c "import bcrypt, os; print(
    bcrypt.hashpw(
    os.environ['PASSWORD'].encode(),
    bcrypt.gensalt()
    ).decode())"
  environment:
    PASSWORD: "{{ monitoring_password }}"
  register: prometheus_password_hash
  changed_when: false
  no_log: true

Opsi no_log: true digunakan untuk menjaga kerahasiaan data dengan menyembunyikan informasi yang bersifat sensitif dari keluaran Ansible selama proses playbook dijalankan.

Menjalankan Ansible

Ketiga, setelah inventory.ini dan install.yml selesai dibuat, koneksi ke STB dapat diuji terlebih dahulu:

ansible targets -i inventory.ini -m ping

Jika koneksi berhasil, maka Ansible akan memberikan respons:

stb-server | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Setelah koneksi dipastikan berhasil, playbook dapat dijalankan:

ansible-playbook -i inventory.ini install.yml

Ansible kemudian menjalankan seluruh task secara berurutan, mulai dari pembaruan repository, instalasi Docker, instalasi CasaOS, pembuatan container Portainer, hingga konfigurasi monitoring. Pada akhir proses, Ansible menampilkan bagian PLAY RECAP.

Contoh hasil yang menunjukkan proses berhasil:

PLAY RECAP

stb-server : ok=21 changed=3 unreachable=0 failed=0 skipped=1

Nilai failed=0 menunjukkan tidak terdapat task yang gagal.

Gambar di atas menunjukkan hasil eksekusi playbook Ansible yang telah dibuat. Berdasarkan hasil tersebut, seluruh proses berjalan dengan baik dan setiap layanan menunjukkan status UP.

Memastikan Service Berjalan

Langkah terakhir, setelah proses otomatisasi selesai, kondisi container dapat diperiksa langsung pada STB menggunakan:

docker ps

Container yang digunakan dalam implementasi antara lain:

portainer
monitoring-cadvisor
monitoring-node-exporter
monitoring-prometheus
monitoring-grafana

Jika seluruh container berada dalam status Up, maka komponen utama server telah berhasil dijalankan.

Selanjutnya layanan dapat diperiksa melalui browser:

Pada tahap ini, STB telah berubah dari perangkat multimedia menjadi mini server Linux yang mampu menjalankan berbagai layanan secara terintegrasi.

Hasil Akhir Implementasi

Implementasi ini menghasilkan beberapa komponen yang saling melengkapi.

• Docker digunakan sebagai platform container untuk menjalankan aplikasi server.
• CasaOS menyediakan antarmuka sederhana untuk mengelola perangkat dan aplikasi.
• Portainer digunakan untuk mengelola container Docker melalui antarmuka web.
• Prometheus bertugas mengumpulkan dan menyimpan metric.
• Node Exporter menyediakan metric sistem STB.
• cAdvisor menyediakan metric container.
• Grafana digunakan untuk memvisualisasikan metric dalam dashboard.

Sementara itu, Bash dan Ansible digunakan untuk mengotomatisasi proses instalasi sehingga konfigurasi tidak perlu dilakukan sepenuhnya secara manual.

Kesimpulan

STB HG680P berhasil dimanfaatkan kembali menjadi mini server Linux menggunakan Armbian. Transformasi ini memungkinkan perangkat yang awalnya digunakan sebagai perangkat multimedia menjalankan berbagai layanan server.

Docker digunakan untuk menjalankan aplikasi dalam container, sedangkan Prometheus, Node Exporter, cAdvisor, dan Grafana digunakan untuk membangun sistem monitoring. CasaOS dan Portainer juga membantu dalam pengelolaan server dan container.

Untuk mendukung proses automation, Bash Script digunakan untuk menyederhanakan instalasi pada perangkat, sementara Ansible digunakan untuk mengatur konfigurasi secara lebih terstruktur. Dengan demikian, STB HG680P dapat menjadi platform berbiaya rendah untuk menerapkan dan mempelajari Linux server, Docker, monitoring, dan automation.