RedBlue’s Blog

Installazione di Docker e Nginx Proxy Manager su Proxmox

2026-05-08T08:55:19+00:00

Oggi parliamo di installazione di Docker su Proxmox, ma non solo, vedremo anche come usare Portainer e Nginx Proxy Manager! Let’s go!

Nel precedente post abbiamo visto la creazione di una VM per HA OS. La differenza tra una Virtual Machine e un Container è sostanziale: le VM emulano un intero sistema operativo, mentre i container condividono il kernel del sistema operativo host. Questo significa che i container sono molto più leggeri e efficienti in termini di risorse.

Installazione di Docker e Portainer

Per semplificare l’installazione di Docker e Portainer, ho utilizzato uno script che ho trovato in giro per il web, da Proxmox VE Scripts.

Basta copiare il comando e incollarlo nella shell del nostro server Proxmox. Lo script farà tutto il lavoro sporco per noi!

bash -c "$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/ct/docker.sh)"

Una volta terminata l’installazione, possiamo accedere a Portainer tramite browser, digitando l’indirizzo IP del nostro server Proxmox seguito dalla porta 9443 (es. https://indirizzo:9443).

Installazione di Nginx Proxy Manager

Nginx Proxy Manager è uno strumento fantastico per gestire i reverse proxy. Ci permette di esporre i nostri servizi in modo semplice e sicuro, gestendo certificati SSL e configurazioni complesse tramite un’interfaccia web intuitiva.

Anche in questo caso, ho utilizzato un altro script da Proxmox VE Scripts per semplificare l’installazione.

Dopo aver incollato il comando nella shell:

bash -c "$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/ct/nginxproxymanager.sh)"

Seguiamo le istruzioni a schermo. Una volta terminata l’installazione, possiamo accedere a Nginx Proxy Manager tramite browser, digitando l’indirizzo IP del nostro server Proxmox seguito dalla porta 81 (es. http://indirizzo:81).

Le credenziali di default sono admin@example.com e changeme. Ovviamente, vanno cambiate quanto prima!

Per la configurazione di Nginx Proxy Manager, la vedremo più avanti, dopo aver installato qualche altro servizio e avendo la necessità di esporre tutto su internet.

Stay tuned!

Installare Home Assistant OS su Proxmox

2026-05-02T07:19:27+00:00

Installare Home Assistant OS su Proxmox è davvero semplice. Questo breve tutorial è il seguito diretto del precedente post sull’installazione di Proxmox, vedremo come creare una VM con Home Assistant OS.

Download del necessario

Per prima cosa, scarichiamo, direttamente all’interno della nostra Proxmox, l’immagine giusta da qui: https://www.home-assistant.io/installation/alternative/, scegliendo l’opzione KVM/Proxmox. In realtà, dal terminale di Proxmox, basta lanciare un:

wget https://github.com/home-assistant/operating-system/releases/download/17.2/haos_ova-17.2.qcow2.xz

E poi, dopo che il file è stato scaricato:

unxz haos_ova-17.2.qcow2.xz

Ovviamente, il nome del file è quello attualmente scaricabile (al momento della scrittura di questo tutorial), adattatelo al vostro caso.

Configurazione della VM per Home Assistant

Colleghiamoci alla Proxmox (normalmente https://indirizzo:8006), click destro, Create VM, inseriamo nome e id (va bene quello proposto di default), poi nella scheda OS selezioniamo Do not use any media.

Nella scheda System, invece:

Machine: q35
BIOS: OVMF
EFI Storege: local-lvm
Pre-Enroll Keys NO (togliere il check)

Eliminiamo il disco proposto nella scheda Disks, mentre nella scheda CPU scegliamo 2 cores, e nella scheda Memory indichiamo 4 GB di RAM (valore 4096). Nella scheda Network lasciamo infine tutto com’è. Andiamo infine su Confirm e clicchiamo Finish, abbiamo la nostra VM!!

Ora viene il bello, in realtà il file che abbiamo scaricato prima non è altro che il disco che abbiamo eliminato in fase di creazione della VM, già pronto all’uso!

Quindi apriamo la shell della Proxmox (tasto dedicato in alto destra) e digitiamo:

qm importdisk <ID VM> <NOME FILE> <EFI>

Dove ID VM è l’id della VM appena creata, NOME FILE il nome del file scaricato, EFI è local-lvm nell’esempio fatto.

Abbiamo quasi terminato tranquilli!

Andiamo sulle impostazioni della VM (selezioniamo a sinistra), clicchiamo sulla scheda Hardware, andiamo su Unused Disk 0 (il file importato con qm al passo precedente), clicchiamo Edit in alto, nella scheda che si apre selezioniamo Discard se abbiamo un disco fisico SSD, e clicchiamo Add, poi, nella scheda Options della VM, in Boot order, selezioniamo solo il disco appena aggiunto (di solito vanno deselezionati l’avvio da CD/DVD e da rete, e abilitato quello di Scsi0).

Finito! Start in alto a destra, e nella console della VM apparirà l’indirizzo a cui connettersi ad Home Assistant!!

Il prossimo passo sarà installare Docker su Proxmox!

Stay tuned!

Proxmox: La mia svolta Open Source per la virtualizzazione

2026-04-29T05:49:47+00:00

Quante volte mi sono trovato a corto di risorse sul mio serverino casalingo? Troppe! Avevo bisogno di far girare più servizi, testare nuove configurazioni, ma senza rischiare di mandare all’aria tutto il sistema. La virtualizzazione è stata la risposta, e Proxmox, beh, Proxmox è stata la svolta. Non avevo alcuna intenzione di acquistare soluzioni commerciali, quindi cercavo un’alternativa solida e, soprattutto, open source. E devo dire, non mi sono pentito della scelta.

Proxmox: Un Mondo di Virtualizzazione Open Source

Proxmox Virtual Environment (VE) è una piattaforma di virtualizzazione open source basata su Debian. In parole povere, ti permette di creare e gestire macchine virtuali (VM) e container LXC su un singolo server fisico. Immagina di avere più computer, ognuno con il suo sistema operativo e le sue applicazioni, che girano tutti su un’unica macchina! Fantastico, no?

L’interfaccia web è intuitiva, anche per uno come me che non si definirebbe un guru dei server. Certo, all’inizio ho avuto qualche difficoltà, ma la community è super disponibile e la documentazione è ben fatta. E poi, diciamocelo, smanettare è parte del divertimento!

Installazione di Proxmox: La Mia Avventura (con qualche intoppo)

L’installazione di Proxmox è abbastanza semplice, ma ci sono alcuni passaggi cruciali che, se sbagliati, possono farti perdere un sacco di tempo. Ci sono passato anch’io, fidati!

Ecco i passaggi che ho seguito:

Download dell’immagine ISO: basta andare sul sito ufficiale di Proxmox e scaricare l’immagine ISO.
Creazione della chiavetta USB avviabile: ho usato Rufus (un programmino gratuito) per creare una chiavetta USB avviabile con l’immagine ISO scaricata.
Configurazione del BIOS: prima di avviare l’installazione, sono entrato nel BIOS del mio server e ho attivato la virtualizzazione (VT-x/AMD-V). Senza questo, Proxmox non può funzionare correttamente.
Installazione vera e propria: ho avviato il server dalla chiavetta USB e ho seguito le istruzioni a schermo. Semplice no?

Dopo aver impostato la password di root e l’indirizzo email (utile per le notifiche), sono passato alla configurazione della rete. Ho impostato un indirizzo IP statico per il mio server Proxmox, in modo da poterlo raggiungere sempre allo stesso indirizzo. Ho anche modificato il nome host in pve-server01.miodominio.interno.

L’installazione è andata a buon fine e, dopo il riavvio, ho potuto accedere all’interfaccia web di Proxmox tramite browser all’indirizzo https://indirizzo_ip:8006.

Repository di Proxmox: Aggiornamenti Senza (Troppi) Compromessi

Una volta entrato nell’interfaccia web, la prima cosa che ho notato è stato un avviso riguardante la sottoscrizione Enterprise. Proxmox offre una versione gratuita e una a pagamento. La versione gratuita ha tutte le funzionalità di base, ma non ha accesso ai repository di aggiornamenti Enterprise, che contengono gli aggiornamenti più recenti e stabili.

Questo significa che, senza una sottoscrizione, potresti non essere in grado di scaricare gli ultimi aggiornamenti di sicurezza.

Per fortuna, esiste una soluzione alternativa: utilizzare il repository “no-subscription”. Questo repository contiene gli aggiornamenti di sicurezza e alcuni aggiornamenti minori. Non è l’ideale, ma è meglio di niente.

Per abilitare il repository “no-subscription”, devi modificare il file /etc/apt/sources.list.d/proxmox.list e commentare (aggiungendo un # all’inizio della riga) i repository Enterprise e decommentare quelli no-subscription.

#deb https://enterprise.proxmox.com/debian/pve bookworm enterprise
deb http://download.proxmox.com/debian/pve bookworm pve-no-subscription

#deb https://enterprise.proxmox.com/debian/ceph-quincy bookworm enterprise
deb http://download.proxmox.com/debian/ceph-quincy bookworm no-subscription

Dopo aver modificato il file, devi aggiornare la lista dei pacchetti con il comando apt update e poi aggiornare il sistema con apt upgrade.

Proxmox vs VMware: La Scelta Giusta per Me

Proxmox offre le stesse funzionalità di base di VMware, come la creazione e la gestione di macchine virtuali e container, la migrazione live, lo storage condiviso e il clustering. E, cosa ancora più importante, è open source! Questo significa che posso personalizzarlo, modificarlo e utilizzarlo come voglio, senza dovermi preoccupare di licenze o costi nascosti.

Prossimi Passi: Virtualizzazione di Home Assistant e Container con Docker

Il mio prossimo obiettivo è quello di creare una macchina virtuale con Home Assistant e un paio di container con Docker per NextCloud e qualche progettino personale, e uno per Nginx Proxy Manager. Stay tuned per i prossimi articoli!

Alla prossima!

Aggiornamento workflow pubblicazione automatica su Github Pages

2025-11-05T00:00:00+00:00

Riprendo l’argomento relativo alla pubblicazione automatica su Github Pages, visto in precedenza, in quanto recentemente il processo era andato in crash e non riuscivo in alcun modo a ripristinarlo.

Cercando in rete, pare che il problema fosse la action che usavo, che presenta delle incompatibilità con la gestione dei certificati SSL delle versioni più recenti delle librerie relative appunto ad SSL.

Fortunatamente, Github fornisce una propria action (che ne mio caso è anche più veloce a deployare il sito), quindi è bastato riscrivere il file relativo al workflow:

name: Deploy Jekyll to gh-pages

on:
  schedule:
    - cron: '0 12 * * *'  # ogni giorno a mezzogiorno UTC
  push:
    branches: ["main"]
  workflow_dispatch:

permissions:
  contents: write   # serve per poter fare push su gh-pages
  pages: write
  id-token: write

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Setup Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.2'
          bundler-cache: true

      - name: Install dependencies
        run: bundle install

      - name: Build site with Jekyll
        run: bundle exec jekyll build

      - name: Add CNAME file
        run: echo "nomedominio.ext" > ./_site/CNAME # necessario se avete un custom domain!!

      - name: Deploy to gh-pages branch
        uses: peaceiris/actions-gh-pages@v4
        with:
          github_token: $
          publish_branch: gh-pages
          publish_dir: ./_site
          commit_message: "Deploy site via GitHub Actions"

Facile no? Lo script è estremamente simile al precedente, ed inoltre ho aggiunto qualche commento qua e là..

Stay tuned..

Domotizzare le luci di casa con Sonoff Mini R4 Extreme e Dual R3

2025-11-03T00:00:00+00:00

Nell’ambito del mio progetto di domotica casalinga, non potevano mancare le luci. Per questa parte, ho deciso di ricorrere a due dispositivi in particolare: il Sonoff Mini R4 Extreme e il Sonoff Dual R3.

Nel primo caso, il Sonoff Mini R4 Extreme è uno switch a due vie capace di pilotare tanto un interruttore, ossia il classico caso in cui abbiamo da accendere e spegnere una lampadina da un unico punto, quanto un deviatore, ovvero un dispositivo usato in tutti quei casi in cui abbiamo la possibilità di accendere una lampada da più punti.

Nel secondo caso invece, il Sonoff Dual R3 è un dispositivo che nasce per pilotare i motori tubolari delle tapparelle elettriche, in quanto permettono di controllare due fasi, quindi appunto salita e discesa, ma può tranquillamente essere usato per pilotare delle lampade collegate ad un relè, ovvero tutti quei casi in cui si hanno due lampadine collegate ad un unico pulsante, e per l’accensione/spegnimento abbiamo il classico ciclo: click 1 -> accende solo lampada 1, click 2 -> accende solo lampada 2, click 3 -> accende entrambe, click 4 -> spegne entrambe.

Con un Sonoff Dual R3 riusciamo ad assegnare una lampadina ad ognuno dei due canali, e quindi pilotarle entrambe con successo (ovviamente, il dispositivo va configurato opportunamente tramite l’apposita app per indicargli che sta gestendo delle luci e non un motore).

Il grande punto di forza di un Sonoff Mini R4 Extreme è invece la dimensione ridottissima, praticamente entra in ogni scatola, anche se già piuttosto “piena” (l’ho installato tranquillamente in una 503 standard piena di cavi, basta giocare un po’ e la si chiude tranquillamente).

Entrambi i dispositivi sono assolutamente integrabili con Alexa, che li riconosce al volo una volta terminata la configurazione iniziale, e possono quindi essere tranquillamente controllati anche con la voce. Ovviamente, in entrambi i casi si mantiene la possibilità di utilizzare il comando fisico preesistente, sarà il dispositivo smart a “riconoscere” il corretto stato delle lampade e ad adeguarsi di conseguenza.

NOTA A MARGINE: prima di scrivere questo articolo ho pensato a lungo a come impostarlo, e soprattutto se dargli un taglio più da recensione o più da guida (quindi dando spazio a delle descrizioni più tecniche e a vere e proprie guide d’installazione). Alla fine ho optato per la recensione, in quanto, pur nella loro estrema semplicità, si tratta di dispositivi che lavorano a 220 V, che quindi vanno trattati da chi sa quello che sta facendo, e senza improvvisare. Inoltre, per funzionare hanno bisogno di un’alimentazione, e quindi di una fase in ingresso e un neutro. Se nel punto in cui dobbiamo installare il nostro dispositivo manca ad esempio il neutro, questo andrà “tirato” prendendolo da qualche parte, andando quindi ad effettuare una (piccola) modifica all’impianto, il che presuppone, appunto, che si sappia cosa fare e si possegga un minimo di attrezzatura. Personalmente, ho quel minimo di background ed esperienza che mi consentono di fare questo genere di lavoretti tranquillamente e in sicurezza, ma in caso contrario va chiamato un elettricista.

Stay tuned..

Aggiornamento dello script relativo alla lavatrice smart

2025-08-10T00:00:00+00:00

In merito all’automazione di Home Assistant per ricevere una notifica tramite Alexa quando la lavatrice termina il lavaggio (qui la guida completa), c’è da fare un piccolo aggiornamento dello script, in quanto vari aggiornamenti di HA hanno leggermente modificato la situazione, e il vecchio script di fatto non funziona.

Adesso le automazione vanno tutte in automations.yaml, quindi il file all’interno della directory packages conterrà di fatto solo l’input_boolean:

########################################################
################INPUT_BOOLEAN############################
########################################################
input_boolean:
  lavatrice_switch:
    name: stato del lavaggio
    initial: off
    icon: mdi:washing-machine

Mentre in automations.yaml (potete anche scegliere di aggiungerle da interfaccia grafica di HA, cosa che ad esempio ho fatto io, per poi modificare quello che mi serviva):

id: '1731346166999'
  alias: Lavatrice fine switch state
  description: ''
  trigger:
  - entity_id: sensor.lavatrice_power
    platform: numeric_state
    below: '5.0'
    for:
      minutes: 1
  condition:
  - condition: state
    entity_id: input_boolean.lavatrice_switch
    state: 'on'
  action:
  - entity_id: input_boolean.lavatrice_switch
    action: input_boolean.turn_off
  mode: single
- id: '1731346431244'
  alias: Lavatrice Finito
  description: ''
  triggers:
  - entity_id: input_boolean.lavatrice_switch
    to: 'off'
    trigger: state
  conditions: []
  actions:
  - action: notify.alexa_media
    metadata: {}
    data:
      message: La lavatrice ha terminato il lavaggio. Ricordati di stendere il bucato
      target: media_player.nome_disposivo_alexa
      data:
        type: announce
  mode: single
- id: '1731346443168'
  alias: lavatrice on
  description: ''
  trigger:
  - entity_id: sensor.lavatrice_power
    platform: numeric_state
    above: '50.0'
    for:
      minutes: 1
  condition: []
  action:
  - entity_id: input_boolean.lavatrice_switch
    action: input_boolean.turn_on
  mode: single

L’automazione tornerà a funzionare regolarmente.

Stay tuned..

Soluzione errore RPC failed; curl 92 HTTP/2 stream 0 was not closed cleanly CANCEL (err 8)

2024-09-22T00:00:00+00:00

Per quanto riguarda la schedulazione della pubblicazione di post su Github Pages (vedi questo precedente articolo), mi sono imbattuto in un errore che di fatto bloccava la pubblicazione automatica.

La soluzione è semplicissima, in fondo al file jekyll.yml, basta aggiungere:

pre_build_commands: git config --global http.postBuffer 157286400

E la action torna a funzionare.

Alla prossima..

Ho reso smart la mia lavatrice!

2024-08-26T00:00:00+00:00

Qualche tempo fa mia moglie mi ha chiesto un modo per sapere quando la lavatrice termina il lavaggio. Viviamo in una casa a più piani, e spesso non siamo nei pressi della lavatrice quando termina il lavaggio, ed ecco che dimenticarsi del tutto del bucato da stendere era diventato una problema.

Escludendo la possibilità di acquistare una modernissima lavatrice nuova, ho cercato in rete qualche progetto che fosse utile al mio scopo, ma non mi andava (e non so nemmeno se sarei stato capace) di saldare/modificare nulla sulla scheda madre, perciò ho cercato una soluzione software.

L’accoppiata Sonoff POW Origin + Home Assistant ha risolto tutto.

Il Sonoff POW Origin è una classico switch domotico, un dispositivo capace cioè di funzionare come un interruttore, ma pilotabile da smartphone (mediante app), integrabile con gli assistenti vocali, ma soprattutto capace di misurare i consumi del carico elettrico a cui è collegato.

Ed ecco l’idea.. Se posso monitorare i consumi della mia lavatrice, posso capire quando è attiva (cioè quando il lavaggio è in corso), e di conseguenza anche quando il lavaggio termina (se prima ha un certo consumo e poi va a zero, vuol dire che ha terminato).

Detto fatto, ho acquistato un POW Origin, l’ho collegato a due spezzoni di cavo elettrico della giusta sezione per un carico come una lavatrice (il classico 3x2,5mm va benissimo). Il collegamento del dispositivo è assolutamente semplice, di fatto vanno collegati il neutro (di solito un cavo di colore blu) e la fase (un cavo di colore solitamente nero o marrone) provenienti dalla linea di casa, rispettivamente su uno dei due morsetti contrassegnati con N (sono in parallelo, quindi è indifferente su quali dei due lo collegate) e su Lin (fase in ingresso); nel mio caso, ho collegato uno spezzone di cavo come indicato e poi all’altro estremo ho messo una spina che andrà in una comune presa elettrica (ho usato una cosiddetta Schuko), mentre l’altro spezzone di cavo, quello che andrà al carico (la lavatrice), va collegato allo stesso modo, ma con la fase su Lout (fase in uscita), ovviamente poi ho completato il mio cavo con una spina femmina (da collegare nel mio caso alla lavatrice).

A questo punto, basta configurare il dispositivo nell’app eWelink e siamo già in grado di dare/togliere corrente alla lavatrice, e soprattutto misurarne il consumo.

Benissimo.. Ma la notifica di fine lavaggio? La logica è chiara e non è nulla di speciale, per realizzarla ho utilizzato il mini server domotico che ho in casa (utilizzato molto meno di quanto avessi previsto in origine, devo ammetterlo), il quale può tranquillamente interfacciarsi tanto con i dispositivi di casa Sonoff, quanto con i più comuni assistenti vocali (nel mio caso Amazon Alexa). Avevo iniziato a buttar giù qualcosa, quando mi sono imbattutto in questo post sul blog di Vincenzo Caputo che praticamente mi ha risolto il problema al volo! Davvero fantastico, non posso fare altro che ringraziarli!

Quindi, esattamente come suggerito, cominciamo con l’indicare al sistema che deve considerare i packages all’interno dell’apposita directory (se non esiste, createla nello stesso percorso del file configuration.yaml):

homeassistant:
  packages: !include_dir_named packages

E all’interno della suddetta directory, va inserito il seguente script, che personalmente ho battezzato washingmachineintegration.yaml:

######################################################
####################AUTOMATION########################
######################################################
automation:
- id: lavatrice_on
  alias: lavatrice on
  trigger:
  -  entity_id: sensor.lavatrice_power
     platform: numeric_state
     above: '50.0'
     for:
       minutes: 1
  action:
  - service: input_boolean.turn_on
    entity_id: input_boolean.lavatrice_switch 

- id: lavatrice_fine_switch_state
  alias: Lavatrice fine switch state
  trigger: 
  - entity_id: sensor.lavatrice_power
    platform: numeric_state
    below: '5.0'
    for:
      minutes: 1
  condition:
  - condition: state
    entity_id: 'input_boolean.lavatrice_switch'
    state: 'on'
  action:
  - service: input_boolean.turn_off
    entity_id: input_boolean.lavatrice_switch

- id: lavatrice_done
  alias: Lavatrice Finito
  trigger:
  - entity_id: input_boolean.lavatrice_switch
    platform: state
    to: 'off'
  action:
  - service: notify.alexa_media
    data:
      message: La lavatrice ha terminato il lavaggio. Ricordati di stendere il bucato
      target: media_player.nome_primo_dispositivo_alexa
      data:
        type: announce  
  - service: notify.alexa_media
    data:
      message: La lavatrice ha terminato il lavaggio. Ricordati di stendere il bucato
      target: media_player.nome_secondo_dispositivo_alexa
      data:
        type: announce
########################################################
################INPUT_BOOLEAN############################
########################################################
input_boolean:
  lavatrice_switch:
    name: stato del lavaggio
    initial: off
    icon: mdi:washing-machine

Si tratta dello script presente al post di cui sopra, che ho adattato alle mie esigenze, ovvero al fatto che volevo che Alexa mi annunciasse la fine del lavaggio. Inoltre, l’ho anche adattato ai consumi della mia lavatrice.

Il cuore è in pratica l’INPUT_BOOLEAN che si trova alla fine, che switchando tra off e on “fa capire” ad Home Assistant se deve partire o meno l’automazione che chiama l’annuncio di fine bucato: nel mio caso, se rileva un consumo di almeno 50 watt per almeno 1 minuto, switcha ad on (lavatrice in funzione), al contrario se rileva un consumo di meno di 5 watt per almeno 1 minuto, switcha ad off (la lavatrice ha terminato). In quest’ultimo caso, cioè se si verifica lo switch da on ad off, parte il “Lavatrice finito”, che fa scattare a sua volta l’annuncio.

Ovviamente quel sensor.lavatrice_power altro non è che il “sensore” relativo al Sonoff POW Origin che ho rinominato in questo modo.

Per gestire dispositivi Sonoff in Home Assistant, basta installare l’integrazione Sonoff LAN da HACS, la quale riconoscera in maniera pressochè istantanea qualsiasi dispositivo di casa Sonoff presente nella vostra rete. Per usare Alexa come media player e riprodurre gli annunci, potete seguire questo post.

Semplice e geniale!

Stay tuned..

Credits: Vincenzo Caputo

Schedulare la pubblicazione dei post su Github Pages con Jekyll

2024-08-24T00:00:00+00:00

Capita spesso di scrivere un post per poi pubblicarlo in un secondo momento. Con Jekyll basta semplicemente “datare” un post con una data futura per fare in modo che non si veda immediatamente dopo il deploy. Il problema è che poi, alla data prevista, sarà necessario forzare il deploy, ad esempio apportando una modifica anche minina ad un file, affinchè Github Pages ricompili l’intero sito e renda visibile il nuovo post.

Questo processo si può automatizzare, usando una Action che compila un branch periodicamente, a prescindere da quello che pubblichiamo, in modo da avere il sito sempre aggiornato. Vediamo come fare:

Per prima cosa, va inserito nel _config.yml la seguente riga:

future: false

Che serve ad indicare a Jekyll di non pubblicare post con data futura.

Creiamo poi un token di sicurezza: Icona del profilo -> Settings -> Developer Settings -> Personal Access tokens -> Fine grained tokens -> Generate new token. Diamo un nome al nuovo token, gli diamo accesso a tutti oppure ad uno specifico repository, e sopratutto concediamo tutti i permessi (sono tanti lo so). Al termine copiamo il nuovo token.

A questo punto, aggiungiamo il token appena creato al repository del sito, quindi selezioniamo il relativo repository, poi andiamo in Settings -> Secrets and variables -> Actions -> New repository secret. Diamo un nome ed incolliamo il token precedente, per poi salvare il tutto.

Adesso viene il bello, occorre creare un workflow per Github, quindi creiamo il file jekyll.yml all’interno di /.github/workflows (persorso che sarà quasi certamente da creare). In questo file indichiamo di usare la action jeffreytse/jekyll-deploy-action. Leggendo la documentazione, io ho scritto quanto segue:

name: Build and deploy site

on:
  schedule:
    - cron: "30 17 * * *"
  workflow_dispatch:

jobs:
  build_and_deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      # Use GitHub Actions' cache to cache dependencies on servers
      - uses: actions/cache@v4
        with:
          path: vendor/bundle
          key: $-gems-$
          restore-keys: |
            $-gems-

      # Use GitHub Deploy Action to build and deploy to Github
      - uses: jeffreytse/jekyll-deploy-action@v0.6.0
        with:
          provider: 'github'
          token: $ 
          branch: 'gh-pages'
          cname: 'url_custom_domain'

Vediamo di commentare un attimo il frammento di codice:

Nella sezione schedule, indichiamo che la compilazione avverrà ogni giorno alle 17.30 (prima si indicano i minuti, poi le ore, potete verificare con questo utile strumento online come usare quella sintassi).
Nel token, dobbiamo indicare il nome scelto in precedenza.
Se abbiamo un custom domain configurato, dobbiamo indicarlo in cname.

Possiamo testare il nostro workflow, dal repository scegliamo Actions, nella colonna a sinistra scegliamo la action appena creata, e a destra clicchiamo su Run Workflow, se tutto va bene dopo qualche minuto la compilazione del sito terminerà correttamente.

A questo punto, sarà stato creato un nuovo branch chiamato gh-pages (ma il nome potete sceglierlo a vostro piacimento), l’ultimo step è quello di indicare a Github di visualizzare il sito da questo nuono branch e non dal main (nel mio caso, usavo la compilazione diretta dal main infatti); per farlo, dal repository andiamo in Settings -> Pages e selezioniamo, sotto Build and deployment, l’opzione Deploy from a branch (dovrebbe essere già selezionata) e come branch indichiamo gh-pages (o qualsiasi altro nome abbiate scelto).

A questo punto, scrivete un post con data futura e godetevi la pubblicazione schedulata.

Stay tuned..

Annunci da Alexa tramite Home Assistant

2024-08-20T00:00:00+00:00

Sapete che è possibile usare un dispositivo Alexa come se fosse un riproduttore musicale tramite Home Assistant? Vediamo come fare..

Basta installare un custom component di Home Assistant chiamato Alexa Media Player.

Consiglio vivamente di installarlo tramite HACS, il Community Store di Home Assistant, installabile da Impostazioni -> Dispositivi e servizi -> Aggiungi integrazione. Quindi entrate in HACS e cercate “Alexa Media Player”, in alternativa clic sui tre puntini in alto a destra -> Archivi digitali personalizzati ed inserite https://github.com/custom-components/alexa_media_player, poi cercate nuovamente ed installate. Al termine Home Assistant va riavviato.

Poi collegatevi qui ed accedete con le vostre credenziali Amazon (se usate Alexa, avete un account Amazon) e portate a termine la procedura per l’autenticazione a due passaggi, obbligatoria per usare questa integrazione.

Occorre cliccare su Aggiungi nuovo telefono o un’app di autenticazione e successivamente sul link Non riesci ad acquisire il codice a barre?; solo a questo punto avremo una schermata con un codice alfanumerico che dovremo appuntare da qualche parte (PS. Non chiudere questa finestra altrimenti bisogna ricominciare daccapo).

Andiamo su Home Assistant, in Impostazioni -> Dispositivi e servizi e selezioniamo Alexa Media Player, poi vanno inseriti i dati di configurazione, ovvero il nostro account Amazon, il dominio amazon.it (MI RACCOMANDO!!), l’URL di Home Assistant (deve essere raggiungibile da Internet ovviamente), e il codice copiato in precedenza, che garantirà l’autenticazione corretta. Clicchiamo su “Invia” e avremo un’OTP da inserire nella pagina precedente (vi avevo detto di non chiuderla!).

Al termine della configurazione, saranno comparsi tutti i dispositivi alexa che avete in casa, e le relative entità, e saranno del tipo media_player.nome_dispositivo:

Poi, tali entità saranno richiamabili a piacimento tramite Home Assistant, ad esempio in un’automazione.

Per utilizzare gli annunci si può usare il servizio “notify.alexa_media”, ad esempio in un’automazione va inserito il seguente codice:

service: notify.alexa_media
data:
  message: Questo è il testo dell'annuncio che sarà riprodotto
  target: media_player.nome_dispositvo_alexa
  data:
    type: announce

Stay tuned..