Dovreste usare Kubernetes? La risposta, in breve, dipende. Ma lasciate che vi illustri il mio percorso di comprensione di Kubernetes e forse vi aiuterà a trovare la vostra risposta.
Ho scritto un intero libro per aiutarvi a percorrere la vostra strada verso Kubernetes (ottenete la prima versione di MEAP da Manning qui). Ma prima di parlare del libro, parliamo un po' del deployment del software e del mio percorso di avvicinamento.
Quasi due decenni fa, ho intrapreso il mio primo tentativo di distribuire un software su Internet per pubblicare il mio primo sito web. All'epoca non sapevo nemmeno da dove cominciare. Un paio di amici di famiglia furono così gentili da offrirmi qualche consiglio:
L'imprenditore ha suggerito:
"Prendete questo libro su Dreamweaver e HTML e non dovrete spendere un centesimo per sviluppare il vostro primo sito web".
L'amministratore di sistema e lo sviluppatore hanno adottato un approccio diverso:
"Ecco, lascia che ti configuri un server FTP per ospitare il tuo sito web; non ti consiglio di imparare a gestire i server".
Entrambe queste persone hanno contribuito a farmi arrivare dove sono oggi, ma una di loro ha involontariamente ritardato il mio apprendimento per molto tempo. Riuscite a indovinare chi?
Ripensando ai miei esordi, appare chiaro quanto siano state cruciali per il mio percorso sia le conoscenze di base sia l'apprendimento attraverso l'esperienza pratica. I consigli degli imprenditori mi hanno spinto a immergermi nello sviluppo web, mentre la guida dell'amministratore di sistema mi ha insegnato il valore degli strumenti che possono semplificare compiti complessi.
Tuttavia, una lezione chiave emersa nel corso del tempo è stata l'importanza di comprendere i principi fondamentali, anche quando si utilizzano strumenti di alto livello. Questa prima esperienza di apprendimento è stata la genesi del mio interesse per Kubernetes, una tecnologia che avrebbe avuto un impatto significativo sulla mia traiettoria professionale. La comprensione di Kubernetes, come di qualsiasi altro strumento, richiede una solida conoscenza della tecnologia sottostante.
Kubernetes è complesso? Si. È perfetto? No. È adatto a tutte le situazioni? No. Ma la questione dell'utilizzo o meno di Kubernetes si riduce spesso alla comprensione della tecnologia sottostante che rende Kubernetes così potente e al modo in cui è possibile utilizzarlo per gestire e proteggere il software.
A coloro che si chiedono "Che cos'è Kubernetes?" o che forse non conoscono ancora il termine "Docker" (al di là del tipo di pantaloni) e la sua associazione con i container, permettetemi di spiegarlo.
Le applicazioni sono in continua evoluzione e ogni componente, dal database al linguaggio di programmazione, rilascia frequentemente nuove versioni. Tenere traccia di più versioni di ogni applicazione e di numerose iterazioni di componenti di terze parti può diventare un problema da gestire, soprattutto quando si tratta di versioni vecchie o legacy prive del supporto mainstream. Anche le versioni supportate del software hanno molte dipendenze a livello di sistema e di installazione di terze parti che possono aggiungere complessità all'esecuzione del software, per non parlare del tentativo di utilizzarlo come componente della vostra applicazione.
Con il tempo, tutti i software diventano obsoleti e vengono sostituiti da versioni più recenti. La sfida consiste nel far funzionare il software più vecchio quando è necessario. Anche cambiamenti apparentemente piccoli nel software possono avere un impatto enorme sulle applicazioni moderne. Per esempio, Python 2.7 (rispetto al più recente Python 3.11) era integrato in Mac OS X di Apple. Python 2.7 aveva una strana sintassi per l'output di testo alla riga di comando: `print "questa cosa" ` invece della versione più logica di `print("questa cosa")` che si trova nelle versioni più recenti di Python. Questo pezzo di sintassi può rompere un'intera applicazione legacy Python a causa delle parentesi mancanti.
Sebbene l'utilizzo di versioni precedenti del software possa essere poco pratico, ci sono certamente situazioni in cui è necessario eseguire software più vecchi. Ma come?
Potremmo dedicare il tempo necessario a trovare un pezzo di hardware o un'immagine VM di un momento specifico che ci permetta di eseguire un vecchio software. Oppure possiamo ricorrere ai container, un concetto introdotto da Docker. I container sono applicazioni autocontenute, confezionate con le loro dipendenze, che possiamo modificare a nostro piacimento. Il loro punto di forza è la capacità di passare senza problemi da un sistema all'altro.
Ecco un esempio di file Docker che utilizza Python 2.7 come elemento costitutivo di un contenitore:
```dockerfile
FROM python:2.7.7-slim
COPY ./src /app/
WORKDIR /app
RUN python -m pip install -r requirements.txt
CMD [“python”, “manage.py”, “runserver”]
``````dockerfile
FROM python:2.7.7-slim
COPY ./src /app/
WORKDIR /app
RUN python -m pip install -r requirements.txt
CMD [“python”, “manage.py”, “runserver”]
```Questo Dockerfile dice a Docker cosa è necessario per costruire questo nuovo contenitore con il codice che esiste sulla nostra macchina locale e il percorso locale sotto `/src`. I file Docker possono essere molto più complicati, ma questo esempio mostra quanto sia facile usare Docker.
Per costruire ed eseguire questa applicazione containerizzata, è semplice come:
```bash
docker build -f Dockerfile -t hello-python:v1 .
docker run hello-python -p 8000:8000
```Senza la containerizzazione, dovremmo installare Python 2.7 direttamente su una macchina, il che non è mai semplice. Docker e altri contenitori possono rendere portatili le nostre applicazioni e si può sostituire Python 2.7 in questo esempio con quasi tutti i linguaggi o gli strumenti open source.
Tuttavia, il problema sorge quando si vuole aggiornare un'applicazione containerizzata, soprattutto in produzione. A livello locale, l'aggiornamento di un contenitore è semplice. Si interrompe l'esecuzione del contenitore, lo si ricostruisce e lo si esegue nuovamente. In produzione, tuttavia, l'aggiornamento di un contenitore può essere fatto allo stesso modo, ma si corre il rischio di un grave downtime se la compilazione fallisce.
È qui che entra in gioco Kubernetes. Kubernetes aiuta a gestire l'instradamento del traffico verso container specifici e supervisiona il numero di container in esecuzione in qualsiasi momento. Se un container si guasta, Kubernetes facilita il rollback alle versioni precedenti con tempi di inattività minimi o nulli.
La configurazione per il deploy di un container su Kubernetes si chiama manifest. Ecco un esempio di manifest relativamente semplice:
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: hello-py-deploy
spec:
replicas: 3
selector:
matchLabels:
app: hello-py-deploy
template:
metadata:
labels:
app: hello-py-deploy
spec:
containers:
- name: hello-py-container
image: jmitchel3/hello-python:v1
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
name: hello-py-service
spec:
type: LoadBalancer
ports:
- name: http
port: 80
targetPort: 8080
protocol: TCP
selector:
app: hello-py-deploy
```Nell'esempio precedente, il manifest di Kubernetes in formato yaml fornisce due risorse: un servizio di bilanciamento del carico e un deployment. Il bilanciatore di carico aiuta a instradare il traffico verso il nostro deployment. Tramite `replica: 3`, del nostro contenitore dichiarato `hello-python:v1`, il nostro deployment sta eseguendo 3 versioni.
Ora, quando vogliamo aggiornare la versione distribuita, possiamo semplicemente cambiare `hello-python:v1` con `hello-python:v2` e Kubernetes aggiornerà con grazia la nostra applicazione. E se qualcosa va storto, tornerà a `hello-py-deploy:v1`. Kubernetes rende questo processo indolore e facile da gestire. I manifesti possono essere facilmente controllati in versione con git, in modo da poter ottenere un rollback molto granulare. Kubernetes è parte integrante del deployment perché fornisce un framework per automatizzare, scalare e gestire le applicazioni containerizzate, garantendo la resilienza e l'efficienza del sistema nei nostri paesaggi software sempre più complessi.
Ho voluto illustrare solo alcuni dei metodi che mi hanno portato a scoprire come Kubernetes potesse semplificare le mie distribuzioni di applicazioni. Per ottenere il massimo da Kubernetes ho dovuto compiere diversi passi, ma è stato un viaggio proficuo. In Road to Kubernetes, faremo un viaggio per distribuire le applicazioni utilizzando varie tecnologie che è importante comprendere prima di lanciarsi in Kubernetes e in altre pratiche di distribuzione moderne.
In Road to Kubernetes spiegheremo come:
- Gestione di repository git su piattaforme self-hosted o cloud
- Distribuire le applicazioni Python e Node.js tramite macchine virtuali basate sul cloud con git
- Automatizzate la configurazione e la distribuzione delle macchine virtuali con Ansible
- Containerizzazione e distribuzione di applicazioni con Docker e Docker Compose
- Esecuzione di container direttamente su macchine virtuali senza orchestrazione
- Spingere e ospitare i container con il registro DockerHub
- Distribuzione di applicazioni containerizzate su Kubernetes
- Implementare applicazioni pubbliche e private su Kubernetes
- Configurazione dei bilanciatori di carico per il traffico HTTP e HTTPs
- Utilizzare le tecniche CI/CD con Github Actions e l'alternativa open-source di Nectos.
- e altro ancora!
Il deployment è il test definitivo del vostro software. Road to Kubernetes condensa quindici anni di conoscenze sul deployment in una guida pratica e accessibile. Vi porta dal deployment del software da zero fino all'implementazione della potenza di Kubernetes. Imparerete pratiche di distribuzione sostenibili che potrete utilizzare con qualsiasi linguaggio e qualsiasi tipo di applicazione web, come creare applicazioni portatili che possono essere trasferite tra le varie opzioni di distribuzione e i fornitori di cloud, e vedrete come è possibile utilizzare Kubernetes per progetti di qualsiasi dimensione.
Commenti