Che cos’è il CaaS – Containers as a Service?

In questo articolo parleremo di Containers as a Service (CaaS). Uno dei più recenti ma potenti modelli di cloud. Imparerete a conoscerne le funzionalità principali, i pro e i contro, il confronto con altri modelli di cloud e come distribuire una semplice applicazione utilizzando i container.

Punti di forza

• Il CaaS facilita lo sviluppo e la distribuzione senza soluzione di continuità con funzionalità integrate.
• Il CaaS offre elevata scalabilità e portabilità, attenuando il vendor lock-in.
• I limiti del CaaS includono i potenziali rischi per la sicurezza e la curva di apprendimento ripida.

Che cos’è Containers as a Service?

La definizione di CaaS è Containers as a Service, un modello di cloud computing che consente agli sviluppatori di caricare, costruire, scalare e gestire i container.

I container DevOps sono leggeri pacchetti eseguibili autonomi che includono tutto ciò che è necessario per eseguire un’applicazione. Si tratta di runtime, codice, librerie, file di configurazione e altro ancora. I container sono altamente portatili, di dimensioni ridotte ed efficienti.

Utilizzando CaaS, gli sviluppatori e i team operativi IT non devono preoccuparsi dell’infrastruttura sottostante. Possono invece pensare a un livello molto più alto.

È sufficiente codificare l’applicazione, dockerizzarla e inviarla al cloud. Il cloud provider si occuperà di tutto il resto, come la scalatura, il bilanciamento del carico e il monitoraggio!

Inoltre, il CaaS è eccellente perché promuove lo sviluppo agile, supporta l’architettura a microservizi ed è estremamente utile per costruire rapidamente applicazioni altamente scalabili.

Quali sono le funzionalità principali di Containers as a Service?

Non esistono specifiche ufficiali che definiscano le caratteristiche che un CaaS deve includere. Esse variano da fornitore a fornitore. Tuttavia, le funzionalità di base di Containers as a Service sono:

• Runtime del contenitore (responsabile dell’esecuzione delle applicazioni containerizzate)
• Registro dei container (consente di memorizzare e distribuire immagini Docker già costruite)
• Scalabilità automatica (aumenta o diminuisce il numero di container in base al traffico)
• Sistema CI/CD integrato (preleva il codice da un sistema VCS come GitHub o GitLab)
• Bilanciamento del carico (divide il traffico tra più container per ottenere migliori prestazioni)
• Monitoraggio e registrazione (fornisce funzionalità avanzate di monitoraggio dei container)

Quali sono i vantaggi di Containers as a Service?

Sviluppo e implementazione più rapidi

Utilizzando CaaS, è possibile accelerare in modo significativo il processo di sviluppo e distribuzione del software. I container semplificano la creazione di ambienti di sviluppo locali per gli sviluppatori in fase di avvio. Tutto ciò che devono fare è eseguire uno o due comandi, invece di installare un mucchio di dipendenze o armeggiare con le impostazioni del sistema operativo.

Inoltre, una volta che il progetto è containerizzato, può essere facilmente distribuito a qualsiasi fornitore CaaS.

Efficienza delle risorse

I contenitori hanno una natura favorevole alle risorse. Sono progettati per utilizzare in modo efficiente le risorse di sistema, come CPU, memoria e storage. Con i container è generalmente possibile eseguire più applicazioni con meno risorse di sistema. Rispetto alle macchine virtuali, i container sono più ottimizzati per le risorse.

Portabilità

Le applicazioni containerizzate sono altamente portabili poiché non dipendono dal sistema operativo o dall’hardware sottostante. Utilizzando CaaS, non avrete mai più il problema “funziona sulla mia macchina”.

Inoltre, i container eliminano il rischio di vendor lock-in. Se non si è soddisfatti del fornitore attuale, si può facilmente passare da un fornitore all’altro senza modificare il codice.

Scalabilità

I container, in combinazione con un software di orchestrazione come Kubernetes, sono altamente scalabili. La maggior parte dei fornitori di CaaS dispone di funzionalità integrate di autoscaling, bilanciamento del carico e altro ancora. Ciò consente loro di gestire qualsiasi traffico e di ridimensionarsi rapidamente una volta terminato il picco di traffico.

Funzionamento semplificato

CaaS colma il divario tra l’ambiente di sviluppo e quello di produzione. Inoltre, semplifica il processo DevOps offrendo un sistema CI/CD integrato, che si integra con il sistema VCS.

Soprattutto, il CaaS vi consentirà di ridurre i costi in quanto non avrete bisogno di amministratori di sistema o ingegneri DevOps.

Quali sono i limiti di Containers as a Service?

Problemi di sicurezza

I container offrono un isolamento e una sicurezza inferiori rispetto alle macchine virtuali, poiché condividono lo stesso kernel di sistema. Questo potrebbe essere un potenziale rischio per la sicurezza. Se si eseguono i processi del container Docker come root, un hacker potrebbe uscire dal container e prendere il controllo del sistema host.

Mancanza di controllo

Le piattaforme CaaS offrono in genere un livello di controllo inferiore rispetto ad altri modelli di cloud. I clienti non possono regolare con precisione le macchine su cui vengono eseguiti i container o configurare la scalabilità delle applicazioni.

Curva di apprendimento

Il modello Containers as a Service è più impegnativo di PaaS o BaaS. Richiede molte conoscenze tecniche sulla programmazione, sulla tecnologia di containerizzazione, su Docker, ecc. Ha una curva di apprendimento più ripida, ma la sua padronanza può aiutarvi a risparmiare molto tempo e denaro.

Persistenza dei dati

I contenitori sono progettati per essere stateless. Non dovrebbero essere usati per memorizzare file, database o qualsiasi altra cosa che richieda la persistenza dei dati. Utilizzando CaaS, dovrete utilizzare un servizio di terze parti per l’hosting dei file, come AWS S3, Google Cloud Storage, ecc. Per quanto riguarda il database, si può optare per una soluzione di database gestito.

Che ruolo hanno Docker e Kubernetes in una piattaforma CaaS?

Docker e Kubernetes svolgono un ruolo fondamentale nella maggior parte delle piattaforme CaaS.

Docker è una piattaforma gratuita e open-source per costruire, distribuire, eseguire e gestire container. È stata rilasciata nel 2013 ed è diventata lo standard di fatto per il confezionamento di software containerizzato.

Kubernetes (talvolta indicato anche come K8s) è un software di orchestrazione. Funziona a un livello superiore rispetto a Docker. Lo scopo di Kubernetes è garantire che i cluster di container funzionino bene insieme. Si occupa della scalatura, del bilanciamento del carico, della sostituzione dei container non funzionanti, ecc.

Come si colloca Containers as a Service rispetto ad altri modelli?

In questa sezione, confronteremo CaaS con altri servizi di cloud computing, tra cui IaaS, PaaS e BaaS. Tutti hanno i loro pro e i loro contro che devono essere presi in considerazione quando si implementa il progetto.

In base ai livelli di astrazione, il CaaS si colloca a metà strada tra IaaS e PaaS (come illustrato nell’immagine seguente).

CaaS vs IaaS

L’Infrastructure as a Service (IaaS) è un modello flessibile di cloud computing in cui un cloud provider offre l’infrastruttura di base in un ambiente virtualizzato. Questo include server, storage, sistemi operativi e reti. L’IaaS è l’opzione meno astratta e offre ai clienti il controllo completo della loro infrastruttura.

Il CaaS è meno flessibile e offre un livello di controllo inferiore rispetto allo IaaS. D’altro canto, però, è molto più facile da gestire e consente una maggiore scalabilità e portabilità. Come regola generale, utilizzate IaaS se avete bisogno di un controllo di alto livello e CaaS se avete bisogno di un modo veloce per distribuire applicazioni scalabili e containerizzate.

CaaS vs PaaS

Platform as a Service (PaaS) è un servizio di cloud computing che fornisce agli sviluppatori gli strumenti per costruire e distribuire le loro applicazioni. Il PaaS consente agli utenti di concentrarsi sulla propria applicazione, invece di preoccuparsi dell’infrastruttura sottostante. La maggior parte dei fornitori di PaaS consente di far funzionare la propria applicazione in uno o due clic!

Il CaaS è più flessibile e scalabile rispetto al PaaS. Il CaaS consente di distribuire praticamente qualsiasi cosa, mentre i fornitori di PaaS sono solitamente limitati a pochi linguaggi di programmazione. In termini di strumenti e funzionalità di sviluppo software, il PaaS è più avanzato. Il PaaS è più adatto alle applicazioni monolitiche, mentre il CaaS supera l’architettura a microservizi.

Per saperne di più sulla Platform as a Service, consultate Cos’è la Paas?

CaaS vs BaaS

Backend as a Service (BaaS) è un modello di cloud computing che astrae completamente dal lato backend di un progetto. È dotato di database, archiviazione di file, gestione degli utenti, API, SDK, notifiche push e autenticazione, solo per citarne alcuni. BaaS consente di concentrarsi sul frontend e sulla logica aziendale, invece di sprecare tempo e denaro in attività di programmazione ripetitive.

CaaS può essere utilizzato per distribuire backend e frontend, mentre BaaS serve soprattutto per distribuire backend. BaaS è estremamente facile da usare e talvolta non richiede alcun codice. CaaS, invece, richiede una discreta conoscenza tecnica di programmazione, dockerizzazione e DevOps.

Per saperne di più sul Backend as a Service, consultate Cos’è il BaaS?

Quali sono i migliori fornitori di Containers as a Service?

Back4app Containers

Back4app Containers è un potente servizio cloud che offre una piattaforma CaaS per il deployment e lo scaling di applicazioni su container distribuiti a livello globale.

Consente agli sviluppatori di concentrarsi sul proprio software e sul processo di dockerizzazione senza preoccuparsi di DevOps. La piattaforma ha un sistema CI/CD integrato, l’integrazione con GitHub e supporta distribuzioni senza tempi morti.

Soprattutto, offre un piano gratuito e vi permette di far funzionare la vostra app in pochi minuti!

Amazon Elastic Container Service

Amazon Elastic Container Service (ECS) è un servizio di orchestrazione di container completamente gestito che semplifica la gestione e la distribuzione di software containerizzato. Tutto ciò che dovete fare è descrivere la vostra applicazione e le risorse necessarie, e AWS si occuperà di tutto il resto.

Non ci sono costi esclusivi per ECS, poiché ECS utilizza altri servizi AWS in background. Per utilizzare efficacemente ECS, è necessario conoscere l’ecosistema AWS. AWS offre anche un livello gratuito per i nuovi clienti.

Google Cloud Kubernetes

Google Cloud Kubernetes (GKE) è la piattaforma di orchestrazione di Google basata su Kubernetes. Consente di mettere i container su un pilota automatico, eliminando la necessità di gestire i nodi. È dotata di applicazioni e modelli Kubernetes precostituiti, funzionalità di autoscaling, gestione multi-cluster e molto altro ancora!

GKE è eccezionalmente performante e flessibile, ma richiede una notevole configurazione iniziale. Per questo motivo non è adatto ai principianti. Come le altre due opzioni, anche Google offre crediti gratuiti per i nuovi utenti.

Come ospitare una semplice applicazione utilizzando i container?

In questa sezione, vedremo come costruire, dockerizzare e distribuire una semplice applicazione web in Python. Questa guida è stata progettata specificamente per Back4app Containers, ma passi simili possono essere applicati a qualsiasi altro provider CaaS.

Obiettivi

1. Codificare l’applicazione.
2. Dockerizzare l’applicazione e testarla.
3. Spingere il codice sorgente su GitHub.
4. Distribuire l’applicazione su CaaS.

Codice App

Per dimostrare il processo di distribuzione, costruiremo una semplice API RESTful utilizzando FastAPI, un framework Python moderno e ad alte prestazioni per la creazione di API pronte per la produzione.

Impostazione del progetto

Iniziate creando una cartella dedicata al progetto e un ambiente virtuale:

$ mkdir fastapi-example && cd fastapi-example
$ python3.9 -m venv env && source env/bin/activate

Successivamente, installare FastAPI con tutte le sue dipendenze:

$ pip install "fastapi[all]"

L’uso dello specificatore extra installa alcune dipendenze opzionali, come il server Uvicorn, il motore di template Jinja2 e così via. Se si vuole il minimo indispensabile, non includere l’extra.

Creare un file main.py con i seguenti contenuti:

# main.py

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Back4app Containers rocks!"}

Questa è l’applicazione FastAPI più elementare che si possa scrivere. Abbiamo dovuto importare FastAPI, inizializzarla e registrare l’endpoint principale. La visita a / dovrebbe restituire il messaggio Back4app Containers rocks!

Esecuzione e test

Per eseguire l’applicazione web, è possibile utilizzare il server ASGI integrato di Uvicorn:

$ uvicorn main:app --reload

INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [9528] using WatchFiles
INFO:     Started server process [26308]
INFO:     Waiting for application startup.
INFO:     Application startup complete.  

Abbiamo aggiunto il flag --reload perché vogliamo che il server venga ricaricato se apportiamo modifiche al codice sorgente.

Utilizzare cURL per inviare una richiesta GET alla radice dell’API:

$ curl http://localhost:8000/

{
    "message": "Back4app Containers rocks!"
}

requisiti.txt

Un’altra cosa da fare è congelare tutti i requisiti in un file requirements.txt. In questo modo, gli altri possono installare rapidamente tutte le dipendenze necessarie per il nostro progetto.

$ pip freeze > requirements.txt

fastapi==0.97.0
pydantic==1.10.9
python-dotenv==1.0.0
...

Useremo questo file per installare le dipendenze di Python nel processo di creazione dell’immagine di Docker.

App Dockerize

Prima di procedere, assicuratevi di avere Docker sulla vostra macchina locale. Il modo migliore per verificarlo è eseguire docker --version nel terminale.

Profilo Docker

Per dockerizzare il nostro progetto, useremo un Dockerfile. Un Dockerfile è un file di testo che contiene tutti i comandi che un utente potrebbe eseguire per assemblare un’immagine.

Creare un file Docker nella radice del progetto in questo modo:

# Dockerfile

# Use Alpine Linux as the base image
# we're using it since it's tiny in size (~5 MB)
FROM python:3.9.6-alpine

# Set the working directory
WORKDIR /app

# Set environmental variables
ENV PYTHONDONTWRITEBYTECODE 1  # Prevents Python from writing out .pyc files
ENV PYTHONUNBUFFERED 1         # Keeps Python from buffering stdin/stdout

# Copy over the requirements file and install the dependencies
COPY ./requirements.txt .
RUN pip install --no-cache-dir --upgrade -r ./requirements.txt

# Copy over the source code
COPY . .

# Expose the port
EXPOSE 80

# Run the server
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]

Consultate i commenti per capire come funzionano le diverse istruzioni.

Non preoccupatevi, non è necessario memorizzare tutte le istruzioni. Se vi bloccate, potete sempre consultare la documentazione di Docker. Inoltre, i file Docker per la maggior parte dei linguaggi e dei framework sono disponibili online. Basta copiarli e adattarli alle proprie esigenze.

.dockerignore

Il nostro progetto contiene file e directory che non vogliamo siano inclusi nell’immagine Docker. Per ignorarli, possiamo usare un file .dockerignore.

Creare un file .dockerignore nella radice del progetto:

# .dockerignore

.git/
.idea/
venv/

Sentitevi liberi di aggiungere altri file e directory.

Costruire, eseguire e testare

Prima di distribuire il codice su CaaS, assicurarsi che il progetto venga compilato ed eseguito correttamente sulla propria macchina.

Iniziare a costruire l’immagine Docker:

$ docker build -t fastapi-example:1.0 .

Sintesi delle argomentazioni:

1. -t fastapi-example:1.0 etichetta/nomina l’immagine.
2. . definisce il contesto di costruzione.

Quindi, verificare se l’immagine è stata creata con successo:

$ docker images

REPOSITORY        TAG       ID             CREATED AT      SIZE
fastapi-example   1.0       33feac11707d   4 seconds ago   72.8MB

Successivamente, utilizzare l’immagine appena creata per avviare un nuovo contenitore:

$ docker run -p 80:80 --name fastapi-example -d fastapi-example:1.0

Sintesi delle argomentazioni:

1. -p 80:80 espone la porta 80.
2. --nome fastapi-example dà il nome al contenitore.
3. -esegue il contenitore in modalità distaccata (senza occupare il terminale).
4. fastapi-example:1.0 specifica quale immagine utilizzare.

Controllare i contenitori in funzione:

$ docker ps

ID        IMAGE                 COMMAND                CREATED   PORTS                
e67fdeg   fastapi-example:1.0   "uvicorn main:app.."   9s ago    0.0.0.0:80->80/tcp  

Infine, inviare una richiesta GET all’indice API per verificare se si ottiene il messaggio:

$ curl http://localhost/

{
    "message": "Back4app Containers rocks!"
}

Per arrestare il contenitore, si può usare il seguente comando:

$ docker kill fastapi-example

Spingere su GitHub

Per i prossimi passi è necessario disporre di un account GitHub. Se non ne avete uno, procedete con l’iscrizione. Inoltre, assicuratevi di avere Git installato e configurato sul vostro computer.

Creare un archivio

Verrete reindirizzati alla vostra dashboard quando accederete al vostro account GitHub. Utilizzate il pulsante Aggiungi in alto a destra per visualizzare il modulo di creazione del repository.

Quindi, assegnare al repository un nome descrittivo e fare clic sul pulsante “Crea repository”.

GitHub impiegherà qualche istante per creare il repository. Una volta creato il repository, si verrà reindirizzati ad esso. Prendere nota dell'”URL del repository remoto”.

Spingere il codice sorgente

Procedendo, tornate al vostro progetto locale.

Prima di controllare la versione del codice, è bene creare un file .gitignore. Un file .gitignore consente di definire quali file e directory non devono essere aggiunti al sistema di controllo della versione. Questo file funziona come un file .dockerignore.

Creare un file .gitignore nella root del progetto con i seguenti contenuti:

# .gitignore

.idea/
venv/
.env
build/

Sentitevi liberi di modificare il file secondo le vostre esigenze.

Quindi, aprire il terminale ed eseguire il seguente comando per inizializzare il repository Git locale:

$ git init

Quindi aggiungere tutti i file a VCS e creare il commit iniziale:

$ git add .
$ git commit -m "my initial commit"

Infine, aggiungere l’origine GitHub remota e inviarvi il codice sorgente:

$ git remote add origin <remote_url>
$ git push origin master

Assicurarsi di sostituire con l’URL remoto del passo precedente.

Dovrebbe essere tutto. Se ora si controlla la pagina del repository GitHub, si dovrebbe vedere che tutti i file sono stati aggiunti con successo.

Distribuire l’applicazione

Per distribuire un’applicazione su Back4app Containers è necessario un account Back4app. Se non ne avete ancora uno, procedete alla registrazione.

Una volta effettuato l’accesso, verrà visualizzato l’elenco delle app. Fare clic sul pulsante “Crea nuova app” per avviare il processo di creazione dell’app.

Back4app consente di distribuire due tipi di applicazioni: Backend as a Service (BaaS) o Containers as a Service (CaaS). Poiché stiamo distribuendo un’applicazione containerizzata, scegliete l’opzione “Containers as a Service”.

Se è ancora necessario collegare il proprio profilo GitHub e importare il repository, creato nel passaggio precedente. Quindi, selezionarlo.

Back4app Containers consente di personalizzare al massimo la distribuzione. È possibile impostare il ramo di distribuzione, la directory principale, attivare la distribuzione automatica e impostare le variabili ambientali.

Poiché stiamo distribuendo un’applicazione semplice, non abbiamo bisogno di nessuna di queste opzioni. È sufficiente impostare il “Nome dell’app” e poi fare clic sul pulsante “Crea app”.

Back4app Containers impiegherà qualche istante per estrarre il codice sorgente da GitHub, creare l’immagine e avviare un nuovo contenitore. Una volta che l’applicazione è pronta, lo stato cambierà in “Ready”.

A questo punto, è possibile fare clic sul link verde sul lato sinistro dello schermo per aprire l’applicazione nel browser. Potreste anche notare che Back4app Containers ha rilasciato un certificato SSL gratuito per la vostra applicazione.

Buon lavoro, è tutto!

Conclusione

In conclusione, avete imparato a conoscere il CaaS, uno dei migliori modelli cloud native per l’architettura a microservizi. Ora ne conoscete le caratteristiche principali, i vantaggi, i limiti e i migliori fornitori di CaaS. Inoltre, avete imparato a distribuire una semplice applicazione dockerizzata su Back4app Containers.

Il codice sorgente del progetto è disponibile sul repository back4app-containers-fastapi.

Ulteriori passi

1. Cercate le build multi-stadio per migliorare i vostri file Docker e renderli più facili da mantenere.
2. È una buona pratica di sicurezza eseguire i processi di Docker Container con un utente non root.
3. Consultate i documenti di Back4app Containers per imparare a distribuire altri linguaggi di programmazione e framework.

FAQ