Créer votre première API REST avec Go

Créer votre première API REST avec Go – Commençons !

Alors, vous avez entendu parler du Go, n'est-ce pas ? C’est rapide, c’est simple, et c’est fondamentalement la star du développement backend de nos jours. Si vous êtes nouveau sur Go ou si vous cherchez simplement à créer quelque chose de cool avec, vous êtes au bon endroit. Cette semaine, nous allons nous plonger dans la création de votre propre API REST avec Go, alors attachez votre ceinture, ça va être une aventure amusante !

Pourquoi y aller ?

Maintenant, pourquoi exactement tant de développeurs se pâment-ils devant Go ? Eh bien, imaginez ceci : les ingénieurs de Google, fatigués d'attendre que leurs programmes soient compilés, ont décidé de créer quelque chose qui ne leur donnerait pas envie de s'arracher les cheveux. Entrez Go, un langage qui non seulement fait le travail, mais le fait rapidement et sans effort.

Go est conçu pour le matériel actuel, tirant pleinement parti des systèmes multicœurs. Son arme secrète ? Goroutines : ces petits travailleurs simultanés magiques qui peuvent gérer des tonnes de tâches simultanément sans transpirer. Que vous créiez des applications Web, des API ou des microservices, Go assure le bon fonctionnement, comme cette machine bien huilée dont vous rêvez toujours.

Et voici le truc : le Go est bêtement facile à apprendre. Que vous passiez de Python, Java ou même quelque chose d'aussi « classique » que PHP, vous serez prêt à coder dans Go avant de pouvoir dire « Bonjour, tout le monde ! Et ça court vite, vraiment très vite. Dois-je en dire plus ?

Configuration de votre projet Go

Très bien, assez de bavardages, mettons la main à la pâte. Tout d’abord, nous devons mettre en place un simple projet Go. Ne vous inquiétez pas, je suis là pour vous :

1. Assurez-vous que Go est installé. Sinon, récupérez-le ici.

2. Maintenant, créons un répertoire de projet et initialisons le projet :
   

   mkdir go-rest-api
   cd go-rest-api
   go mod init github.com/yourusername/go-rest-api

1. Dans ce répertoire, créez un nouveau fichier appelé main.go et préparez-vous à un peu de magie du codage.

Ecrire l'API

C’est ici que les choses deviennent passionnantes ! Nous allons créer une API super simple pour gérer une liste de livres (car qui n'aime pas les livres ?). Notre API aura les points de terminaison suivants :

• GET /books – Récupère tous les livres (oui, des livres !)
• POST /books – Ajouter un nouveau livre
• GET /books/:id – Récupère un livre spécifique par son identifiant (car tous les livres ne sont pas créés égaux)

Prêt ? Passons au code :

package main

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

    "github.com/gorilla/mux"
)

type Book struct {
    ID     int    `json:"id"`
    Title  string `json:"title"`
    Author string `json:"author"`
}

var books []Book

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

// Get a single book by ID
func getBook(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    id, err := strconv.Atoi(params["id"])
    if err != nil {
        http.Error(w, "Invalid book ID", http.StatusBadRequest)
        return
    }
    for _, book := range books {
        if book.ID == id {
            w.Header().Set("Content-Type", "application/json")
            json.NewEncoder(w).Encode(book)
            return
        }
    }
    http.Error(w, "Book not found", http.StatusNotFound)
}

// Add a new book
func createBook(w http.ResponseWriter, r *http.Request) {
    var book Book
    _ = json.NewDecoder(r.Body).Decode(&book)
    book.ID = len(books) + 1 // Assign an ID (we’re just winging it here)
    books = append(books, book)
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(book)
}

func main() {
    // Add some dummy data to start with
    books = append(books, Book{ID: 1, Title: "The Go Programming Language", Author: "Alan A. A. Donovan"})
    books = append(books, Book{ID: 2, Title: "Learning Go", Author: "Jon Bodner"})

    // Initialize the router
    r := mux.NewRouter()

    // Define the endpoints
    r.HandleFunc("/books", getBooks).Methods("GET")
    r.HandleFunc("/books/{id}", getBook).Methods("GET")
    r.HandleFunc("/books", createBook).Methods("POST")

    // Start the server
    fmt.Println("Server is running on port 8000...")
    log.Fatal(http.ListenAndServe(":8000", r))
}

Le décomposer

1. Mux Router : nous utilisons gorilla/mux pour gérer le routage dans notre API. Il facilite la définition d'itinéraires et constitue un outil incontournable pour créer des services Web dans Go. Vous pouvez l'installer avec :

   go get -u github.com/gorilla/mux

1. Gestionnaires : Nous avons configuré les fonctions getBooks, getBook et createBook pour gérer les requêtes HTTP. Ils utilisent le package net/http de Go pour gérer les réponses et l’encodage/décodage des données. Facile, c'est facile !

2. Encodage JSON : le package json intégré de Go fait le gros du travail ici, en convertissant nos données au format JSON pour une communication facile entre le client et l'API.

Exécuter l'API

Maintenant, passons à la partie amusante : exécutons ce truc ! Dans votre terminal, exécutez simplement :

go run main.go

Boum ! Votre API est opérationnelle. Vous pouvez désormais utiliser des outils comme Postman ou curl pour le tester :

• Obtenez tous les livres :

  curl http://localhost:8000/books

• Obtenez un livre spécifique :

  curl http://localhost:8000/books/1

• Ajouter un nouveau livre :

  curl -X POST http://localhost:8000/books -d '{"title":"New Book","author":"New Author"}' -H "Content-Type: application/json"

Quelle est la prochaine étape ?

Cette petite API n'est que la pointe de l'iceberg en ce qui concerne ce que Go peut faire en matière de développement backend. La semaine prochaine, nous passerons au niveau supérieur en ajoutant l'authentification (oui, nous passons au JWT complet) et en protégeant ces points de terminaison contre les visiteurs indésirables.

Restez à l'écoute pour la partie 2 -- Configuration du middleware pour l'authentification dans une API REST à l'aide de JWT (JSON Web Tokens) dans Go

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!