Memorizzare nella cache le dipendenze per aumentare la velocità

Ha mai notato che il workflow scarica di nuovo le stesse dipendenze ogni volta? Questo rallenta tutto!

Il caching in GitHub Actions consente di archiviare e riutilizzare i file delle esecuzioni precedenti. In questo modo le esecuzioni successive del workflow diventano molto più veloci.

GitHub mette a disposizione un'action speciale chiamata actions/cache@v3. Questa action è progettata per salvare e ripristinare i file, così da rendere più veloci i workflow.

È intelligente: verifica se la cache esiste già prima di tentare di ripristinarla e la salva se non esiste.

Due parametri fondamentali di actions/cache sono key e path:

• key: una stringa univoca che identifica la cache. Se viene trovata una cache con questa chiave, viene ripristinata.
• path: i percorsi dei file o le directory da memorizzare nella cache. Indica all'action *che cosa* salvare o ripristinare.

La chiave include spesso un hash dei file delle dipendenze, per garantire che la cache venga invalidata quando le dipendenze cambiano.

Memorizziamo nella cache node_modules di un progetto Node.js. Useremo hashFiles per creare una chiave dinamica basata su package-lock.json.

Provi a eseguire questo semplice frammento di workflow:

Che cosa succede se la key esatta non corrisponde a una cache? È qui che entrano in gioco le restore-keys!

Le restore-keys forniscono un elenco di chiavi di fallback da cercare. Se la chiave principale, ad esempio npm-${{ hashFiles(...) }}, non produce risultati, GitHub Actions prova a trovare una cache usando le restore-keys nell'ordine indicato.

Nel nostro esempio, npm- cerca qualsiasi cache che inizi con "npm-", una soluzione utile se sono cambiate solo versioni minori delle dipendenze.

Il caching non è riservato a Node.js! È possibile applicare lo stesso principio ad altri linguaggi, come Python. In questo caso, memorizziamo nella cache l'ambiente virtuale di Python e la cache di pip.

Qui la chiave usa hashFiles('requirements.txt'), mentre il percorso punta all'ambiente virtuale e alla directory della cache di pip.

Una cache è utile solo se è sufficientemente aggiornata. Se cambiano le dipendenze, dovrebbe cambiare anche la cache!

La cache viene invalidata automaticamente se cambia la key principale, ad esempio npm-${{ hashFiles('package-lock.json') }}. Se package-lock.json viene aggiornato, l'hash cambia e viene creata una nuova cache.

È anche possibile forzare la ricostruzione della cache modificando manualmente la chiave, ad esempio aggiungendo un suffisso di versione come npm-v2-${{ hashFiles(...) }}.

È utile sapere come funziona la cache in background:

• Ambito: le cache sono definite per repository e per branch. Una cache del branch main non verrà usata in un branch di funzionalità, a meno che non si configuri esplicitamente lookup-path.
• Limite di dimensione: ogni cache può avere una dimensione massima di 10 GB.
• Conservazione: le cache vengono conservate per 7 giorni dall'ultimo accesso. Le cache vecchie e inutilizzate vengono rimosse automaticamente.

Per ottenere il massimo dal caching:

• Usare hashFiles: collegare sempre la chiave della cache ai file manifest delle dipendenze, come package-lock.json e requirements.txt.
• Specificare con precisione path: memorizzare nella cache solo ciò che è necessario, come node_modules e ~/.cache/pip.
• Usare restore-keys: fornire fallback per aumentare la percentuale di cache hit.
• Evitare il caching dei dati volatili: non memorizzare nella cache file che cambiano frequentemente o che sono molto grandi e unici per ogni esecuzione, come gli artefatti di build destinati alla distribuzione.

Si dispone di un progetto Java che usa Maven. Le dipendenze sono definite in pom.xml e Maven archivia in genere i JAR scaricati in ~/.m2/repository.

Quale configurazione della cache garantisce al meglio che le dipendenze Maven vengano memorizzate nella cache e invalidate correttamente quando cambia pom.xml?

Ottimo lavoro! Ha imparato a implementare il caching in GitHub Actions per velocizzare significativamente i workflow CI/CD.

• L'action actions/cache è lo strumento da usare.
• Usare key e path per definire che cosa memorizzare nella cache e come farlo.
• hashFiles crea chiavi dinamiche per un'invalidazione intelligente.
• restore-keys fornisce fallback preziosi.

Memorizzando le dipendenze nella cache in modo intelligente, si risparmiano tempo di build e risorse computazionali, rendendo le pipeline più efficienti!