Créer une API REST simple avec Go

Go est un excellent langage pour la programmation système, mais il brille également sur le Web, notamment lors de la création d'API REST. Ce guide explique la création d'une API REST simple à l'aide de la bibliothèque standard de Go. Nous allons créer une API pour gérer une liste de serveurs, nous permettant d'ajouter, de supprimer et d'afficher les enregistrements du serveur. Nous allons également utiliser les nouvelles améliorations du routeur Go 1.22 pour la correspondance des méthodes, ce qui nous permet d'avoir des itinéraires et des gestionnaires plus propres.

Ce guide suppose que vous avez une compréhension de base de Go et qu'il est installé sur votre ordinateur.

Configuration

Créez un nouveau répertoire pour votre projet et initialisez un module Go :

mkdir server-api
cd server-api
go mod init server-api

Le code

Créez un fichier appelé main.go. Nous utiliserons le package http standard de Go - il contient tout ce dont nous avons besoin pour une API de base.

package main

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

Tout d'abord, définissons à quoi ressemble un serveur. Nous allons garder les choses simples : juste un identifiant, un nom, une adresse IP et une région :

type Server struct {
    ID     string `json:"id"`
    Name   string `json:"name"`
    IP     string `json:"ip"`
    Region string `json:"region`
}

Nous stockerons nos serveurs en mémoire à l'aide d'une tranche. Dans une application réelle, vous utiliseriez probablement une base de données :

var servers = []Server{
    {ID: "srv1", Name: "prod-1", IP: "10.0.1.1", Region: "us-east"},
    {ID: "srv2", Name: "prod-2", IP: "10.0.1.2", Region: "eu-west"},
}

Création du routeur

Ensuite, nous configurerons nos itinéraires. Go 1.22 a introduit une nouvelle syntaxe de routage qui rend cela assez simple :

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc("GET /servers", listServers)
    mux.HandleFunc("GET /servers/{id}", showServer)
    mux.HandleFunc("POST /servers", createServer)
    mux.HandleFunc("DELETE /servers/{id}", deleteServer)

    fmt.Println("Server starting on port 8080...")
    log.Fatal(http.ListenAndServe(":8080", mux))
}

Gestionnaires

Implémentons maintenant chaque gestionnaire. Tout d'abord, lister tous les serveurs :

func listServers(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(servers)
}

Obtenir un seul serveur par ID :

func showServer(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    id := r.PathValue("id")

    for _, server := range servers {
        if server.ID == id {
            json.NewEncoder(w).Encode(server)
            return
        }
    }

    http.Error(w, "Server not found", http.StatusNotFound)
}

Création d'un nouveau serveur :

func createServer(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")

    var server Server
    if err := json.NewDecoder(r.Body).Decode(&server); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    servers = append(servers, server)
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(server)
}

Et enfin, supprimer un serveur :

func deleteServer(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id")

    for i, server := range servers {
        if server.ID == id {
            servers = append(servers[:i], servers[i+1:]...)
            w.WriteHeader(http.StatusNoContent)
            return
        }
    }

    http.Error(w, "Server not found", http.StatusNotFound)
}

Utiliser l'API

Une fois le code en place, exécutez-le :

go run main.go

Voici comment interagir avec chaque point de terminaison à l'aide de cURL :

Liste de tous les serveurs :

curl localhost:8080/servers

Obtenir un serveur spécifique :

curl localhost:8080/servers/srv1

Ajouter un serveur :

curl -X POST localhost:8080/servers   -H "Content-Type: application/json";   -d '{"id":"srv3","name":"prod-3","ip":"10.0.1.3","region":"ap-south"}';

Supprimer un serveur :

curl -X DELETE localhost:8080/servers/srv1

Quelle est la prochaine étape ?

Il s'agit d'une API de base, mais vous pouvez en ajouter beaucoup :

• Validation des entrées
• Gestion appropriée des erreurs
• Serveurs persistants avec une base de données telle que PostgreSQL
• Authentification
• Demande de journalisation
• Tests unitaires

La bibliothèque standard est étonnamment capable de créer des API. Bien qu'il existe des frameworks plus complets disponibles, commencer par la bibliothèque standard vous aide à comprendre les bases sans qu'aucune magie ne se produise en coulisses.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!