Go pour le développement mobile : backend, API et utilitaires

Qu'est-ce que Go ?

Go est un langage compilé à typage statique avec gestion automatique de la mémoire via le ramasse-miettes. Les principaux objectifs de Go : compilation rapide, simplicité du code et support intégré de la concurrence. Go se compile en un binaire natif sans machine virtuelle — un seul fichier exécutable contient tout, y compris les dépendances.

La bibliothèque standard de Go couvre le serveur HTTP, le marshaling JSON, l'analyse des flags de ligne de commande, le chiffrement et les opérations de base de données. Aucun framework externe n'est nécessaire pour un serveur HTTP — net/http est intégré. Go Modules (depuis v1.16) est le système de gestion des dépendances standard. La version actuelle est Go 1.23 (2025) avec un paquet iter amélioré pour les itérateurs.

Go a été conçu pour résoudre les problèmes de passage à l'échelle rencontrés par Google : compilation lente du C++, complexité de Java, concurrence inefficace de Python. Le résultat est un langage qui alimente Docker, Kubernetes, Prometheus, Terraform et Hugo.

Syntaxe de Go

Go est minimaliste : 25 mots-clés (contre 84 en C++). Pas de classes, d'héritage, de génériques (jusqu'à v1.18), de surcharge d'opérateurs ni d'exceptions. Les erreurs sont traitées explicitement via le retour err. Les structures et interfaces remplacent la POO.

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

type User struct {
	ID    int    `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email"`
}

func userHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	user := User{ID: 1, Name: "Alice", Email: "alice@example.com"}
	json.NewEncoder(w).Encode(user)
}

func main() {
	http.HandleFunc("/api/user", userHandler)
	fmt.Println("Server on :8080")
	http.ListenAndServe(":8080", nil)
}

La structure User avec des tags JSON définit la sérialisation. http.HandleFunc enregistre un gestionnaire. json.NewEncoder(w).Encode(user) sérialise la structure en JSON directement dans la réponse. Le serveur HTTP intégré traite les requêtes dans des goroutines séparées automatiquement.

Goroutines et canaux : le modèle de concurrence de Go

Goroutines sont des fils d'exécution légers gérés par l'environnement d'exécution Go. Contrairement aux fils OS (1–8 Mo de pile), une goroutine commence avec 4 Ko de pile qui croît dynamiquement. On peut exécuter 100 000 goroutines sur un seul serveur. Lancer une goroutine — go functionName().

Canaux (channels) sont des files d'attente typées pour transférer des données entre goroutines. Un canal est créé via make(chan Type). L'opérateur <- envoie des données, <-chan reçoit. Les canaux peuvent être tamponnés (avec capacité) ou non tamponnés (synchrones).

package main

import (
	"fmt"
	"net/http"
	"time"
)

func fetchURL(url string, ch chan<- string) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprintf("Error: %s", err)
		return
	}
	defer resp.Body.Close()
	elapsed := time.Since(start)
	ch <- fmt.Sprintf("%s — %dms", url, elapsed.Milliseconds())
}

func main() {
	urls := []string{"https://google.com", "https://github.com", "https://stackoverflow.com"}
	ch := make(chan string, len(urls))

	for _, url := range urls {
		go fetchURL(url, ch)
	}

	for range urls {
		fmt.Println(<-ch)
	}
}

Trois requêtes s'exécutent concurremment via go fetchURL. Le canal ch collecte les résultats. defer resp.Body.Close() garantit la fermeture de la réponse au retour de la fonction. select {} n'est pas utilisé puisque toutes les goroutines envoient dans le canal — la goroutine principale lit exactement len(urls) fois.

Go pour le backend des applications mobiles

Go est l'un des meilleurs langages pour le backend des applications mobiles. HTTP/2 et HTTP/3 intégrés, sérialisation rapide protobuf/gRPC et faible empreinte mémoire rendent Go idéal pour les APIs servant des milliers de clients mobiles.

Frameworks populaires : Gin (jusqu'à 10x plus rapide qu'Express.js), Echo (minimaliste, middleware JWT), Fiber (style Express), Chi (compatible net/http). Gin est le plus populaire avec 70k+ étoiles sur GitHub. Pour gRPC, on utilise google.golang.org/grpc.

package main

import (
	"database/sql"
	"log"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	_ "github.com/mattn/go-sqlite3"
)

func main() {
	db, err := sql.Open("sqlite3", "mobile_app.db")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	r := gin.Default()
	r.GET("/api/v1/posts", func(c *gin.Context) {
		type Post struct {
			ID        int       `json:"id"`
			Title     string    `json:"title"`
			CreatedAt time.Time `json:"created_at"`
		}
		rows, _ := db.Query("SELECT id, title, created_at FROM posts ORDER BY created_at DESC LIMIT 20")
		defer rows.Close()

		var posts []Post
		for rows.Next() {
			var p Post
			rows.Scan(&p.ID, &p.Title, &p.CreatedAt)
			posts = append(posts, p)
		}
		c.JSON(http.StatusOK, posts)
	})
	r.Run(":8080")
}

Gin.GET enregistre une route avec un gestionnaire. sql.Open ouvre une base SQLite, db.Query exécute une requête. c.JSON sérialise le slice posts en un tableau JSON. La fonction anonyme à l'intérieur de GET capture db du contexte externe. Gin gère les paniques, journalise les requêtes et supporte les middleware.

Microservices et passerelles API en Go

Go est le langage principal pour l'architecture de microservices. La faible consommation mémoire par microservice (15–30 Mo) permet d'exécuter des dizaines de services sur un seul serveur. Démarrage rapide (millisecondes) et taille de binaire réduite (10–20 Mo) simplifient le déploiement dans des conteneurs.

Une passerelle API en Go agrège les requêtes d'une application mobile vers les services internes. Une passerelle Go gère l'authentification (JWT), la limitation de débit, le routage et la mise en cache. Implémentations populaires : Kong (basé sur OpenResty avec plugins Go), Tyk(en Go), passerelles personnalisées sur Gin.

gRPC et protobuf

gRPC est un framework d'appel de procédure distante de Google utilisant Protocol Buffers pour la sérialisation et HTTP/2 pour le transport. Go a le meilleur support gRPC parmi tous les langages. Pour les backends mobiles, gRPC offre un débit 5 à 10 fois supérieur à REST/JSON.

package main

import (
	"context"
	"log"
	"net"

	"google.golang.org/grpc"
	pb "example.com/proto"
)

type server struct {
	pb.UnimplementedUserServiceServer
}

func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.UserResponse, error) {
	return &pb.UserResponse{
		Id:    req.Id,
		Name:  "Alice",
		Email: "alice@example.com",
	}, nil
}

func main() {
	lis, _ := net.Listen("tcp", ":50051")
	s := grpc.NewServer()
	pb.RegisterUserServiceServer(s, &server{})
	log.Fatal(s.Serve(lis))
}

pb.UnimplementedUserServiceServer est un stub généré par protoc à partir du fichier .proto. La structure server redéfinit la méthode GetUser. grpc.NewServer() crée un serveur avec des intercepteurs pour la journalisation, l'authentification et les métriques.

Go pour les utilitaires CLI et outils développeur

Go est le meilleur langage pour les utilitaires CLI utilisés dans le développement mobile. Un seul binaire statique (~10 Mo) sans dépendances fonctionne sur toutes les plateformes : macOS, Linux, Windows. La compilation prend quelques secondes. Les utilitaires Go ne nécessitent pas d'installation d'interpréteur ou d'environnement d'exécution.

Exemples d'outils Go dans l'écosystème mobile : Migrate (migrations BD), Kubectl (Kubernetes pour backend mobile), Terraform (infrastructure), Prometheus (surveillance). Les développeurs écrivent des utilitaires Go pour générer des modèles à partir de fichiers proto, valider des configurations et déployer des microservices.

package main

import (
	"flag"
	"fmt"
	"os"
)

func main() {
	project := flag.String("project", "", "Project directory")
	version := flag.String("version", "1.0.0", "App version")
	verbose := flag.Bool("verbose", false, "Verbose output")
	flag.Parse()

	if *project == "" {
		fmt.Println("Usage: deploy --project=path [--version=x.x.x]")
		os.Exit(1)
	}

	if *verbose {
		fmt.Printf("Deploying project %s version %s\n", *project, *version)
	}
	// ici la logique de déploiement
	fmt.Println("Deploy complete")
}

flag.String définit un flag de ligne de commande de type chaîne avec nom, valeur par défaut et description. flag.Parse() analyse les arguments os.Args. Les pointeurs *project sont déréférencés pour obtenir les valeurs. Le binaire est compilé avec go build -o deploy deploy.go.

Gomobile : Go dans les bibliothèques natives pour iOS et Android

Gomobile est un outil Google pour compiler du code Go en bibliothèques mobiles natives. go bind -target=android génère .aar pour Android, go bind -target=ios génère .xcframework pour iOS. Cela permet d'écrire la logique métier commune en Go et de l'appeler depuis Kotlin et Swift.

Principaux cas d'usage de Gomobile : cryptographie (schémas de chiffrement personnalisés), réseau (protocole WebSocket personnalisé), traitement de données (compression, encodage, analyse). L'interface utilisateur n'est pas écrite en Go — son but est de remplacer C++ pour les modules natifs multiplateformes.

package mobile

import "crypto/aes"

// EncryptData chiffre les données avec AES-256-GCM (exporté vers .aar)
func EncryptData(key []byte, plaintext []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	ciphertext := make([]byte, len(plaintext))
	block.Encrypt(ciphertext, plaintext)
	return ciphertext, nil
}

func DecryptData(key []byte, ciphertext []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	plaintext := make([]byte, len(ciphertext))
	block.Decrypt(plaintext, ciphertext)
	return plaintext, nil
}

Les fonctions exportées (majuscules) sont encapsulées par Gomobile dans des interfaces Java/Swift. Depuis Kotlin, l'appel ressemble à Mobile.encryptData(key, plaintext). Gomobile convertit automatiquement les types : []byte → byte[] (Java) / Data (Swift).

Go vs Java et Kotlin pour le backend : comparaison

Go concurrence Java et Kotlin dans le développement serveur. Différences clés : Go se compile en binaire natif, ne nécessite pas de JVM, consomme 2 à 3 fois moins de mémoire et démarre en millisecondes. Java l'emporte par la maturité de son écosystème et le nombre de bibliothèques.

Go est choisi pour les microservices, les passerelles API et les outils. Java/Kotlin — pour les applications d'entreprise avec une logique métier riche. Dans le développement mobile, la combinaison optimale est : Go pour le backend, Kotlin/Swift pour le client.