Un cluster Kubernetes self-managed su AWS con kops (e la trappola del gossip DNS)
Dal gruppo IAM al primo kubectl get nodes: come mettiamo in piedi cluster Kubernetes gestiti da noi su AWS.

Ci sono progetti che non giustificano un cluster Kubernetes, e progetti che non giustificano nient’altro. Questo articolo racconta il secondo caso: un cliente con qualche servizio containerizzato, un carico di lavoro contenuto e prevedibile, e la necessità di poter spostare tutto altrove senza riscrivere il modo in cui si pubblicano le applicazioni. Niente di enorme: una macchina che coordina il cluster, una manciata di macchine che ci lavorano sopra, un budget che si conta in decine di euro al mese.
Per questo tipo di cluster usiamo kops, abbreviazione di Kubernetes Operations: uno strumento a riga di comando che costruisce un Kubernetes “puro”, cioè senza aggiunte proprietarie, partendo da un file di configurazione conservato in un bucket S3. Qui trovate la procedura che seguiamo, le ragioni dietro ogni scelta e gli ostacoli che abbiamo incontrato. Tra questi ce n’è uno grosso, una deprecazione che nel 2026 mette fuori gioco i cluster kops esistenti, e riguarda anche i nostri.
Due parole che torneranno spesso, per chi non vive dentro Kubernetes tutti i giorni. Il control plane è il cervello del cluster: sa cosa deve girare e dove, e risponde ai comandi. I nodi worker sono le macchine su cui le applicazioni vengono davvero eseguite. Il control plane può fermarsi senza che le applicazioni si spengano, ma finché è fermo il cluster non accetta modifiche.
Perché kops e non EKS
La domanda è legittima: AWS un Kubernetes gestito ce l’ha già. Perché non usarlo? Quattro motivi.
Lo stesso cluster su AWS, Google Cloud o Azure. È la ragione che pesa di più, ed è una funzionalità vera, non un dettaglio da addetti ai lavori: kops non lavora soltanto con AWS. Con lo stesso strumento e la stessa procedura si crea un cluster su Google Cloud o su Azure, e quello che ne esce è sempre Kubernetes fatto allo stesso modo. I nostri clienti non stanno tutti sulla stessa piattaforma, spesso per motivi che con la tecnologia non c’entrano nulla: accordi commerciali, crediti da consumare, politiche interne. Se domani un progetto deve nascere altrove, non ricominciamo da capo e non dobbiamo imparare un servizio gestito diverso. Con EKS, quella competenza vale solo dentro AWS.
Il costo, sui cluster piccoli. Il control plane di EKS costa circa 73 $ al mese per cluster, sempre, indipendentemente da quanto ci gira sopra. Su un cluster da tre macchine è quasi quanto costano le macchine stesse: la spesa raddoppia per far funzionare le stesse identiche applicazioni. Con kops il control plane è una macchina come le altre e si paga come tale. Su un cluster grande il ragionamento si ribalta e quella cifra diventa trascurabile.
Il controllo. Con kops possiamo entrare nelle macchine, cambiare i parametri, scegliere quale versione di Kubernetes installare e quando aggiornarla. Con EKS il control plane è una scatola chiusa che AWS aggiorna secondo il proprio calendario. Per molti progetti quella scatola chiusa è un vantaggio, perché toglie lavoro; quando qualcosa non funziona come dovrebbe, è esattamente il contrario.
Nessun vincolo. Quello che esce da kops è Kubernetes così come lo pubblica la comunità. Gli stessi file di configurazione funzionerebbero su un altro fornitore cloud o su un server in azienda.
Poi c’è il motivo più banale di tutti: di cluster kops ne abbiamo già in produzione, con le competenze e le procedure ormai rodate.
Lo scambio è chiaro. In cambio del risparmio e del controllo, la gestione tocca a noi: aggiornamenti, manutenzione, backup. In fondo all’articolo trovate chi, secondo noi, farebbe meglio a non accettarlo.
Prerequisiti: IAM e state store
Prima di poter fare qualsiasi cosa, kops ha bisogno di due cose: credenziali AWS abbastanza ampie e un bucket S3 in cui conservare lo stato del cluster.
Partiamo dalle credenziali. La documentazione ufficiale richiede sette policy gestite da AWS. Le colleghiamo a un gruppo dedicato e al gruppo agganciamo un utente dedicato: un gruppo e un utente per ogni cluster, mai condivisi.
# ATTENZIONE: assicurarsi di avere esportato le credenziali dell'account
# giusto. È il modo più facile di creare un cluster nel posto sbagliato.
export AWS_ACCESS_KEY_ID=...
export AWS_SECRET_ACCESS_KEY=...
export CLUSTER=my-fancy-cluster
aws iam create-group --group-name $CLUSTER
for policy in AmazonEC2FullAccess AmazonRoute53FullAccess AmazonS3FullAccess \
IAMFullAccess AmazonVPCFullAccess AmazonSQSFullAccess \
AmazonEventBridgeFullAccess; do
aws iam attach-group-policy \
--policy-arn arn:aws:iam::aws:policy/$policy \
--group-name $CLUSTER
done
aws iam create-user --user-name $CLUSTER
aws iam add-user-to-group --user-name $CLUSTER --group-name $CLUSTER
aws iam create-access-key --user-name $CLUSTER
È opportuno ricordare che abbiamo appena dato in mano a quell’utente permessi molto ampi: IAMFullAccess e AmazonS3FullAccess, e può creare ruoli e leggere qualunque bucket dell’account. In un account dedicato a un solo cluster il rischio è accettabile; in un account condiviso con altre risorse va valutato, e la strada corretta è restringere a mano le policy. Non è un lavoro breve, ed è il motivo per cui la documentazione ufficiale non lo propone come strada normale. Noi preferiamo tenere l’account separato: è più semplice, e la separazione dei costi arriva senza sforzo.
Il secondo elemento è lo state store: un bucket S3 con il versioning attivo, dove kops conserva la descrizione completa del cluster. Il versioning non è un dettaglio da ignorare: se una modifica sbagliata finisce dentro quel file, le versioni precedenti sono l’unico modo per tornare indietro.
export REGION=eu-north-1
aws s3api create-bucket \
--bucket ${CLUSTER}-state-store \
--region $REGION \
--create-bucket-configuration LocationConstraint=$REGION
aws s3api put-bucket-versioning \
--bucket ${CLUSTER}-state-store \
--versioning-configuration Status=Enabled
Una nota per chi lavora nella regione us-east-1: lì il parametro --create-bucket-configuration va omesso, perché quella regione è quella di partenza storica delle API di AWS e indicarla esplicitamente fa fallire la chiamata.
La trappola: il gossip DNS non esiste più
Arriviamo alla parte che distingue questo articolo da qualsiasi guida su kops scritta prima del 2025. Se avete un cluster kops in produzione conviene leggerla anche se non ne create uno nuovo da anni.
Storicamente kops offriva due modi per far trovare il control plane alle macchine del cluster. Il primo era una zona DNS vera, ospitata su Route 53, con il cluster chiamato per esempio k8s.esempio.it. Il secondo era il gossip DNS, che si attivava semplicemente dando al cluster un nome con il suffisso .k8s.local: una rete di comunicazione diretta tra le macchine, che si passavano l’indirizzo del control plane senza appoggiarsi a un DNS esterno. Molto comodo, perché non c’era nessuna zona da registrare e nessun dominio da comprare. Per anni è stata la strada battuta da tutte le guide, ed è quella che compare nei nostri appunti interni più vecchi.
Il gossip è stato rimosso. Questa la cronologia, ricostruita dalla documentazione di kops:
- kops 1.29: il gossip viene dichiarato deprecato e i cluster nuovi iniziano a usare None-DNS in automatico.
- kops 1.35:
kops create clusternon crea più cluster gossip, nemmeno chiedendoglielo. Un nome che finisce in.k8s.localproduce ormai un cluster None-DNS. Restano gossip soltanto i cluster nati con versioni precedenti. - kops 1.36: i cluster gossip passano a una modalità mista. Il control plane continua a usare il gossip, mentre i worker si collegano direttamente al bilanciatore che lo espone.
- kops 1.37: il gossip sparisce del tutto. I cluster che lo usano vanno convertiti con kops 1.36 prima di poter passare alla versione successiva.
Le ragioni della rimozione sono solide e descrivono un rischio a cui era esposto anche il vostro cluster. Il gossip si appoggiava a librerie esterne non più mantenute, eseguite oltretutto da un processo con privilegi elevati su ogni macchina. In più, perché le macchine si riconoscessero tra loro, servivano permessi molto larghi sull’account AWS anche sui semplici worker: permessi che rendevano leggibile la struttura del cluster a chiunque potesse arrivare al ruolo associato a una macchina.
Al posto del gossip si usa None-DNS (--dns=none), disponibile da kops 1.26. Copre gli stessi casi d’uso, cioè i cluster senza una zona DNS esterna a disposizione, comprese le regioni AWS in cui Route 53 non esiste. La differenza è che non c’è più nulla da far comunicare tra le macchine: i worker si collegano direttamente al bilanciatore del control plane e il cluster non pubblica alcun record DNS.
Mentre scriviamo, la versione stabile è kops 1.36.1 e la 1.37 è in alpha. Chi ha cluster gossip ha davanti una finestra di tempo, non un rinvio indefinito.
Convertire un cluster gossip esistente
Questa è la parte che ci tocca da vicino, perché i nostri cluster più vecchi usano il gossip. La buona notizia è che la procedura è più breve di quanto la parola “migrazione” faccia temere, e soprattutto il nome del cluster non cambia: certificati, state store e configurazione di kubectl restano gli stessi, e anche il modo di collegarsi non cambia.
La conversione va fatta con kops 1.36, prima di aggiornare kops alla versione successiva.
# 1. Cluster già aggiornato a kops 1.36: applica e passa alla modalità mista
# (toglie il gossip dalle macchine worker)
kops reconcile cluster --yes
# 2. kops edit cluster: disattiva il gossip impostando la topologia DNS a None
spec:
topology:
dns:
type: None
Su AWS c’è un vincolo in più da conoscere prima di premere invio: None-DNS richiede un Network Load Balancer davanti al control plane. Se il cluster usa ancora un Classic Load Balancer, nella stessa modifica va indicato anche:
spec:
api:
loadBalancer:
class: Network
# 3. Applica: questo sostituisce le macchine del control plane, che smettono
# di usare il gossip. kops rimuove da sé il componente dns-controller ormai
# inutilizzato (prima della 1.36 andava cancellato a mano).
kops reconcile cluster --yes
# 4. Verifica
kops validate cluster --wait 10m
Un ultimo dettaglio, di quelli che fanno fallire il controllo di validità in modo poco intuitivo: i campi gossipConfig e dnsControllerGossipConfig sono deprecati e non hanno più alcun effetto, ma la loro semplice presenza fa rifiutare la configurazione. Se sono rimasti nel file del vostro cluster, vanno tolti prima dell’aggiornamento.
Attenzione al passaggio 3, perché sostituisce le macchine del control plane. Su un cluster che ne ha una sola, per tutta la durata della sostituzione il cluster non accetta comandi: le applicazioni già avviate continuano a funzionare, ma non si possono pubblicare nuove versioni. Va programmato in una finestra di manutenzione, non fatto d’impulso un giovedì pomeriggio.
Creare il cluster
Da qui in avanti l’articolo dà per scontato un cluster nuovo su kops 1.36, quindi in modalità None-DNS. Cominciamo dalle variabili, che conserviamo in uno script per ogni cluster invece di affidarle alla memoria del terminale:
export AWS_ACCESS_KEY_ID=... # le chiavi dell'utente kops creato sopra
export AWS_SECRET_ACCESS_KEY=...
export NAME=myfancy.cluster.k8s.local
export KOPS_STATE_STORE=s3://my-fancy-cluster-state-store
export ZONES=eu-north-1a
export CONTROL_PLANE_COUNT=1
export CONTROL_PLANE_SIZE=t3.medium
export CONTROL_PLANE_VOLUME_SIZE=48
export NODE_COUNT=1
export NODE_SIZE=t3.medium
export NODE_VOLUME_SIZE=48
Prima di scegliere la zona conviene chiedere ad AWS quali sono disponibili nella regione, invece di andare a memoria:
aws ec2 describe-availability-zones --region eu-north-1
E poi il comando vero e proprio:
kops create cluster \
--name $NAME \
--cloud aws \
--zones $ZONES \
--control-plane-count $CONTROL_PLANE_COUNT \
--control-plane-size $CONTROL_PLANE_SIZE \
--control-plane-zones $ZONES \
--control-plane-volume-size $CONTROL_PLANE_VOLUME_SIZE \
--node-count $NODE_COUNT \
--node-size $NODE_SIZE \
--node-volume-size $NODE_VOLUME_SIZE \
--networking calico \
--topology private
Vediamo cosa c’è dietro a ciascuna scelta, perché è qui che si decide come sarà fatto il cluster per gli anni a venire.
--name con suffisso .k8s.local. Su kops 1.36 questa forma dà un cluster None-DNS, non più gossip. Se invece avete una zona Route 53 e volete un nome vero, per esempio k8s.esempio.it, basta indicarlo e kops crea i record DNS. Il nome vero è raggiungibile dall’esterno senza giri strani; .k8s.local non richiede nulla da registrare.
--control-plane-count 1 e una sola zona. Va detto senza giri di parole: così il control plane diventa un punto singolo di rottura. Se quella macchina si guasta, il cluster smette di accettare comandi finché kops non la sostituisce. Le applicazioni già in esecuzione sui worker continuano a funzionare, perché Kubernetes è progettato per sopravvivere alla perdita del control plane, ma nel frattempo il cluster è sordo a qualsiasi richiesta. Per un ambiente di produzione piccolo è un compromesso che ci prendiamo sapendo cosa comporta; per un servizio critico si passa a tre macchine di control plane distribuite su tre zone. È anche il motivo per cui --control-plane-zones chiede un numero dispari di zone: per prendere una decisione il cluster ha bisogno che una maggioranza delle copie sia raggiungibile.
--control-plane-size t3.medium. Il primo tentativo l’avevamo fatto con t3.small e abbiamo cambiato quasi subito: 2 GB di memoria sono al limite per far girare tutti i componenti che coordinano il cluster. Vale poi la pena ricordare che le macchine della famiglia t3 hanno prestazioni variabili, perché accumulano crediti quando lavorano poco e, una volta esauriti, la potenza di calcolo viene limitata. Per un control plane sempre sotto carico è un comportamento da tenere d’occhio, e se il cluster cresce conviene passare a una famiglia a prestazioni costanti come m6i o c6i.
--networking calico. Qui serve un avviso, perché la situazione è cambiata: kops oggi installa cilium se non gli dite altro, non più calico. Sono entrambe valide e sono i due sistemi di rete più diffusi sui cluster kops. Noi restiamo su calico per uniformità con i cluster che abbiamo già, ma per un cluster nuovo tanto vale prendere quello che kops propone di suo. Chi arriva da una guida datata e si aspetta calico “perché è il default” oggi si sbaglia.
--topology private. Le macchine finiscono in reti private, senza indirizzo IP pubblico, e per raggiungere internet passano da un NAT Gateway. È la topologia corretta per la produzione e ha due costi che è giusto mettere in conto. Il primo è il NAT Gateway stesso, che si paga sia a ore sia in base al traffico: siamo intorno ai 30-40 $ al mese solo perché esiste. Il secondo è che per collegarsi via SSH a una macchina serve un accesso intermedio, il cosiddetto bastion, che kops sa creare aggiungendo --bastion. Con la topologia public le macchine hanno indirizzi pubblici, il NAT non serve e la spesa scende: per un ambiente di prova è una scelta del tutto sensata.
Ritocchi alla configurazione
kops create cluster non crea nulla su AWS: si limita a scrivere la descrizione del cluster nello state store. È quindi il momento giusto per sistemarla prima che qualcosa prenda vita davvero. Il comando kops edit cluster ${NAME} apre quel file nell’editor e, al salvataggio, lo riscrive su S3.
Le due voci che aggiungiamo quasi sempre sono queste:
spec:
awsLoadBalancerController:
enabled: true
certManager:
enabled: true
managed: false
La prima, awsLoadBalancerController, installa l’AWS Load Balancer Controller, il componente che traduce le richieste di pubblicazione dei servizi in bilanciatori AWS veri e propri. Non l’abbiamo aggiunto per eleganza: ci serviva un bilanciatore con porte TCP e UDP sullo stesso indirizzo, e con il componente vecchio, quello incluso nell’integrazione storica con AWS, un servizio che dichiara insieme porte TCP e UDP non si riesce proprio a creare. Il limite non è di AWS, i suoi bilanciatori le porte miste le gestiscono benissimo: è il componente vecchio che non sa chiederle. Quello nuovo sì, e come vantaggio aggiuntivo smette anche di creare un Classic Load Balancer per ogni servizio esposto, che è la soluzione datata e a parità di funzioni costa di più.
La seconda, certManager con managed: false, è la riga che genera più dubbi. Il controller di cui sopra ha bisogno di cert-manager, lo strumento che gestisce i certificati dentro il cluster. Scrivere enabled: true significa dire a kops “cert-manager è presente, gli altri componenti possono contare su di lui”; aggiungere managed: false significa “ma non installarlo tu, ce ne occupiamo noi”. Lo facciamo per decidere noi quale versione di cert-manager installare e come configurarla, con gli stessi strumenti che usiamo per il resto del cluster, invece di dipendere dai tempi di kops. Se non volete quella responsabilità, managed: true fa installare cert-manager direttamente a kops e funziona altrettanto bene. Quello che conta è che una delle due strade sia percorsa fino in fondo: con enabled: true, managed: false e nessun cert-manager installato, il controller dei bilanciatori non parte.
Instance group: dove finiscono le applicazioni
Questa è la parte che le guide tendono a saltare ed è quella che nel lavoro quotidiano usiamo di più.
kops non ragiona per singole macchine, ma per instance group, gruppi di macchine con le stesse caratteristiche. kops create cluster ne prepara due, uno per il control plane e uno per i worker, ma nulla vieta di averne cinque, ciascuno con la propria configurazione. È il meccanismo che permette di dire “queste applicazioni girano su macchine con molta memoria, queste altre su macchine economiche”.
export IG_NAME=service
kops create ig $IG_NAME --name $NAME --subnet $ZONES
Il comando apre l’editor sul nuovo gruppo. I campi che contano sono pochi:
spec:
machineType: t3.medium
minSize: 1
maxSize: 3
nodeLabels:
fancypixel.it/node-group: service
Le nodeLabels sono la chiave di tutto: etichette che kops applica alle macchine del gruppo nel momento in cui nascono, e che permettono a un’applicazione di chiedere dove vuole essere eseguita, tramite un nodeSelector:
# deployment.yaml
spec:
template:
spec:
nodeSelector:
fancypixel.it/node-group: service
Una nota sui nomi, perché sbagliarli fa perdere tempo: il prefisso dell’etichetta deve essere un dominio valido, e i prefissi kubernetes.io/ e k8s.io/ sono riservati. Se li usate, la richiesta viene rifiutata.
Gli stessi campi si modificano anche sui gruppi già esistenti:
kops edit ig --name $NAME nodes-eu-north-1a
kops edit ig --name $NAME control-plane-eu-north-1a
Ed è qui che si trova il modo più efficace per contenere la spesa: portare minSize e maxSize a 0. Il gruppo spegne tutte le sue macchine, la sua definizione resta nello state store, e riportarlo a 1 lo fa tornare operativo in un paio di minuti. Per i gruppi dedicati a lavorazioni periodiche, per esempio macchine potenti che servono solo a un’elaborazione notturna, significa pagarle soltanto mentre lavorano.
C’è però un effetto collaterale poco intuitivo, ed è il modo più comune di mettersi nei guai da soli: se azzerate tutti i worker, i componenti di servizio del cluster non hanno più dove essere eseguiti. Il primo è CoreDNS, che si occupa della risoluzione dei nomi interni, e senza CoreDNS il controllo di validità fallisce. Ci torniamo tra poco.
Applicare, e aspettare
Fino a questo momento abbiamo soltanto scritto file su S3. Adesso si passa alle risorse vere:
kops update cluster ${NAME} --admin --yes
Il --yes è ciò che separa la simulazione dalla realtà: senza, kops si limita a stampare quello che farebbe e si ferma lì. Guardare l’elenco prima di procedere è un’abitudine sana. Il --admin, invece, aggiunge alla configurazione locale di kubectl un utente amministratore, così subito dopo si può iniziare a lavorare.
Poi si aspetta, e non poco: servono venti o trenta minuti perché il cluster sia davvero pronto. Nel frattempo AWS crea la rete, le sottoreti, il NAT, il bilanciatore e i gruppi di macchine; le istanze si avviano, il control plane comincia a rispondere e i worker si registrano.
kops validate cluster --wait 10m
kubectl get nodes
Dalla versione 1.32 kops mette a disposizione un comando che rende superflua la sequenza in due passaggi degli script più vecchi: kops reconcile cluster --yes applica le modifiche e sostituisce control plane e worker uno dopo l’altro, in un’unica operazione. È quello che usiamo per intervenire sui cluster già esistenti. La vecchia coppia di comandi resta valida quando si vogliono separare i due momenti:
kops update cluster ${NAME} --yes # applica la configurazione all'infrastruttura
kops rolling-update cluster --yes # sostituisce le macchine per applicare le
# modifiche che richiedono istanze nuove
La distinzione è importante: cambiare il tipo di macchina di un gruppo non tocca le istanze già avviate. update aggiorna il modello con cui le nuove macchine verranno create, ma finché non si esegue rolling-update (oppure reconcile) restano in servizio quelle vecchie. Più di una volta ci siamo chiesti come mai la macchina fosse ancora una t3.small.
Quando la validazione fallisce per CoreDNS
È il caso in cui vi imbatterete seguendo il consiglio di azzerare i gruppi non necessari: kops validate segnala che CoreDNS non è pronto. Le macchine del control plane hanno un taint che blocca l’avvio di normali applicativi, e se i worker sono a zero CoreDNS non ha più alcun posto in cui essere eseguito.
La soluzione strutturale è tenere acceso almeno un worker. Se invece serve un rimedio temporaneo per completare una manutenzione, si può togliere quel taint:
# temporaneo: consente ai componenti di servizio di girare sul control plane
kubectl taint nodes <nome-nodo> node-role.kubernetes.io/control-plane:NoSchedule-
Il trattino finale è quello che rimuove il taint invece di aggiungerlo. Va rimesso appena il cluster torna alla normalità, perché lasciare che le applicazioni girino sul control plane significa esporsi al rischio che un processo troppo affamato di memoria porti giù il cervello del cluster.
Accedere al cluster
Da Kubernetes 1.19 l’autenticazione con utente e password non esiste più: l’accesso passa da certificati e token, e a generare la configurazione ci pensa kops.
kops export kubeconfig ${NAME} --admin
L’opzione --admin produce una credenziale amministrativa dalla durata limitata: 18 ore, salvo diversa indicazione. Non è una dimenticanza, è la scelta giusta: una credenziale di amministratore senza scadenza sul portatile di uno sviluppatore, prima o poi, finisce male. Quando scade, si rilancia il comando.
Un accorgimento pratico che ci ha evitato più di un guaio: quando si lavora su più cluster conviene non scrivere nella configurazione predefinita di kubectl, ma tenerne una per ciascun cluster.
KUBECONFIG="$(pwd)/config" kops export kubeconfig --admin --name $NAME
In questo modo il cluster attivo è sempre quello della cartella in cui state lavorando, e non capita di lanciare un comando distruttivo su un cluster diverso da quello che avevate in mente.
Manutenzione quotidiana
Etichettare le macchine a mano, quando serve distinguere una singola macchina e non un gruppo intero:
kubectl label nodes ip-172-20-51-42.eu-north-1.compute.internal \
fancypixel.it/node-name=fancy-1
# per rimuovere un'etichetta: il nome della chiave seguito da un trattino
kubectl label nodes ip-172-20-51-42.eu-north-1.compute.internal \
fancypixel.it/node-name-
Con un’avvertenza: le etichette applicate in questo modo appartengono a quella specifica macchina e spariscono insieme a lei. Se AWS la sostituisce, l’etichetta non c’è più. Quelle che devono sopravvivere al ricambio delle istanze vanno messe nelle nodeLabels del gruppo.
Guardare il cluster nel modo che serve a voi. Il risultato normale di kubectl get nodes riporta nome, stato, ruolo, età e versione: informazioni corrette per un cluster qualsiasi, poco utili quando la domanda è “quale gruppo sta servendo cosa, e su che macchine”. Con custom-columns si costruisce la tabella che interessa:
kubectl get nodes -o custom-columns="\
NODE_GROUP:metadata.labels.fancypixel\.it/node-group,\
NAME:.metadata.name,\
INSTANCE:.metadata.labels.node\.kubernetes\.io/instance-type,\
VERSION:.status.nodeInfo.kubeletVersion"
Ne esce una tabella che risponde in un colpo solo alle domande di tutti i giorni: quante macchine ha acceso ogni gruppo, se sta usando davvero il tipo di istanza che credete, e se dopo una sostituzione tutte le macchine sono arrivate alla versione nuova. È il primo comando che lanciamo ogni volta che qualcosa non torna.
Aggiornare il cluster, che poi è il lavoro che con EKS non avreste:
kops upgrade cluster ${NAME} --yes # porta la configurazione alla versione voluta
kops reconcile cluster --yes # applica e sostituisce control plane e worker
kops validate cluster --wait 10m
kops 1.36 arriva a supportare Kubernetes 1.36 e ha abbandonato la 1.30, quindi l’intervallo utilizzabile va dalla 1.31 alla 1.36. La regola generale è semplice: la versione massima di Kubernetes supportata coincide con quella di kops, più le due precedenti. Tradotto, se restate indietro con kops restate indietro anche con Kubernetes, e recuperare più versioni tutte insieme è molto più faticoso che tenersi aggiornati.
Sempre sulla 1.36 ci sono altre rimozioni che possono bloccare un aggiornamento, ed è meglio scoprirle adesso che a metà strada: Amazon Linux 2, Ubuntu 20.04 e Debian 10 non sono più supportati e i cluster che li usano vanno spostati prima su un sistema più recente; chi ha personalizzato la configurazione di containerd deve passare alla versione 3 del formato TOML.
Il conto
Vediamo dove finiscono i soldi su un cluster kops di piccole dimensioni. Sono ordini di grandezza calcolati sui prezzi di listino AWS: variano da regione a regione, quindi vanno letti come proporzioni e non come un preventivo.
- EC2, cioè control plane e worker. Su
t3.mediumsiamo intorno ai 30 $ al mese per macchina accesa in modo continuativo. È la voce che domina la spesa, ed è quella su cui l’azzeramento dei gruppi non essenziali incide direttamente. - NAT Gateway, solo con la topologia
private: intorno ai 30-40 $ al mese per la sola esistenza, più il traffico. Su un cluster da due macchine può diventare la seconda voce del conto, il che rende--topology publicun’alternativa seria per gli ambienti di prova. - Network Load Balancer davanti al control plane: qualche decina di dollari al mese.
- EBS, i dischi da 48 GB di ogni macchina: pochi euro l’uno con i volumi gp3.
- S3, dove vive lo state store: qualche megabyte, una cifra meno significativa.
Il confronto onesto con EKS suona così: risparmiate i 73 $ al mese del control plane gestito, ma ne restituite una parte pagando la macchina su cui gira il control plane vostro. Su un cluster piccolo il saldo resta a favore di kops, però è meno vantaggioso di quanto lasci pensare il confronto sul solo costo del servizio gestito, e soprattutto non tiene conto del tempo che dedicherete agli aggiornamenti.
Fare pulizia
Se avete seguito l’articolo per provare kops, la cosa più importante da fare adesso è smontare il cluster. Un cluster in topologia private costa per il solo fatto di esistere: NAT Gateway e bilanciatore si pagano a ore anche quando sopra non gira nemmeno un’applicazione, e sono la sorpresa classica di chi lascia acceso un esperimento del venerdì pomeriggio.
La buona notizia è che kops sa disfare quello che ha costruito, e lo fa con un comando solo. Prima però conviene rimuovere dal cluster le risorse AWS che non ha creato lui, ma che sono comparse mentre il cluster era in funzione: i bilanciatori dei servizi esposti e i dischi richiesti dalle applicazioni.
kubectl delete svc --all-namespaces --field-selector spec.type=LoadBalancer
kubectl delete pvc --all --all-namespaces
Poi si passa al comando vero. Senza --yes funziona come simulazione: elenca tutto quello che verrebbe cancellato e si ferma.
# simulazione: leggete la lista
kops delete cluster --name=$NAME --state=$KOPS_STATE_STORE
# e solo dopo, per davvero
kops delete cluster --name=$NAME --state=$KOPS_STATE_STORE --yes
Lanciatelo sempre prima senza --yes e leggete quella lista. Non è pignoleria: il comando non chiede conferma e non si può annullare, e quella simulazione è l’unica occasione che avete per accorgervi di aver caricato per sbaglio le variabili di un altro cluster.
Due cose sopravvivono alla cancellazione, e vanno rimosse a mano se l’obiettivo è tornare all’account pulito di partenza:
- Il bucket dello state store. Ha il versioning attivo, quindi svuotarlo dei file correnti non basta: prima di poterlo eliminare vanno rimosse anche tutte le versioni precedenti.
- Il gruppo IAM, l’utente e la sua chiave di accesso creati all’inizio. Nell’ordine: staccare le policy dal gruppo, togliere l’utente dal gruppo, cancellare la chiave, poi eliminare utente e gruppo.
Cosa abbiamo imparato
Il punto non è che kops sia meglio di EKS. Il punto è che il costo di un Kubernetes gestito è quasi fisso, mentre quello di un cluster piccolo no, e sotto una certa soglia quella parte fissa domina la spesa. Se a questo si aggiunge la possibilità di creare lo stesso cluster su AWS, Google Cloud o Azure con un unico strumento, per il tipo di lavoro che facciamo kops resta la scelta giusta.
Chi invece, secondo noi, farebbe meglio a lasciar perdere:
- Chi non ha in squadra nessuno disposto ad aggiornare Kubernetes. Con kops gli aggiornamenti sono una vostra responsabilità, si presentano ogni pochi mesi, e rimandarli non fa che peggiorare la situazione. Se questa frase vi ha fatto storcere il naso, pagate quei 73 $ e dormite sereni.
- Chi ha bisogno di alta affidabilità senza volerla progettare. Un control plane singolo è un punto singolo di rottura, e portarne tre su tre zone triplica quella voce di spesa. EKS l’affidabilità del control plane la include nel prezzo.
- Chi vive dentro l’ecosistema AWS. Se il piano prevede di appoggiarsi a fondo ai servizi gestiti e alle integrazioni native della piattaforma, con EKS quella strada è già spianata. Con kops si arriva agli stessi risultati, ma facendo più lavoro.
C’è infine una lezione più generale, ed è quella che ci ha convinti a scrivere l’articolo: gli appunti di infrastruttura invecchiano peggio del codice. La nostra procedura interna diceva “crea un cluster gossip” e ha funzionato per anni, finché quella riga non è diventata prima sconsigliata, poi impossibile da seguire, e alla fine un debito da pagare su cluster in produzione. Il codice che non compila più ve lo dice subito; un comando che continua a funzionare mentre tutto intorno cambia, invece, ve lo dice il giorno in cui l’aggiornamento si rifiuta di partire.
Il lato positivo è che un cluster kops si ricostruisce: la sua descrizione completa vive in un bucket, e quello che avete letto qui è la sequenza per rifarlo da capo. Nel prossimo articolo racconteremo come ci mettiamo sopra le applicazioni, tra pubblicazione dei servizi, certificati e rilasci. A presto.