Vecchio RaspberryPi, Nuova HomeLab!

Per Natale vorrei regalarmi un nuovo RaspberryPi
E' iniziata così questa esperienza. La voglia di metter su una HomeLab con un nuovo RaspberryPi 5, tanto c'è Natale, quale miglior occasione per regalarselo e cestinare il vecchio RaspberryPi 3?
E invece no. Il RaspberryPi 3 non si butta. Il RaspberryPi 3 può ancora regalare delle soddisfazioni. Il RaspberryPi 3 mi ha convinto nuovamente e costruirò la mia nuova HomeLab su misura per lui.
In fondo, a Natale, siamo tutti più buoni, no?

Iniziamo
Per prima cosa, dobbiamo assicurarci di poterci collegare al nostro RaspberryPi.
Generiamo quindi una chiave ssh:

ssh-keygen -t rsa -b 2048

e copiamola dentro al RaspberryPi:

ssh-copy-id user@raspberry_pi_ip_address

Automatizziamo tutto con Ansible
Ora, vogliamo veramente installare tutto il software a mano sul nostro RaspberryPi? Oppure vogliamo pensare di automatizzare questo processo il più possibile? Ecco, io ho optato per la seconda opzione, ed ho scelto Ansible come strumento per risolvere questo problema.
Nel mio caso, per installare Ansible sul mio Macbook, ho semplicemente eseguito questo comando:

brew install ansible

Progettiamo la nostra Infrastruttura
Sicuramente la parte più "succosa" di tutto questo percorso è la creazione dell'infrastruttura.
Per prima cosa, dobbiamo creare il file inventory.ini dove indicare le "coordinate" per raggiungere il nostro RaspberryPi:

[raspberry_pi]
raspberrypi ansible_host=raspberrypi_host ansible_user=user ansible_become=true

Ora, possiamo concentrarci sulla creazione dei vari "playbooks", questi sono quelli individuati per iniziare:

• update: aggiornamento dei pacchetti
• install-docker
• install-dockge

Playbook "update": aggiornamento dei pacchetti
Questo playbook (file: playbooks/update.yml) consente di tenere sempre aggiornato il nostro RaspberryPi.

---
- name: Update Raspberry Pi
  hosts: raspberry_pi
  gather_facts: true
  tasks:
    - name: Update the package cache
      apt:
        update_cache: true
        cache_valid_time: 3600

    - name: Upgrade all packages to the latest version
      apt:
        upgrade: dist
        autoclean: true
        autoremove: true

    - name: Check if a reboot is required
      stat:
        path: /var/run/reboot-required
      register: reboot_required

    - name: Reboot the system if a reboot is required
      reboot:
        msg: "Rebooting the system to complete the update"
        connect_timeout: 5
      when: reboot_required.stat.exists

E può essere lanciato tramite il comando:

ansible-playbook -i inventory.ini playbooks/update.yml

In questi casi, però, preferisco sempre creare un Makefile in modo da poter lanciare tutti i comandi in maniera più semplice.
In questo caso:

make update

(il comando make senza argomenti restituisce la lista di tutti i comandi disponibili, e dal mio punto di vista è davvero molto utile).

Playbook "install-docker": aggiornamento di docker
Sicuramente docker è un elemento imprescindibile nella mia HomeLab.
Il playbook playbooks/install-docker.yml consente di installare docker nel nostro RaspberryPi.

---
- name: Install Docker on Raspberry Pi
  hosts: raspberry_pi
  become: true
  vars_files:
    - vars/main.yml
  tasks:
    - name: Install prerequisites for APT
      apt:
        name:
          - apt-transport-https
          - ca-certificates
          - curl
          - software-properties-common
        state: present
        update_cache: true

    - name: Add Docker's GPG key
      ansible.builtin.shell: |
        set -o pipefail
        mkdir -p /etc/apt/keyrings
        curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
      args:
        executable: /bin/bash
        creates: /etc/apt/keyrings/docker.gpg  # Run only if the key file doesn't already exist

    - name: Add Docker's repository
      ansible.builtin.apt_repository:
        repo: "deb [arch=armhf signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian {{ ansible_distribution_release }} stable"
        state: present

    - name: Update APT cache
      apt:
        update_cache: true

    - name: Install Docker
      apt:
        name: docker-ce
        state: present

    - name: Start and enable Docker service
      systemd:
        name: docker
        enabled: true
        state: started

    - name: Add docker user user to the Docker group (optional)
      ansible.builtin.user:
        name: "{{ docker_user }}"
        groups: docker
        append: true
        state: present

    - name: Check Docker version
      ansible.builtin.shell: |
        set -o pipefail
        docker --version
      args:
        executable: /bin/bash
      register: docker_version
      changed_when: false

    - name: Display the installed Docker version
      ansible.builtin.debug:
        msg: "{{ docker_version.stdout }}"

Nel playbook viene utilizzata la variabile docker_user, che va definita nel file playbooks/vars/main.yml:

docker_user: pi

Playbook "install-dockge": aggiornamento di dockge
Per orchestrare i container utilizzeremo il software dockge.
Il playbook playbooks/install-dockge.yml consente di installare docker nel nostro RaspberryPi.

---
- name: Install Dockge using Docker Compose
  hosts: raspberry_pi
  become: true

  tasks:
    - name: Ensure the required directories exist
      file:
        path: "{{ item }}"
        state: directory
        owner: root
        group: root
        mode: '0755'
      loop:
        - /opt/stacks
        - /opt/dockge

    - name: Download compose.yaml for Dockge
      get_url:
        url: "https://dockge.kuma.pet/compose.yaml?port=5001&stacksPath=%2Fopt%2Fstacks"
        dest: /opt/dockge/compose.yaml
        owner: root
        group: root
        mode: '0644'

    - name: Start Dockge using Docker Compose
      community.docker.docker_compose_v2:
        project_src: /opt/dockge
        state: present
      register: output

It Works!
Per accedere alla console di dockge, basta collegarsi all'indirizzo:

http://<raspberrypi-host>:5001

La prima volta, occorre creare un'utenza di ammnistratore.
Questo il risultato:

Proviamo a creare uno stack di prova
Proviamo ora a creare uno stack con nginx:

Il servizio nginx ora è attivo sulla porta 9080 del nostro RaspberryPi, se proviamo ad aprire la pagina possiamo vedere che funziona:

Conclusioni
Questo vuole essere solo un punto di partenza per la mia HomeLab.
Durante questo percorso ho imparato che a volte l'obsolescenza è solo nella nostra testa, perchè semplicemente vogliamo qualcosa di nuovo. Parliamo molto spesso di valore, ma quando ci troviamo di fronte a delle scelte, a volte scegliamo di "buttar via" anzichè sfruttare bene ciò che si ha. E questo non vale solo per il software purtroppo.
Altra cosa che ho imparato, e che considero molto importante: la "DevOps" culture è anche nelle piccole cose, e spesso la pigrizia è un nemico duro da sconfiggere, perchè applica una resistenza molto forte al cambiamento. Sperimentare per migliorarsi, applicare e sbagliare per costruire: un "mantra" che mi piace applicare, e che voglio continuare a fare mio anche nei prossimi anni.

Se volete dare un'occhiata al mio repository della infra, questo è il link.