Comprendre et utiliser le contexte dans Go et GoFr-Golang-php.cn

Context in go

Qu'est-ce que le contexte ?

Dans Go, le package de contexte est un outil fondamental conçu pour gérer et partager des données liées aux requêtes, des signaux d'annulation et des délais d'attente ou des délais entre différentes couches d'une application.
Le type context.Context fournit un moyen de transmettre les délais, les signaux d'annulation et d'autres valeurs de portée de demande de manière chaînable et hiérarchique. Il est conçu pour être immuable, ce qui signifie que chaque nouveau contexte dérivé porte les propriétés de son contexte parent tout en ajoutant de nouvelles valeurs ou comportements.
Imaginez un contexte comme un sac de transport spécial contenant toutes les informations et instructions nécessaires pour une tâche spécifique. Ce sac peut être transmis de fonction en fonction, garantissant que toutes les personnes impliquées disposent du même contexte (informations) et peuvent agir en conséquence. Il peut également contenir un bouton d'autodestruction (signal d'annulation) pour arrêter l'opération si besoin.

Pourquoi avons-nous besoin de contexte ?

Avant l'introduction de Context in Go, la gestion des données liées aux requêtes et des signaux d'annulation était une tâche fastidieuse. Les développeurs devaient s'appuyer sur des solutions ad hoc, telles que la transmission de structures personnalisées ou l'utilisation de variables globales, pour partager des données et des signaux entre fonctions et goroutines. Cependant, ces approches étaient sujettes aux erreurs, difficiles à maintenir et conduisaient souvent à un couplage étroit entre les composants.
La nécessité d'un contexte découle du fait que de nombreuses opérations dans un programme sont asynchrones, concurrentes ou dépendantes de systèmes externes. Dans de tels cas, il est essentiel de disposer d'un moyen de propager les signaux d'annulation, les délais et les données liées aux requêtes sur plusieurs fonctions et goroutines.

Considérons quelques scénarios pour illustrer la nécessité d'un contexte :

1. L’analogie du restaurant

Imaginez que vous êtes la personne qui prend les commandes dans un restaurant animé. Lorsqu'une commande arrive, vous l'attribuez à l'un de vos cuisiniers qualifiés. Mais que se passe-t-il si le client décide soudainement de partir ? Sans hésitation, vous informeriez le chef d'arrêter de traiter cette commande pour éviter de gaspiller des ingrédients. Ce scénario reflète le fonctionnement du contexte dans Go.

Propagation de l'annulation : Dans l'analogie du restaurant, le départ du client correspond à un signal d'annulation. De même, dans Go, le contexte permet une propagation gracieuse des signaux d'annulation. Lorsqu'une opération parent (par exemple, un gestionnaire de requêtes HTTP) est annulée, toutes les opérations enfants associées (par exemple, requêtes de base de données ou appels d'API) se terminent rapidement. Cela évite les fuites de ressources et garantit un nettoyage efficace.

2. Gestion des API lentes et des délais d'attente

Supposons que votre application envoie des requêtes Web à des API externes ou exécute des commandes système. Dans les systèmes de production, il est essentiel de définir des délais d'attente. Voici pourquoi :

Dépendance API : imaginez que votre service s'appuie sur une API externe. Si cette API s'exécute lentement ou ne répond plus, vous ne voudriez pas que votre système sauvegarde avec les requêtes en attente. Un délai d'attente garantit que si l'appel d'API dépasse une durée spécifiée, le contexte associé s'annule, permettant à votre application de gérer la situation avec élégance.
Dégradation des performances : sans délais d'attente, ralentissement externe
les dépendances peuvent conduire à un effet en cascade. Les demandes en retard augmentent la charge, dégradent les performances et ont un impact sur la réactivité globale du système. En utilisant le contexte avec des délais, vous pouvez éviter ce problème.

Utilisations du contexte :

Le package contextuel de Go est polyvalent et utilisé dans divers scénarios pour gérer les données liées aux requêtes, les signaux d'annulation et les délais d'attente.

Voici quelques cas d'utilisation courants dans le monde réel :

1. Propagation des identifiants de trace sur les services distribués
Dans une architecture de microservices, le suivi des requêtes sur différents services est crucial pour la surveillance et le débogage. Le package de contexte vous permet de propager les ID de trace et autres métadonnées au-delà des limites du service, garantissant ainsi des informations de journalisation et de traçage cohérentes tout au long du cycle de vie de la demande.

2. Passer les jetons d'authentification
Dans de nombreuses applications, les jetons d'authentification ou les informations utilisateur doivent être transmis via différentes couches de l'application. Le package de contexte fournit un moyen simple de gérer cela, garantissant que les informations d'authentification sont disponibles là où elles sont nécessaires sans polluer les signatures de fonction avec des paramètres supplémentaires.

3. API WebSocket et Streaming
Dans WebSocket et les API de streaming, le contexte est utilisé pour gérer la durée de vie de la connexion et propager les données au niveau de la requête, telles que l'ID utilisateur et les informations de session. Cela vous permet de mettre en œuvre efficacement des fonctionnalités telles que l'authentification, la limitation du débit et la gestion des sessions.

Différents types de contexte dans Go :

Le package contextuel de Go propose plusieurs façons de créer et de manipuler des objets contextuels. Voici une liste des types couramment utilisés :

1. Contexte de base/Contexte TODO

C'est le contexte le plus basique et sert de point de départ vide. Il ne comporte aucun signal d’annulation ni délai. Utilisez-le lorsqu'aucun contexte spécifique n'est requis.
La seule fois où TODO est utilisé à la place de Background, c'est lorsque l'implémentation n'est pas claire ou que le contexte n'est pas encore connu.

Généralement utilisé dans les fonctions principales, l'initialisation et les tests.

ctx := context.Background()
ctx2 := contexte.TODO()

2. contexte.AvecAnnuler

Crée un nouveau contexte dérivé d'un contexte parent. La méthode WithCancel renvoie une copie du contexte parent avec une fonction d'annulation ; l'invocation de la fonction d'annulation libère les ressources liées au contexte et doit être appelée dès que les opérations dans le type Context sont enfin terminées.

Utilisé pour annuler des opérations dans une goroutine lorsque certaines conditions sont remplies.

parentCtx := context.Background()
ctx, annuler := context.WithCancel(parentCtx)
defer Cancel() // Nettoyer les ressources

3. contexte.WithDeadline

De la même manière que vous vous fixez une date limite, vous pouvez fixer une date limite en fonction du contexte. Go annulera automatiquement le contexte pour vous si le délai que vous avez spécifié pour qu'il se termine est atteint. Il crée un nouveau contexte dérivé d'un contexte parent avec une date limite spécifique.

Utile lorsque vous avez un délai précis pour réaliser une opération.

parentCtx := context.Background()
date limite := time.Now().Add(10 * time.Second)
ctx, annuler := context.WithDeadline(parentCtx, date limite)
defer Cancel() // Nettoyer les ressources

4. contexte.AvecValeur

Crée un nouveau contexte dérivé d'un contexte parent avec une paire clé-valeur associée. Cela vous permet de stocker et de récupérer des informations spécifiques à la demande dans le contexte. WithValue accepte un contexte parent et renvoie une copie de contexte. Par conséquent, plutôt que d’écraser la valeur, il crée un nouveau doublon avec une nouvelle paire clé-valeur.

Utile pour transmettre des données liées à la requête via le contexte, telles que des jetons d'authentification ou des ID de trace.

parentCtx := context.Background()
userIDKey := "jeton d'authentification"
ctx := context.WithValue(parentCtx, userIDKey, "abc123")

5. contexte.WithTimeout

Crée un contexte avec un délai d'attente associé. Le contexte s'annule automatiquement après la durée spécifiée. WithTimeout, permet à un programme de continuer là où il pourrait autrement se bloquer, offrant ainsi à l'utilisateur final une meilleure expérience. Il accepte une brève période comme paramètre, ainsi que le contexte parent, et termine la fonction si elle s'exécute au-delà du délai d'attente.

Utile pour fixer des délais sur les opérations.

parentCtx := context.Background()
ctx, annuler := context.WithTimeout(parentCtx, 5*time.Second)
defer Cancel() // Nettoyer les ressources

Different types of context in Golang

Contexte GoFr : contexte suralimenté pour les applications Go

Maintenant que nous avons exploré la puissance du contexte dans Go, voyons comment GoFr va encore plus loin avec GoFr Context.

GoFr est un cadre de développement de microservices avisé construit sur Go. Il vise à rationaliser le processus de développement en fournissant une approche structurée pour créer des microservices robustes et évolutifs.

GoFr Context étend magnifiquement les fonctionnalités du package de contexte Go standard en créant un wrapper autour de lui. Ce wrapper fournit un riche ensemble de dépendances préconfigurées directement accessibles via l'objet contextuel. Ce contexte entièrement chargé permet aux développeurs d'accéder de manière transparente à la journalisation, aux connexions de base de données, aux services sous-jacents, aux traces et aux métriques - à partir d'un seul objet contextuel.

Exemple

func MyHandler(c *gofr.Context) (interface{}, error) {
  // Logging
  c.Info("Processing request...")

  // Database access
  var value int
  err := c.SQL.QueryRowContext(c, "select 2+2").Scan(&value)
  if err != nil {
    return nil, datasource.ErrorDB{Err: err, Message: "error from sql db"}
  }

  // Accessing another service
  resp, err := c.GetHTTPService("anotherService").Get(c, "book", nil)
  if err != nil {
    return nil, err
  }

  // Creating a tracing span
  span := c.Trace("some-sample-work")
  defer span.End()
  // ... perform some work

  return value, nil
}

Copier après la connexion

Dans cet exemple, remarquez comment nous pouvons accéder à des fonctionnalités telles que la journalisation (c.Info), l'interaction avec la base de données (c.SQL), les appels de service (c.GetHTTPService) et le traçage (c.Trace) directement via l'objet Contexte GoFr. (c).

Le contexte GoFr est disponible dans tous les gestionnaires HTTP, améliorant considérablement l'expérience de développement en fournissant un moyen centralisé de gérer les différents aspects de l'application. Cette intégration garantit que les développeurs peuvent se concentrer sur la logique métier tout en tirant parti des capacités de GoFr pour une gestion efficace du contexte.

Conclusion

En matière de conception de programmes, le package contextuel Golang est un outil extrêmement utile. Context in Go constitue un outil puissant pour gérer les données liées aux demandes, les signaux d'annulation et les délais. Que vous créiez des microservices, des API ou des applications Web, le contexte garantit une gestion propre des ressources et un comportement cohérent.