Come distribuire un’applicazione su Heroku?

Questo tutorial illustra il processo di distribuzione di un’applicazione basata su Python su Heroku. Leggendo questo articolo, è possibile comprendere le funzionalità principali di Heroku, il processo di distribuzione delle applicazioni di Heroku e come distribuire un’applicazione su Heroku.

Inoltre, fornisce istruzioni per distribuire la stessa applicazione su Back4app Containers, un’ottima alternativa gratuita a Heroku.

Obiettivi

Alla fine di questo tutorial, sarete in grado di:

• Comprendere Heroku e le sue funzionalità

• Distribuire le applicazioni su Heroku

• Conoscere i contenitori Back4app e le loro caratteristiche

• Distribuite le vostre applicazioni nei contenitori Back4app

• Determinare quale servizio utilizzare per la vostra applicazione

Che cos’è Heroku?

Heroku, fondata nel 2007, è una delle piattaforme Platform as a Service (PaaS) più affidabili. La piattaforma cloud consente di creare, gestire, distribuire e scalare facilmente le applicazioni.

Supporta nativamente Ruby, Python, Java, Clojure, Node, Scala, Go e PHP. Tuttavia, consente di distribuire altri linguaggi di programmazione e framework tramite Docker.

I principali vantaggi di Heroku sono la facilità d’uso, le capacità di scalare, le caratteristiche di sicurezza, i componenti aggiuntivi, la Heroku CLI e la centralità dello sviluppatore.

D’altra parte, Heroku è spesso criticato per il suo costo elevato, per il supporto regionale inadeguato e per il ritardo rispetto alle ultime tendenze di sviluppo.

Uno dei motivi principali per cui Heroku è così popolare è l’offerta di servizi gratuiti in passato. Fino a novembre 2022, era possibile utilizzare Heroku per ospitare applicazioni e persino database in modo assolutamente gratuito.

Purtroppo hanno deciso di cancellare questi servizi gratuiti per combattere le frodi e gli abusi del livello gratuito. Nonostante i recenti cambiamenti, Heroku rimane una delle piattaforme di hosting più popolari. Continuate a leggere per scoprire come effettuare il deploy su Heroku.

Per saperne di più su Heroku, consultate il nostro altro articolo intitolato Cos’è Heroku?

Impostazione del progetto

Per dimostrare come distribuire le applicazioni su Heroku e Back4app Containers, ho preparato una semplice applicazione web per insegnare come distribuire un’applicazione Python su Heroku. L’applicazione web utilizza il framework FastAPI e serve come semplice servizio di accorciatore di URL. È dotata di due endpoint:

1. /shorten assegna un alias a una long_url
2. / reindirizza l’utente al corrispondente long_url

Sentitevi liberi di verificare la vostra comprensione seguendo il vostro progetto.

Prerequisiti

• Conoscenza di base di Python e Git
• Python 3.9+ installato sulla macchina locale
• Git Bash e Docker Desktop installati e configurati
• Un account GitHub personale

Clona ed esegui

L’implementazione di Heroku inizia con il fork di questo repository su GitHub e poi con la clonazione del fork sul vostro computer locale:

$ git clone <fork_remote_git_url>
$ cd back4app-heroku-deploy

Se non si vuole fare il fork, si può creare il proprio repository e inviarvi il codice sorgente.

Creare un ambiente virtuale e attivarlo:

$ python -m venv env && source env/bin/activate

Quindi, installare i requisiti del progetto:

(env)$ pip install -r requirements.txt

Infine, avviare il server di sviluppo:

(env)$ python -m uvicorn main:app --reload 

INFO:     Will watch for changes in these directories: [...]
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [1488] using WatchFiles
INFO:     Started server process [2316]
INFO:     Application startup complete.

Aprite il vostro browser web preferito e visitate il sito http://localhost:8000/docs. Utilizzare la documentazione interattiva per testare l’applicazione web. Se avete bisogno di aiuto per formattare le richieste, consultate il file test_main.http.

Come distribuire un’applicazione su Heroku?

In questa sezione, distribuiremo un’applicazione su Heroku.

I passaggi seguenti richiedono un account Heroku. Se non ne avete ancora uno, procedete con l’iscrizione. Inoltre, assicuratevi di aggiungere le informazioni di pagamento al vostro account Heroku.

Se si elimina l’applicazione subito dopo l’esercitazione, non dovrebbe essere addebitato nulla.

Passare a un nuovo ramo chiamato heroku:

$ git checkout -b heroku

Obiettivi

1. Installare Heroku CLI.
2. Creare un’applicazione Heroku.
3. Specificare il tempo di esecuzione tramite runtime.txt.
4. Specificare i processi dell’applicazione tramite Procfile.
5. Spingere il codice sorgente su Heroku.

Heroku CLI

Esistono diversi modi per interagire con Heroku. È possibile utilizzare la dashboard, la CLI di Heroku o l’API di Heroku.

Preferisco Heroku CLI perché è uno strumento potente che consente di svolgere il lavoro in modo rapido. Lo utilizzeremo in tutto il tutorial.

Per prima cosa, installate Heroku CLI seguendo le istruzioni di installazione ufficiali.

Successivamente, verificare che l’installazione sia andata a buon fine controllando la versione della CLI:

$ heroku --version
heroku/8.4.2 win32-x64 node-v16.19.0

Quindi, verificare gli aggiornamenti della CLI e autenticarsi con il proprio account Heroku:

$ heroku update
$ heroku login

Quando si esegue il secondo comando, si apre una finestra del browser. Per autenticarsi, fare clic su “Accedi” e chiudere la finestra del browser.

Creare un’applicazione Heroku

Per distribuire su Heroku, occorre innanzitutto creare un’applicazione Heroku.

Aprite nuovamente il terminale, navigate nel progetto locale (ad esempio, nella cartella back4app-heroku-deploy ) ed eseguite il seguente comando:

$ heroku create -a <app_name>

Creating ⬢ <app_name>... !
https://<app_name>-31a6fd70e769.herokuapp.com/ | 
https://git.heroku.com/<app_name>.git

Assicurarsi di sostituire <app_name> con il nome dell’applicazione desiderata.

Quindi, verificare se l’applicazione è stata creata correttamente elencando le applicazioni:

$ heroku apps

=== <email_address> Apps
<app_name>

Quindi controllare i dettagli dell’applicazione:

$ heroku apps:info <app_name>

=== <app_name>
Auto Cert Mgmt: false
Dynos:
Git URL:        https://git.heroku.com/<app_name>.git
Owner:          <email_address>
Region:         us
Repo Size:      0 B
Slug Size:      0 B
Stack:          heroku-22
Web URL:        https://<app_name>-21de155883d3.herokuapp.com/

Come forse sapete, Heroku è strettamente integrato con Git. Quando si crea un’applicazione Heroku, viene creato un repository Git remoto a cui è possibile inviare il codice sorgente per distribuirlo. Nel nostro caso, l’URL Git remoto è:

https://git.heroku.com/<app_name>.git

Heroku CLI registra automaticamente un telecomando Git quando si crea un’applicazione. Provare a elencare i remoti:

$ git remote -v

heroku  https://git.heroku.com/back4app-url-shortener.git (fetch)
heroku  https://git.heroku.com/back4app-url-shortener.git (push)
origin  [email protected]:duplxey/back4app-heroku-deploy.git (fetch)
origin  [email protected]:duplxey/back4app-heroku-deploy.git (push)

Nella prossima sezione useremo il telecomando di heroku per distribuire il nostro codice sorgente.

runtime.txt

Un file runtime.txt consente di specificare l’esatta versione di Python che si desidera utilizzare per Heroku. Questo è importante se il progetto richiede una versione specifica di Python per funzionare. Al momento della stesura del presente documento, la versione predefinita è python-3.11.5.

Per specificare il runtime, creare un file runtime.txt contenente la versione del runtime. Esempio:

python-3.11.5

Per l’elenco dei runtime Python supportati, consultare il sito Heroku Python Support.

Profilo di processo

Un Procfile consente di definire i comandi da eseguire per avviare i processi dell’applicazione. Utilizzeremo un Procfile per avviare il server web Uvicorn.

Creare un Procfile nella radice del progetto con il processo web:

web: gunicorn -w 1 -k uvicorn.workers.UvicornWorker main:app

Con le applicazioni di produzione, è probabile che si vogliano generare più worker invece di uno. Poiché un database non supporta la nostra applicazione (utilizza dati in memoria), non possiamo sincronizzare i dati tra più processi worker. Pertanto, dobbiamo usare un solo worker.

Spingere le modifiche al proprio repository GitHub:

$ git add .
$ git commit -m "configured app for heroku"
$ git push origin heroku

Distribuzione dell’applicazione Heroku

Heroku utilizza i cosiddetti buildpack per trasformare le applicazioni in unità che possono essere eseguite sui dynos. Un buildpack non è altro che un insieme di script specializzati per uno specifico linguaggio di programmazione.

Quando si invia il codice a Heroku, Heroku rileva automaticamente il linguaggio di programmazione del progetto e il buildpack necessario per costruirlo. Nel caso di Python, controlla se è presente un file requirements.txt.

Per distribuire la vostra applicazione, tutto ciò che dovete fare è inviare il codice al telecomando di heroku:

$ git push heroku heroku:main

Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 8 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 318 bytes | 318.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0), pack-reused 0
remote: Updated five paths from 30a4ffb
remote: Compressing source files... done.
remote: Building source:
remote:
remote: -----> Building on the Heroku-22 stack
remote: -----> Using buildpack: heroku/python
remote: -----> Python app detected
remote: -----> Requirements file has been changed, clearing cached dependencies
remote: -----> Installing python-3.11.5
remote: -----> Installing pip 23.2.1, setuptools 68.0.0 and wheel 0.41.0
remote: -----> Installing SQLite3
remote: -----> Installing requirements with pip
remote: -----> Discovering process types
remote:        Procfile declares types -> web
remote:
remote: -----> Compressing...
remote:        Done: 30.6M
remote: -----> Launching...
remote:        Released v5
remote:        https://<app_name>-31a6fd70e769.herokuapp.com/ deployed to Heroku
remote:
remote: Verifying deploy... done.

Heroku ha selezionato automaticamente un buildscript appropriato, ha installato i requisiti e ha distribuito l’applicazione su un dyno.

Se l’installazione non è riuscita, utilizzare Heroku CLI per visualizzare i log:

$ heroku logs --tail

Successivamente, controllate lo stato della vostra applicazione:

$ heroku apps:info <app_name>

=== <app_name>
Auto Cert Mgmt: false
Dynos:          web: 1
Git URL:        https://git.heroku.com/<app_name>.git
Owner:          <your_email>
Region:         us
Repo Size:      9 KB
Slug Size:      31 MB
Stack:          heroku-22
Web URL:        https://<app_name>-31a6fd70e769.herokuapp.com/

Provate a visitare la vostra applicazione nel browser navigando verso l'”URL Web”.

Questo è tutto per la parte Heroku. La sezione seguente analizzerà il deploy della stessa applicazione su Back4app Containers.

Come distribuire un’applicazione su Back4app Containers?

In questa sezione, distribuiremo un’applicazione su Back4app Containers.

Che cos’è Back4app Containers?

Back4app Containers è un’ottima piattaforma Containers as a Service (CaaS). Consente di distribuire, gestire e scalare le applicazioni su container distribuiti a livello globale.

La piattaforma è strettamente integrata con GitHub e fornisce un sistema CI/CD integrato. Tra le altre caratteristiche vi sono le distribuzioni senza tempi morti, il collegamento a domini personalizzati, la registrazione, il monitoraggio e altro ancora.

La cosa migliore è che la piattaforma offre un generoso livello gratuito. Con oltre 600 ore mensili gratuite di container, potete facilmente prototipare e ospitare i vostri progetti. Man mano che la vostra applicazione cresce, potete passare ai livelli premium con prezzi prevedibili.

Per saperne di più sui container come servizio, consultate Cos’è CaaS – Containers as a Service?

Passare a un nuovo ramo chiamato back4app basato sul ramo master:

$ git checkout master && git checkout -b back4app

Obiettivi

1. Dockerizzare l’applicazione.
2. Collegate il vostro GitHub con il vostro account Back4app.
3. Importare il repo GitHub desiderato.
4. Distribuire!

Dockerizzare

Per distribuire un’applicazione su Back4app Containers, è necessario prima dockerizzarla.

La dockerizzazione è il processo di costruzione, distribuzione ed esecuzione di applicazioni in contenitori Docker. Il modo più semplice per dockerizzare un’applicazione è tramite un file Docker.

Profilo Docker

Un Dockerfile è uno script contenente le istruzioni per creare un’immagine di un contenitore Docker. È possibile usare questo file per definire l’ambiente, le dipendenze e altri comandi necessari per costruire ed eseguire un’applicazione.

La sintassi è la seguente:

COMMAND <arg_1> <arg_2> ... <arg_n>

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

FROM python:3.9.6-alpine

# Set the working directory
WORKDIR /app

# Set environment variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# 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

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]

Questo file Docker è basato sull’immagine python:3.9.6-alpine. Per prima cosa imposta la directory di lavoro, le variabili d’ambiente e poi gestisce i requisiti. Successivamente, copia il codice sorgente, espone la porta 80 e avvia il server Uvicorn su quella porta.

Per la distribuzione di altri linguaggi di programmazione e framework, potete prendere i file Docker dai documenti di Back4app Containers.

Se avete bisogno di chiarimenti sul funzionamento di un comando Dockerfile, consultate il riferimento a Dockerfile.

.dockerignore

Possiamo usare un file .dockerignore per ridurre le dimensioni dell’immagine Docker. Questi file funzionano in modo simile ai file .gitignore. È necessario definire i file e le directory che si desidera escludere dall’immagine.

Nel nostro caso, si tratta dell’ambiente virtuale, dei file IDE e della cartella .git.

Creare un file .dockerignore come questo:

.git/
.idea/
venv/

Sentitevi liberi di adattare il file .dockerignore alle esigenze del vostro progetto.

Spingere le modifiche al proprio repository GitHub:

$ git add .
$ git commit -m "configured app for back4app"
$ git push origin back4app

Costruire, eseguire e testare

Prima di inviare il codice nel cloud, è bene testarlo localmente.

Per prima cosa, costruite l’immagine e assegnatele un tag:

$ docker build -t back4app-url-shortener:1.0 .

Successivamente, elencare le immagini:

$ docker images

REPOSITORY                      TAG            IMAGE ID       CREATED         SIZE
back4app-url-shortener          1.0            1cbe348a04ad   1 minute ago    68.7MB

Eseguire il contenitore usando l’immagine appena costruita:

$ docker run -p 80:80 --name back4app-url-shortener back4app-url-shortener:1.0

Spiegazione dell’argomento:

1. -p 80:80 vincola la porta 80 della macchina host alla porta 80 del contenitore
2. --nome back4app-url-shortener nomina l’istanza del contenitore

Si può usare -d per eseguire il contenitore in modalità distaccata (senza occupare il terminale).

Controllare se il contenitore è in funzione:

$ docker ps

CONTAINER ID   IMAGE                        CREATED    STATUS    PORTS
b3b82313ab65   back4app-url-shortener:1.0   3s ago     1s        0.0.0.0:80->80/tcp

Aprite il vostro browser web preferito e navigate su http://localhost/docs. Dovreste essere in grado di vedere il servizio di abbreviazione degli URL.

Distribuire l’applicazione

I passaggi seguenti richiedono un account Back4app. Se non ne avete ancora uno, registratevi per un account gratuito. Tutto ciò che faremo in questo tutorial sarà all’interno del livello gratuito.

Quando si accede al proprio account Back4app, viene presentato l’elenco delle app. Cliccate su “Build new app” per avviare il processo di creazione dell’app.

Back4app offre due soluzioni:

1. Backend as a Service (BaaS): una soluzione di backend pronta per l’uso.
2. Containers as a Service (CaaS): una piattaforma di distribuzione di container alimentata da Docker.

Poiché stiamo distribuendo un’applicazione Python personalizzata, sceglieremo CaaS. Selezionate “Containers as a Service” sul lato destro dello schermo.

Vi verrà chiesto di collegare il vostro account GitHub se è la prima volta che lavorate con Back4app. Inoltre, assicuratevi di importare tutti i repository che desiderate distribuire.

Quindi, “selezionare” il repo GitHub che si desidera distribuire:

Poiché stiamo distribuendo un’applicazione semplice, non dobbiamo configurare molto l’ambiente. Tutto ciò che si deve fare è impostare:

1. Nome dell’applicazione: back4app-url-shortener (è possibile scegliere un nome diverso)
2. Ramo: back4app (il vostro ramo GitHub)

Quindi fare clic su “Deploy”.

Back4app Containers offre molte opzioni di configurazione, tra cui il deploy automatico, le impostazioni delle porte, le variabili d’ambiente e i controlli sullo stato di salute.

Back4app Containers impiegherà un po’ di tempo per costruire e distribuire l’immagine Docker. Una volta che l’applicazione è pronta, il suo stato cambierà in “Disponibile”. Per visitare l’applicazione, fare clic sul link sotto lo stato, come illustrato nell’immagine.

Ottimo lavoro! Avete distribuito con successo un’applicazione web su Back4app Containers.

Conclusione

Questa esercitazione ha insegnato come distribuire una semplice applicazione web su Heroku e Back4app Containers. Entrambe le piattaforme hanno pro e contro che vanno considerati quando si distribuisce un’applicazione.

Come regola generale, sceglierei Back4app Containers per le applicazioni che non richiedono un database. Back4app Containers vi aiuterà a risparmiare e il suo livello gratuito è più che sufficiente per i vostri progetti.

Heroku potrebbe essere migliore se la vostra applicazione si basa su un database o su componenti aggiuntivi sofisticati.

Nella tabella seguente sono riassunte alcune delle principali differenze tra le piattaforme:

Sentitevi liberi di prendere il codice sorgente finale dal repository GitHub.

FAQ