Très bien, nous avons donc lancé notre API Go, mais il est temps de lui donner un peu de mémoire à long terme. Cette semaine, nous connectons notre API à PostgreSQL, afin que vous puissiez stocker toutes ces précieuses données sans les perdre à la seconde où vous fermez votre application. Croyez-moi, vos utilisateurs vous remercieront.

Pourquoi PostgreSQL ?

PostgreSQL ou « Postgres » en abrégé, est la vraie affaire en matière de bases de données. Voici pourquoi c'est la base de données la plus populaire :

1. Fonctionnalité complète : Que vous souhaitiez stocker du texte brut, du JSON ou même des données géographiques complexes, Postgres est là pour vous. Il est également entièrement conforme à l'ACID (lire : il maintient vos données cohérentes et sécurisées) et suffisamment d'options d'interrogation sophistiquées pour faire sourire n'importe quel passionné de données.

2. Open-Source et gratuit : C'est vrai, Postgres est totalement gratuit et open-source. De plus, il dispose d'une communauté active qui l'améliore constamment, vous n'aurez donc jamais à craindre qu'il devienne obsolète.

3. Évolue comme un pro : que vous créiez une petite application ou un service d'entreprise massif et gourmand en données, Postgres peut le gérer. Il est conçu pour évoluer, avec une exécution de requêtes parallèles et une magie d'optimisation pour que tout fonctionne sans problème.

4. Construit comme un tank : avec des décennies de développement à son actif, Postgres est solide comme un roc. Il reçoit des mises à jour régulières, dispose de nombreuses fonctionnalités de sécurité et est utilisé en production par des géants comme Apple et Netflix.

Vous avez tout ça ? Cool, connectons-le à notre API Go et commençons à utiliser la magie des bases de données !

Étape 0 : configuration de PostgreSQL

Si PostgreSQL n'est pas déjà installé, récupérez-le ici. Alors allons-y :

1. Se connecter à PostgreSQL :

   psql -U postgres

1. Créer une base de données :

   CREATE DATABASE bookdb;

1. Mettez une table pour nos livres :

   \c bookdb;
   CREATE TABLE books (
       id SERIAL PRIMARY KEY,
       title VARCHAR(255) NOT NULL,
       author VARCHAR(255) NOT NULL
   );

Vous disposez désormais d’une nouvelle base de données prête à l’emploi. Il est temps de commencer à en parler !

Étape 1 : Connectez-vous Accédez à PostgreSQL

Nous utilisons la bibliothèque pgx pour celui-ci. C'est rapide, c'est léger et ça fait le travail.

go get github.com/jackc/pgx/v5

Ouvrez votre fichier main.go et ajoutez ce code pour établir une connexion à la base de données :

var db *pgxpool.Pool

func connectDB() *pgxpool.Pool {
    url := "postgres://postgres:yourpassword@localhost:5432/bookdb"
    config, err := pgxpool.ParseConfig(url)
    if err != nil {
        log.Fatalf("Unable to parse DB config: %v\n", err)
    }

    dbpool, err := pgxpool.NewWithConfig(context.Background(), config)
    if err != nil {
        log.Fatalf("Unable to connect to database: %v\n", err)
    }

    return dbpool
}

Remplacez votre mot de passe par votre mot de passe PostgreSQL. Cette fonction se connecte à notre base de données bookdb et renvoie un pool de connexions, ce qui signifie essentiellement que notre application disposera d'un ensemble de connexions réutilisables prêtes à fonctionner. Efficacité, bébé ! ?

Étape 2 : Mettre à jour la fonction principale

Assurons-nous que notre connexion à la base de données se déclenche lorsque notre serveur le fait :

func main() {
    db = connectDB()
    defer db.Close()

    // Initialize router and define routes here (as before)
}

Étape 3 : Opérations CRUD – Importation des données

Très bien, ajoutons quelques fonctions pour récupérer, créer et gérer des livres dans notre base de données.

Récupérer tous les livres

func getBooks(w http.ResponseWriter, r *http.Request) {
    rows, err := db.Query(context.Background(), "SELECT id, title, author FROM books")
    if err != nil {
        http.Error(w, "Database error", http.StatusInternalServerError)
        return
    }
    defer rows.Close()

    var books []Book
    for rows.Next() {
        var book Book
        err := rows.Scan(&book.ID, &book.Title, &book.Author)
        if err != nil {
            http.Error(w, "Error scanning row", http.StatusInternalServerError)
            return
        }
        books = append(books, book)
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(books)
}

Ajouter un nouveau livre

func createBook(w http.ResponseWriter, r *http.Request) {
    var book Book
    err := json.NewDecoder(r.Body).Decode(&book)
    if err != nil {
        http.Error(w, "Bad request", http.StatusBadRequest)
        return
    }

    _, err = db.Exec(context.Background(), "INSERT INTO books (title, author) VALUES ($1, $2)", book.Title, book.Author)
    if err != nil {
        http.Error(w, "Error inserting book", http.StatusInternalServerError)
        return
    }

    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(book)
}

Étape 4 : Protéger les routes avec un middleware

Nous voulons nous assurer que seuls les utilisateurs authentifiés peuvent accéder à nos nouveaux points de terminaison basés sur une base de données. Utilisez le middleware d'authentification de la semaine 2 et vous êtes prêt !

func main() {
    db = connectDB()
    defer db.Close()

    r := mux.NewRouter()

    r.HandleFunc("/login", login).Methods("POST")
    r.Handle("/books", authenticate(http.HandlerFunc(getBooks))).Methods("GET")
    r.Handle("/books", authenticate(http.HandlerFunc(createBook))).Methods("POST")

    fmt.Println("Server started on port :8000")
    log.Fatal(http.ListenAndServe(":8000", r))
}

Le tester

Mettons cette chose à l'épreuve :

1. Ajouter un nouveau livre :

   curl -X POST http://localhost:8000/books -d '{"title": "1984", "author": "George Orwell"}' -H "Content-Type: application/json"

1. Récupérer tous les livres :

   curl http://localhost:8000/books

Et boum ! Vous disposez d'une API Go avec PostgreSQL, prête à gérer des données réelles.

Quelle est la prochaine étape ?

La prochaine fois, nous rendrons notre API encore plus fluide avec un middleware personnalisé pour la journalisation et la gestion des erreurs. Restez à l'écoute pour en savoir plus !