Aller au contenu

Exercices#

Créer une API RESTful qui renvoie des données JSON#

Présentation du projet et des objectifs#

  • Le projet consiste à développer une API RESTful simple en Go qui gère les ressources d'un livre de recettes. Cette API devra créer, lire, mettre à jour et supprimer (CRUD) des recettes dans une structure de données en mémoire.
  • Les recettes seront stockées sous forme de structures Go, qui seront converties en JSON lorsqu'elles seront renvoyées par l'API.
  • L'objectif est de comprendre comment construire des services web en Go, comment travailler avec JSON et comment structurer un projet Go.

Conception de l'API RESTful avec gorilla/mux#

  • Utilisation du package gorilla/mux pour router les requêtes HTTP à leurs gestionnaires respectifs.
    • Exemple de code : r := mux.NewRouter()
    • Ajouter des routes : r.HandleFunc("/recipes", getRecipes).Methods("GET")
  • Les requêtes HTTP GET, POST, PUT et DELETE seront mappées à des fonctions CRUD dans notre code.
  • Les routes seront structurées comme /recipes pour l'ensemble des recettes et /recipes/{id} pour une recette spécifique.

Implémentation de l'encodage et décodage JSON#

  • Utilisation du package "encoding/json" de la bibliothèque standard de Go pour l'encodage et le décodage JSON.
  • Fonction json.NewEncoder(w).Encode(recipes) pour encoder les recettes en JSON et les envoyer dans la réponse HTTP.
  • Fonction json.NewDecoder(r.Body).Decode(&recipe) pour décoder le corps de la requête HTTP en une nouvelle recette.

Test et débogage de l'API RESTful#

  • Utilisation de l'outil curl ou de Postman pour tester l'API.
  • Exemple de commande curl pour créer une nouvelle recette : curl -X POST -H "Content-Type: application/json" -d '{"title":"Pizza Margherita", "ingredients":["Tomatoes", "Mozzarella", "Basil", "Oil", "Salt"]}' http://localhost:8000/recipes

Retour d'expérience et améliorations#

  • Discussion sur la structuration du code Go pour des projets plus importants.
  • Introduction à la documentation des API avec Swagger ou API Blueprint.
  • Discussion sur l'utilisation des bases de données pour stocker les recettes de manière persistante.

Implémenter un client et un serveur qui communiquent avec des messages protobuf#

Présentation du projet et des objectifs#

  • Le projet consiste à créer un service de chat simple avec un serveur et un client qui communiquent via Protocol Buffers (protobuf).
  • L'objectif est de comprendre comment protobuf fonctionne, comment générer du code Go à partir de fichiers .proto, et comment implémenter des communications réseau en Go.

Conception des messages et services protobuf#

  • Utilisation de la syntaxe protobuf pour définir les messages de chat et le service de chat.
    • Exemple de code .proto :
      syntax = "proto3";
      
      message ChatMessage {
          string sender = 1;
          string content = 2;
      }
      
      service ChatService {
          rpc SendChat (ChatMessage) returns (ChatMessage) {}
      }
      
  • Compilation du fichier .proto en code Go à l'aide de la commande : `prot

oc --go_out=plugins=grpc:. chat.proto`

Génération de code Go à partir de fichiers .proto#

  • Explication sur le code généré, notamment le code pour les messages et le code pour le service.
  • Utilisation de la bibliothèque gRPC de Google pour créer le client et le serveur.

Implémentation du client et du serveur en Go#

  • Création du serveur avec une fonction qui implémente le service de chat.
    • Exemple de code :
      type server struct{}
      
      func (s *server) SendChat(ctx context.Context, message *ChatMessage) (*ChatMessage, error) {
          return message, nil
      }
      
  • Création du client qui envoie des messages au serveur.
    • Exemple de code :
      conn, _ := grpc.Dial("localhost:9000", grpc.WithInsecure())
      defer conn.Close()
      
      c := NewChatServiceClient(conn)
      
      message := &ChatMessage{Sender: "Client", Content: "Hello, server!"}
      response, _ := c.SendChat(context.Background(), message)
      fmt.Println("Received:", response.Content)
      

Test, débogage et optimisation des communications protobuf#

  • Utilisation de l'outil grpcurl pour tester le service de chat.
  • Exemple de commande grpcurl : grpcurl -d '{"sender":"Client","content":"Hello, server!"}' -plaintext localhost:9000 ChatService/SendChat
  • Discussion sur la manière d'optimiser les communications protobuf et sur l'utilisation des flux de messages (streaming).