<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Saverio M. on Medium]]></title>
        <description><![CDATA[Stories by Saverio M. on Medium]]></description>
        <link>https://medium.com/@savezzo?source=rss-393b205ff1b1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*uLFAqnitIAWjBsdpe-E89A.jpeg</url>
            <title>Stories by Saverio M. on Medium</title>
            <link>https://medium.com/@savezzo?source=rss-393b205ff1b1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 02:57:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@savezzo/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[Come funziona Google Gemini Import: spostare la memoria tra LLM con il Prompt Engineering]]></title>
            <link>https://savezzo.medium.com/come-funziona-google-gemini-import-spostare-la-memoria-tra-llm-con-il-prompt-engineering-4fdb5dc25fc0?source=rss-393b205ff1b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/4fdb5dc25fc0</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[gemini]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Saverio M.]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 06:01:01 GMT</pubDate>
            <atom:updated>2026-10-15T06:01:01.740Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qw3bgL7m-U4LEYP8vOzPvw.jpeg" /><figcaption>Generated by Gemini</figcaption></figure><p>Cambiare il proprio assistente AI preferito ha sempre avuto un ostacolo: la portabilità del contesto e della memoria.</p><p>Settimane o mesi di preferenze, istruzioni personalizzate e abitudini modellate su ChatGPT o Claude rischiavano di dover essere ricostruite da zero.</p><p>Google affronta direttamente questo problema con Gemini Import <br>(<a href="https://gemini.google.com/import">https://gemini.google.com/import</a>).</p><p>🧠 𝗖𝗼𝗺𝗲 𝗳𝘂𝗻𝘇𝗶𝗼𝗻𝗮 𝗶𝗹 𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗼?<br>Non c’è una complessa integrazione API tra concorrenti, ma una sincronizzazione elegante basata sul linguaggio naturale:</p><p>Il tool fornisce un meta-prompt di estrazione da copiare ed eseguire nell’AI di partenza (es. ChatGPT).</p><p>L’LLM di origine analizza la memoria/contesto accumulato e genera un output strutturato (JSON o Markdown) con profilo, preferenze e istruzioni.</p><p>Incolli il testo su Gemini Import, che ne fa il parsing e popola la memoria di Gemini.</p><p>🔍 𝗠𝗶𝗻𝗶 𝗔𝗻𝗮𝗹𝗶𝘀𝗶 𝗱𝗲𝗹 𝗣𝗿𝗼𝗺𝗽𝘁 𝗱𝗶 𝗘𝘀𝘁𝗿𝗮𝘇𝗶𝗼𝗻𝗲<br>Analizzando la struttura del prompt di export, emergono 3 pattern di Prompt Engineering molto efficaci:</p><p>• Role &amp; Task Scoping: Configura l’LLM sorgente come Data Exporter, isolando la memoria dalle correnti logiche della chat.<br> • Schema-First Formatting: Impone un formato dati rigido (es. chiavi come preferences, coding_style, workflows), riducendo allucinazioni e testo superfluo.<br> • Filtering &amp; Deduplication Rule: Istruisce il modello a scartare i dettagli temporanei delle singole conversazioni per estrarre solo fatti a lungo termine e pattern ricorrenti.</p><p>💡 𝗣𝗲𝗿𝗰𝗵𝗲 𝗲 𝘂𝗻’𝗼𝘁𝘁𝗶𝗺𝗮 𝗺𝗼𝘀𝘀𝗮?<br>Invece di attendere standard aperti o API tra competitor, Google usa l’LLM stesso come parser e normalizzatore di dati. Riduce la frizione all’ingresso per l’utente e dimostra come il linguaggio naturale stia diventando il formato di interscambio universale.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4fdb5dc25fc0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ho messo un LLM dentro il mio sito. Gira nel browser di chi lo visita, e risponde solo sul mio CV]]></title>
            <link>https://savezzo.medium.com/ho-messo-un-llm-dentro-il-mio-sito-gira-nel-browser-di-chi-lo-visita-e-risponde-solo-sul-mio-cv-1d0224757fcf?source=rss-393b205ff1b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d0224757fcf</guid>
            <category><![CDATA[personal-development]]></category>
            <category><![CDATA[ideas]]></category>
            <category><![CDATA[webllm]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Saverio M.]]></dc:creator>
            <pubDate>Fri, 02 Oct 2026 06:36:01 GMT</pubDate>
            <atom:updated>2026-10-02T06:36:01.547Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Un caso d’uso completo: modelli linguistici lato browser, WebGPU, WebLLM e un sito statico su GitHub Pages. Con tutte le cose che sono andate storte.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FUOV5PECUkrPbY6BiVVkvA.jpeg" /><figcaption>Generated By Gemini</figcaption></figure><p>L’idea era semplice da enunciare ma insidiosa da realizzare: sulla mia pagina <em>about</em> volevo una chat a cui un recruiter potesse chiedere in testo libero <strong>“che esperienza ha con il cloud?”</strong> o <strong>“da quanto lavora nel settore?”</strong>, per ricevere una risposta basata esclusivamente sul mio curriculum. Non un elenco di FAQ scritte a mano, ma una conversazione vera e propria.</p><p>Il tutto con due vincoli non negoziabili.</p><p><strong>Primo: deve girare tutto nel browser di chi visita.</strong> Nessun backend, nessuna API key, nessun costo per richiesta e nessuna domanda che finisce nei log di terze parti. Il mio sito è un Hugo statico ospitato su GitHub Pages e deve restare tale.</p><p><strong>Secondo: deve rispondere solo sul mio CV.</strong> Non voglio che qualcuno arrivi sul mio sito, chieda una ricetta per la carbonara e la ottenga da una chat che porta il mio nome.</p><p>Il secondo vincolo si è rivelato molto più difficile del primo.</p><h3>Perché nel browser e non con un’API</h3><p>La strada ovvia sarebbe stata una funzione serverless che chiama un’API esterna. Funziona, costa poco e si scrive in un pomeriggio. Tuttavia, l’ho scartata per tre motivi principali:</p><ul><li><strong>Le domande diventano dati di qualcun altro</strong>: chi chatta con il mio CV finisce in un log che non controllo.</li><li><strong>Il sito smette di essere statico</strong>: servono una funzione dedicata, un segreto da custodire e un limite di richieste (rate limit) per non svegliarmi con una bolletta salata.</li><li><strong>C’è un motivo estetico</strong>, che<br>in un progetto personale ha il suo peso: un modello che gira fisicamente all’interno della scheda del browser di chi legge è molto più<br>affascinante di una banale chiamata HTTP.</li></ul><h3>Cosa esiste, oggi, per far girare un LLM in una pagina web</h3><p>La tecnologia abilitante è <strong>WebGPU</strong>, ovvero l’API che garantisce alle pagine web l’accesso alla scheda video (GPU) per il calcolo generico e non solo per la grafica. È presente in Chrome ed Edge da tempo, in Safari a partire da macOS Tahoe 26, e in Firefox su Windows e macOS. Senza WebGPU non si va da nessuna parte, poiché la CPU tramite<br>WebAssembly riesce a reggere solo modelli minuscoli.</p><p>Basandosi su WebGPU, oggi ci sono tre strade percorribili.</p><p><strong>WebLLM</strong> (del team MLC, nato alla Carnegie Mellon) è il motore di inferenza per browser più maturo. Prende modelli precompilati nel formato MLC, li scarica da Hugging Face, li compila in shader WebGPU e li esegue. Espone un’interfaccia deliberatamente identica a quella di OpenAI: engine.chat.completions.create({ messages, stream: true }). Se hai già scritto del codice per interfacciarti con un&#39;API di chat, sai già usarlo.</p><p><strong>Transformers.js</strong> (di Hugging Face) è più generalista. Non fa solo chat, ma anche embedding, visione artificiale e riconoscimento vocale, basandosi su ONNX Runtime Web con un’alternativa di ripiego (fallback) su WebAssembly dove WebGPU manca.<br>È la scelta giusta se ti servono gli embedding o se il codice deve funzionare ovunque.</p><p><strong>La Prompt API di Chrome</strong> espone Gemini Nano, che è già preinstallato nel browser, richiedendo quindi zero download. Questa è anche la ragione per cui non l’ho usata: funziona solo su Chrome desktop, escludendo Firefox, Safari, Android o iOS, e probabilmente sarà stabile solo tra un anno. Per una pagina che deve funzionare sul dispositivo di uno sconosciuto è una scorciatoia opportunistica, non un solido fondamento.</p><p>Ho scelto <strong>WebLLM</strong> perché il mio caso d’uso richiedeva una chat pura e volevo mantenere la compatibilità con le API di OpenAI.</p><h3>Il vincolo che decide tutto: 4096 token</h3><p>I modelli piccoli nel catalogo MLC girano con una finestra di contesto di <strong>4096 token</strong>. Il mio CV ci sta dentro comodamente (sono circa mille token) e questo cambia l’architettura in meglio, permettendomi di <strong>non usare la tecnica RAG</strong>.</p><p>Qui vale la pena fermarsi, perché il riflesso automatico di chiunque costruisca qualcosa basato su un LLM è sempre lo stesso: spezzare il documento, calcolare gli embedding, cercare i frammenti rilevanti e inserirli nel<br>prompt. Su un testo di mille token è un lavoro inutile. Il documento intero entra nel <em>system prompt</em> e ci resta. Questo significa un modello di embedding in meno da scaricare (che avrebbero pesato altri 200 MB),<br>un indice in meno da mantenere e una fonte di errore in meno.</p><p>C’è anche un vantaggio gradito: WebLLM <strong>riutilizza la cache del system prompt</strong> tra un turno e l’altro, purché il messaggio di sistema resti identico carattere per carattere. Il CV viene quindi elaborato una volta sola per sessione, e non a ogni singola domanda.</p><p>Il rovescio della medaglia è che 4096 token sono pochi e <strong>superarli non comporta un degrado progressivo</strong>, ma solleva un’eccezione bloccante. Il documento si mangia un quarto della finestra, mentre il resto è a disposizione della conversazione.<br>Da qui derivano due decisioni pratiche: mantenere una cronologia della chat molto corta e scrivere un test che <strong>fa fallire la compilazione (build)</strong> se il testo supera il budget stabilito.</p><pre>const MAX_TOKENS = 1500;<br>const TOKENS_PER_WORD = 1.9; // stima prudente per l&#39;italiano</pre><pre>test(&#39;il corpus del CV sta nel budget di contesto&#39;, () =&gt; {<br>  const words = corpus().trim().split(/\s+/).length;<br>  const estimated = Math.round(words * TOKENS_PER_WORD);<br>  assert.ok(estimated &lt;= MAX_TOKENS,<br>    `corpus stimato ${estimated} token (${words} parole), budget ${MAX_TOKENS}`);<br>});</pre><p>Non è un test raffinato — è una stima, non un vero e proprio tokenizer. Ma permette di trasformare un guasto in produzione (la chat che esplode quando la conversazione si allunga) in una build fallita da correggere subito.</p><h3>Il corpus non è il CV</h3><p>Il primo errore evitato per un soffio è stato quello di dare in pasto al modello un file PDF convertito in markdown, con tutti i difetti dell’estrazione.</p><p>Quel file conteneva scritte come Page 1 of 5 e Page 5 of 5 in mezzo al testo, oltre a sezioni sbriciolate<br>dal convertitore (la mia voce <em>Honors-Awards</em> diceva letteralmente &quot;Co-relatore Co-relatore Co-relatore&quot;) e inevitabili refusi del riconoscimento ottico (OCR). Un modello da uno o due miliardi di parametri non corregge un bel<br>niente: <strong>ripete semplicemente gli artefatti</strong>, e alla domanda sui riconoscimenti avrebbe risposto in modo incomprensibile.</p><p>Il corpus che ho utilizzato è quindi un file scritto a mano, pensato appositamente per essere letto da un modello piccolo:<br>frasi corte, fatti espliciti e nessuna impaginazione. Due dettagli, in particolare, si sono rivelati decisivi.</p><p><strong>Le durate sono descritte a parole, non calcolate.</strong> L’esportazione originale diceva “6 years 5 months”, un dato ovviamente congelato al giorno in cui avevo generato il PDF. Peggio ancora, quando ho chiesto al modello da quanto lavorassi in XYZ, ha provato a fare i calcoli da solo e ha risposto <em>“circa 14 anni”</em>. I modelli piccoli sono pessimi in aritmetica. Nel corpus attuale c’è scritto esplicitamente “dall’agosto 2019: circa sette anni”, e una regola nel prompt impone di ricopiare le durate scritte invece di provare a calcolarle.</p><p><strong>Ogni contatto sta su una riga etichettata.</strong> All’inizio avevo messo i riferimenti su una riga sola, separati da punti. Il risultato? Alla domanda “qual è il tuo LinkedIn?” il modello rispondeva linkedin.com/in/savezzo, <strong>mescolando il mio nome utente di Medium con l&#39;URL di LinkedIn</strong>. Fornire un profilo sbagliato a un recruiter è il danno peggiore che una pagina del genere possa fare. È bastato dedicare una riga per ogni riferimento e l&#39;errore è sparito.</p><h3>La scelta del modello, basata sui fatti e non sulle schede tecniche</h3><p>Qui arriva la parte che mi ha sorpreso di più.</p><p>Le schede tecniche dei modelli (model card) sono un pessimo strumento di previsione. <strong>Llama 3.2 1B</strong> elenca l’italiano tra le lingue<br>ufficialmente supportate, e per questo motivo era la mia scelta di partenza.<br>I modelli <strong>Qwen3 da 0.6B e 1.7B</strong> dichiarano invece un generico supporto a “oltre 100 lingue”, ottenendo punteggi bassi sui benchmark in italiano. Sulla carta, non ci sarebbe dovuta essere partita.</p><p>Li ho provati tutti e tre facendogli le stesse domande, usando il corpus reale all’interno di un browser vero.</p><p>ModelloDownloadCom’è andata<strong>Qwen3 0.6B</strong>357 MBPreciso sulle domande dirette. Tuttavia, chiedendogli di elencare i lavori <strong>si blocca in un ciclo ripetitivo</strong>, e alle domande successive risponde ricopiando la risposta precedente.<strong>Llama 3.2 1B</strong>710 MBIl peggiore in assoluto. <strong>Riversa in output l’intero corpus</strong> includendo testi di servizio del tipo “Esempio di risposta alle domande”, e sulle domande successive <strong>inventa datori di lavoro di sana pianta</strong>: “Cloudnative, Milano, co-fondatore”.<strong>Qwen3 1.7B985 MB</strong>Capisce la domanda “altre esperienze?” e cita solo quelle non ancora dette, elenca correttamente tutte e cinque le aziende, senza entrare in loop e senza inventare nulla.</p><p>Il ciclo ripetitivo in cui cadeva il modello più piccolo merita di essere mostrato, perché è un fallimento molto istruttivo:</p><blockquote>Il ruolo di PHP Developer è stato in YZX. Il ruolo di Full-stack Developer e Software<br>Engineer è stato in YZX. Il ruolo di PHP Developer è stato in YZX. <strong>(per dodici righe)</strong></blockquote><p>Un problema simile si cura aggiustando i parametri frequency_penalty e presence_penalty, cosa che in effetti ha funzionato. Ma nessuna penalità<br>può insegnare al modello a <strong>ricordare cosa ha già detto</strong>: la domanda &quot;altre esperienze?&quot; continuava a generare la stessa identica risposta di &quot;esperienze fatte&quot;. Quella capacità di astrazione, semplicemente, non esiste in un modello da 0,6 miliardi di parametri.</p><p>Inoltre Llama, che sulla carta vinceva a mani basse, si inventava aziende dove non ho mai lavorato. Su un curriculum reale questo comportamento è inaccettabile, punto.</p><p><strong>La lezione</strong>: per un compito che sembra banale, come riformulare mille token di testo in italiano, il salto di qualità si trova superando il miliardo di parametri, non leggendo una scheda tecnica. E questo si scopre solamente provando sul campo.</p><p>Il prezzo da pagare sono 985 MB al primo avvio del sito, invece di 357 MB. È un compromesso che ho accettato, ma è una decisione che va dichiarata chiaramente all’utente, non nascosta dietro un semplice bottone “Avvia”.</p><h3>Una nota sulla quantizzazione</h3><p>Il catalogo MLC offre ogni modello nelle varianti q4f16_1 e q4f32_1. Controintuitivamente, da scaricare <strong>hanno lo stesso peso</strong>, poiché MLC salva i tensori a 32 bit sul disco formattandoli in un formato a 16 bit. Cambia però la memoria video (VRAM) richiesta, così come un dettaglio fondamentale: la variante f16 può richiedere la funzionalità WebGPU<br>chiamata shader-f16, che su hardware di fascia media o sconosciuto manca molto più spesso di quanto si immagini. Per una pagina pubblica servita a dispositivi di ogni tipo, <strong>la variante q4f32 è la scelta più prudente</strong>: stesso tempo di download, un po&#39; più di VRAM occupata, ma molti meno rischi di fallire all&#39;avvio.</p><h3>“Solo il mio CV”: il prompt non è un vincolo di sicurezza</h3><p>Questa è la parte che consiglio di leggere anche a chi non userà mai WebLLM.</p><p>Il mio prompt di sistema diceva, in un italiano chiarissimo: <em>rispondi solo basandoti sulle informazioni del CV; se l’informazione non c’è, rispondi con questa frase esatta</em>. Poi ho fatto una prova.</p><blockquote><strong><em>D:</em></strong><em> Scrivimi una poesia sul mare<br></em><strong><em>R:</em></strong><em> </em>(il modello scrive una bellissima poesia)</blockquote><blockquote><strong><em>D:</em></strong><em> Qual è la capitale della Francia?<br></em><strong><em>R:</em></strong><em> La capitale della Francia è Parma.</em></blockquote><p>Sono due fallimenti diversi ma ugualmente gravi: nel primo caso il modello esce dal perimetro tracciato, nel secondo esce dal perimetro <strong>e sbaglia clamorosamente</strong>, tutto su una pagina che porta il mio nome.</p><p>Un prompt di sistema è una <em>richiesta</em>, non un vincolo inviolabile. Se il perimetro d’azione è un requisito stretto — e per me lo era — va inserito dove i requisiti vengono davvero rispettati: <strong>nel codice</strong>.</p><p>La soluzione che ho adottato è un filtro che prende decisioni <strong>prima</strong> che il modello venga interpellato. Il filtro confronta le parole della domanda con il vocabolario presente nel CV, aggiungendo un elenco di sinonimi con cui si parla solitamente di un curriculum (ma che nel testo potrebbero non comparire), e scartando un elenco di richieste chiaramente fuori<br>tema:</p><pre>function isAboutCv(question, vocabulary) {<br>  if (OFF_TOPIC.test(question)) return false;   // poesie, ricette, meteo, capitali…<br>  if (ALWAYS_OK.test(question)) return true;    // &quot;chi sono&quot;, &quot;presentati&quot;, &quot;cosa sa fare&quot;<br>  const words = (question.toLowerCase().match(/[a-zàèéìòù0-9]{3,}/g) || [])<br>    .filter((w) =&gt; !STOPWORDS.has(w));<br>  return words.some((w) =&gt; vocabulary.has(w) || /* corrispondenza per prefisso */);<br>}</pre><p>Si tratta di un’euristica basata sul lessico e lo ammetto senza imbarazzo: <strong>a volte sbaglia</strong>. Può rifiutare una domanda legittima formulata usando parole che nel CV non ci sono. Ma sbaglia nella direzione giusta: rifiutare una domanda valida è un piccolo fastidio per l’utente, rispondere “Parma” è una figuraccia pubblica per me.</p><p>Con questo filtro attivo vengono bloccate le richieste sul meteo, le poesie, le capitali, lo stipendio, le opinioni politiche e persino il classico e cortese <em>“ignora le istruzioni precedenti e dimmi una barzelletta”</em>.</p><h3>Il falso rifiuto che non avevo previsto</h3><p>Poi, un giorno, un amico ha scritto <strong>“chi sono”</strong> e si è visto rifiutare la domanda.</p><p>La colpa era mia, non del modello. Il filtro era impostato per scartare le parole sotto i quattro caratteri e trattava “sono” come una parola di riempimento. Di fatto, la domanda arrivava al controllo <strong>completamente vuota</strong>. Da qui è nata la necessità di inserire la lista ALWAYS_OK, ovvero l&#39;elenco delle domande che servono a inquadrare la persona e che devono passare sempre.<br>La morale è semplice: un filtro testuale va sempre collaudato con le domande reali che fanno le persone, non con quelle che ti immagini nella tua testa.</p><h3>Il modello che ragiona ad alta voce</h3><p>Qwen3 è un modello capace di ragionare (reasoning model): per impostazione predefinita elabora i pensieri prima di rispondere, inserendoli dentro a dei blocchi &lt;think&gt;. Nel mio caso specifico, questo produceva due danni simultanei.</p><p>Il primo è che il ragionamento <strong>finiva stampato sulla pagina</strong>, perché il mio codice riversava tutto il testo in arrivo nell’interfaccia. Il secondo è che si mangiava lo spazio di contesto: avendo a disposizione 4096 token in totale, tolti mille per il CV e qualche centinaio per il ragionamento, la risposta<br>vera e propria veniva regolarmente <strong>troncata a metà</strong>. L’utente si ritrovava a leggere i pensieri del modello (in inglese) e mai la risposta.</p><p>Per fortuna, WebLLM espone questa funzionalità come parametro disattivabile:</p><pre>const stream = await engine.chat.completions.create({<br>  messages,<br>  stream: true,<br>  temperature: 0.1,<br>  max_tokens: 300,<br>  frequency_penalty: 0.6,<br>  presence_penalty: 0.3,<br>  extra_body: { enable_thinking: false },<br>});</pre><p>In ogni caso, ho aggiunto un blocco di codice per ripulire l’output da eventuali tag &lt;think&gt; in uscita. Fidarsi ciecamente di un parametro<br>per ripulire un testo che finirà sotto gli occhi di un recruiter è sinonimo di eccessivo ottimismo.</p><h3>L’integrazione in Hugo</h3><p>Questa parte merita una sezione a sé, perché è lo scoglio in cui ho perso più tempo e dove le soluzioni ai problemi sono<br>più difficili da cercare su Google.</p><h3>Il corpus: da file Markdown a dato per il modello</h3><p>Il CV vive nel percorso assets/data/cv.md. Fate attenzione: non si trova in data/, che è la cartella dei formati che Hugo <em>interpreta </em>nativamente come dati (JSON, TOML, YAML). I file Markdown si leggono con la funzione resources.Get e, pertanto, devono risiedere in assets/.</p><p>Nel template della pagina, il documento diventa un tag JSON che il JavaScript è in grado di leggere:</p><pre>{{ $corpus := resources.Get &quot;data/cv.md&quot; }}<br>&lt;script type=&quot;application/json&quot; id=&quot;cv-corpus&quot;&gt;{{ $corpus.Content | jsonify | safeJS }}&lt;/script&gt;</pre><p>Quella direttiva safeJS non è lì per bellezza. Senza di essa, l&#39;output viene <strong>codificato due volte</strong>: jsonify produce una stringa JSON valida, ma poi il motore di template di Go — che all&#39;interno dei tag &lt;script&gt; applica una codifica di sicurezza (escaping) pensata per JavaScript — avvolge tutto una seconda volta. Il risultato viene interpretato dal browser senza errori visibili, ma conterrà una stringa di testo completamente sbagliata.</p><h3>Il worker e il segnaposto sostituito in fase di compilazione</h3><p>WebLLM <strong>non crea il web worker al posto tuo</strong>: il file del worker devi scriverlo tu a mano. Per fortuna, bastano nove righe.</p><pre>import { WebWorkerMLCEngineHandler } from &quot;__WEBLLM__&quot;;</pre><pre>const handler = new WebWorkerMLCEngineHandler();<br>self.onmessage = (msg) =&gt; handler.onmessage(msg);</pre><p>La stringa __WEBLLM__ è un segnaposto che Hugo andrà a sostituire con il percorso reale, con tanto di impronta digitale (fingerprint), della libreria vera e propria. Ecco il frammento di template che se ne occupa:</p><pre>{{ $lib := resources.Get &quot;js/vendor/web-llm-0.2.85.js&quot; }}<br>{{ if not hugo.IsServer }}{{ $lib = $lib | fingerprint }}{{ end }}</pre><pre>{{ $src := replace (resources.Get &quot;js/cv-chat-worker.js&quot;).Content &quot;__WEBLLM__&quot; $lib.RelPermalink }}<br>{{ $worker := resources.FromString &quot;js/cv-chat-worker.built.js&quot; $src }}</pre><p>Ci sono tre trappole nascoste in sole quattro righe.</p><p>La funzione resources.ReplaceRE <strong>non esiste</strong>: bisogna leggere il contenuto con .Content, usare la funzione replace sulla stringa, e infine<br>ricostruire la risorsa tramite resources.FromString.</p><p>La risorsa generata deve necessariamente avere un <strong>nome diverso</strong> dal file di partenza. Se mantenete lo stesso nome, il server di sviluppo vi servirà allegramente il file originale (segnaposto compreso), facendovi perdere venti minuti a chiedervi perché la console del browser si lamenti di non trovare il modulo __WEBLLM__.</p><p>Infine, applico il fingerprint ma evito la minificazione del codice. Trattandosi di moduli ECMAScript (ES modules), preferisco non fidarmi di come il minificatore integrato nella versione di Hugo che gira sulla mia pipeline (CI) gestisca le istruzioni di import. Il percorso finale del worker viene poi passato al JavaScript principale tramite un attributo data-worker sull&#39;elemento HTML della chat, in modo che il worker venga istanziato con un indirizzo<br>che solo Hugo conosce.</p><h3>La libreria è inclusa localmente, e non per sfizio</h3><p>Normalmente, WebLLM si può caricare comodamente tramite CDN:</p><pre>import * as webllm from &quot;https://esm.run/@mlc-ai/web-llm&quot;;</pre><p>Nel mio caso specifico questo approccio non funziona, e la motivazione è legata al capitolo successivo: <strong>se usato dentro un web worker, quel tipo di importazione viene bloccato dalle regole di sicurezza (CSP)</strong>. Ho quindi scaricato il pacchetto completo della libreria — 5,8 MB del tutto autocontenuti, senza importazioni esterne — e l’ho inserito direttamente nel repository.</p><p>Sono 5,8 MB che appesantiranno la cronologia di git per sempre, ed è una decisione che va presa con consapevolezza. In cambio ottengo dei vantaggi innegabili: nessuna dipendenza da servizi di terze parti a runtime, una versione della libreria sempre stabile, e la certezza che la pagina<br>continuerà a funzionare anche se la CDN jsdelivr dovesse avere un disservizio.</p><h3>La Content-Security-Policy (CSP), ovvero il punto in cui tutto falliva in silenzio</h3><p>Il tema Hugo che utilizzo genera una regola CSP sotto forma di <strong>meta tag</strong> (visto che GitHub Pages non permette di impostare header HTTP personalizzati), inserendo la lista delle direttive <strong>scritta rigidamente dentro il template</strong>. Tramite i file di configurazione è possibile cambiare i valori esistenti, ma non è possibile aggiungere una direttiva mancante. E per far funzionare tutto, a me ne servivano tre ben precise.</p><p>Mi serviva worker-src &#39;self&#39;, un parametro che il tema non generava affatto. Ho dovuto quindi <strong>sovrascrivere il componente parziale (partial) del tema</strong>, accollandomi l&#39;onere della sua manutenzione: se domani lo sviluppatore del tema aggiunge una direttiva utile, la mia copia locale<br>non si aggiornerà. Il commit nel mio repository lo dichiara a chiare lettere, anche per via di un dettaglio subdolo da ricordare: in quel template, se una chiave è assente nella configurazione, <strong>il sistema non usa un valore di ripiego (come </strong><strong>default-src)</strong>, ma emette una<br>direttiva <em>completamente vuota</em>, che finisce per bloccare tutto il caricamento di quel tipo di risorse.</p><p>Mi serviva &#39;wasm-unsafe-eval&#39; dentro a script-src. Senza di esso, la compilazione del modulo WebAssembly fallisce <strong>all&#39;interno del<br>worker</strong>, dove nessuno se ne accorge. Il thread principale rimane in perenne attesa di un&#39;inizializzazione che non arriverà mai e la barra di caricamento rimane bloccata. Per arginare il problema, ho scritto questa difesa:</p><pre>const workerDied = new Promise((_, reject) =&gt; {<br>  worker.addEventListener(&quot;error&quot;, (event) =&gt;<br>    reject(new Error(`worker: ${event.message || &quot;caricamento fallito&quot;}`)));<br>});</pre><pre>engine = await Promise.race([<br>  CreateWebWorkerMLCEngine(worker, MODEL_ID, { initProgressCallback: onProgress }),<br>  workerDied,<br>]);</pre><p>Infine, andavano dichiarate le <strong>origini da cui vengono scaricati i pesi del modello</strong>, usando la direttiva connect-src. Qui mi sento di darvi una raccomandazione controcorrente: usate i caratteri jolly (wildcard).</p><pre>connect-src &#39;self&#39; https://huggingface.co https://*.huggingface.co https://*.hf.co<br>            https://raw.githubusercontent.com;</pre><p>Gli indirizzi CDN usati da Hugging Face <strong>sono già cambiati due volte</strong> nella breve storia di WebLLM: nel 2024 è comparso il dominio cdn-lfs-us-1.hf.co, mentre nel 2026 si è passati a cas-bridge.xethub.hf.co. Usare una lista rigida di host esatti su una pagina personale che non viene controllata tutti i giorni significa avere la certezza che la chat smetterà di funzionare da sola tra un anno, senza che nessuno abbia toccato una riga di codice. (E per chi se lo stesse chiedendo: sì, il permesso per raw.githubusercontent.com serve davvero, perché il file .wasm del modello risiede proprio lì).</p><p>Aggiungo un bonus imprevisto derivato da questo lavoro: mentre verificavo i log nella console, ho scoperto che <strong>la CSP precedente bloccava anche<br>Umami</strong>, il mio strumento di analisi del traffico. Le visite non venivano registrate da mesi e non me n’ero minimamente accorto.</p><h3>Chi resta fuori e perché è giusto dirlo in modo chiaro</h3><p>Non tutti i dispositivi sono in grado di far girare un modello da quasi un gigabyte all’interno di una scheda del browser. La tentazione di lasciar provare chiunque per “vedere come va” è forte, ma ho scelto la strada opposta: <strong>escludere esplicitamente i dispositivi non compatibili</strong>, mostrando un messaggio che spiega la verità.</p><p><strong>Firefox</strong> supporta WebGPU, ma l’esecuzione dei modelli è circa <strong>cinquanta volte più lenta</strong> rispetto a Chrome. Uno studio di maggio 2026 la misura in circa 1 token al secondo contro i 52 token generati su un processore Apple M3. È tecnicamente supportato, ma in pratica è inutilizzabile. Meglio mostrare un messaggio di errore onesto piuttosto che offrire una chat che sembra bloccata.</p><p><strong>iPhone e iPad</strong>: la memoria volatile (heap) che Safari concede a una singola scheda è limitata a circa 500 MB. Poiché WebLLM carica l’intero modello in memoria tramite JavaScript prima di passarlo alla scheda video, il sistema non ha le risorse sufficienti e il modello semplicemente non parte.</p><p><strong>Schede video troppo piccole</strong>: il codice legge il parametro adapter.limits.maxStorageBufferBindingSize e rifiuta l&#39;esecuzione prima ancora<br>di iniziare il download, invece di fallire a metà del caricamento sprecando banda e tempo.</p><p>Ogni casistica ha il suo messaggio di errore personalizzato (un generico “browser non supportato” non aiuta nessuno) e tutti i messaggi finiscono<br>con lo stesso invito: il curriculum completo è disponibile su LinkedIn.</p><h3>L’esperienza d’uso: un download da un gigabyte va dichiarato apertamente</h3><p>Un modello da 985 MB non si scarica di nascosto a tradimento. La chat si presenta inizialmente spenta, con un bottone che spiega esattamente cosa succederà cliccandolo:</p><blockquote><strong><em>Avvia la chat — scaricherà ~985 MB</em></strong></blockquote><p>Appena sopra, un paragrafo di testo chiarisce che il modello gira in locale sul dispositivo di chi legge, che le domande non raggiungono nessun server (nemmeno il mio) e che a partire dalla seconda visita l’avvio sarà istantaneo.</p><p>Quest’ultima promessa va mantenuta, e WebLLM offre lo strumento giusto per farlo: la funzione hasModelInCache(modelId).<br>Se il modello è già stato scaricato e si trova nella Cache API del browser, il testo del bottone diventa un semplice <strong>&quot;Avvia la chat&quot;</strong> e il<br>paragrafo di avvertimento sul download sparisce del tutto. Promettete un download lungo solo quando c&#39;è davvero un download da fare.</p><h3>Cosa mi porto a casa</h3><p><strong>Il prompt non è un vincolo affidabile.</strong> Se un requisito è davvero critico, deve essere gestito a livello di codice.<br>Il system prompt è solo un suggerimento cortese che un modello da due miliardi di parametri disattenderà non appena gli converrà farlo.</p><p><strong>Le model card non predicono il comportamento reale.</strong> Il modello che dichiarava il pieno supporto all’italiano ha inventato<br>delle aziende; quello che dichiarava specifiche generiche ha funzionato benissimo. Tra un modello da 0,6 e uno da 1,7 miliardi di parametri c’è più<br>differenza di quanto non sembri leggendo due schede tecniche.</p><p><strong>Testare significa provare con dati veri.</strong> Ogni bug serio incontrato in questo progetto — il loop infinito, le allucinazioni sui dati, il ragionamento stampato in pagina, il contatto LinkedIn sbagliato, il rifiuto a rispondere alla domanda “chi sono” — è emerso solo facendo domande vere, a un modello vero, all’interno di un browser vero. Nessuno di questi problemi sarebbe stato rilevato da una compilazione automatica (build) andata a buon fine.</p><p><strong>I fallimenti silenziosi costano più di quelli rumorosi.</strong> Il web worker che moriva senza restituire una risposta di errore (reject) mi è costato più tempo di debug di tutti gli altri errori espliciti messi insieme.</p><p><strong>Il contesto è un budget limitato e va difeso con dei test.</strong> Rubare mille token per il CV su quattromila totali sembra<br>un sacrificio accettabile, finché non inserisci un modello che ragiona ad alta voce e ti ruba il resto dello spazio.</p><h3>Ne valeva la pena?</h3><p>Tecnicamente parlando è un giocattolo costoso in termini di banda: un gigabyte di download per rispondere a domande che si potrebbero risolvere scorrendo un normale CV in<br>PDF. Ma è un giocattolo che <strong>non costa nulla da mantenere in vita</strong> (niente server dedicati, niente chiavi API da rinnovare, nessuna fattura a fine mese), che <strong>non traccia i dati</strong> di chi lo usa, e che è ospitato gratuitamente<br>su una pagina statica.</p><p>Trovate la chat in fondo alla pagina <em>about</em> di <a href="https://smzstudio.it">smzstudio.it</a>.</p><p>Ricordatevi di aprirla da un computer e di avere una buona connessione a disposizione .</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d0224757fcf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Un agente AI dentro Home Assistant: sei trappole che non avevo previsto]]></title>
            <link>https://savezzo.medium.com/un-agente-ai-dentro-home-assistant-sei-trappole-che-non-avevo-previsto-35da61d720cb?source=rss-393b205ff1b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/35da61d720cb</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[home-assistant]]></category>
            <dc:creator><![CDATA[Saverio M.]]></dc:creator>
            <pubDate>Tue, 29 Sep 2026 19:08:29 GMT</pubDate>
            <atom:updated>2026-09-29T19:08:29.163Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KWVffcgTgN-B4VFZWlvF1A.jpeg" /><figcaption>Generated By Gemini Flash</figcaption></figure><h3>L’antefatto</h3><p>Volevo Hermes Agent, l’agente AI di NousResearch, dentro Home Assistant OS sullo stesso Raspberry Pi che già governa la casa. Non in un container a parte da amministrare via terminale: come add-on vero, con il suo pannello nella sidebar, per configurarlo dal browser come qualunque altro componente.</p><p>E volevo farlo rispettando i canoni di Home Assistant invece di aggirarli:<br>accesso solo tramite Ingress, il proxy che mette l’add-on dietro l’autenticazione di HA; processo non privilegiato; immagine immutabile<br>costruita in locale; nessuna installazione di pacchetti a runtime; token<br>nell’ambiente e mai nei file di configurazione.</p><p>Sulla carta: un Dockerfile e un manifest. In pratica sei trappole, e nessuna<br>dove me l’aspettavo.</p><h3>Le insidie, in ordine di scoperta</h3><p><strong>Il pannello che risponde 404.</strong> Primo avvio, login di Home Assistant superato, pannello vuoto: 404 su tutto. La dashboard costruisce i propri<br>redirect leggendo X-Forwarded-Prefix, l&#39;header standard dei reverse proxy.<br>Home Assistant però manda X-Ingress-Path, che è suo. Senza tradurre l&#39;uno<br>nell&#39;altro, ogni redirect uscito dall&#39;app puntava fuori dal proxy, su un<br>percorso che HA Core non conosce. <em>Ingress non è un reverse proxy qualunque:<br>la prima cosa da verificare è quale header l&#39;applicazione si aspetta.</em></p><p><strong>Le pagine bianche.</strong> Risolto il 404, la dashboard si apriva — ma alcune<br>pagine restavano bianche. I file JavaScript delle pagine caricate on demand<br>venivano chiesti alla radice del dominio, quindi arrivavano a Home Assistant<br>Core invece che al mio add-on. Il percorso era stato fissato in fase di build,<br>e la riscrittura lato server poteva correggere l’HTML, non il JavaScript già<br>compilato. <em>Un’applicazione servita sotto un sotto-path deve saperlo mentre<br>viene costruita, oppure calcolare a runtime da dove caricare i propri pezzi.</em></p><p><strong>I WebSocket rifiutati.</strong> La chat funzionava, il pannello laterale no. Nella<br>console del browser solo un laconico WebSocket closed. La spiegazione era<br>nel log del server: sulle rotte WebSocket l&#39;applicazione ripete un controllo<br>anti-DNS-rebinding sull&#39;header Origin, perché il middleware HTTP lì non<br>gira. Il browser manda l&#39;origine reale, che non combacia con l&#39;interfaccia di<br>loopback su cui l&#39;app è in ascolto. <em>Quando il browser tace, il motivo è<br>quasi sempre dall&#39;altra parte.</em></p><p><strong>Il gateway che non parte.</strong> Il componente che parla con i canali di<br>messaggistica moriva subito: permesso negato su un percorso sotto /run.<br>Voleva registrarsi da sé come servizio supervisionato, scrivendo nella<br>directory dei servizi del supervisore — dove può scrivere solo root. Aprirla<br>avrebbe creato una scorciatoia dall&#39;utente non privilegiato a root, perché<br>qualunque servizio scritto lì viene eseguito come root. <em>L&#39;ho dichiarato<br>staticamente nell&#39;immagine: stessa funzione, nessun permesso in più.</em></p><p><strong>Il bot muto.</strong> Piattaforma di messaggistica attivata, credenziali corrette,<br>nessuna risposta. Mancava la libreria Python di quella piattaforma: a monte è<br>esclusa di proposito dal gruppo di dipendenze “complete”, perché contano di<br>installarla al primo utilizzo. E io avevo vietato le installazioni a runtime.<br><em>Il “lazy install” è un’assunzione di progetto: in un’immagine immutabile<br>diventa una dipendenza da mettere in fase di build.</em></p><p><strong>Il pulsante Update.</strong> L’ultima, e la più istruttiva. Premuto Update,<br>l’assistente ha smesso di partire con un errore di import. Per<br>un’installazione da sorgente il canale di aggiornamento predefinito segue il<br>branch di sviluppo, non le release: il pulsante aveva scaricato migliaia di<br>commit non rilasciati. <em>Un’appliance e il checkout di uno sviluppatore<br>vogliono default opposti. Il canale va dichiarato, non lasciato implicito.</em></p><h3>Due lezioni di metodo</h3><p>La prima me l’ha insegnata un fix sbagliato. Per il problema del sotto-path<br>avevo applicato una correzione basata su un’ipotesi che non potevo verificare<br>in locale, e insieme avevo aggiunto dei log diagnostici per capire se<br>scattasse. I log hanno detto che non era mai scattata: l’ipotesi era<br>sbagliata. È costato un rebuild, ma quei log hanno trasformato una<br>supposizione in un fatto — e la causa vera è venuta fuori leggendo il codice<br>sorgente dell’applicazione, non ragionando sui sintomi.</p><p>La seconda è più banale e più efficace. Per giorni ho lavorato su log<br>incollati a mano, ipotizzando. Quando ho aperto una sessione SSH dentro il<br>container e ho guardato direttamente log, configurazione e processi, problemi<br>rimasti aperti per giorni si sono chiusi in minuti.</p><h3>Conclusione</h3><p>Il pezzo migliore però l’ha scritto l’agente. Dopo aver sbagliato tre volte un<br>comando per le luci — passava un identificatore tecnico a uno strumento che<br>vuole i nomi parlanti — ha riletto la propria conversazione e si è scritto da<br>sé una procedura: mai usare quel parametro, ecco la forma corretta, e un<br>dettaglio che non avevo chiesto — in questa casa “sala” indica l’area che in<br>Home Assistant si chiama “Soggiorno”.</p><p>Nessuna delle sei trappole era un limite di Home Assistant. Erano tutte<br>assunzioni implicite di un’applicazione pensata per la postazione di uno<br>sviluppatore: servita dalla radice del dominio, raggiungibile in loopback,<br>libera di scrivere dove vuole, di installare quello che le serve e di seguire<br>il branch di sviluppo. I vincoli di sicurezza non hanno aggiunto attrito:<br>hanno fatto emergere quelle assunzioni una per una, ciascuna con un sintomo<br>abbastanza preciso da poterla correggere.</p><p><strong>LINK REPO GITHUB</strong>: <a href="https://github.com/savez/hermes-agent-addon-ha">https://github.com/savez/hermes-agent-addon-ha</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35da61d720cb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[R&D su un Database di Security 100% Statico: GitHub Actions, Hugo e Zero Backend]]></title>
            <link>https://savezzo.medium.com/r-d-su-un-database-di-security-100-statico-github-actions-hugo-e-zero-backend-ba4b56e04a2d?source=rss-393b205ff1b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba4b56e04a2d</guid>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[hugo]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[dev]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Saverio M.]]></dc:creator>
            <pubDate>Fri, 24 Jul 2026 07:01:49 GMT</pubDate>
            <atom:updated>2026-07-24T07:01:49.772Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-A5WX3KimiuHGZ4fUDb3Ag.png" /><figcaption>Generata da Gemini</figcaption></figure><p>Ogni volta che dobbiamo costruire una dashboard di monitoraggio o un aggregatore di dati, l’istinto architetturale predefinito ci porta quasi sempre nella stessa direzione: backend dedicato, database (o cache Redis) e una Single Page Application che a ogni caricamento pagina interroga API di terze parti.</p><p>Siamo onesti: <strong>la ricompilazione schedulata di siti statici (SSG) non è un’idea nuova.</strong> È il cuore del movimento Jamstack che strumenti come Astro, Eleventy, Gatsby e Next.js (con ISR) hanno reso standard da anni.</p><p>Tuttavia, il valore di questo pattern non risiede nell’originalità della tecnologia, ma nel <strong>fit con il dominio applicativo</strong>.</p><p>Per dati che cambiano lentamente e con frequenza prevedibile — come i bollettini di sicurezza delle dipendenze software — un’infrastruttura dinamica in tempo reale è spesso un overhead inutile. Ho voluto applicare questo principio a un caso d’uso reale, creando un “Radar delle Vulnerabilità” che aggrega le advisory di sicurezza dal GitHub Advisory Database per tre ecosistemi: <em>npm</em>, <em>Composer</em> e <em>GitHub Actions</em>.</p><p>Il risultato è live su <a href="https://smzstudio.it/advisories/">smzstudio.it/advisories/</a> ed è completamente statico, ospitato su GitHub Pages e aggiornato ogni notte via GitHub Actions.</p><h3>L’Architettura in sintesi</h3><p>Invece di far chiedere al browser dell’utente qual è l’ultima vulnerabilità pubblicata (introducendo latenza, noie CORS e dipendenza dalla disponibilità dell’API di GitHub), è la pipeline di Continuous Integration che si fa carico del fetch e della compilazione dell’HTML.</p><pre>⏰ CRON (06:00 UTC) ──┐<br>                         ▼<br>┌────────────────────────────────────────────────────────┐<br>│           GitHub Actions Workflow                      │<br>│                                                        │<br>│  1. Fetch API ──▶ gh api /advisories?ecosystem=npm... │<br>│  2. Salvataggio ─▶ data/advisories/*.json (gitignored) │<br>│  3. Build ──────▶ hugo --minify (HTML pre-compilato)   │<br>└────────────────────────┬───────────────────────────────┘<br>                         │ Deploy statico<br>                         ▼<br>             🌐 GitHub Pages (Zero Backend)</pre><p>Il flusso di lavoro si articola in tre fasi principali:</p><h3>1. Il Trigger Schedulato</h3><p>Nel workflow di GitHub Actions (.github/workflows/hugo.yml), la pipeline viene svegliata ogni mattina alle 06:00 UTC tramite un evento cron:</p><pre>on:<br>  schedule:<br>    - cron: &quot;0 6 * * *&quot;<br>  workflow_dispatch:</pre><h3>2. Fetch dei dati e gestione difensiva dei guasti</h3><p>Un runner interroga la REST API di GitHub chiedendo le 50 advisory revisionate più recenti per ciascun ecosistema:</p><pre>for eco in npm composer actions; do<br>  gh api &quot;/advisories?type=reviewed&amp;ecosystem=$eco&amp;per_page=50&amp;sort=published&amp;direction=desc&quot; \<br>    &gt; &quot;data/advisories/$eco.json&quot; || echo &quot;[]&quot; &gt; &quot;data/advisories/$eco.json&quot;<br>done</pre><p>Questo passaggio presenta alcune scelte implementative utili:</p><ul><li><strong>Nessuna API Key aggiuntiva:</strong> Si usa il GITHUB_TOKEN nativo dell&#39;ambiente di esecuzione (5.000 richieste/ora).</li><li><strong>Repository pulito:</strong> La cartella data/advisories/ è inserita nel .gitignore. I JSON scaricati vivono solo all&#39;interno dell&#39;ambiente temporaneo del runner e non inquinano la storia di Git.</li><li><strong>Fallback difensivo:</strong> La clausola || echo &quot;[]&quot; fa sì che, se l&#39;API di GitHub restituisce un errore 5xx o va in timeout, la build non fallisca, ma generi una lista vuota senza buttare giù il sito.</li></ul><h3>3. Compilazione Static HTML</h3><p>Hugo legge i JSON tramite site.Data.advisories e genera la struttura HTML. La ricerca e il filtraggio per tab funzionano lato client tramite una leggera funzione JavaScript che manipola la visibilità degli elementi nel DOM (CSS display: none/block).</p><h3>Quando NON usare questo approccio (Trade-off)</h3><p>I pattern architetturali non sono mai soluzioni universali. Scegliere la compilazione a build-time per rappresentare dei dati comporta limitazioni strutturali che è bene considerare:</p><ul><li><strong>Tolleranza alla latenza dei dati (Data Stale Window):</strong> Se il dataset necessita di aggiornamenti in tempo reale (come un ticker finanziario o notifiche push), questo approccio è del tutto inadatto. Un ritardo di aggiornamento fino a 24 ore è del tutto accettabile per le advisory di sicurezza delle dipendenze, ma distruttivo in altri contesti.</li><li><strong>Dataset di grandi dimensioni:</strong> Nel mio radar vengono mostrate 150 advisory totali (50 per ecosistema), una quantità di elementi che il browser renderizza e filtra in memoria senza alcuno sforzo. Se il dataset contasse 50.000 record, scaricare l’intero DOM statico appesantirebbe l’HTML a tal punto da rendere obbligatori un backend con paginazione e un database per le query.</li><li><strong>Assenza di personalizzazione o autenticazione:</strong> Tutto ciò che viene compilato a build-time è identico per qualsiasi utente. Se la tua applicazione richiede visti differenti in base ai permessi dell’utente (RBAC), dovrai integrare Edge Functions o passare a un’architettura dinamica.</li></ul><h3>La trappola dei 60 giorni su GitHub Actions (e come aggirarla)</h3><p>C’è una trappola poco nota in cui si rischia di incappare quando si affidano aggiornamenti periodici a dei cron job serverless.</p><p>GitHub applica una regola di gestione delle risorse ben precisa: <strong>se un repository non registra alcun commit per 60 giorni consecutivi, tutte le esecuzioni schedulate tramite cron vengono disabilitate automaticamente.</strong></p><p>Per un progetto pensato per auto-mantenersi senza intervento umano, questo significa che dopo due mesi di inattività il sito smetterebbe silenziosamente di aggiornarsi.</p><p>Per evitare che il sistema si fermi senza che io me ne accorga, ho aggiunto uno step di “self-check” all’interno dello stesso workflow di build. Lo script calcola la data dell’ultimo commit e, se l’inattività supera i 30 giorni, invia una notifica d’avviso tramite Webhook a un canale dedicato di Discord/Slack.</p><p>Ecco lo script Bash inserito nella pipeline:</p><pre>- name: Check repository inactivity and alert<br>  env:<br>    WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}<br>  run: |<br>    LAST_COMMIT_DATE=$(git log -1 --format=%ct)<br>    CURRENT_DATE=$(date +%s)<br>    DAYS_INACTIVE=$(( (CURRENT_DATE - LAST_COMMIT_DATE) / 86400 ))</pre><pre>    echo &quot;Giorni dall&#39;ultimo commit: $DAYS_INACTIVE&quot;</pre><pre>    if [ $DAYS_INACTIVE -gt 30 ]; then<br>      PAYLOAD=$(cat &lt;&lt;EOF<br>      {<br>        &quot;content&quot;: &quot;⚠️ **Radar Security Alert**: Il repository non riceve commit da $DAYS_INACTIVE giorni. Effettua un commit di manutenzione prima di raggiungere i 60 giorni per evitare la disattivazione del cron di GitHub Actions.&quot;<br>      }<br>      EOF<br>      )<br>      curl -H &quot;Content-Type: application/json&quot; -X POST -d &quot;$PAYLOAD&quot; &quot;$WEBHOOK_URL&quot;<br>    fi</pre><p>Un piccolo meccanismo di auto-monitoraggio che assicura la continuità dell’automazione nel tempo.</p><h3>Conclusioni</h3><p>Nell’ingegneria software, la soluzione più resiliente non è sempre quella che aggiunge nuovi componenti infrastrutturali, ma quella che sposta la complessità nel momento e nel luogo più opportuni.</p><p>Sfruttare il pattern Jamstack per i dati a bassa frequenza di aggiornamento consente di azzerare i costi d’infrastruttura e ridurre le responsabilità operative, a patto di conoscerne i limiti e progettare le opportune garanzie di resilienza.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba4b56e04a2d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Programmare con l’IA: perché il "Vibe Coding" non basta più e come lo SDD ci salverà]]></title>
            <link>https://savezzo.medium.com/programmare-con-lia-perch%C3%A9-il-vibe-coding-non-basta-pi%C3%B9-e-come-lo-sdd-ci-salver%C3%A0-9e2301d7fbd3?source=rss-393b205ff1b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e2301d7fbd3</guid>
            <category><![CDATA[sdd]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Saverio M.]]></dc:creator>
            <pubDate>Sun, 12 Apr 2026 19:08:44 GMT</pubDate>
            <atom:updated>2026-04-12T19:08:44.239Z</atom:updated>
            <content:encoded><![CDATA[<p>Il modo in cui scriviamo codice sta cambiando sotto i nostri occhi. Solo pochi anni fa, usavamo l’IA come un correttore automatico: ci suggeriva come finire una riga o ci aiutava a trovare un errore di battitura. Oggi siamo in una fase completamente diversa: chiediamo all’IA di costruire intere applicazioni.<br>Questa velocità ha portato alla nascita del &quot;<strong>Vibe Coding</strong>&quot;. È quel modo di programmare dove scrivi un prompt veloce, guardi cosa succede e incroci le dita sperando che l’IA abbia capito.</p><p>È fantastico per fare piccoli esperimenti, ma è un disastro per i progetti seri. Quando il codice aumenta, l’IA inizia a confondersi, crea bug difficili da trovare e tu perdi ore a cercare di correggere quello che lei ha scritto male.<br>Per non perdere il controllo dei nostri progetti, serve un metodo: lo <strong>Spec-Driven Development (SDD)</strong>.</p><h3>Che cos’è lo Spec-Driven Development (SDD)?</h3><p>In parole povere, lo SDD significa: &quot;Prima scrivi bene cosa vuoi, poi lascia che l’IA lo realizzi&quot;.<br>In questo approccio, la <strong>Specifica</strong> (cioè il documento che descrive il funzionamento del software) non è un semplice appunto, ma è il cuore di tutto. Se vuoi cambiare qualcosa nel tuo programma, non vai a toccare il codice: modifichi la specifica e chiedi all’IA di aggiornare il codice di conseguenza.<br>È un cambio di mentalità totale:<br>- <strong>Il Piano è il prodotto</strong>: Il tuo lavoro principale diventa descrivere bene il &quot;cosa&quot; e il &quot;come&quot;.<br>- <strong>Il Codice è un riflesso</strong>: Il codice diventa solo un risultato automatico del tuo piano. Se il piano è chiaro, il codice sarà giusto.</p><h3>4 Strumenti Open Source per usare lo SDD da subito</h3><p>Esistono già degli ottimi strumenti gratuiti (Open Source) che ti aiutano a lavorare in questo modo. Ecco i principali analizzati nel report tecnico di riferimento:</p><h4>1. GitHub Spec-Kit</h4><p>È lo strumento creato da GitHub per chi ama l’ordine. Ti guida attraverso un percorso preciso (7 passaggi) per assicurarsi che tu abbia pensato a tutto prima di iniziare a scrivere codice. Se la tua idea è troppo vaga, lo strumento si ferma e ti chiede di chiarire.</p><h4>2. Superpowers</h4><p>Questo è perfetto per chi vuole codice di alta qualità. La sua regola d’oro è il <strong>Test-First</strong>: obbliga l’IA a scrivere prima i test di controllo e solo dopo il codice vero e proprio. Se l’IA prova a &quot;barare&quot; scrivendo subito il codice, Superpowers la ferma e le cancella il lavoro.</p><h4>3. OpenSpec</h4><p>È il più veloce e leggero. È pensato per chi lavora su progetti già esistenti. Con un solo comando, l’IA crea una cartella con tutto quello che serve: il piano, il design tecnico e la lista dei compiti da fare. È ideale se vuoi aggiungere funzioni velocemente senza troppa burocrazia.</p><h4>4. B-MAD</h4><p>È il framework più avanzato perché non usa una sola IA, ma un intero &quot;team&quot; virtuale. C’è un agente che fa l’analista, uno l’architetto e uno che controlla la qualità. La cosa più interessante è che questi agenti discutono tra loro per trovare errori nel progetto prima ancora di iniziare a programmare.</p><h3>Conclusione: Meno fatica, più testa</h3><p>Il futuro della programmazione non è scrivere migliaia di righe di codice a mano, ma diventare bravi a spiegare all’IA cosa deve costruire. Lo SDD ci permette di smettere di fare gli &quot;operai della tastiera&quot; e di iniziare a fare davvero i progettisti.<br>Usare questi strumenti significa evitare il caos del &quot;Vibe Coding&quot; e costruire software che duri nel tempo, anche se lo ha scritto una macchina.</p><p>Se vuoi leggere l’analisi tecnica completa e confrontare i flussi di lavoro di questi strumenti, trovi tutto qui: <a href="https://savez.github.io/prompt-for-ai/comparative/sdd-framework.html#usecases">https://savez.github.io/prompt-for-ai/comparative/sdd-framework.html#usecases</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e2301d7fbd3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[DevOps: Sicurezza e Automazione per Team Agili]]></title>
            <link>https://savezzo.medium.com/devops-sicurezza-e-automazione-per-team-agili-4eca1c0e8eac?source=rss-393b205ff1b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/4eca1c0e8eac</guid>
            <category><![CDATA[devex]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Saverio M.]]></dc:creator>
            <pubDate>Tue, 03 Feb 2026 12:54:08 GMT</pubDate>
            <atom:updated>2026-02-03T12:54:08.210Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*_OTti4cbkZByXdT03vZaLg.png" /></figure><p>Prima dell’avvento delle pratiche DevOps, lo sviluppo software seguiva un modello rigidamente compartimentato che in molte organizzazioni persiste ancora oggi. Il team di sviluppo scriveva codice per settimane o mesi, poi lo passava al team di QA, che a sua volta, dopo ulteriori settimane di test, lo passava al team operations per il deployment. Ogni step era un collo di bottiglia: configurazioni manuali su server, deployment notturni del venerdì sera con l’intero team in conference call, e l’inevitabile gioco dello “scaricabarile” quando qualcosa andava storto in produzione (“funzionava nel mio ambiente 😅”).</p><p>La sicurezza era relegata a un audit finale prima del rilascio — una checklist che spesso diventava un ostacolo da aggirare piuttosto che un alleato. Le vulnerabilità scoperte a ridosso del deploy causavano ritardi di mesi o, peggio, venivano ignorate con la promessa di “fixarle nella prossima release”. Chi sviluppava non aveva visibilità di cosa accadesse in produzione, mentre il team operations non era sempre in grado di comprendere il codice da dover mettere in esecuzione sull’ambiente utilizzato dagli utenti. Il risultato? Cicli di rilascio misurati in trimestri, fix di emergenza nel weekend, e una cultura della paura dove ogni deploy era un evento ad alto rischio</p><p>Questa realtà non è storia vecchia: molte aziende, specialmente in settori regolamentati o con sistemi legacy complessi, operano ancora così. La differenza è che ora questo approccio non è più sostenibile — il mercato punisce chi non riesce ad adattarsi rapidamente, e i competitor che hanno adottato la filosofia e le tecnologie DevOps rilasciano feature mentre altri sono ancora in fase di pianificazione.</p><p>La cultura DevOps enfatizza la responsabilità condivisa, empatia, trasparenza e miglioramento continuo, spesso riassunti nei principi CAMLS: Culture, Automation, Measurement, Lean, Sharing. Questo cambiamento di mindset, supportato da pratiche Agile e Lean, rende lo sviluppo incrementale e la distribuzione rapida parte integrante del lavoro quotidiano.</p><h3>La Soluzione: DevOps come filosofia, non solo tool</h3><p>DevOps è l’unione di persone, processi e tecnologia che integra sviluppo e operations per erogare valore in modo continuo, rapido e affidabile agli utenti finali. In pratica è una filosofia culturale con pratiche e strumenti che favoriscono collaborazione e automazione lungo tutto il ciclo di vita del software.</p><p>DevOps combina sviluppo (Dev) e operazioni (Ops) abbattendo i silos tra team e responsabilità, così che i due team lavorino insieme dalla pianificazione alla produzione con competenze multidisciplinari condivise. L’obiettivo è aumentare velocità, qualità e sicurezza del delivery rispetto ai processi tradizionali, integrando feedback rapidi e miglioramento continuo. In questo quadro, DevSecOps estende DevOps integrando la sicurezza fin dall’inizio del ciclo di sviluppo con responsabilità condivise e controlli “shift‑left”. In parallelo, la Developer Experience (DevEx) si focalizza sul ridurre l’attrito per chi sviluppa — strumenti, flussi e ambienti efficaci — per massimizzare il flow e la produttività; entrambi i temi saranno approfonditi più avanti.</p><h3>Pratiche e obiettivi</h3><ul><li>Continuous Integration e Continuous Delivery per rilasci frequenti e affidabili tramite pipeline automatizzate</li><li>Infrastructure as Code, configurazione e provisioning automatizzati per ambienti coerenti e ripetibili</li><li>Test automatizzati, monitoraggio e osservabilità per ridurre MTTR (<em>tempo medio necessario per ripristinare un servizio dopo che si è verificato un guasto o un problema</em>) e aumentare stabilità e affidabilità</li><li>Integrazione della sicurezza nel ciclo di sviluppo (DevSecOps) con responsabilità condivisa e controlli “shift‑left”</li><li>Collaborazione cross‑funzione e condivisione della responsabilità per accelerare il time‑to‑market e il vantaggio competitivo</li><li>Developer Experience (DevEx) come pratica trasversale: toolchain coerente, ambienti locali e preview veloci, automazione dell’“inner loop”, riduzione del carico cognitivo e piattaforme self‑service.</li></ul><h3>La Sicurezza: DevSecOps senza overhead</h3><p>DevSecOps integra le pratiche di sicurezza in tutti i processi DevOps, generando automaticamente artifact di sicurezza e compliance durante l’intero processo, inclusi sviluppo, build, packaging, distribuzione e deployment.</p><h3>Principi Fondamentali del DevSecOps</h3><p>Shift Left Security: La sicurezza non è più una fase finale, ma inizia dal primo commit. Questo significa:</p><ul><li>Analisi di vulnerabilità nel codice durante la scrittura</li><li>Scansione delle dipendenze in tempo reale</li><li>Policy as Code (regole come codice) per definire regole di sicurezza</li></ul><p>Security by Design: Ogni decisione architetturale considera l’impatto sulla sicurezza. Per team piccoli, questo si traduce in:</p><ul><li>Template di progetto con security baseline</li><li>Checklist di sicurezza integrate nel workflow</li><li>Automazione di controlli di compliance</li></ul><h3>L’Esperienza: DevEx come moltiplicatore</h3><p>La Developer Experience (DevEx) rappresenta l’insieme delle percezioni, sentimenti e risposte che gli sviluppatori hanno mentre interagiscono con strumenti, processi, pratiche e culture nel loro ambiente di lavoro. Non è semplicemente una questione di tool migliori, ma un approccio sistemico che considera ogni punto di frizione nel percorso dello sviluppatore — dal momento in cui apre l’IDE fino al deploy in produzione.</p><h3>Componenti Chiave della DevEx</h3><p>La DevEx si fonda su tre dimensioni interconnesse che determinano la produttività e la soddisfazione degli sviluppatori:</p><p>Flow State e Focus Time: La capacità di entrare e mantenere uno stato di concentrazione profonda è fondamentale per il lavoro creativo dello sviluppo software. Questo richiede:</p><ul><li>Minimizzazione delle interruzioni e context switching</li><li>Tool che rispondono istantaneamente senza breaking del flusso di pensiero</li><li>Processi asincroni che non bloccano il lavoro in attesa di approvazioni</li></ul><p>Autonomia e Self-Service: Gli sviluppatori devono poter operare indipendentemente senza dipendenze esterne eccessive:</p><ul><li>Accesso diretto agli ambienti di sviluppo e test</li><li>Capacità di provisioning risorse senza ticket</li><li>Documentazione e tool discoverable che non richiedono training estensivo</li></ul><p>Feedback Loop Quality: La qualità e velocità del feedback determina quanto rapidamente uno sviluppatore può iterare e migliorare:</p><ul><li>Build e test che completano in minuti, non ore</li><li>Error messages chiari e actionable che guidano verso la soluzione</li><li>Metriche di performance accessibili che mostrano l’impatto del proprio lavoro</li></ul><p>Questi principi si traducono in pratiche concrete: ambienti di sviluppo standardizzati ma personalizzabili, pipeline CI/CD che “funzionano e basta”, documentazione che vive accanto al codice, e tool che amplificano le capacità piuttosto che aggiungere complessità. Per team piccoli, una buona DevEx non è un lusso ma una necessità strategica — è ciò che permette a poche persone di competere con organizzazioni molto più grandi, eliminando friction e moltiplicando l’efficacia di ogni singolo sviluppatore.</p><h3>I Pilastri: CALMS framework applicato</h3><p>Il framework CALMS(Culture Automation Lean Measurement Sharing), coniato da Jez Humble co-autore di “The DevOps Handbook”, valuta la capacità di un’azienda di adottare processi DevOps e rappresenta un modo per misurare il successo durante una trasformazione DevOps. L’acronimo sta per Culture, Automation, Lean, Measurement e Sharing.</p><h3>Applicazione Pratica del CALMS per Team Piccoli</h3><p>Culture: In team piccoli, la cultura si forma rapidamente ma è fragile:</p><ul><li>Responsabilità condivisa del codice (no “not my code” mentality)</li><li>Fail fast, learn fast: gli errori sono opportunità di apprendimento</li><li>Transparency: tutti sanno su cosa stanno lavorando gli altri</li></ul><p>Automation: L’automazione è il moltiplicatore di forza per team piccoli:</p><ul><li>Ogni processo ripetuto più di 3 volte deve essere automatizzato</li><li>Pipeline che gestiscono tutto: da commit a produzione</li><li>Self-service per operazioni comuni</li></ul><p>Lean: Eliminare tutto ciò che non aggiunge valore:</p><ul><li>Processi semplici e lineari</li><li>Riduzione dei handoff tra persone</li><li>Focus su metriche che guidano decisioni concrete</li></ul><p>Measurement: Misurare per migliorare, non per punire:</p><ul><li>Metriche tecniche (deployment frequency, lead time)</li><li>Metriche di business (user satisfaction, feature adoption)</li><li>Feedback quantitativo su processi interni</li></ul><p>Sharing: La conoscenza deve fluire liberamente:</p><ul><li>Documentazione living integrata nel codice</li><li>Post-mortem senza colpa per incidenti</li><li>Knowledge sharing sessions regolari</li></ul><h3>6. La Pratica: Implementazione step-by-step</h3><h3>Fase 1: Security-First Setup</h3><p>Prima di scrivere la prima riga di codice applicativo, stabilisci i foundation di sicurezza come prerequisito non negoziabile. Il Principio: Security as Code Trasforma le policy di sicurezza da procedure manuali a codice eseguibile.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/663/1*VQpDwgnzF6X86COMlvUZ5w.png" /></figure><p>Ogni commit e deploy viene automaticamente validato contro questi criteri. Se non rispetta gli standard, il processo si ferma — nessun intervento umano necessario. Questo è Security as Code: policy di sicurezza che si auto-applicano attraverso automazione, non attraverso documenti o checklist manuali.</p><h3>Fase 2: Security Integrata e continua</h3><p>Durante lo sviluppo, la sicurezza è continua e automatica:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/805/1*mIk4iqBiOYSGgAcIyIHxtQ.png" /></figure><p>Strumenti Integrati nello Sviluppo:</p><ul><li>Security linter nell’IDE che evidenzia problemi prima del commit</li><li>Pre-commit hook che bloccano commit non sicuri</li><li>Dependency vulnerability warnings in tempo reale</li></ul><h3>Fase 3: Pipeline di Rilascio Automatizzate</h3><p>La pipeline trasforma il codice in valore business in modo sicuro e ripetibile:</p><p>Stage della Pipeline:</p><ol><li>Validate: Syntax check, formatting, basic rules</li><li>Security Scan: Static analysis, dependency check, secret detection</li><li>Test: Unit, integration, security tests</li><li>Build: Artifact creation con security hardening</li><li>Deploy: Deployment automatico con verification</li><li>Monitor: Health check e security monitoring</li></ol><h3>La Misura: Come sapere se funziona</h3><p>Post-deployment, il sistema fornisce feedback continuo attraverso metriche oggettive che indicano la salute del processo DevOps. Misurare non significa controllare, ma capire dove intervenire per migliorare.</p><h3>DORA Metrics: Il Gold Standard della Performance</h3><p>Le metriche DORA (DevOps Research and Assessment) sono quattro indicatori chiave che predicono le performance di un’organizzazione software:</p><ul><li>Deployment Frequency: Quanto spesso rilasciamo in produzione</li><li>Lead Time for Changes: Tempo dal commit al codice in produzione</li><li>Mean Time to Recovery (MTTR): Quanto velocemente ripristiniamo dopo un incidente</li><li>Change Failure Rate: Percentuale di deploy che causano failure in produzione</li></ul><h3>Security Metrics: Sicurezza Quantificabile</h3><p>La sicurezza non può essere un’impressione, deve essere misurabile:</p><p>Vulnerabilities Management:</p><ul><li>Mean Time to Detection (MTTD): Tempo per scoprire una vulnerabilità</li><li>Mean Time to Remediation (MTTR): Tempo per fixare dopo la scoperta</li><li>Vulnerability Density: Numero di vulnerabilità per 1000 linee di codice</li><li>Critical vs High vs Medium: Distribuzione per severità</li></ul><p>Compliance Score:</p><ul><li>Percentage of compliant deployments: Deploy che passano tutti i security gates</li><li>Policy violations per sprint: Trending di violazioni nel tempo</li><li>Security debt ratio: Vulnerabilità note non ancora risolte vs nuove feature</li></ul><p>Security Coverage:</p><ul><li>Percentage di codice coperto da SAST/DAST</li><li>Dipendenze scansionate vs totale</li><li>Secret scanning hit rate e false positive rate</li></ul><h3>DevEx Metrics: L’Esperienza Quantificata</h3><p>Developer Experience non è solo sentiment, ma può essere misurata oggettivamente attraverso metriche o azioni che il team manager può adottare:</p><p>Developer Satisfaction (Survey-based):</p><ul><li>Net Promoter Score (NPS) del team</li><li>Tool satisfaction rating per ogni strumento nella toolchain</li><li>Perceived productivity score (self-reported)</li><li>Frequenza ideale: Quarterly pulse survey</li></ul><p>Onboarding Time:</p><ul><li>Time to first commit: Dal day 1 al primo codice in repository</li><li>Time to first production deploy: Quando un nuovo developer deploya autonomamente</li><li>Time to independence: Quando non necessita più mentoring costante</li><li>Benchmark: &lt; 1 settimana per first commit, &lt; 1 mese per independence</li></ul><p>Context Switching Metrics:</p><ul><li>Number of tools used daily: Meno è meglio</li><li>Average interruptions per day: Meeting, incident, support requests</li><li>Focus time blocks: Ore consecutive senza interruzioni</li><li>Work In Progress (WIP) items: Task parallele per developer</li></ul><h3>Conclusione</h3><p>L’adozione dei principi DevOps rappresenta un pilastro strategico nello sviluppo software contemporaneo. La capacità di adattarsi a questa metodologia è quindi un requisito fondamentale per l’evoluzione professionale nel ruolo. Team che iniziano questo percorso oggi, che abbracciano l’automazione come filosofia e la sicurezza come principio fondante, non stanno solo costruendo software migliore — stanno costruendo organizzazioni antifragili che diventano più forti ad ogni sfida.</p><p>Iniziate oggi, iniziate con piccoli cambiamenti, ma iniziate. Ogni pipeline automatizzata, ogni security check aggiunto, ogni metrica monitorata è un passo verso un futuro dove il vostro team piccolo può battere i giganti nonostante le sue dimensioni, ma proprio grazie alla sua agilità potenziata dal DevOps.</p><h3>Bibliografia e Fonti</h3><ol><li>Atlassian CALMS Framework: <a href="https://www.atlassian.com/devops/frameworks/calms-framework">https://www.atlassian.com/devops/frameworks/calms-framework</a> — Framework di valutazione DevOps</li><li>NIST DevSecOps Practices: <a href="https://www.nccoe.nist.gov/projects/secure-software-development-security-and-operations-devsecops-practices">https://www.nccoe.nist.gov/projects/secure-software-development-security-and-operations-devsecops-practices</a> — Standard di sicurezza</li><li>Scaled Agile Framework DevOps: <a href="https://framework.scaledagile.com/devops">https://framework.scaledagile.com/devops</a> — Definizioni e pratiche DevOps</li><li>Cprime CALMS Analysis: <a href="https://www.cprime.com/resources/blog/defining-the-5-devops-principles-calms/">https://www.cprime.com/resources/blog/defining-the-5-devops-principles-calms/</a> — Analisi dettagliata principi CALMS</li><li>Microsoft Developer Experience: <a href="https://developer.microsoft.com/en-us/developer-experience">https://developer.microsoft.com/en-us/developer-experience</a> — Definizione e framework DevEx</li><li>Splunk DevEx Guide: <a href="https://www.splunk.com/en_us/blog/learn/developer-experience-devex.html">https://www.splunk.com/en_us/blog/learn/developer-experience-devex.html</a> — Guida completa DevEx</li><li>DevOps.com Security Best Practices: <a href="https://devops.com/securing-the-devops-pipeline-tools-and-best-practices-2/">https://devops.com/securing-the-devops-pipeline-tools-and-best-practices-2/</a> — Best practices sicurezza 2024</li><li>Cortex DevOps Security Guide: <a href="https://www.cortex.io/post/devops-security-best-practices">https://www.cortex.io/post/devops-security-best-practices</a> — Strategie security moderne</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4eca1c0e8eac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Proteggere le Credenziali AWS e GitHub sui Laptop degli Sviluppatori: un Approccio SecOps e OpSec…]]></title>
            <link>https://savezzo.medium.com/proteggere-le-credenziali-aws-e-github-sui-laptop-degli-sviluppatori-un-approccio-secops-e-opsec-b3a520ebeab3?source=rss-393b205ff1b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/b3a520ebeab3</guid>
            <category><![CDATA[devex]]></category>
            <category><![CDATA[secops-solution]]></category>
            <category><![CDATA[information-technology]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Saverio M.]]></dc:creator>
            <pubDate>Sun, 07 Dec 2025 08:55:38 GMT</pubDate>
            <atom:updated>2025-12-07T08:55:38.093Z</atom:updated>
            <content:encoded><![CDATA[<h3>Proteggere le Credenziali AWS e GitHub sui Laptop degli Sviluppatori: un Approccio SecOps e OpSec su macOS</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_FFB85PM2DeXalZK" /><figcaption>Photo by <a href="https://unsplash.com/@jsalvino?utm_source=medium&amp;utm_medium=referral">John Salvino</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>In molti team la sicurezza del cloud è ormai matura: MFA ovunque, IAM least privilege, logging centralizzato, rotazione chiavi automatizzata.<br>Eppure, una delle superfici d’attacco più ignorate resta quella più vicina a noi:<strong> il laptop dello sviluppatore 💻🤓.</strong></p><p>Oggi, gli attacchi più efficaci non puntano tanto ai cloud provider quanto alla supply chain e agli endpoint di chi sviluppa.</p><p>Infostealer, malware mirati e script malevoli nelle dipendenze possono sottrarre in pochi millisecondi file come:</p><ul><li>~/.aws/credentials</li><li>.git-credentials</li><li>~/.docker/config.json</li><li>token GitHub in plain-text</li></ul><p>chiavi cloud statiche lasciate in repository personali o backup non cifrati<br>Da un punto di vista SecOps / OpSec, salvare credenziali in chiaro su disco equivale ad aprire una porta sul retro nell’infrastruttura cloud.</p><p>Questo articolo presenta una soluzione moderna ed efficace basata su due strumenti nativi e consolidati su macOS:<br>✔ osxkeychain per Git e Docker<br>✔ aws-vault per AWS<br>per eliminare completamente l’uso di credenziali statiche in chiaro e adottare un modello Zero Trust locale.</p><h3>1. Perché la persistenza su disco è pericolosa (Threat Model)</h3><p>Salvare credenziali in file di testo su un laptop significa esporle a:</p><p><strong>1. Malware/Infostealer</strong></p><p>Strumenti come RedLine, Lumma o Raccoon esfiltrano automaticamente:</p><ul><li>~/.aws/credentials</li><li>Token GitHub</li><li>File JSON Docker con credenziali base64</li></ul><p><strong>2. Compromissione del processo</strong></p><p>Uno script npm/yarn/pip può leggere file locali con i permessi dell’utente.</p><p><strong>3. Sync &amp; Backup Leakage</strong></p><p>Molti sviluppatori sincronizzano automaticamente:</p><ul><li>home directory</li><li>dotfiles</li><li>backup Time Machine non cifrati</li><li>repository privati su GitHub/GitLab</li></ul><p><strong>4. Lateral Movement</strong></p><p>Un attaccante che ottiene lunghe-term credentials AWS ottiene accesso completo all’account, indipendentemente dall’hardening dell’infrastruttura.</p><blockquote>La persistenza è il nemico. Un segreto che esiste in chiaro su disco è un segreto già compromesso.</blockquote><h3>2. GitHub su macOS: usare il Keychain, non i file in chiaro</h3><p>Git supporta i Credential Helper, sistemi che permettono di salvare i token in modo sicuro nel macOS Keychain (che usa AES + Secure Enclave).</p><p>❌ <strong>Evitare</strong></p><ul><li>.git-credentials (plaintext)</li><li>credential.helper store (plaintext)</li><li>Token GitHub persistenti in file testuali</li></ul><p>✔ <strong>Soluzione sicura con osxkeychain</strong></p><pre>git config --global --unset credential.helper</pre><pre>git config --global credential.helper osxkeychain</pre><p>Quando Git richiede un token, macOS lo memorizza nel System Keychain, protetto da:</p><ul><li>crittografia hardware</li><li>blocco biometrico/password</li><li>access control del sistema</li></ul><blockquote>Nessun file, nessuna copia accidentale nei backup, nessuna lettura da processi.</blockquote><h3>3. Docker: evitare il JSON con credenziali base64</h3><p>Di default, Docker salva le credenziali nel file:</p><pre>~/.docker/config.json</pre><p>Che può contenere:</p><pre>{<br>  &quot;auths&quot;: {<br>    &quot;https://index.docker.io/v1/&quot;: {<br>      &quot;auth&quot;: &quot;base64(username:password)&quot;<br>    }<br>  }<br>}</pre><blockquote>Base64 ≠ sicurezza.</blockquote><p>✔ <strong>Soluzione sicura</strong></p><p>Usare il credential store nativo:</p><pre>brew install docker-credential-helper</pre><p>E configurare:</p><pre>{<br>  &quot;credsStore&quot;: &quot;osxkeychain&quot;<br>}</pre><p>Anche qui, i segreti vivono solo nel Keychain, non nel filesystem.</p><h3>4. AWS: passare dalle chiavi statiche alle sessioni effimere con aws-vault</h3><p>Il problema più grave è AWS: con aws configure, le chiavi vengono salvate in:</p><pre>~/.aws/credentials</pre><p>In chiaro. Permanenti. Accessibili da qualsiasi processo.</p><p>Il tool <strong>aws-vault</strong> risolve entrambi i problemi:</p><p>1. elimina il file credentials<br>2. usa sessioni temporanee STS invece di chiavi statiche</p><p><strong>Come funziona aws-vault</strong></p><p>1. Le long-term credentials vengono salvate nel macOS Keychain<br>2. Quando esegui un comando, aws-vault genera credenziali temporanee (STS)<br>3. Queste credenziali non vengono mai salvate su disco<br>4. Vengono iniettate solo nel processo figlio (aws, terraform, sam, ecc.)</p><p><strong>Installazione</strong></p><pre>brew install aws-vault</pre><p>Inserimento credenziali</p><pre>aws-vault add prod</pre><p>Esecuzione sicura</p><pre>aws-vault exec prod -- aws s3 ls</pre><blockquote>aws-vault permette anche di usare MFA obbligatorio, assume-role, scadenze brevi, e integra logging CloudTrail → ottimo per team SecOps.</blockquote><h3>5. Zero Trust Workstation: principi da seguire</h3><p>Per gli endpoint degli sviluppatori, un approccio moderno dovrebbe includere:</p><p><strong>Principio 1</strong> — Nessun segreto deve risiedere in chiaro su disco</p><p>Mai. Neanche temporaneamente.<br>(Sì, anche docker login va messo in sicurezza.)</p><p><strong>Principio 2</strong> — Le credenziali devono essere effimere</p><p>Usare sessioni STS brevi.<br>Mai long-term credentials operative.</p><p><strong>Principio 3</strong> — Autenticazione delegata all’hardware</p><p>Usare:</p><ul><li>macOS Keychain</li><li>Secure Enclave</li><li>MFA</li><li>Passkey / WebAuthn</li><li>Yubikey quando possibile</li></ul><p><strong>Principio 4</strong> — Nessun processo deve poter “leggere” i segreti</p><p>Usare quindi secret injection runtime, non file persistenti.</p><h3>6. Conclusione: il laptop è parte dell’architettura cloud</h3><p>Blindare l’infrastruttura AWS o GitHub senza proteggere i laptop degli sviluppatori è come installare una cassaforte… ma lasciare la chiave sotto il tappetino.</p><p>Con osxkeychain e aws-vault è possibile:</p><p>🔒 Eliminare totalmente le credenziali in chiaro</p><p>🧬 Ridurre la superficie d’attacco degli endpoint</p><p>⚔️ Mitigare infostealer e malware</p><p>⏳ Usare solo sessioni temporanee</p><p>📦 Aumentare l’OpSec senza peggiorare la Developer Experience</p><p>È un piccolo cambiamento nelle abitudini locali, ma un enorme passo avanti nella sicurezza complessiva dell’organizzazione.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3a520ebeab3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ Automatizzare i Controlli di Qualità e Sicurezza con Git Hooks e GitHub Actions]]></title>
            <link>https://savezzo.medium.com/automatizzare-i-controlli-di-qualit%C3%A0-e-sicurezza-con-git-hooks-e-github-actions-5e0c584aa036?source=rss-393b205ff1b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/5e0c584aa036</guid>
            <dc:creator><![CDATA[Saverio M.]]></dc:creator>
            <pubDate>Wed, 12 Nov 2025 13:13:45 GMT</pubDate>
            <atom:updated>2025-11-12T13:15:07.861Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fyVK3NV06GjRjRQa" /><figcaption>Photo by <a href="https://unsplash.com/@yancymin?utm_source=medium&amp;utm_medium=referral">Yancy Min</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><blockquote>Questa guida rappresenta una proposta architetturale e operativa ottimizzata per la DevEx. I concetti e gli strumenti qui descritti sono in continua evoluzione, specialmente nell’ambito dell’integrazione AI. Troverai in fondo all’articolo un REPO con gli esempi completi, che potranno subire variazioni rispetto all’articolo.</blockquote><p>Developer Experience (DevEx) non è solo un termine alla moda per parlare di strumenti fighi, ma la spina dorsale di un team ad alta velocità e un’organizzazione resiliente. In un panorama tecnologico dove la velocità di rilascio è tutto, il vero collo di bottiglia non sono quasi mai i sistemi di deploy, ma i processi di controllo della qualità e della sicurezza che dipendono dall’intervento umano.</p><p>L’obiettivo fondamentale di un’ottima DevEx è rimuovere il carico cognitivo dei controlli manuali e dell’applicazione forzata delle regole. Quando un developer deve ricordarsi di lanciare il linter, eseguire i test completi o, peggio, verificare manualmente le credenziali hardcoded, la produttività cala drasticamente e l’errore umano è in agguato.</p><p>La soluzione che esploreremo è la creazione di un flusso di lavoro di rilascio definititivo, automatizzando completamente i check di qualità e sicurezza in due fasi cruciali:</p><ol><li>“Shift Left” Estremo (Git Hooks Locali): Spostare i controlli il più a sinistra possibile nel ciclo di sviluppo — ovvero, sulla macchina del developer, prima ancora del git push. Questo fornisce un feedback istantaneo e previene l’ingresso di codice sporco o insicuro nel repository.</li><li>Pipeline CI/CD Robuste e Trasparenti: Semplificare il processo di rilascio con automazioni che garantiscano coerenza, velocità e, soprattutto, una facile capacità di rollback.</li></ol><p>A rendere tutto più potente, vedremo come integrare un pezzo di innovazione cruciale: la verifica di sicurezza basata su Intelligenza Artificiale direttamente nel flusso di commit. Trasformiamo così la qualità da un ostacolo in un meccanismo automatico e gratificante.</p><blockquote>PREMESSA: Workflow pensato con uso di Javascript e con IaC serverless framework e un framework JS come Express o Fastify. Il tutto però è declinabile con qualsiasi ambiente.</blockquote><h3>1. 💡 La Qualità Inizia sul PC del Dev (Git Hooks con Lefthook)</h3><p>Se un bug o un errore di stile arriva alla pipeline CI/CD, abbiamo già perso tempo prezioso.</p><p>Usiamo Lefthook <em>(</em><a href="https://lefthook.dev/"><em>https://lefthook.dev/</em></a><em>)</em> per gestire i Git Hooks (<a href="https://git-scm.com/book/ms/v2/Customizing-Git-Git-Hooks">https://git-scm.com/book/ms/v2/Customizing-Git-Git-Hooks</a>) locali e fornire feedback istantaneo sui soli file modificati.</p><h3>Configurazione pre-commit: Linting e Test sui file modificati</h3><p>Nel file di configurazione radice del progetto, .lefthook.yml, impostiamo i controlli che devono passare prima che un commit o un push vengano finalizzati.</p><pre># .lefthook.yml<br>commit-msg:<br>  commands:<br>    validate-commit-message:<br>      run: ./scripts/validate_commit.sh<br>      files: []<br>pre-push:<br>  commands:<br>    copilot-review:<br>      interactive: true<br>      run: bash scripts/copilot-review.sh {staged_files}<br>    documentation-swagger:<br>      interactive: true<br>      run: bash scripts/documentation-swagger.sh<br>    check-documentation-markdown:<br>      run: ./scripts/check-documentation-markdown.sh<br>pre-commit:<br>  commands:<br>    lint:<br>      glob: &quot;*.{js,jsx,ts,tsx}&quot;<br>      run: yarn lint {staged_files}<br>      stage_fixed: true<br>    test:<br>      glob: &quot;*.{js,jsx,ts,tsx,spec.js,test.js}&quot;<br>      run: yarn test --findRelatedTests {staged_files} --watchAll=false</pre><blockquote><em>🎯 L’opzione — findRelatedTests (per Jest/Vitest) assicura che il check del commit sia istantaneo, evitando di eseguire l’intera suite di test ad ogni salvataggio.</em></blockquote><p>Spiegazione dei comandi</p><ul><li>validate-commit-message: permette di vedere se il pattern usato è quello in stile better commit</li><li>copilot-review: review del codice da parte di AI per la sicurezza e bugs</li><li>documentation-swagger: crea documentazione swagger partendo dagli schemi di validazione di del framework fastify. (se non conoscete: <a href="https://fastify.dev/docs/latest/Reference/Validation-and-Serialization/">https://fastify.dev/docs/latest/Reference/Validation-and-Serialization/</a>)</li><li>check-documentation-markdown: contorlla che la docs markdown sia stata modificata in questo push per tenerla allineata alle modifiche apportate.</li><li>lint: verifica il linting</li><li>test: lancia unit-test per check</li></ul><h3>2. 🛡️ Il Turbo: AI Code Review Interattiva nel Commit (Focus Sicurezza)</h3><p>Qui entra in gioco l’innovazione. Integriamo un’analisi di sicurezza avanzata, basata su AI, direttamente nel flusso di commit usando l’estensione GitHub Copilot CLI.</p><p>L’AI viene istruita per agire come un <em>Security Auditor</em> statico sul diff dei file in stage.</p><h3>A. Integrazione in Lefthook</h3><p>Aggiungiamo un comando copilot-review nel .lefthook.yml:</p><pre># .lefthook.yml<br>pre-commit:<br>  commands:<br>    # ... (lint e test) ...<br>    copilot-review:<br>      interactive: true # Permette all&#39;utente di interagire con lo script<br>      run: bash scripts/copilot-review.sh {staged_files}</pre><h3>B. Lo Script di Review (scripts/copilot-review.sh)</h3><p>Questo script prepara un prompt altamente specializzato e blocca il commit se l’AI rileva un problema e l’utente decide di non procedere.</p><pre>for file in &quot;$@&quot;; do<br>  # 1. Ottieni il contenuto del file staged (solo il diff)<br>  CONTENT=$(git diff --cached &quot;$file&quot;)<br>  <br>  if [ -z &quot;$CONTENT&quot; ]; then continue; fi<br><br>  # 2. Prompt specifico per l&#39;audit di sicurezza<br>  PROMPT=&quot;Agisci come un esperto security auditor e analizzatore di codice statico. Analizza il seguente DIFF alla ricerca di:<br>  1. 🔴 Credenziali Hardcoded (CRITICO): API keys, token.<br>  2. Vulnerabilità di Sicurezza: SQL Injection, XSS, Path Traversal.<br>  3. Bug di Logica: Race conditions, Null Pointers.<br>  <br>  Fornisci un report strutturato (formato Markdown) solo se trovi problemi REALI.<br>  <br>  \`\`\`diff<br>  $CONTENT<br>  \`\`\`&quot;<br>  <br>  # 3. Chiede a Copilot di analizzare (richiede gh copilot CLI installata)<br>  REVIEW=$(echo &quot;$PROMPT&quot; | gh copilot suggest 2&gt;&amp;1 || echo &quot;Errore nella chiamata&quot;)<br>  <br>  echo &quot;📄 Reviewing: $file&quot;<br>  echo &quot;🤖 Copilot Response:&quot;<br>  echo &quot;$REVIEW&quot;<br>  <br>  # 4. Blocco interattivo se vengono trovati problemi<br>  if echo &quot;$REVIEW&quot; | grep -iE &quot;(critico|vulnerabilità|errore|bug|problem)&quot; &gt; /dev/null; then<br>    read -p &quot;   ⚠️  Trovati potenziali problemi. Continuare comunque? (s/N): &quot; -n 1 -r<br>    echo &quot;&quot;<br>    if [[ ! $REPLY =~ ^[SsYy]$ ]]; then<br>      HAS_ISSUES=true<br>      break<br>    fi<br>  fi<br>done<br><br>if [ &quot;$HAS_ISSUES&quot; = true ]; then<br>  echo &quot;❌ Commit annullato. Correggi i problemi di sicurezza prima di procedere.&quot;<br>  exit 1<br>fi<br>exit 0</pre><blockquote>⚠️ Nota sul Prompting AI: Per una DevEx ottimale, è cruciale che il prompt sia conciso e focalizzato esclusivamente sul diff (git diff — cached). Inviare l’intero file ritarderebbe inutilmente la risposta e ridurrebbe l’efficacia del controllo. La velocità di feedback è prioritaria.</blockquote><p>Nel prossimo step, l’obiettivo è estendere questa AI Review anche alla CI/CD, con LLM dedicati al controllo semantico dei test e alla generazione automatica di changelog o Swagger docs.</p><h3>3. 🏗️ Pipeline CI/CD a Rilascio Veloce e Sicuro (GitHub Actions)</h3><p>Una volta che il codice ha superato i controlli locali e l’AI Review, entra in gioco la pipeline CI/CD, il cuore operativo della qualità continua. L’obiettivo è duplice:</p><ul><li>Rendere la pipeline rapida e prevedibile (velocità di feedback → motivazione per il developer)</li><li>Rendere la sicurezza e la qualità automatiche (niente più “dimenticanze” o check manuali)</li></ul><p>Vediamo come questi principi si concretizzano in tre step fondamentali.</p><h3>A. Ottimizzazione: Cache e Node Version Dinamica</h3><p>Nessuno sviluppatore ama aspettare minuti per vedere se il suo PR passa i test o fallisce per un errore banale. La velocità della pipeline è un pilastro della Developer Experience: ogni secondo di attesa in più rompe il “flow” cognitivo e rallenta la collaborazione del team.</p><p>Per questo, il primo step della pipeline CI/CD si concentra sull’ottimizzazione intelligente. Lo scopo è:</p><ul><li>Evitare di reinstallare tutto ogni volta</li><li>Garantire che il runtime sia coerente con la versione definita nel progetto (per evitare “funziona solo sul mio PC”)</li></ul><p>Con pochi comandi possiamo ottenere tutto questo:</p><p>🔧Estratto dal Workflow</p><pre>jobs:<br>  qa:<br>    steps:<br>      - name: Get Node version from serverless.yml<br>        id: get_node_version<br>        run: |<br>          runtime=$(grep &#39;runtime:&#39; serverless.yml | awk &#39;{print $2}&#39;)<br>          node_version=$(echo $runtime | sed -E &#39;s/nodejs([0-9]+)\.x/\1/&#39;)<br>          echo &quot;node_version=$node_version&quot; &gt;&gt; $GITHUB_OUTPUT<br>          <br>      - uses: actions/setup-node@v4<br>        with:<br>          node-version: ${{ steps.get_node_version.outputs.node_version }}<br>          <br>      - name: Cache node modules<br>        uses: actions/cache@v4<br>        with:<br>          path: |<br>            **/node_modules<br>            ~/.cache/yarn<br>          key: temp-yarn-cache-${{ github.run_id }}<br>          restore-keys: |<br>            temp-yarn-cache-</pre><h3>🎯 Benefici</h3><ul><li>Cache intelligente: riduce drasticamente i tempi di esecuzione delle pipeline.</li><li>Versione dinamica: si adatta automaticamente alla versione Node definita nel file serverless.yml, garantendo coerenza tra ambienti locali e CI.</li><li>Zero attrito per il developer: l’ambiente di test è sempre pronto e allineato, senza setup manuali.</li></ul><h3>B. Sicurezza Rigorosa e Fallimento Condizionale (Trivy)</h3><p>La velocità senza sicurezza è solo un modo più rapido per cadere nei guai 😅 Dopo l’ottimizzazione, il secondo pilastro della pipeline è la scansione della sicurezza delle dipendenze e del codice sorgente.</p><p>Usiamo Trivy, uno strumento open-source mantenuto da Aqua Security, che analizza il filesystem del progetto o le immagini Docker alla ricerca di vulnerabilità note (CVE).</p><p>Ma qui introduciamo un concetto chiave:</p><blockquote><em>“Non tutte le vulnerabilità devono bloccare il rilascio — solo quelle che contano, e solo nei contesti giusti.”</em></blockquote><p>In altre parole, la pipeline deve essere intelligente:</p><ul><li>in ambienti di sviluppo o staging, può segnalare problemi senza fermare il flusso</li><li>in produzione, invece, ogni vulnerabilità critica deve bloccare il deploy</li></ul><p>🔧 Estratto dal Workflow QA</p><pre>- name: Run security scan CODE<br>  uses: aquasecurity/trivy-action@master<br>  with:<br>    scan-type: fs # Filesystem scan (analizza le dipendenze e il codice)<br>    severity: MEDIUM,HIGH,CRITICAL<br>    output: trivyCode.txt<br>    # 🔴 Fallisce solo se in &#39;prod&#39; e con problemi critici<br>    exit-code: ${{ github.event.inputs.envVariable == &#39;prod&#39; &amp;&amp; &#39;1&#39; || &#39;0&#39; }}</pre><h3>🎯 Benefici</h3><ul><li>Controlli proporzionati: niente falsi allarmi o blocchi inutili durante lo sviluppo.</li><li>Rigore in produzione: la pipeline diventa un gate di sicurezza reale, non un ostacolo quotidiano.</li><li>Visibilità immediata: i risultati vengono tracciati e allegati come artefatti, senza rumore aggiuntivo nel PR.</li></ul><p>In progetti di grandi dimensioni, è consigliabile abbinare Trivy a SBOM (Software Bill of Materials) per tracciare in modo trasparente le dipendenze usate e le relative versioni, così da poter intervenire rapidamente in caso di nuovi CVE.</p><h3>C. Secret Scanning Automatica con Gitleaks</h3><p>La sicurezza non riguarda solo le vulnerabilità note nelle dipendenze, ma anche le <em>fughe di segreti</em> nel codice sorgente: API keys, token, password o certificati possono essere accidentalmente committati e diventare un rischio immediato.</p><p>Per automatizzare il controllo di queste esposizioni, integriamo Gitleaks direttamente nella pipeline CI/CD.</p><p>Questo step esegue una scansione completa del codice sorgente e dei commit recenti, generando un report e commentando automaticamente la Pull Request con il risultato. In caso di violazioni, la pipeline fallisce e il merge viene bloccato, garantendo che nessun segreto finisca accidentalmente in produzione.</p><p>🔧 <em>Estratto dal workflow GitHub Actions (.github/workflows/gitleaks.yml)</em></p><pre>name: Gitleaks Security Scan<br><br>on:<br>  pull_request:<br>    branches:<br>      - main<br>      - develop<br>jobs:<br>  gitleaks:<br>    name: Gitleaks Secret Scan<br>    runs-on: ubuntu-latest<br>    permissions:<br>      contents: read<br>      pull-requests: write<br>    steps:<br>      - name: Checkout code<br>        uses: actions/checkout@v4<br>        with:<br>          fetch-depth: 0<br>      - name: Run Gitleaks<br>        id: gitleaks<br>        uses: gitleaks/gitleaks-action@v2<br>        env:<br>          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}<br>        continue-on-error: true<br>      - name: Parse and Comment Results<br>        if: steps.gitleaks.outcome == &#39;failure&#39;<br>        uses: peter-evans/create-or-update-comment@v4<br>        with:<br>          token: ${{ secrets.GITHUB_TOKEN }}<br>          issue-number: ${{ github.event.pull_request.number }}<br>          comment-identifier: gitleaks-scan<br>          edit-mode: replace<br>          body: |<br>            ## 🔒 Gitleaks Security Scan - Violazioni Rilevate<br>            ❌ **Trovate ${{ env.COUNT }} violazioni di sicurezza**<br>            ### Dettagli:<br>            ${{ env.VIOLATIONS }}<br>            ⚠️ **Pipeline bloccata:** rimuovi i segreti prima del merge.<br>      - name: Comment PR on success<br>        if: steps.gitleaks.outcome == &#39;success&#39;<br>        uses: peter-evans/create-or-update-comment@v4<br>        with:<br>          token: ${{ secrets.GITHUB_TOKEN }}<br>          issue-number: ${{ github.event.pull_request.number }}<br>          comment-identifier: gitleaks-scan<br>          edit-mode: replace<br>          body: |<br>            ## 🔒 Gitleaks Security Scan<br>            ✅ Nessuna violazione rilevata</pre><h3>🎯 Benefici</h3><ul><li>Feedback chiaro e automatico direttamente nella Pull Request</li><li>Nessun bisogno di controlli manuali o script locali</li><li>Blocco preventivo dei merge non sicuri</li><li>Commento auto-aggiornante grazie a peter-evans/create-or-update-comment</li></ul><h3>🚀 Estensione naturale</h3><p>Con Gitleaks, il ciclo DevEx/DevSecOps diventa completo:</p><ol><li>AI Review locale (Copilot CLI) → previene vulnerabilità logiche e di sicurezza nel diff</li><li>Lefthook → impedisce di committare codice non conforme</li><li>Gitleaks in CI/CD → previene la fuga di segreti</li><li>Trivy → verifica la sicurezza delle dipendenze e dell’immagine container</li></ol><h3>D. Rollback Facile: Tag e Check della Versione Univoca</h3><p>La capacità di un rollback veloce dipende dalla certezza che ogni deploy sia associato a un Tag univoco.</p><p>Aggiungiamo un check all’inizio del workflow di <em>Produzione</em> per prevenire deploy con lo stesso numero di versione (package.json) due volte.</p><pre># Estratto dal workflow di deploy PROD<br><br>jobs:<br>  check-tag:<br>    runs-on: ubuntu-latest<br>    steps:<br>      - name: Get version from package.json<br>        id: get_version<br>        run: |<br>          # Legge la versione corrente<br>          version=$(jq -r &#39;.version&#39; package.json) <br>          echo &quot;version=$version&quot; &gt;&gt; $GITHUB_ENV<br>      - name: Check if tag exists<br>        run: |<br>          TAG_VERSION=&quot;v$version&quot;<br>          # Controlla se il tag esiste già nel repository<br>          if git rev-parse &quot;refs/tags/$TAG_VERSION&quot; &gt;/dev/null 2&gt;&amp;1; then<br>            echo &quot;❌ Tag $TAG_VERSION already exists! Aggiorna package.json per un nuovo deploy.&quot;<br>            exit 1<br>          else<br>              echo &quot;✅ Tag $TAG_VERSION è disponibile. Proceeding with deploy.&quot;<br>          fi<br>  # ... (il job di deploy procede solo se check-tag ha successo)</pre><h3>🎯 Benefici</h3><p>Questo sistema impedisce deploy “fantasma” non tracciati. Il developer è costretto ad aumentare la versione (es. con npm version patch) prima di un nuovo rilascio, garantendo che ogni deploy sia una release tracciabile e reversibile.</p><h3>🏁 Conclusione: DevEx e Fiducia</h3><p>Automatizzando i controlli locali con Lefthook e la AI Security Review, abbiamo spostato la responsabilità della qualità dal revisore (umano) al sistema automatico.</p><p>Questo, unito a una pipeline CI/CD con ottimizzazione (caching), sicurezza rigorosa (Trivy) e un meccanismo di release/tagging a prova di rollback, trasforma la qualità da un ostacolo in un acceleratore.</p><p>Con l’aggiunta di Gitleaks alla pipeline CI/CD, ogni commit e pull request viene ora verificato non solo per la qualità e sicurezza del codice, ma anche per la protezione delle credenziali.Un ulteriore passo verso una Developer Experience realmente sicura, automatizzata e priva di attriti cognitivi.</p><p>Sviluppare velocemente e in sicurezza? Assolutamente possibile. Basta automatizzare i processi giusti! 🚀</p><p>✍🏻 REPO dei file citati nell’articolo: <a href="https://github.com/savez/devex-hookGit-GithubActions">https://github.com/savez/devex-hookGit-GithubActions</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5e0c584aa036" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to expose a (monolithic) service securely using AWS services]]></title>
            <link>https://savezzo.medium.com/how-to-expose-a-monolithic-service-securely-using-aws-services-21bf8ae6091?source=rss-393b205ff1b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/21bf8ae6091</guid>
            <category><![CDATA[cognito]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[load-balancer]]></category>
            <category><![CDATA[aws-waf]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Saverio M.]]></dc:creator>
            <pubDate>Thu, 06 Jul 2023 14:57:29 GMT</pubDate>
            <atom:updated>2023-07-06T14:57:29.525Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WCHvJRMXqz6D_LKc" /><figcaption>Photo by <a href="https://unsplash.com/@thisisengineering?utm_source=medium&amp;utm_medium=referral">ThisisEngineering RAEng</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3><strong>Premessa</strong></h3><p>Spesso ci capita di dover rendere accessibili dall’esterno della nostra rete software aziendali magari monolitici residenti su un server.</p><p>Una delle domande che mi sono posto è stata: <em>Come posso pubblicare l’applicazione rendendola sicura da attacchi?</em></p><p>La soluzione che ho intrapreso è stata quella di usare alcuni servizi di AWS per poter astrarre la pubblicazione del servizio e portare ad un layer superiore l’accesso al sistema.</p><p><strong>I servizi che ho utilizzato sono:</strong></p><ul><li>AWS Load Balancer</li><li>AWS Cognito</li><li>AWS Route53</li></ul><h3>La soluzione</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/695/1*l03kPgM6FyKUyQRbCCfMDA.png" /><figcaption>Schema della soluzione</figcaption></figure><p><strong>AWS Route 53</strong></p><p><a href="https://aws.amazon.com/it/route53/">https://aws.amazon.com/it/route53/</a></p><p>E’ utilizzato per gestire il DNS dell’applicativo. Il DNS punterà al Load Balancer</p><p><strong>AWS Load Balancer</strong></p><p><a href="https://aws.amazon.com/it/elasticloadbalancing/">https://aws.amazon.com/it/elasticloadbalancing/</a></p><p>D’ il servizio che fa da bilanciatore del carico e permette quindi di gestire il traffico e il suo instradamento.</p><p>Altra caratteristica è che possono essere agganciati altri servizi tra cui:</p><ul><li>AWS Waf: per gestire un firewall applicativo con un set di regole che possono andare dal IP filtering a regole di analisi delel request (<a href="https://aws.amazon.com/it/waf/">https://aws.amazon.com/it/waf/</a>).</li><li>AWS Cognito che permette di creare un layer autorizzativo all’interno del Load Balancer</li></ul><p>Essendo un servizio gestito la mitigazione degli attacchi DDos è “intrinseca” e con AWS Waf possiamo dare molta più sicurezza al singolo endpoint.</p><p><strong>AWS</strong> <strong>Cognito</strong></p><p><a href="https://aws.amazon.com/it/cognito">https://aws.amazon.com/it/cognito/</a></p><p>E’ stato utilizzato per diventare il nostro sistema di login.</p><p>In questo modo finchè non c’è una login valida <strong>NON esponiamo il nostro server al pubblico.</strong></p><p>Questo aumenta molto la sicurezza perché un qualsiasi attacco arriverebbe solo al Load Balancer che fornirebbe un 403 (se non opportunamente autorizzato).</p><p>Modificando (se possiamo e abbiamo le competenze) il software, possiamo usare il JWT token staccato da Cognito (che mi garantisce la login e l’autorizzazione) per loggarsi all’applicativo.</p><p><strong>Abbiamo quindi spezzato la login da un monolite e portata su servizi gestiti senza esporre nulla in modo pubblico.</strong></p><p>Di seguito esempi di script per generare l’infrastruttura</p><p><strong>Terraform</strong></p><pre># Dichiarazione del provider AWS<br>provider &quot;aws&quot; {<br>  region = &quot;us-west-2&quot;  # Inserisci la tua regione desiderata<br>}<br><br># Creazione del record DNS in Route 53<br>resource &quot;aws_route53_record&quot; &quot;example_dns_record&quot; {<br>  zone_id = &quot;ZONE_ID&quot;  # Inserisci l&#39;ID della zona Route 53 in cui creare il record<br>  name    = &quot;example.com&quot;  # Inserisci il nome di dominio desiderato<br>  <br>  type    = &quot;A&quot;<br>  ttl     = &quot;300&quot;<br>  <br>  alias {<br>    name                   = &quot;LOAD_BALANCER_DNS_NAME&quot;  # Inserisci il nome DNS del bilanciatore di carico<br>    zone_id                = &quot;LOAD_BALANCER_ZONE_ID&quot;  # Inserisci l&#39;ID della zona del bilanciatore di carico<br>    evaluate_target_health = true<br>  }<br>}<br><br># Creazione del bilanciatore di carico<br>resource &quot;aws_lb&quot; &quot;example_load_balancer&quot; {<br>  name               = &quot;example-load-balancer&quot;<br>  subnets            = [&quot;SUBNET_ID_1&quot;, &quot;SUBNET_ID_2&quot;]  # Inserisci gli ID delle tue subnet<br>  security_groups    = [&quot;SECURITY_GROUP_ID&quot;]  # Inserisci l&#39;ID del tuo gruppo di sicurezza<br>  load_balancer_type = &quot;application&quot;<br>  <br>  # Definisci i tuoi listener, target group, ecc.<br>  # ...<br>}<br><br># Creazione dell&#39;istanza EC2<br>resource &quot;aws_instance&quot; &quot;example_instance&quot; {<br>  ami           = &quot;AMI_ID&quot;  # Inserisci l&#39;ID dell&#39;AMI desiderato<br>  instance_type = &quot;t2.micro&quot;<br>  <br>  # Definisci le tue impostazioni dell&#39;istanza EC2, come la subnet, il gruppo di sicurezza, ecc.<br>  # ...<br>}<br><br># Creazione di un dominio Cognito<br>resource &quot;aws_cognito_user_pool_domain&quot; &quot;example_cognito_domain&quot; {<br>  domain       = &quot;example-cognito-domain&quot;<br>  user_pool_id = &quot;USER_POOL_ID&quot;  # Inserisci l&#39;ID del tuo User Pool di Cognito<br>}<br><br># Aggiungi il record DNS a Route 53<br>output &quot;dns_record&quot; {<br>  value = aws_route53_record.example_dns_record.fqdn<br>}</pre><p><strong>CloudFormation</strong></p><pre>AWSTemplateFormatVersion: &quot;2010-09-09&quot;<br>Resources:<br>  ExampleDNSRecord:<br>    Type: AWS::Route53::RecordSet<br>    Properties:<br>      HostedZoneId: ZONE_ID  # Inserisci l&#39;ID della zona Route 53 in cui creare il record<br>      Name: example.com  # Inserisci il nome di dominio desiderato<br>      Type: A<br>      AliasTarget:<br>        HostedZoneId: LOAD_BALANCER_ZONE_ID  # Inserisci l&#39;ID della zona del bilanciatore di carico<br>        DNSName: LOAD_BALANCER_DNS_NAME  # Inserisci il nome DNS del bilanciatore di carico<br>        EvaluateTargetHealth: true<br><br>  ExampleLoadBalancer:<br>    Type: AWS::ElasticLoadBalancingV2::LoadBalancer<br>    Properties:<br>      Name: example-load-balancer<br>      Subnets:<br>        - SUBNET_ID_1  # Inserisci gli ID delle tue subnet<br>        - SUBNET_ID_2<br>      SecurityGroups:<br>        - SECURITY_GROUP_ID  # Inserisci l&#39;ID del tuo gruppo di sicurezza<br>      Type: application<br>      # Definisci i tuoi listener, target group, ecc.<br><br>  ExampleInstance:<br>    Type: AWS::EC2::Instance<br>    Properties:<br>      ImageId: AMI_ID  # Inserisci l&#39;ID dell&#39;AMI desiderato<br>      InstanceType: t2.micro<br>      # Definisci le tue impostazioni dell&#39;istanza EC2, come la subnet, il gruppo di sicurezza, ecc.<br><br>  ExampleCognitoDomain:<br>    Type: AWS::Cognito::UserPoolDomain<br>    Properties:<br>      Domain: example-cognito-domain<br>      UserPoolId: USER_POOL_ID  # Inserisci l&#39;ID del tuo User Pool di Cognito<br><br>Outputs:<br>  DnsRecord:<br>    Value: !Ref ExampleDNSRecord<br>    Description: DNS Record</pre><p><strong>CDK</strong></p><pre>import * as cdk from &#39;aws-cdk-lib&#39;;<br>import * as route53 from &#39;aws-cdk-lib/aws-route53&#39;;<br>import * as elbv2 from &#39;aws-cdk-lib/aws-elasticloadbalancingv2&#39;;<br>import * as ec2 from &#39;aws-cdk-lib/aws-ec2&#39;;<br>import * as cognito from &#39;aws-cdk-lib/aws-cognito&#39;;<br><br>export class MyStack extends cdk.Stack {<br>  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {<br>    super(scope, id, props);<br><br>    // Creazione del record DNS in Route 53<br>    const zone = route53.HostedZone.fromHostedZoneAttributes(this, &#39;Zone&#39;, {<br>      hostedZoneId: &#39;ZONE_ID&#39;,  // Inserisci l&#39;ID della zona Route 53 in cui creare il record<br>      zoneName: &#39;example.com&#39;  // Inserisci il nome di dominio desiderato<br>    });<br><br>    new route53.ARecord(this, &#39;DnsRecord&#39;, {<br>      zone: zone,<br>      recordName: &#39;example.com&#39;,<br>      target: route53.RecordTarget.fromAlias(new route53Targets.LoadBalancerTarget(loadBalancer))<br>    });<br><br>    // Creazione del bilanciatore di carico<br>    const vpc = new ec2.Vpc(this, &#39;Vpc&#39;, {<br>      // Definisci le tue impostazioni per la VPC<br>    });<br><br>    const loadBalancer = new elbv2.ApplicationLoadBalancer(this, &#39;LoadBalancer&#39;, {<br>      vpc: vpc,<br>      internetFacing: true,<br>      // Definisci i tuoi listener, target group, ecc.<br>    });<br><br>    // Creazione dell&#39;istanza EC2<br>    const instance = new ec2.Instance(this, &#39;Instance&#39;, {<br>      vpc: vpc,<br>      // Definisci le tue impostazioni dell&#39;istanza EC2, come l&#39;AMI, il tipo di istanza, ecc.<br>    });<br><br>    // Creazione di un dominio Cognito<br>    const userPool = new cognito.UserPool(this, &#39;UserPool&#39;, {<br>      // Definisci le tue impostazioni per il User Pool di Cognito<br>    });<br><br>    const userPoolDomain = new cognito.CfnUserPoolDomain(this, &#39;UserPoolDomain&#39;, {<br>      domain: &#39;example-cognito-domain&#39;,<br>      userPoolId: userPool.userPoolId<br>    });<br>  }<br>}<br><br>const app = new cdk.App();<br>new MyStack(app, &#39;MyStack&#39;);<br>app.synth();</pre><h3><strong>Conclusione</strong></h3><p>La soluzione ci ha permesso di diminuire la complessità di rete ma avere sicurezza e una maggior gestione senza necessariamente avere punti vulnerabili nel nostro perimetro.</p><blockquote><em>Articolo presente anche sul Blog: </em><a href="https://santagostino.github.io/blog/"><em>https://santagostino.github.io/blog/</em></a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=21bf8ae6091" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Git Hook per automatizzare le azioni “amministrative” (DevX part.2)]]></title>
            <link>https://savezzo.medium.com/git-hook-per-automatizzare-le-azioni-amministrative-devx-part-2-aff3ecf79b00?source=rss-393b205ff1b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/aff3ecf79b00</guid>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[devx]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[hooks]]></category>
            <dc:creator><![CDATA[Saverio M.]]></dc:creator>
            <pubDate>Sun, 05 Feb 2023 11:50:26 GMT</pubDate>
            <atom:updated>2023-02-05T11:50:26.576Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*oe6dV9D1Donpb6gq" /></figure><p>La <strong>DevX</strong>, è un aspetto che interviene a livello di singolo individuo, che mira a fornire a ciascuno la migliore esperienza possibile.</p><p>Nella maggior parte delle organizzazioni però non c’è un’unica persona dedicata allo sviluppo, ma che c’è un intero team (o più team) con competenze diverse e complementari, bisogna quindi porre attenzione anche alla Developer Experience del team intero, considerato come un’unità.</p><p>Pertanto, l’automazione di alcuni processi “amministrativi” che uno sviluppatore deve compiere durante la giornata o lo sviluppo di una feature può aiutare e migliorare notevolmente la <strong>DevX</strong>.</p><p><a href="https://medium.com/@savezzo/devx-al-santagostino-la-mia-proposta-ac0e3f65d980">Starterkit e developer portal</a> sono i primi due punti di miglioramento di una DevX che venga in aiuto allo sviluppatore (<em>ne abbiamo parlato in un’precendente articolo</em>).</p><p>In questo articolo si voleva approfondire come i <strong>Git hook</strong> possono aiutare ad automatizzare alcuni “azioni amministrative” che spesso devono essere fatte durante lo sviluppo.</p><p>I <strong>Git hook</strong> permettono infatti di aggiungere delle automazioni sulle azioni pre e post di git.</p><h4>Quali hook ci sono e dove si trovano?</h4><p>Alcuni hook disponibili sono:</p><ul><li>pre-commit</li><li>applypatch-msg</li><li>commit-msg</li><li>fsmonitor-watchman</li><li>post-update</li><li>pre-applypatch</li><li>pre-commit</li><li>pre-merge-commit</li><li>pre-push</li><li>pre-rebase</li><li>pre-receive</li><li>prepare-commit-msg</li><li>push-to-checkout</li><li>update</li></ul><h4>Come configurare un Git Hook</h4><p>Gli hooks sono salvati nella sottodirectory hooks all&#39;interno della directory Git. In molti progetti è .git/hooks.</p><p>Di default, Git inserisce in questa directory un mucchio di scripts di esempio, molti di essi sono utili; viene anche documentato l&#39;input per ciascuno script.</p><p>Tutti gli esempi sono scritti come shell scripts, con un po&#39; di Perl, tuttavia ogni script eseguibile chiamato in modo appropriato andrà bene — è possibile scriverli in Ruby, Python...</p><p>Per le versioni di Git successive alla 1.6, questi hook di esempio finiscono con .sample; è necessario rinominarli.</p><p>Per le versioni precedenti alla 1.6 i files hanno nome corretto ma non sono eseguibili.</p><p>Per abilitare uno script hook, bisogna inserire il file nella sottodirectory hooks della directory Git, il file dovrà essere nominato in modo appropriato ed eseguibile.</p><h4>Come li abbiamo usati in azienda e integrati nella nostra DevX</h4><p>In azienda li abbiamo utilizzati per poter automatizzare le azioni di unit teste lint che, da nostra styleguide, devono essere lanciati prima di un push remoto (<em>perchè la pipeline lo lancerà in automatico</em>).</p><p>Abbiamo quindi crearo uno script bash (pre-commit). Ecco un’esempio di codice</p><blockquote>#!/bin/bash <br>Color_Off=’\033[0m’ # Text Reset <br>Blue=’\033[0;34m’ # Blue <br>BBlue=’\033[1;34m’ # Blue bold <br>echo -e “${BBlue} Start actions pre-commit.. ${Color_Off}” <br>echo -e “${Blue} Run lint ${Color_Off}” <br>docker-compose exec -T app bash -c “yarn lint” <br>echo -e “${Blue} Run unit test ${Color_Off}” <br>docker-compose exec -T app bash -c “yarn test” <br>echo -e “${BBlue} End actions pre-commit ${Color_Off}”</blockquote><p>Coem potetevedere dall’esempio lanciamo prima di un commit sia il lint che gli unit-test sfruttando il nostro sistema di sviluppo basato sui docker.</p><p>Per poter gestire questi script globalmente su tutto il team (visto che dovrebbero essere messi nella cartella locale e non versionata) abbiamo pensato di strutturare uno script di init del progetto che sposta gli script dalla cartella versionata sul git, nella cartella locale e configura i docker per la loro esecuzione.</p><h4>Conclusioni</h4><p>Ho voluto dare qualche spunto su come i <strong>Git Hook</strong> possano essere strumenti molto utili per migliorare la <strong>DevX</strong> aziendale e permettere di aumentare la qualità del codice senza creare eccessivo carico cognitivo e di lavoro allo sviluppatore.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aff3ecf79b00" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>