Come gestire risorse con CloudFormation
Pubblicato il 05/08/2023 da alnao nella categoria AWS

CloudFormation è un servizio che permette di creare e gestire risorse AWS, si tratta del principale servizio AWS di tipo Infrastructure as Code (IaC) di AWS, questo paradigma prevede che i componenti nel Cloud siano create da codice programmato, nello specifico questo servizio prevede un file che definisce una lista di risorse AWS che vengono create, gestite dal servizio CloudFormation in maniera programmatica.

Il servizio prevede due concetti chiave che devono essere ben compresi: 

  • template: il file che elenca un gruppo di risorse con specificate tutte le caratteristiche per ogni risorsa, sono previsti due possibili formati: Json o Yaml, per poter usare questo servizio è necessario conoscere almane uno dei due formati, esistono dei tool grafici per la creazione di questi template e il convertitore da un formato all’altro
  • stack: è la realizzazione di un template con tutte le risorse create a partire da un template. CloudFormation garantisce che tutte le risorse all’interno di uno stack vengano create, modificate ed eliminate come una unica “unità”. Se non è possibile creare una risorsa, AWS CloudFormation esegue il rollback dell’intero stack ed elimina automaticamente tutte le altre risorse create. Se una risorsa non può essere eliminata, tutte le risorse rimanenti vengono mantenute fino a quando lo stack non può essere eliminato correttamente

Per usare CloudFormation non bisogna distinguere i due concetti, paragonandoli ai concetti culinari di stampo e biscotto: il file template è lo stampo mentre gli stack sono i biscotti, ogni biscotto è creato da uno stampo e ci possono essere più biscotti creati dallo stesso stapo, in questo caso ogni stack ha un nome che lo identifica e le risorse create saranno cloni nati dallo stesso template. Maggiori dettagli su questi concessi si possono trovare nella pagina ufficiale. I template prevedono la presenza di queste sezioni:

  • Intestazione: versione di CloudFormation e descrizione del template, questa sezione è sempre fissa ed unica per ogni template.
  • Parameters: elenco dei parametri del template, per ogni parametro è necessario impostare il nome e il tipo (come String). Per ogni parametro è possibile impostare un valore di default, un elenco di possibili valori e alcune regole specifiche (come MinLen e Constraint)
  • Resources: elenco delle risorse, ogni risorsa deve avere un nome univoco, il tipo e l’elenco dei parametri, alcuni obbligatori altri facoltativi a seconda delle regole di ogni tipo di risorsa
  • Outputs: elenco dei valori che lo stack deve ritornare e visualizzare in Console o nella Cli al momento di creazione o aggiornamento

Uno degli esempi di template più semplici su AWS è descrivere la creazione di un storage S3 senza nessuna configurazione particolare, il template CloudFormation è:

#Intestazione con la descrizione
AWSTemplateFormatVersion: 2010-09-09
Description: CloudFormation di esempio s3
#blocco Parametri
Parameters:
  NomeBucket:
    Type: String
    Default: esempio01buckets3
    Description: Nome del bucket
    MinLength: 9
#blocco Risorse
Resources:
  S3Bucket: 
    Type: 'AWS::S3::Bucket'
    Properties:
      BucketName: !Ref NomeBucket
#blocco Outputs
Outputs:
  S3Bucket:
    Value: !GetAtt S3Bucket.Arn
    Description: S3 bucket ARN

Per caricare un template e creare uno stack ci sono due possibilità: Console web o CLI-SAM. Nella console web, nella pagina principale del servizio c’è la lista di tutti gli stack con un dettaglio di tutte le risorse appartamenti al gruppo e il template originario, è presente anche il bottone “create stack”, questa procedura guidata prevede quattro passi:

  • selezionare se il template è già pronto (template is ready) oppure la creazione tramite designer web (sconsigliato in quanto non è molto efficiente come metodo)
  • selezionare un file dal proprio pc oppure un file già depositato in un bucket S3, nel primo caso l’upload del file verso S3 viene eseguito dalla console
  • inserimento dei parametri dello stack come il nome univoco e inserire i valori di tutti i parametri previsti dal template, la pagina web visualizza anche il valore di default se previsto o la lista di valori possibili
  • inserimento dei parametri avanzati come tag, la regola IAM, le impostazioni di rollback ed altre impostazioni che possono essere ignorate da un utente poco esperto

All’avvio del processo di creazione, lo stack compare nello stato “CREATE_IN_PROGRESS”, se la creazione genera degli errori lo stato diventa “ROLLBACK_COMPLETE” ed è possibile controllare i log nel dettaglio. Se lo stack viene creato con successo viene visualizzato con lo stato “CREATE_COMPLETE”, i parametri di Output di un template possono essere visualizzati nel dettaglio dello stack stesso, tramite console è possibile anche aggiornare uno stack ricaricando un file template. La rimozione di uno Stack può essere eseguita da console con l’accorgimento che, di default, tutte le risorse descritte nel template e create in AWS vengono eliminate quando viene rimosso uno stack, è possibile modificare questo comportamento impostando che le risorse rimangano quando lo stack viene rimosso con la proprietà:

DeletionPolicy: Retain

che deve essere inserita nel blocco Resources del template.

Come si può notare dal semplice esempio, nei template è possibile usare alcuni metodi come Ref e GetAtt per far riferimento a parametri e ad risorse, questa tecnica è molto usata nei template complessi dove ci sono molte risorse legate tra loro. La AWS-CLI mette a disposizione una serie di comandi per la gestione di template e stack, l’elenco completo può essere trovato nel sito ufficiale, il più interessante è il comando per recuperare la lista di tutti gli stack con i relativi stati e le informazioni basiche, la sintassi è:

aws cloudformation list-stacks

ed è possibile recuperare il dettaglio di ogni stack con i comandi

aws cloudformation describe-stacks --stack-name CIT
aws cloudformation describe-stack-events --stack-name CIT --max-items 2
aws cloudformation describe-stack-resources --stack-name CIT

i comandi visualizzano rispettivamente la descrizione generica di uno stack, gli eventi e le risorse appartenenti a quello specifico stack. Tramite i comandi CLI è possibile creare e distruggere stack ma è consigliato l’uso della CLI-SAM specifica per questo tipo di operazioni. Per usare la CLI-SAM che è necessario installare il pacchetto specifico dopo aver configurato la CLI di AWS, la guida per l’installazione si trova nel sito ufficiale, questa è un gruppo di comandi specifici per la gestione dei servizi serverless come CloudFormation. I principali comandi messi a disposizione dalla CLI-SAM per la gestione di template e stack sono:

  • sam validate: esegue la validazione del template e visualizzare messaggi di errori se presenti, non è obbligatorio ma è sempre buona prassi validare il template prima di eseguirlo
  • sam build: crea una sottocartella “.aws-sam” con i file necessari per il rilascio
  • sam pacakge: se si tratta di template composti da più file questo passo è necessario per creare il file unico da rilasciare. Se il template è composto da un solo file, il passo non è da eseguire
  • sam deploy: esegue il rilascio e crea lo stack con tutte le sue risorse

L’elenco completo di tutti i comandi previsti è disponibile nella documentazione ufficiale. Usando il template di esempio di creazione del bucket S3, per eseguire la creazione di uno stack, i comandi da eseguire nella cartella dove è salvato il template in un file con il nome “template.yaml”:

sam validate
sam build
sam deploy --stack-name esempio1buckets3 --capabilities CAPABILITY_IAM

Nel deploy è sempre indispensabile impostare il nome dello stack e la regola base IAM di tipo “CAPABILITY_IAM”, senza questa regola CloudFormation non disporrà delle necessarie autorizzazioni e restituirà un errore. Quando il comando deploy viene seguito, vengono visualizzate le informazioni dei passi eseguiti e, se lo stack viene creato senza errori, vengono visualizzati gli Output indicati nel template:

Initiating deployment
=====================
Waiting for changeset to be created..
CloudFormation stack changeset
-------------------------------------------------------------------------
Operation           LogicalResourceId                   ResourceType     
-------------------------------------------------------------------------   
+ Add               S3Bucket                            AWS::S3::Bucket  
-------------------------------------------------------------------------
2042-04-02 00:00:00 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 0.5 seconds)
-------------------------------------------------------------------------   
ResourceStatus      ResourceType                        LogicalResourceId
-------------------------------------------------------------------------   
CREATE_IN_PROGRESS  AWS::CloudFormation::Stack          esempio1buckets3 
CREATE_IN_PROGRESS  AWS::S3::Bucket                     S3Bucket         
CREATE_IN_PROGRESS  AWS::S3::Bucket                     S3Bucket         
CREATE_COMPLETE     AWS::S3::Bucket                     S3Bucket         
CREATE_COMPLETE     AWS::CloudFormation::Stack          esempio1buckets3 
-------------------------------------------------------------------------
CloudFormation outputs from deployed stack
-------------------------------------------------------------------------
Outputs
-------------------------------------------------------------------------   
Key                 S3Bucket
Description         S3
Value               arn:aws:s3:::esempio01buckets3
-------------------------------------------------------------------------   
Successfully created/updated stack - esempio1buckets3 in None

I comandi della CLI-SAM mettono a disposizione alcuni comandi specifici per le operazioni negli stack: 

  • per rimuovere uno stack e di tutte le sue risorse con il comando:
sam delete --stack-name esempio1buckets3
  • per valorizzare i parametri obbligatori o modificare i valori di default dei parametri di un template con il comando “parameter-overrides”:
sam deploy --stack-name esempio1buckets3 --capabilities CAPABILITY_IAM 
   --parameter-overrides NomeBucket=nome-bucket-personalizzato
  • se un template è formato da più file, è necessario usare il comando pacakge prima del deploy, il comando necessita di tre parametri: il nome del file che verrà creato, un bucket e un path:
sam package --output-template-file <packagedV1.yaml> --s3-bucket <bucket-name> --s3-prefix <path>
  • come per la CLI, anche la CLI-SAM usa il profilo di default impostato, se si vuole personalizzare profilo e zona di rilascio bisogna aggiungere il parametro “profile” quando deploy e delete vengono usati:
sam deploy --stack-name esempio1buckets3 --profile <nomeProfilo>
sam delete --stack-name esempio1buckets3 --profile <nomeProfilo>

Nei successivi articoli in questo sito che trattano i servizi AWS, se il servizio è compatibile con con CloudFormation, verrà introdotto un template specifico per la gestione di risorse con template, per temi avanzati come la dipendenza tra template e i template annicati si rimanda ad articoli futuri. Tutti i dettagli e le caratteristiche del servizio si possono trovare nel sito ufficiale, questa fonte è molto utile perchè ricca di esempi e sono elencati tutte le proprietà possibili per ogni tipo di risorsa supportata dal servizio CloudFormation. Bisogna ricordare anche che il servizio è gratuito ma ogni risorsa creata negli stack è a pagamento quindi bisogna sempre prestare alle risorse create nei template.

Tutti gli esempi di template di CloudFormation presentati in questo sito sono disponibili in un repository pubblico:

https://github.com/alnao/AWSCloudFormationExamples
MENU