Come distribuire un’applicazione Golang

Go (Golang) è un linguaggio di programmazione sviluppato da Google nel 2009 per risolvere problemi comuni nello sviluppo di sistemi su larga scala, come la lentezza di compilazione e la necessità di programmazione concorrente.

Il linguaggio è stato progettato per garantire semplicità, efficienza e facilità d’uso, con una sintassi simile a quella del C. Inoltre, Go è compilato, il che lo rende più veloce dei linguaggi interpretati.

Una delle caratteristiche principali di Go è il suo supporto per la concorrenza, che consente di eseguire più attività contemporaneamente attraverso thread leggeri chiamati goroutine.

Go è noto anche per il suo forte supporto allo sviluppo di reti e del web. La libreria standard di Go contiene pacchetti per HTTP, TCP/IP e altri protocolli di rete, rendendo semplice la creazione di applicazioni in rete.

In questo articolo esplorerete i vantaggi, le limitazioni e le opzioni di distribuzione delle applicazioni Go. Inoltre, creerete, dockerizzerete e distribuirete un’applicazione Go utilizzando il servizio di containerizzazione gratuito di Back4app.

Continuate a leggere per scoprire come distribuire un’applicazione Go.

Vantaggi di Golang nello sviluppo web

La crescente popolarità di Go non è casuale. Sono molti i vantaggi che si possono ottenere e sfruttare utilizzando Go per le proprie applicazioni.

Prestazioni elevate

Le prestazioni elevate sono uno dei motivi principali per cui aziende come Dropbox e Uber utilizzano Go. Go è progettato per tempi di esecuzione rapidi, il che rende il linguaggio la scelta ideale per le applicazioni che richiedono prestazioni elevate.

Go impiega un garbage collector che riduce la gestione della memoria, consentendo tempi di esecuzione più rapidi. Inoltre, è possibile utilizzare il supporto alla concorrenza integrato in Go per aumentare le prestazioni dell’applicazione.

Scalabilità

Go è una scelta eccellente per la creazione di applicazioni scalabili. Con Concurrency è possibile creare programmi in grado di gestire molte attività, rendendo Go adatto alle applicazioni che gestiscono carichi di traffico elevati e che devono scalare rapidamente.

Go dispone inoltre di un eccellente supporto per i sistemi distribuiti, che lo rende una scelta ideale per la realizzazione di applicazioni su larga scala che devono essere eseguite su più macchine.

Go è testato in battaglia

Molte aziende famose utilizzano Go per costruire applicazioni su larga scala, tra cui quelle utilizzate da Google, Uber e Dropbox. Ciò implica che Go è stato testato in battaglia per essere affidabile e stabile per la creazione di applicazioni complesse per grandi basi di utenti.

Go punta molto sulla retrocompatibilità e le applicazioni scritte in Golang continueranno a funzionare anche quando il linguaggio si evolverà.

Grande supporto della comunità

Da quando è stato rilasciato, Go è stato uno dei linguaggi in più rapida crescita in termini di adozione, creando così una comunità ampia e attiva. Il fatto che Go abbia una grande comunità attiva significa che è possibile trovare facilmente risorse e risposte alle domande.

Go ospita molte librerie e strumenti open-source che possono essere utilizzati per accelerare i tempi di sviluppo. Strumenti di compilazione popolari come Kubernetes, Docker e Hugo utilizzano pacchetti come Cobra nei loro strumenti CLI.

Limitazioni di Golang

Mentre Golang è un linguaggio di programmazione altamente performante e scalabile, Go ha dei limiti che è bene considerare prima di sviluppare con questo linguaggio.

Maggiore complessità per alcune attività

Go può essere facile da imparare e da leggere, ma compiti specifici sono più facili in altri linguaggi che in Go. Costruire un’interfaccia utente interattiva con Go può essere impegnativo, perché Go ha bisogno di un toolkit GUI integrato e i pacchetti di terze parti apportano complessità al progetto.

Il modello di concorrenza di Go può essere impegnativo per i principianti

Il modello di concorrenza di Go può essere difficile da capire e da usare in modo efficace per i principianti. Go utilizza goroutine e canali per la concorrenza, strumenti potenti ma che possono essere difficili da comprendere. È necessario imparare a usare i canali in modo efficace per evitare deadlock o condizioni di gara.

Il modello di concorrenza di Go richiede anche di pensare in modo diverso alla struttura e alla progettazione del codice. Per chi è abituato a modelli di programmazione sequenziali, questo è difficile.

Ecosistema di librerie meno maturo rispetto ad altri linguaggi

Sebbene la libreria standard di Golang sia completa e disponga della maggior parte delle funzionalità necessarie per creare applicazioni Go, è meno matura delle librerie di linguaggi come Java o Python.

Golang è un linguaggio di programmazione relativamente nuovo; alcune librerie popolari non sono ancora disponibili. Questo può essere un limite per progetti specifici, soprattutto per quelli che richiedono funzionalità più specializzate.

Inoltre, le librerie di terze parti per Golang sono meno diffuse di quelle disponibili per altri linguaggi e potrebbe essere necessario implementare alcune funzionalità da soli, il che può richiedere molto tempo.

Opzioni di distribuzione di Golang

Dopo aver realizzato le applicazioni in Go, si hanno a disposizione diverse opzioni di distribuzione, ognuna con vantaggi e svantaggi.

Avete a disposizione un’ampia gamma di opzioni: servizi IaaS come AWS, servizi PaaS come Heroku, servizi BaaS come Back4app e Google Firebase e servizi CaaS come Back4App Containers.

Infrastruttura come servizio (IaaS) come AWS

I fornitori di Infrastructure as a Service (IaaS), come Amazon Web Services (AWS), offrono funzionalità per la distribuzione e la gestione di macchine virtuali di proprietà sul cloud.

Con AWS, è possibile utilizzare servizi come Elastic Compute Cloud (EC2) per distribuire la propria applicazione Golang su una macchina virtuale con Linux o Windows. È anche possibile utilizzare servizi come Elastic Container Service (ECS) per distribuire l’applicazione in un container.

Un vantaggio dell’utilizzo di un servizio IaaS come AWS è il controllo completo dell’infrastruttura sottostante. È possibile configurare la macchina virtuale per soddisfare le proprie esigenze specifiche. Tuttavia, siete responsabili della gestione e della manutenzione della macchina virtuale, che può essere tecnica e impegnativa.

Altre piattaforme IaaS includono:

• Linode
• Microsoft Azure
• Rackspace
• Amazon Web Services (AWS)
• DigitalOcean
• Google Compute Engine (GCE)

Piattaforma come servizio (PaaS) come Heroku

I fornitori di Platform as a Service (PaaS) , come Heroku, forniscono una piattaforma per la distribuzione di applicazioni Golang senza compromettere l’infrastruttura sottostante.

Heroku offre una semplice interfaccia a riga di comando per distribuire la vostra applicazione con pochi comandi. Heroku supporta anche il bilanciamento automatico del carico, facilitando la gestione di un traffico elevato per la vostra applicazione.

Il vantaggio di utilizzare un servizio PaaS come Heroku è che potete concentrarvi sullo sviluppo della vostra applicazione senza preoccuparvi dell’infrastruttura. Heroku gestisce tutta la gestione e la manutenzione dell’infrastruttura, facendovi risparmiare tempo e risorse.

Tuttavia, questo significa anche che avete meno controllo sull’infrastruttura e dovrete lavorare entro i limiti della piattaforma.

Altri fornitori di PaaS includono:

• Render
• AWS Elastic Beanstalk
• Microsoft Azure App Service
• DigitalOcean App Platform
• The Fly Platform

Backend come servizio (BaaS) come Back4app

I fornitori di Backend as a Service (BaaS), come Google Firebase e Back4app, forniscono una soluzione di backend completa per la vostra applicazione, che comprende un database, l’autenticazione e l’hosting. Firebase supporta diversi linguaggi di programmazione, tra cui Golang, e fornisce una semplice API che è possibile utilizzare per accedere ai suoi servizi.

Un vantaggio dell’utilizzo di un servizio BaaS come Firebase è la possibilità di configurare in modo semplice e veloce un backend per la propria applicazione senza dover gestire alcuna infrastruttura. Firebase offre una serie di funzionalità e servizi; tuttavia, è necessario un maggiore controllo sull’infrastruttura.

Altre piattaforme BaaS includono:

• AWS Amplify
• Cloudkit
• Backendless
• Back4App
• Pocketbase

La containerizzazione come servizio come Back4app Containers

La containerizzazione è molto diffusa per la distribuzione delle applicazioni. Con la containerizzazione, è possibile impacchettare l’applicazione e le sue dipendenze in un contenitore che può essere distribuito rapidamente su qualsiasi piattaforma che supporti la tecnologia dei contenitori.

Back4App è un fornitore di servizi di containerizzazione che potete usare per distribuire e gestire la vostra applicazione Golang in un contenitore.

Uno dei vantaggi di utilizzare la containerizzazione come fornitore di servizi come Back4App è che potete distribuire la vostra applicazione su qualsiasi piattaforma che supporti i container senza preoccuparvi dell’infrastruttura sottostante.

Il fornitore CaaS gestisce tutta la gestione e la manutenzione dei container, facendovi risparmiare tempo e risorse. Tuttavia, potreste dover lavorare entro i limiti della piattaforma di containerizzazione senza avere accesso all’infrastruttura.

Altre piattaforme CaaS includono:

• AWS Container Service
• Azure Container Service
• Docker Enterprise
• Google Container Engine
• IBM Kubernetes Service
• Oracle Container Service

Processo di distribuzione di Golang

Qui imparerete come distribuire la vostra applicazione Golang sulla piattaforma CaaS di Back4app.

Che cos’è Back4app?

Back4app è un’offerta cloud che potete utilizzare per creare e distribuire servizi di backend per le vostre applicazioni mobili e web.

È possibile utilizzare la funzione CaaS di Back4app per distribuire ed eseguire container personalizzati sui server backend di Back4app. È possibile aggiungere logica personalizzata alla propria applicazione utilizzando le immagini dei container senza dover gestire l’infrastruttura del server.

In questa sezione, imparerete a costruire una semplice API CRUD RESTful in Go, a containerizzare i programmi Go e a distribuire il container su Back4app.

Impostazione dell’ambiente di sviluppo

Dopo aver installato Go sul computer dalla pagina di download, è possibile creare una nuova directory e inizializzare un nuovo progetto Go per la propria applicazione Go.

Eseguite il comando seguente per creare una nuova directory per il vostro progetto.

mkdir deployAPI && cd deployAPI

Eseguire il comando mod init per inizializzare un nuovo progetto nella directory di lavoro corrente con lo strumento Go.

Così:

go mod init

Si costruirà l’API RESTful con il pacchetto Gorilla Mux.

Eseguite il comando seguente per installare il pacchetto Gorilla Mux come dipendenza del vostro progetto.

go get -u github.com/gorilla/mux

Il passo successivo è la creazione dell’API RESTful. Il primo passo per costruire un’API RESTful con Gorilla Mux è importare i pacchetti necessari nel file Go.

Ecco l’elenco delle importazioni necessarie per il progetto.

import (
	"encoding/json"
	"log"
	"net/http"
	"strconv"

	"github.com/gorilla/mux"
)

Dopo aver elencato le importazioni, è necessario impostare un database per l’applicazione. Per semplicità, useremo una mappa per memorizzare e recuperare i dati.

È possibile aggiungere la mappa all’applicazione in questo modo:

var users = map[int]string{}

Poiché la mappa è vuota, è necessario inserire i dati con una richiesta POST.

La funzione di gestione della richiesta POST

La richiesta POST deve ricevere i dati dal client, analizzarli e salvarli nell’archivio dati della mappa.

Aggiungere il blocco di codice all’applicazione per implementare il gestore di richieste POST:

func createUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	var data map[string]string

	err = json.NewDecoder(r.Body).Decode(&data)
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	users[id] = data["name"]

	w.WriteHeader(http.StatusCreated)
}

La funzione handler createUserHandler riceve i dati dal client (JSON), li analizza e li salva nella mappa. Quando il gestore aggiunge con successo i dati alla mappa, scrive al client il codice di successo StatusCreated.

La richiesta GET

Si leggeranno i dati dall’archivio dati con una richiesta GET. La funzione di gestione della richiesta GET recupererà un ID dal client, effettuerà una ricerca e restituirà i dati al client.

Aggiungere il blocco di codice all’applicazione per implementare il gestore della richiesta GET:

func readUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	name, ok := users[id]
	if !ok {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	data := map[string]string{"name": name}

	jsonData, err := json.Marshal(data)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	w.Write(jsonData)
}

La funzione readUserHandler recupera l’ID con la funzione Vars del pacchetto mux e cerca i dati nella mappa prima di restituirli come JSON al client, insieme a un codice di successo StatusOk.

La funzione di gestione della richiesta PUT

Si aggiorneranno i dati nel proprio archivio dati con una richiesta PUT. Il gestore della richiesta PUT accetterà l’ID e un campo JSON per il processo di aggiornamento.

func updateUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	var data map[string]string

	err = json.NewDecoder(r.Body).Decode(&data)
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	users[id] = data["name"]

	w.WriteHeader(http.StatusOK)
}

La funzione updateUserHandler riceve l’ID con la variabile vars, decodifica il JSON dal corpo della richiesta e aggiorna il campo o l’ID con i dati JSON del corpo della richiesta.

La funzione di gestione della richiesta DELETE

La funzione di gestione della richiesta DELETE prenderà l’ID del campo dalla richiesta ed eliminerà il campo dall’archivio dati.

Aggiungere il blocco di codice all’applicazione per implementare il gestore della richiesta DELETE:

func deleteUserHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	id, err := strconv.Atoi(vars["id"])
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	delete(users, id)

	w.WriteHeader(http.StatusOK)
}

La funzione deleteUserHandler cancella il campo con la funzione delete, che prende il nome della mappa e l’ID e restituisce al client il codice StatusOk.

Montaggio delle funzioni del gestore sulle rotte

Dopo aver definito gli endpoint dell’applicazione, è necessario assegnare le funzioni di gestione alle rotte. Le rotte sono l’interfaccia pubblica dell’API.

func main() {
	r := mux.NewRouter()

	r.HandleFunc("/users/{id}", createUserHandler).Methods(http.MethodPost)
	r.HandleFunc("/users/{id}", readUserHandler).Methods(http.MethodGet)
	r.HandleFunc("/users/{id}", updateUserHandler).Methods(http.MethodPut)
	r.HandleFunc("/users/{id}", deleteUserHandler).Methods(http.MethodDelete)

	log.Fatal(http.ListenAndServe(":8080", r))
}

Nella funzione principale, r è un’istanza di un nuovo router mux e il metodo HandleFunc accetta una rotta e una funzione di gestione. La funzione Methods specifica i metodi HTTP sulle rotte.

Containerizzazione di applicazioni Go con Docker

Docker è una delle tecnologie di containerizzazione più popolari. Docker è stato costruito con Go ed è possibile containerizzare le applicazioni Go per la portabilità con Docker.

Dovrete creare un nuovo dockerfile in cui specificare le istruzioni di compilazione.

Eseguire il comando seguente per creare un file Docker nella directory di lavoro del progetto.

touch Dockerfile

Aprite il file Docker e incollate queste istruzioni di compilazione per containerizzare la vostra applicazione Go con Docker.

# Use an official Golang runtime as a parent image
FROM golang:latest

# Set the working directory to /app
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Download and install any required dependencies
RUN go mod download

# Build the Go app
RUN go build -o main .

# Expose port 8080 for incoming traffic
EXPOSE 8080

# Define the command to run the app when the container starts
CMD ["/app/main"]

Le istruzioni di compilazione nel dockerfile specificano la versione di Go per il progetto, la directory di lavoro, i file per l’applicazione e le istruzioni di compilazione per il dockerfile.

Ecco la ripartizione del file Docker:

• Il file inizia con FROM golang: latest, che specifica che si vuole usare l’ultima versione dell’immagine ufficiale di Golang come immagine di base per il contenitore Docker.
• La riga WORKDIR /app imposta la directory di lavoro del contenitore alla directory /app.
• Il comando COPY . /app copia il contenuto della propria directory corrente nella directory /app del contenitore.
• Il download di RUN go mod scarica le dipendenze necessarie della vostra applicazione.
• Il comando RUN go build -o main . compila l’applicazione Go e crea un file eseguibile chiamato main nella directory /app.
• La riga EXPOSE 8080 indica a Docker di esporre la porta 8080, la porta su cui l’applicazione Go ascolta le richieste in arrivo.
• La riga CMD ["/app/main"] specifica il comando da eseguire all’avvio del contenitore (in questo caso, l’eseguibile principale ).

Eseguendo il file docker, Docker costruisce l’immagine dell’applicazione ed espone l’applicazione sulla porta 8080.

Il comando avvia il contenitore e mappa la porta 8080 del computer host sulla porta 8080 del contenitore; si dovrebbe essere in grado di accedere all’API su [http://localhost:8080](http://localhost:8080).

Distribuzione del contenitore su Back4app

Per distribuire i container è necessario creare un account su Back4app (se non ne avete uno).

Ecco i passaggi per creare un account su Back4app.

1. Visitate il sito web di Back4app.
2. Fare clic sul pulsante Iscriviti nell’angolo in alto a destra della pagina di destinazione per creare un nuovo account.
3. Infine, compilate il modulo di iscrizione e inviatelo.

Dopo aver creato il vostro account Back4app, accedete al vostro account e fate clic sul pulsante NUOVA APP nell’angolo in alto a destra dell’interfaccia utente.

Il pulsante NEW APP porta a una pagina in cui si sceglie come distribuire l’applicazione. Poiché si sta distribuendo un contenitore, selezionare l’opzione Containers as a Service.

Quindi, collegate il vostro account GitHub al vostro account Back4app. Potete scegliere di dare a Back4app l’accesso al codice sorgente di tutti i repository del vostro account o a una directory specifica del progetto.

Scegliere l’applicazione che si desidera distribuire, in questo caso l’applicazione costruita in questa esercitazione, quindi fare clic su Seleziona.

Facendo clic sul pulsante di selezione si accede a una pagina in cui si compilano le informazioni sulla propria applicazione, dal nome al ramo, alla directory principale e alle variabili ambientali.

Assicurarsi di compilare tutte le variabili ambientali richieste dall’applicazione. Dopo aver compilato i dettagli richiesti, fare clic su Crea applicazione.

Facendo clic su questo pulsante si avvia il processo di distribuzione dell’applicazione Go, come mostrato nell’immagine seguente.

Conclusione

Avete imparato a distribuire un’applicazione Go containerizzata su Back4app. Seguendo i passi di questo tutorial, si dovrebbe avere un’API Go in esecuzione su Back4app.

Il deploy delle applicazioni su Back4app è un ottimo modo per semplificare la gestione dell’infrastruttura di backend. Back4App fornisce strumenti potenti per gestire i dati, scalare le applicazioni e monitorarne le prestazioni. È una scelta eccellente per gli sviluppatori che desiderano creare grandi applicazioni piuttosto che gestire i server.

FAQ