Geyser gRPC - Meilleures pratiques

Ce guide couvre les modèles essentiels pour construire des applications robustes et prêtes à la production avec Geyser gRPC. Solana Stream SDK prend en charge Geyser gRPC.

Début

  • Commencez par des abonnements à slot pour vous familiariser avec le streaming avant d'ajouter des filtres complexes.
  • Utilisez les filtres à bon escient: inscrivez-vous uniquement à ce dont vous avez besoin pour réduire la bande passante/CPU. Les transactions de vote sont ~70% du trafic — les laisser tomber si vous n'en avez pas besoin.
rust
SubscribeRequestFilterTransactions {
    vote: Some(false),   // Exclude ~70% vote txs
    failed: Some(false), // Exclude failed txs
    ..Default::default()
}

Gestion des connexions

  • Réconnection automatique: attendez des problèmes de réseau; reconnectez-vous avec une rétrocession exponentielle.
  • Ping/pong manipulation: les serveurs Yellowstone gRPC envoient ping. Répondez toujours avec le pong ou le serveur peut fermer la connexion (cause commune de déconnexion de ~30s).
rust
if matches!(update.update_oneof, Some(UpdateOneof::Ping(_))) {
    subscribe_tx.send(SubscribeRequest {
        ping: Some(SubscribeRequestPing { id: 1 }),
        ..Default::default()
    }).await?;
}
  • Récupération des lacunes: utilisation from_slot après la reconnexion pour éviter la perte de données (les duplications sont acceptables).
rust
subscribe_request.from_slot = if tracked_slot > 0 {
    Some(tracked_slot) // Optionally subtract a small buffer to dodge reorgs
} else {
    None
};

Modèles d'architecture

  • Séparer l'entrée et le traitement avec les canaux pour découpler IO réseau de la logique d'affaires et ajouter la contre-pression.
rust
let (tx, rx) = mpsc::channel::<SubscribeUpdate>(10_000);
// ingress task reads stream and tx.send(...)
// processing task consumes rx and does business logic
  • Utiliser des canaux délimités: choisir la capacité en fonction de la vitesse de traitement et de la tolérance à la perte de données (plus petite = moins de mémoire, plus de gouttes; plus grande = plus de mémoire, moins de gouttes).

Performance et résilience

  • Surveiller la latence de traitement et le log lorsque les seuils sont dépassés.
  • Batch DB écrit; rincer sur la taille ou l'intervalle du lot.
  • Utiliser les IO d'async pour les appels externes; décharger les gros calculs aux tâches des travailleurs/threads.
  • Réutiliser les demandes d'abonnement pour réduire les allocations.

Gestion des erreurs

  • Types d'erreur distincts (stream vs traitement vs canal).
  • Décollage exponentiel sur reconnect (démarrer petit, bouchon à un maximum raisonnable).
  • Journal/metric des mises à jour abandonnées pour suivre les conditions de consommation lentes.

Gestion des données

  • Gérer les duplicatas lors de l'utilisation from_slot (limites de cache ou de DB).
  • Choisir l'engagement par cas d'utilisation:
  • traité: tableaux de bord les plus rapides, peut retourner en arrière
  • confirmé: bon par défaut pour la plupart des applications/indexers
  • Finalisation: lorsque la certitude absolue est requise

Abonnements dynamiques

Utilisez le flux bidirectionnel pour mettre à jour les abonnements au moment de l'exécution (filtres hot-swap, étendre la couverture) sans reconnecter.

Liste de contrôle de la production

  • La reconnexion automatique avec une sortie exponentielle
  • Relèvement des écarts en utilisant from_slot
  • Ping/pong manipulation (éviter les déconnexions de 30s)
  • Déplacement et traitement séparés avec canaux délimités/backpressure
  • Erreur d'enregistrement et de mesures/alerting
  • Suivi des latences de traitement
  • Dupliquer la manipulation et l'optimisation des filtres
  • Lot écrit (si elle persiste)
  • Arrêt gratuit et contrôles sanitaires

Ressources supplémentaires