Ti serve un ambiente di test su Azure? Niente di complicato. Solo una rete virtuale, un paio di macchine virtuali, un account di richiviazione. Quindi accedi al portale, trovi il pulsante per i gruppi di risorse e inizi a cliccare. Un clic per creare il gruppo, altri per impostare la rete virtuale. Poi segui la procedura guidata per la VM, scegli regione, dimensioni, immagine, configuri il disco e la rete. Sono forse 50 clic solo per questo. Poi ripeti tutto per la seconda VM, configuri l'account di archiviazione e imposti le regole del firewall. Ed è qui il punto. Ogni singolo clic è un'occasione per commettere un errore. Scegli la regione sbagliata e l'app valenta, scegli la dimensione errata della VM e paghi troppo fin dal primo giorno. Dimentichi di chiudere una porta e hai esposto l'ambiente a internet senza rendertene conto. Ora moltiplica tutto per tre ambienti. Sviluppo, test, produzione. All'improvviso non fai più 50 clic, ma 150. E in questo processo la produzione finisce per essere completamente diversa dallo sviluppo. Un'impostazione qui, una casella lì. Piccole differenze che causano un grande grattaccape in seguito. Ma se potessi descrivere l'intera configurazione di Azure in un file invece di cliccare su tutte quelle schermate? E se potessi eseguire quel file una volta sola e ottenere lo stesso risultato ogni singola volta? Di questo parleremo oggi. Alla fine di questo episodio capirai cos'è davvero l'Infrastructure as Code perché i T-Major ci si affidano e come iniziare a usarla senza essere uno sviluppatore. Quanto ti costa davvero il provisioning manuale? Analizziamo una tipica configurazione Azure. Ti serve un gruppo di risorse e al suo interno una rete virtuale con un paio di subnet poi due macchine virtuali una per il server web e una per il database e un account di archiviazione per i dati. Dal portale è un intero pomeriggio passato a cliccare. Ed ecco il problema. Ogni singolo clic ha una potenziale fonte di error. Magari scegli la regione sbagliata perché il meno a tendina predefinisce IstoS mentre ti serviva WestEurope. Magari scegli una dimensione della VM troppo costosa per ciò che ti serve realmente. Magari lasci accidentalmente una porta di gestione aperta su internet. Sono errori che capitano. Capitano perché il portale rende facile cliccare velocemente e difficile a rallentare per controllare i propri errori. Il costo reale non è solo il tempo che perdi a correggere quegli errori. È il tempo che passi a ripetere gli stessi clic per sviluppo, test, staging e produzione. Perché? Ecco che succede. Crea l'ambiente di sviluppo lunedì. Ti ci vogliono tre ore e funziona alla perfezione. Martedì crea l'ambiente di test. Sei un po' più veloce questa volta, due ore e mezza, ma dimentichi un'impostazione. Una regola del firewall che era aperta in sviluppo e chiusa in test. La tua applicazione si comporta in modo diverso e passi un'ora a fare il debug. Quando arrivi alla produzione venerdì, in tuo ambiente, non assomiglia per nulla a quello di sviluppo. Dimensioni di VM diverse, configurazioni di storage diverse, alcune impostazioni cambiate perché qualcuno ha detto prova questo al volo. Questo è il configuration drift, il risultato naturale di costruire gli ambienti a mano. Il vero problema è che non puoi verificare un click del mouse. Non puoi annullare un click del mouse. Se qualcosa si rompe in produzione tra sei settimane, non ricorderai quale casella avevi spuntato o deselezionato. Non avrai un registro di cosa è cambiato tra sviluppo e produzione. Quindi, e se potessi descrivere l'intera configurazione azzurra in un file invece di cliccare su vari schermi? Un solo file che definisce esattamente come dovrebbe essere il tuo ambiente. Esegui una volta e ottieni lo stesso risultato ogni volta. Esegui di nuovo e ottieni lo stesso risultato ancora. Nessuna deriva, nessuna impostazione dimenticata, nessun ambiente di produzione è diverso da quello di sviluppo. Infrastructure as code. La definizione è una frase. Infrastructure as code significa descrivere la propria infrastruttura in un file che Azure può leggere e costruire per tutto qui. Una sola frase. Scrivi un file, Azure lo legge e il tuo ambiente appare. Pensalo come un edificio per ufficio. Se volessi allestire un nuovo ufficio, potresti girare e dire a ogni lavoratore dove mettere ogni scrivania e ogni sedia. Questo è l'approccio manuale. Funziona ma è lento e tutti finiranno con una disposizione leggermente diversa. Potresti consegnare un progetto. Foglio di carta che dice esattamente dove va ogni cosa. Ogni stanza è identica perché tutti hanno seguito lo stesso piano. Tuo file è carico e il progetto. È l'unica fonte di verità per l'intero ambiente azzurro. Tutto ciò di cui l'ambiente ha bisogno. Gruppi di risorse, reti virtuali, VM, account di storage, regole firewall. È tutto in quel file. Ora, c'è una distinzione importante qui. L'IAC utilizza quello che viene chiamato approccio dichiarativo. È un modo elegante per dire che comunichi ad Azzurro cosa vuoi e non come costruirlo passo dopo passo. Dopo passo. Non dici crea un gruppo di risorse, poi crea una rete virtuale al suo interno, poi crea una sottorete lì dentro. Dici voglio un gruppo di risorse con una rete virtuale che abbia una sottorete. Azzurro capisce l'ordine. Questo è diverso dagli script che gli amministratori di sistema usano da anni. Gli script sono imperativi. Dicono al sistema esattamente cosa fare passo dopo passo. Fai questo, poi quello, poi quest'altro. E se un passaggio fallisce, tutto si blocca. Vi ha il cielo opposto. Tu descrivi lo stato finale e il sistema capisce come arrivarci. Ecco un esempio concreto. Invece di digitare 50 comandi CLI separati per creare una macchina virtuale, scrivi qualcosa come ho bisogno di una macchina virtuale con 8 GB di RAM con Ubuntu 22.24 collegata a questa rete virtuale con un account di archiviazione collegato. Tutto qui. Una descrizione invece di 100 comandi. E questo conta per Azzurro nello specifico perché il portale rende tutto così facile da iniziare. Puoi avere una macchina virtuale in esecuzione in 10 minuti con pochi click. Ma il portale non è scalabile. Quando hai bisogno di 10 ambienti invece di uno, il portale diventa un problema. Lì c'è il modo in cui esci da quella trappola. Quindi sembra utile, vero? Ma quali strumenti ti offre Microsoft per scrivere questi file di progetto? Il toolkit Azzurro, ARM, Biceppe e l'elefante nella stanza. Quindi quali strumenti ti offre Microsoft per scrivere questi file di progetto? Primo si chiama modelli ARM. ARM sta per Azure Resource Manager e questi modelli esistono fin dall'inizio. Sono scritti in JSON, un formato dati che sembra un file di configurazione del 2015. Tante parentesi graffe, tante parentesi quadre, molte indentazioni. Se hai mai visto un file JSON sai cosa intendo? È funzionale ma non è piacevole da leggere. I modelli ARM sono ancora ampiamente usati, specialmente in ambienti aziendali. Le grandi aziende hanno investito anni nella creazione delle loro librerie di modelli e non hanno intenzione di buttare via quel lavoro. Ma se sei un principiante, guardare un modello ARM per la prima volta può essere intimidatorio. È prolisso, è facile da rompere. Una virgola mancante e tutto fallisce. Scriverne una mano è doloroso. Microsoft ha riconosciuto questo problema. Così è creato Bicep. Bicep è la risposta di Microsoft al fatto che i modelli ARM sono troppo complicati. È un linguaggio più nuovo che compila i modelli ARM dietro le quinte, ma la sintassi è molto più pulita. Sembra vero codice. Scrivi qualcosa come Resource My VM Microsoft. Compute Virtual Machines, anziché pagine di JSON annidato. È progettato prima di tutto per gli esseri umani. Ora c'è un'altra opzione di cui sentirai parlare. Terraform. Terraform è uno strumento di un'azienda chiamata HashiCorp, che funziona con Azure e altri cloud. Se devi gestire l'infrastruttura su AWS, Google Cloud e Azure contemporaneamente, Terraform è la scelta migliore e più portabile. Ma questa portabilità ha un costo. Terraform aggiunge un livello di astrazione tra te e Azure. Devi imparare il linguaggio di Terraform HCL, oltre a comprendere Azure stesso. È potente, ma introduce una sua complessità. Quindi, quale dovrebbe scegliere un principiano? Se usi solo Azure, inizia con Bichap. Il motivo è semplice, l'integrazione è nativa. Bichap è creato da Microsoft specificamente per Azure. Almeno componenti mobili, riceve il supporto completo di Microsoft. E poiché compila in template ARM, non sei vincolato a nulla, puoi sempre passare i template ARM a grezzi in seguito se necessario. Bichap è la via di minore resistenza per chi vuole iniziare. Ecco come funzionano questi strumenti in adrati. Scrivi un file, un file by CEP, un template ARM, qualunque cosa tu scegli. Poi esegui un comando. Per Bichap, quel comando è Azure Deployment Group Create. Azure legge il tuo file, lo confronta con ciò che esiste già e costruisce ciò che manca o modifica ciò che è diverso. Non devi dire ad Azure in che ordine fare le cose. Lo capisce da solo. Ed è qui che la cosa si fa dover interessare. Puoi collegarlo a una pipeline CI-CD, integrazione continua e distribuzione continua. Significa che ogni volta che invia una modifica al tuo repository di codice, Azure esegue automaticamente il tuo file e si aggiorna la tua infrastruttura. Nessun passaggio manuale, nessuno che accede al portale solo modifica il codice che fluiscono automaticamente in produzione. Quindi hai un file che descrive la tua infrastruttura. Puoi eseguirlo e ottenere un risultato coerente. Puoi persino automatizzare il tutto con una pipeline. Ma cosa sblocca effettivamente? È lì che le cose diventano davvero potenti. Cosa fa il controllo di versione per il tuo ambiente Azure? Ecco la cosa di cui la gente non parla abbastanza. Vero superpotere dell'AEC non è il formato del template in sé. Non è Bichap contro ARM contro Terraform. Il vero superpotere è il controllo di versione. Quando archivi i tuoi file IAS in un repository come GitHub o Azure Repos, ogni singola modifica diventa tracciabile. Chi ha cambiato cosa quando l'ha cambiato? Perché l'ha cambiato. Ottieni una cronologia completa di ogni modifica alla tua infrastruttura fin dal primo giorno. E questo significa che puoi tornare indietro. Se un deployment rompe qualcosa, non devi indovinare cosa sia andato storto. Non devi scavare tra i log di controllo del portale sperando di trovare la risposta. Ripristini semplicemente l'ultima versione funzionante del tuo file IAC e ridistribuisci. Il problema scompare. Questa è una cosa che non puoi assolutamente fare con i click del mouse. Significa anche che i tuoi ambienti rimangono coerenti. Sviluppo, test e produzione provengono tutti dagli stessi file. Non file simili, non file che erano uguali all'inizio ma che si sono differenziati nel tempo. Gli stessi file. Distribuisci la mente di sviluppo del tuo principe. Quando sei pronto per il test, distribuisci gli stessi file nella sottoscrizione di test. Quando sei pronto per la produzione, distribuisci nuovamente gli stessi file. Ogni ambiente è identico perché ogni ambiente è stato costruito dallo stesso progetto. E poiché questi file risiedono in un repository, puoi fare revisione del codice per l'infrastruttura. Prima che chiunque distribuisca una modifica, un altro membro del team deve guardarla e approvarla. Questo corregge gli errori prima ancora che raggiunga il tuo ambiente. È lo stesso processo che gli sviluppatori software usano per il codice applicativo, applicato alla tua configurazione azzurra. Ecco un esempio reale. Qualcuno nel tuo team ha precedentemente un account di archiviazione al pubblico. Senza IAC potresti non accorgertene finché non arriva il conto. O qualcuno ti dice che i tuoi dati sono esposti. Con IAC quella modifica è visibile nel repository. Passa attraverso la revisione del codice. Qualcuno lo nota e dice quell'account di archiviazione non dovrebbe essere pubblico. La modifica viene bloccata prima che raggiunga. E se in qualche modo dovesse sfuggire, puoi annullarla in pochi secondi. Puoi persino usare strategie di brain. Puoi sperimentare una nuova configurazione. Crea un branch separato, apporta le tue modifiche, distribuisci in un ambiente di test e vedi se funziona. Se funziona, unisci il branch principale. Se non funziona, elimina il branch e prova qualcos'altro. Il tuo ambiente di produzione non viene mai toccato finché non sei sicuro che la modifica sia sicura. L'acquerenza è ottima, ma IAC rende anche la tua configurazione azzurra più sicura. E questo conta che tu abbia una sola persona che gestisce tutto o un intero team. Sicurezza per progettazione, non per caso. Ecco qualcosa che sorprende molte persone. Quando usi IAC, la sicurezza non è qualcosa che aggiungi in seguito. È integrata nel modello fin dall'inizio. Invece di ricordarti di attivare la crittografia su ogni nuovo account di archiviazione, è già nel tuo file. Invece di sperare che qualcuno abbia configurato correttamente le regole del firewall, le regole sono scritte e applicate ogni singola volta. Questa idea ha un nome, Policy as Code. Codifichi le tue regole di sicurezza direttamente di distribuzione. Quindi ogni volta che qualcuno tenta di distribuire un account di archiviazione, la pipeline verifica che HTPS sia attivo, che la crittografia sia abilitata, che l'accesso pubblico sia bloccata e che l'accesso blocca. Se il modello non soddisfatta le regole, la distribuzione fallisce. La configurazione non sicura non raggiunge mai il tuo ambiente. Pensa a ciò che questo sostituisce. Decine di controlli manuali. Qualcuno che ricorda di selezionare la casella giusta. Qualcun altro che controlla quelle caselle in seguito. Tutto questo scompare. Qualcun ogni distribuzione soddisfa automaticamente i tuoi standard di sicurezza. Ma ecco dove diventa davvero interessante il disaster recovery. Il file che descrive la tua infrastruttura può ricostruirla ovunque. Se un attaccante compromette il tuo ambiente, non devi passare giorni a cercare di capire cosa hanno cambiato e come risolvere. Lo smantelli. Effettua una nuova distribuzione del tuo file AC. Il tuo ambiente pulito è tornato in pochi minuti. Questo non è possibile quando la tua infrastruttura è stata costruita male. E poiché tutto è nel controllo di versione e è una traccia di controllo. Ogni modifica della tua infrastruttura viene registrata. Chi l'ha fatta? Quando? Perché? Questa è una prova di conformità senza che nessuno debba compilare un foglio di calcolo. Per piccoli team senza personale di sicurezza dedicato questo è un moltiplicatore di forza. Ottieni pratiche di sicurezza a livello enterprise senza assumere un team di sicurezza a livello enterprise. Tutto questo suona bene sulla carta ma iniziare può sembrare oppimente. Lascia che ti offra un percorso realistico da seguire. Come iniziare senza rompere nulla? Regola numero uno. Non iniziare con la produzione. Non posso sottolinearlo abbastanza. La AC è potente ma è anche nuovo. Ammettere degli errori. Falli dove non importa. Scegli un piccolo pezzo del tuo ambiente Azure. Un gruppo di risorse con una singola macchina virtuale o un account di archiviazione. Qualcosa di semplice che è già in esecuzione. Qualcosa che sai che funziona. Ecco il trucco. Il portale Azure può effettivamente generare modelli ARM dalle tue risorse esistenti. Vai nel tuo gruppo di risorse, clicchi su Esporta modello e Azure ti fornisce il file JSON che descrive tutto in quel gruppo. Non è perfetto. Il modello esportato include spesso cose che non ti servono. Ma è un punto di partenza. Prendi qualcosa che hai costruito manualmente e lo converti in codice. Questo è l'approccio di reverse engineering ed è il modo più veloce per imparare. Inizia con Bicep e gli strumenti gratuiti di Azure. Microsoft offre un'estensione di VS Code per Bicep che fornisce evidenziazione della sintassi completamente automatico all'anteprima visiva di ciò che stai creando. Puoi visualizzare la tua rete virtuale e le tue subnet come un diagramma prima di distribuire qualsiasi cosa. Ciò rende molto più semplice capire cosa fa effettivamente il tuo codice. Usa una sottoscrizione separata per i test. La maggior parte delle sottoscrizioni azzure ha limiti di spese e crediti gratuiti. Crea una sottoscrizione di test. Distribuiscele ai tuoi azzi. Rompi le cose. Riparala. Impara. Quando ti senti sicuro passa una sottoscrizione non di produzione. La produzione viene per ultima. Ecco la parte che potrebbe sorprenderti. Non devi essere un ingegnere del software per farlo. Aspetta lo sviluppatore occasionale e di disneveloper. Bicep è stato progettato per chi gestisce l'infrastruttura Azure e non per programmatori professionisti. È leggibile. Ha meno formalità rispetto ai linguaggi di programmazione tradizionali. È focalizzato su Azure e nient'altro. Se sai cos'è una macchina virtuale puoi imparare a descriverne una in Bicep. Il tuo primo progetto pratico? Automatizza lo smantellamento e le ricostruzioni di sviluppo. Scrivi un file by Cep che crea la tua configurazione di sviluppo. Distribuiscilo. Usalo, quindi smantellalo e distribuiscilo di nuovo. Fallo un paio di volte finché il processo non diventa una routine. Questo esercizio ti insegnerà più sulla IAC di qualsiasi tutorial. Alcuni consigli comuni per i principi anni. Esegui il commit presto spesso. Ogni volta che ottieni una parte del tuo modello funzionante salva nel tuo repository. Ciò ti offre di checkpoint a cui puoi ritornare. E avvia sempre il comando di anteprima prima di distribuire. In Bicep si tratta del comando 1. Ti mostra esattamente cosa cambierà prima che accada qualcosa di concreto. Nessuna sorpresa. Anche con le migliori intenzioni. Ci sono alcune trappole in cui cadono i principianti. Lascia che ti risparmi alcune sessioni di debug notturne. Tre errori che ti perseguiteranno e come evitarli. L'errore numero uno è classico. Inserire segreti nel code. Hai fretta? Devi far funzionare un modello. Quindi inserisci la password del database direttamente nel file. Funziona, vai avanti. E ora la tua password si trova nelle repositorie e i HCI visibili a chiunque abbia l'accesso. Ovvio col senno di poio. Ma è incredibilmente facile farlo quando sei concentrato sul far funzionare qualcosa? La soluzione è Azure Key Vault. Sia i modelli Bicep che quelli ARM possono prelevare segreti direttamente da Key Vault al momento della distribuzione. Il tuo file indica di recuperare la password da questo vault invece di contenere la password effettiva. Il segreto non tocca mai il tuo repositor. Non inserire mai password, stringhe di connessione o chiave API nei tuoi file. Usa sempre Key Vault ogni singola volta. L'errore numero due è trattare l'IAE come uno script usa e getta. Scrivi un template, lo distribuisci, funziona e non lo guardi mai più. Sei mesi dopo qualcosa si rompa. Apri il file e non hai idea di cosa faccia a metà del codice. Quel parametro chiamato paramuno? Nessuna idea. Quella risorsa dal metriptico? Nessun indizio. Scrivi il tuo IEC come se qualcun altro dovesse mantenerlo tra sei mesi perché quel qualcuno sarai probabilmente tu e avrai dimenticato tutto. Aggiungi commenti. Usa nomi descrittivi invece di abbreviazioni. Mantieni i file piccoli e focalizzati su una sola cosa. Un file bytes app che crea una rete virtuale dovrebbe riguardare solo le reti virtuali non l'intero datacenter. L'errore numero tre è bypassare la pipeline per correzioni rapide. Il portale è sempre una tentazione. Devi modificare una sola impostazione. Ci vorrebbero 5 minuti per modificare il template, fare il commit e distribuire tramite Rappac. Oppure puoi semplicemente accedere al portale e cliccare tre volte e finire in 30 secondi. Quel cambiamento rapido che la drift è una deriva di configura. Il tuo codice dice una cosa la realtà ne dice un'altra. La prossima volta che distribuisci dal template Azzur tenta di annullare la tua modifica manuale o peggio non nota la deriva e il tuo ambiente diverge lentamente finché la produzione si comporta in modo completamente diverso dallo sviluppo. La disciplina è semplice apporta la modifica nei codici. Distribuisci tramite la pipeline anche se richiede 5 minuti in più. Quei 5 minuti ti faranno risparmiare ore di debugging in seguito. Un consiglio bonus esegui sempre il comando di anteprima prima di applicare le modifiche. In bicep si chiama what if ti mostra esattamente cosa verrà creato modificato o eliminato. Nessuna sorpresa. Vedi l'impatto prima che accada? Questa lì è ci piegate in modo semplice. E' se gergo te senza fronzoli di marketing. Solo uno strumento pratico che semplifica la tua vita su azzur. L'unica cosa da provare questa settimana. E ecco cosa abbiamo trattato. L'IAQ trasforma la tua infrastruttura Azzur in un progetto sicuro ripetibile e controllato tramite versionamento. Un unico file che descrive tutto distribuito allo stesso modo ogni volta. La tua sfida di questa settimana esporta una risorsaggio resistente come template ARM apri la in VS Code vedi se riesci a capire cosa fa. Questo singolo esercizio ti insegnerà più di qualsiasi spiegazione io possa darti. Nel prossimo episodio di questa serie vedremo come scrivere il tuo primo file by chat passo dopo passo. Iscriviti sulla tua piattaforma podcast preferita e condividi questo episodio con un collega che clicca ancora manualmente sul portale.