Go vs Rust en 2026 : un comparatif honnête pour le backend

Dernière mise à jour : 29 avril 2026

Go vs Rust : le comparatif en bref

Go l'emporte sur presque tout ce qu'une équipe backend cherche à optimiser. Les avantages de Rust comptent pour une petite part du travail système.

Faut-il choisir Go ou Rust ?

flowchart TD
    Start(["`**Building a backend service in 2026**`"])
    Start --> Q{"`Systems-level software?`"}

    Q -->|"`**No** — 90%+ of backend work`"| Go(["`**Go**`"])
    Q -->|"`**Yes** — a narrow strip`"| Rust(["`**Rust**`"])

    Go --> GoUse["`**What you build**
    ─────────────
    CRUD APIs
    Microservices
    Control planes
    CLIs and operators
    Cloud-native tooling
    gRPC services`"]
    GoUse --> GoProof["`**Shipping in production**
    ─────────────
    Kubernetes · Docker
    Terraform · etcd
    Prometheus · Grafana
    CockroachDB · Caddy
    Tailscale · containerd

    Backends at Uber, Netflix,
    Cloudflare, Twitch, Monzo`"]

    Rust --> RustUse["`**What you build**
    ─────────────
    Hypervisors
    Hot-path proxies
    Database engines
    Codecs and crypto
    Sub-ms tail latency`"]
    RustUse --> RustProof["`**Shipping in production**
    ─────────────
    Cloudflare Pingora
    AWS Firecracker
    Discord Read States
    Polkadot
    Linkerd2-proxy`"]

    classDef start fill:#0b2942,color:#d6deeb,stroke:#1d3b53,stroke-width:1px,rx:8,ry:8
    classDef question fill:#0b2942,color:#d6deeb,stroke:#1d3b53,stroke-width:2px
    classDef goPick fill:#00ADD8,color:#011627,stroke:#5DC9E2,stroke-width:3px
    classDef goPanel fill:#0b2942,color:#d6deeb,stroke:#00ADD8,stroke-width:2px,rx:6,ry:6
    classDef rustPick fill:#CE3263,color:#fff,stroke:#ef5350,stroke-width:3px
    classDef rustPanel fill:#0b2942,color:#d6deeb,stroke:#CE3263,stroke-width:2px,rx:6,ry:6

    class Start start
    class Q question
    class Go goPick
    class GoUse,GoProof goPanel
    class Rust rustPick
    class RustUse,RustProof rustPanel

    linkStyle 0 stroke:#7a8fa3,stroke-width:1.5px
    linkStyle 1 stroke:#00ADD8,stroke-width:2.5px
    linkStyle 2 stroke:#CE3263,stroke-width:2.5px
    linkStyle 3 stroke:#00ADD8,stroke-width:2.5px
    linkStyle 4 stroke:#00ADD8,stroke-width:2.5px
    linkStyle 5 stroke:#CE3263,stroke-width:2.5px
    linkStyle 6 stroke:#CE3263,stroke-width:2.5px

La plupart du travail backend tombe du côté de Go. La branche Rust couvre un ensemble restreint et bien défini de systèmes.

En ligne, le débat Go vs Rust donne souvent l'impression que les deux langages se disputent les mêmes usages. Dans l'ensemble, ce n'est pas le cas. Go a été conçu pour le backend distribué et concurrent, qui constitue l'essentiel de l'infrastructure moderne. Rust a été conçu pour la programmation système, le territoire autrefois réservé au C et au C++.

Cet article vous aide à déterminer de quel côté se situe votre projet, et pourquoi presque toutes les équipes backend en 2026 finissent du côté de Go. Lorsqu'une source primaire existe, elle est liée dans le texte pour que vous puissiez vérifier le chiffre vous-même.

Table des matières

• La réponse courte
• Performances : Rust est-il plus rapide que Go en 2026 ?
• Gestion de la mémoire : le GC de Go vs l'ownership de Rust
• Concurrence : goroutines vs Tokio
• Courbe d'apprentissage : Rust est-il plus difficile que Go ?
• Temps de compilation : vitesse de build Go vs Rust
• Écosystème et frameworks
• Études de cas concrètes
• Golang vs Rust : emplois et salaires en 2026
• Quand utiliser Go ou Rust : grille de décision
• Questions fréquentes
• Sources

---

La réponse courte

Choisissez Go par défaut pour le backend. Voici ce que vous y gagnez :

• Des livraisons plus rapides. Les nouvelles recrues apportent des modifications significatives dès leur première semaine.
• Un recrutement plus facile, car le vivier de développeurs Go est bien plus large que celui de Rust.
• Une bonne concurrence sans cérémonie. Les goroutines, les channels et context couvrent l'essentiel de vos besoins.
• La stack cloud-native dominante. Kubernetes, Docker, Terraform, Prometheus et tous les grands SDK cloud sont écrits en Go.
• Un runtime assez rapide pour que vous n'ayez plus à y penser.

Ne vous tournez vers Rust que si vous avez un besoin strict et durable de latence de queue prévisible à un seul chiffre en millisecondes, d'une empreinte mémoire très faible ou d'abstractions à coût nul au plus près du matériel. Cela concerne les proxies, les bases de données, les hyperviseurs, les agents embarqués et les codecs. Pas un énième service HTTP.

Performances : Rust est-il plus rapide que Go en 2026 ?

La plupart des services backend sont limités par les E/S. Ils passent leur temps à attendre la base de données, le réseau ou le sérialiseur, si bien que le runtime est rarement le goulot d'étranglement.

Sur du travail intensif en CPU comme le parsing, la compression et la cryptographie, Rust peut prendre l'avantage, en particulier dans les boucles numériques inlinées sans vérification des bornes. Le travail CPU d'un service backend typique, c'est du JSON, du protobuf, du hachage et des regex. Le compilateur et la bibliothèque standard de Go sont bien optimisés pour cela, et en production l'écart est généralement trop faible pour être perceptible.

Méfiez-vous du benchmark « 10x ». Le chiffre phare de la réécriture d'Aurora DSQL chez AWS (Werner Vogels : « Just make it scale ») compare Kotlin sur la JVM à Rust, sur un control plane qui se heurtait aux limites du warm-up et du GC de la JVM. Ce n'est pas un chiffre Go vs Rust, et migrer un service Go ne vous apportera rien de comparable à ce multiplicateur.

Les versions récentes de Go continuent de réduire l'écart là où cela compte :

• Le nouveau ramasse-miettes Green Tea réduit le surcoût du GC de 10 à 40 % dans les programmes qui allouent beaucoup.
• Le surcoût de base d'un appel cgo a baissé d'environ 30 %.
• Sources : notes de version de Go 1.26, The Green Tea Garbage Collector. Voir aussi Les nouveautés de Go 1.26.

Go gère aussi bien les allocations. Le compilateur pratique une escape analysis agressive, si bien qu'une bonne partie de ce qui ressemble à une allocation sur le tas finit sur la pile, où elle ne coûte presque rien. Du Go idiomatique qui utilise sync.Pool, strings.Builder et des slices préallouées est efficace.

example.gogo
package main

import (
    "fmt"
    "strings"
)

func main() {
    parts := []string{"go", "is", "fine", "for", "most", "things"}
    var b strings.Builder
    for _, p := range parts {
        b.WriteString(p)
        b.WriteString(" ")
    }
    fmt.Println(strings.TrimSpace(b.String()))
}

L'équivalent Rust fonctionne aussi. Vous le payez toutefois d'emblée, en réfléchissant aux durées de vie et à l'ownership à chaque ligne, y compris celles où cela n'a aucune importance :

example.rustrust
fn main() {
    let parts = ["rust", "is", "strict", "but", "predictable"];
    let mut s = String::with_capacity(64);
    for p in parts {
        s.push_str(p);
        s.push(' ');
    }
    println!("{}", s.trim_end());
}

Savoir quel langage est le plus rapide compte moins que savoir s'il est assez rapide pour que vous cessiez d'y penser. Pour le backend, Go l'est. Quand il ne l'est pas, profilez d'abord. Le goulot d'étranglement est presque toujours une requête en base de données ou un problème N+1, pas le runtime.

Gestion de la mémoire : le GC de Go vs l'ownership de Rust

L'argument de Rust ici, c'est le déterminisme. La mémoire est libérée à la fin de l'ownership, il n'y a donc ni collecteur en arrière-plan ni budget de tas à régler. La contrepartie, c'est que vous raisonnez sur les durées de vie partout, même dans du code qui serait sûr sans cela.

Le GC de Go est très bon. Après des années d'utilisation en production, et désormais avec le collecteur Green Tea, des pauses inférieures à la milliseconde sur des tas de plusieurs gigaoctets sont la norme. Pour des services ordinaires sur des VM de longue durée, vous ne le remarquerez pas, qu'il s'agisse d'une API CRUD, d'un control plane ou d'un microservice.

Le cas Discord est réel, mais restreint. Le service Read States de Discord conservait des millions d'entrées dans un cache LRU en mémoire, et la version Go subissait des pics de latence chaque fois que le GC parcourait ce cache. La réécriture en Rust a supprimé ces pics (blog technique de Discord : Why Discord is switching from Go to Rust).

Les ingénieurs de Discord en soulignent eux-mêmes les limites dans le même article :

• Il s'agissait d'un service bien précis, fonctionnant à une échelle extrême.
• Le reste du backend de Discord est toujours en Go.
• L'article dit en toutes lettres « Go served us well ».

Sur les charges de travail de la plupart des équipes (API CRUD, microservices, control planes, CLI), le GC de Go n'apparaîtra pas dans vos traces. Le modèle mémoire de Rust ne prend l'avantage qu'avec de très gros caches en mémoire, des budgets de latence de queue très serrés ou des déploiements edge denses où la mémoire est rare.

Concurrence : goroutines vs Tokio

C'est la différence la plus profonde entre les deux langages, et c'est là que l'argument en faveur de Go comme choix par défaut est le plus clair.

Le modèle de Go est stackful et préemptif.

• Chaque goroutine a sa propre pile extensible.
• Le runtime peut suspendre une goroutine pour en exécuter une autre.
• Vous écrivez du code bloquant et le runtime le rend concurrent.
• Il n'y a ni mot-clé async, ni coloration des fonctions, ni casse-tête de sûreté à l'annulation.
• Les goroutines sont légères, vous pouvez donc en lancer des milliers.

Si les goroutines sont nouvelles pour vous, Go Concurrency Fundamentals présente go, les channels, select et l'annulation via context avec des exemples exécutables.

example.gogo
package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            time.Sleep(10 * time.Millisecond)
            fmt.Printf("worker %d done\n", id)
        }(i)
    }
    wg.Wait()
}

Le modèle de Rust est stackless et coopératif.

• Les fonctions async renvoient des Future, et un exécuteur (presque toujours Tokio) les fait avancer.
• La coloration des fonctions signifie qu'une async fn se propage à tous ses appelants.
• Vous apprenez Pin, les durées de vie à travers .await et la sûreté à l'annulation à vos dépens.
• Ce qui doit se passer quand une future est abandonnée au milieu d'un await fait encore l'objet de discussions actives (Cancelling async Rust, Oxide RFD 400).

example.rustrust
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let mut handles = vec![];
    for i in 0..5 {
        handles.push(tokio::spawn(async move {
            sleep(Duration::from_millis(10)).await;
            println!("worker {i} done");
        }));
    }
    for h in handles {
        h.await.unwrap();
    }
}

Pourquoi les goroutines sont le bon choix par défaut pour le backend :

• Elles correspondent à la façon dont les développeurs pensent déjà le travail parallèle.
• Elles se composent sans coloration des fonctions.
• Répartir le travail, attendre et collecter les résultats tient en quelques lignes évidentes au lieu d'un casse-tête de durées de vie.
• Le race detector de Go détecte les data races pendant l'exécution de vos tests. Vous obtenez ainsi l'essentiel de la sûreté sans le surcoût du système de types.
• go, les channels, sync, context et le race detector font tourner ensemble certains des plus grands systèmes concurrents en production, dont Kubernetes, Docker et etcd.

Pour les patterns de concurrence qui prennent souvent les équipes au dépourvu en production, consultez 10 erreurs courantes à éviter en Go.

Quand vous avez vraiment besoin de ce contrôle, l'async de Rust est l'outil le plus puissant. Vous le payez à chaque ligne, que vous en tiriez parti ou non, et les services backend n'en ont généralement pas besoin.

Courbe d'apprentissage : Rust est-il plus difficile que Go ?

Go est petit par choix. Il compte 25 mots-clés, une bibliothèque standard resserrée et, en général, une seule façon évidente de faire les choses. Les nouvelles recrues lisent le code existant et apportent des modifications significatives dès leur première semaine. Cette rapidité d'intégration est un avantage business sous-estimé, et elle rapporte à nouveau à chaque personne que vous recrutez.

Rust est vaste par choix. Le borrow checker, les durées de vie, les trait bounds, Pin, Send/Sync et la sémantique async sont le prix d'entrée, pas des options facultatives. Une fois qu'une équipe a passé ce cap, le compilateur devient un binôme utile. Mais le cap est réel, et les équipes le paient en montée en compétence plus longue, en revues plus lentes et en temps passé à se battre avec les types au lieu de livrer des fonctionnalités.

La différence se voit aussi en code review. Les pull requests Rust ont tendance à être plus longues et à être relues plus attentivement. Les pull requests Go ont tendance à être plus petites et à avancer plus vite. Si votre équipe tient à livrer, à déboguer en production et à intégrer rapidement de nouveaux ingénieurs, le modèle de productivité de Go est difficile à battre.

Le Go Generics Masterclass montre à peu près où plafonne la complexité de Go : paramètres de type, contraintes et patterns génériques autoréférentiels. C'est à peu près le code le plus complexe que vous écrirez en Go idiomatique.

Temps de compilation : vitesse de build Go vs Rust

Un service Go de taille moyenne se compile en quelques secondes, et les builds incrémentaux se terminent généralement en moins d'une seconde. Rust est beaucoup plus lent, surtout pour les builds complets et dans une CI basée sur Docker.

L'équipe Rust n'a cessé d'améliorer ce point, et le nouveau trait solver comme le front-end parallèle sont arrivés dans des versions récentes. L'écart reste important.

Cela compte surtout pour les équipes qui livrent de nombreux petits services et itèrent rapidement. Avec des builds rapides, vous lancez les tests plus souvent, vous poussez plus souvent et vous gardez des boucles de feedback courtes. Avec Rust, vous attendez, et cette attente change la façon dont les gens travaillent.

Écosystème et frameworks

Les deux écosystèmes sont matures en 2026, chacun à sa manière.

L'écosystème web de Go s'est stabilisé et a été durement éprouvé en production.

• Le net/http de la bibliothèque standard a reçu d'importantes améliorations du routage en 1.22 et continue de progresser. Beaucoup de services n'ont besoin d'aucun framework.
• database/sql avec pgx pour PostgreSQL est le choix sobre et correct pour l'accès aux données.
• Côté frameworks, le rapport JetBrains Go Ecosystem in 2025 place Gin à environ 48 %, Echo à environ 16 % et Fiber à environ 11 %.
• slog et le SDK OpenTelemetry vous donnent des logs structurés, des métriques et des traces avec très peu de configuration.

L'écosystème web de Rust s'est stabilisé autour d'Axum, maintenu par l'équipe Tokio et le framework web Rust le plus utilisé dans les enquêtes récentes. Actix Web reste populaire pour le code sensible aux performances, et SQLx et SeaORM sont les principales options pour l'accès aux bases de données.

L'avance de Go tient à son étendue. Les SDK cloud, les bibliothèques natives Kubernetes et les opérateurs sortent d'abord en Go. Si vous voulez un SDK de premier plan pour un grand fournisseur cloud dès le premier jour, Go est la réponse. Rust a rattrapé son retard sur les briques les plus importantes, mais l'avance de Go est réelle et elle se maintient.

Études de cas concrètes

L'essentiel des discussions en ligne tourne autour d'une poignée de réécritures en Rust très médiatisées. Le tableau change dès que vous comptez les systèmes qui font tourner une grande partie de l'internet moderne sans faire les gros titres.

Là où Go fait tourner le cloud

La stack cloud-native est écrite en Go : Kubernetes, Docker, containerd, etcd, Terraform, Prometheus, Grafana, CockroachDB, InfluxDB, Caddy, Traefik, Hugo, Gitea et Tailscale. Tout comme les microservices d'Uber, Twitch, Netflix, Cloudflare, Dropbox, Mercari et Monzo.

Ces projets ont choisi Go pour la vitesse de livraison, la facilité d'intégration des contributeurs, une concurrence prévisible et des performances suffisantes. Ils gèrent chaque jour un trafic à l'échelle d'internet. C'est la partie sans éclat du tableau, et de loin la plus grande.

Golang vs Rust : emplois et salaires en 2026

Les données salariales varient beaucoup selon la source. Voici les chiffres qui revenaient de façon cohérente début 2026.

Dernière vérification le 29 avril 2026. Considérez ces fourchettes comme indicatives, et non comme faisant autorité.

Au total :

• Les salaires Go se situent à peu près entre 120 000 $ et 135 000 $.
• Les salaires Rust se situent à peu près entre 110 000 $ et 147 000 $. L'écart est plus large parce que l'échantillon est plus petit.
• Rust paie toujours une prime, mais elle est plus faible qu'en 2022, et elle reflète surtout la rareté plutôt qu'une productivité supérieure des ingénieurs.

La demande compte plus que le salaire. Les offres d'emploi Go dépassent systématiquement et largement les offres Rust sur tous les grands sites d'emploi, et presque toutes les entreprises du cloud-native, de la fintech et de l'outillage d'infrastructure font tourner Go en production.

Côté opinion des développeurs, le 2025 Stack Overflow Developer Survey place Rust près du sommet des langages « most admired » et Go dans la partie haute du classement. Les deux langages ont des utilisateurs satisfaits, mais Go dispose d'un marché de l'emploi bien plus large.

Si vous choisissez quoi apprendre, Go est le meilleur premier pari pour presque tout le monde. Le marché de l'emploi est bien plus large, vous devenez employable plus tôt et vous travaillez directement avec la stack cloud-native dominante. Le cours Go Fundamentals de LevelUpGo est un bon point de départ.

Quand utiliser Go ou Rust : grille de décision

Choisissez Go si (cela couvre l'essentiel du travail backend) :

• Vous construisez un service CRUD, une API ou un microservice.
• Vous construisez un control plane, une CLI ou un outil de développement.
• Votre équipe est petite, d'expérience hétérogène ou recrute rapidement.
• Le délai de mise sur le marché compte un tant soit peu.
• Vous livrez de nombreux services et tenez à l'itération rapide.
• Vous voulez un outillage de premier plan pour Kubernetes, les SDK cloud, gRPC ou les opérateurs.
• Vous avez besoin d'une concurrence solide sans vous lancer dans un chantier de système de types async.
• Votre budget de performance a une marge qui se mesure en millisecondes. (C'est presque toujours le cas.)

Choisissez Rust si (un ensemble de cas plus restreint et précis) :

• Une latence de queue prévisible à un seul chiffre en millisecondes est une exigence stricte (proxies, trading, systèmes temps réel).
• L'empreinte mémoire doit être minimale (workers edge, embarqué, sidecars denses).
• Vous écrivez un moteur de base de données, un runtime, un compilateur, un hyperviseur ou un composant de noyau.
• Le travail consiste en calculs lourds limités par le CPU (codecs, crypto, parseurs, inférence ML).
• Vous pouvez vous permettre une montée en compétence plus longue et disposez d'ingénieurs seniors pour accompagner l'équipe.

Utilisez les deux à grande échelle

Un pattern courant en 2026 consiste à utiliser Go pour les services applicatifs et les control planes, et à réserver Rust aux composants du data plane sur le chemin critique. Les deux interopèrent proprement via gRPC, des files de messages partagées ou le FFI si nécessaire.

Se demander quel langage gagne ne vous aidera pas beaucoup. Demandez-vous plutôt ce dont ce service précis a besoin, et quel langage vous y mène au coût total le plus bas sur cinq ans. Pour la grande majorité des services backend, c'est Go.

Questions fréquentes

Rust est-il plus rapide que Go ?

Sur des microbenchmarks serrés limités par le CPU, Rust est souvent légèrement plus rapide, de quelques pour cent jusqu'à 2x sur les boucles numériques. Dans les vrais services backend qui attendent des bases de données et le réseau, l'écart disparaît généralement, et Go est assez rapide pour que le runtime soit rarement ce qui vous limite.

Faut-il apprendre Go ou Rust en 2026 ?

Apprenez Go. Le marché de l'emploi est bien plus large, le langage est assez petit pour que vous soyez productif en une semaine, et la stack cloud-native repose dessus (Kubernetes, Docker, Terraform, Prometheus, tous les grands SDK cloud). Rust constitue un excellent second langage plus tard si vous voulez faire du travail au niveau système.

Go ou Rust : lequel est le meilleur pour le développement backend ?

Go. C'est le bon choix par défaut pour presque tout le travail backend en 2026, y compris les services CRUD, les microservices, les control planes et les API. Rust n'est le meilleur choix que pour un ensemble restreint de charges de travail au niveau système où une latence déterministe ou une empreinte mémoire minimale comptent.

Pourquoi Discord est-il passé de Go à Rust ?

Discord a réécrit un service bien précis, Read States, parce que le GC de Go provoquait des pics de latence en parcourant un très gros cache en mémoire contenant des millions d'entrées. La réécriture a supprimé ces pics. L'essentiel du backend de Discord est toujours en Go, et les ingénieurs de Discord le disent dans l'article d'origine.

Rust est-il en train de remplacer Go ?

Non. Rust remplace le C et le C++ dans le travail système critique pour les performances, comme les proxies et les hyperviseurs. Go domine toujours l'infrastructure cloud-native, les microservices backend et l'outillage de développement, et les offres d'emploi, l'activité open source et l'étendue de l'écosystème montrent toutes que son empreinte grandit.

Peut-on utiliser Go et Rust ensemble ?

Oui. La plupart des grandes organisations qui utilisent les deux font tourner Go pour les services applicatifs et Rust pour les composants du data plane sur le chemin critique, reliés via gRPC, des files de messages partagées ou le FFI. Placer la frontière sur un protocole réseau stable est généralement plus simple que d'embarquer un runtime dans l'autre.

Qui offre le plus d'emplois, Go ou Rust ?

Go, et de loin. Presque toutes les entreprises du cloud-native, de la fintech et de l'outillage d'infrastructure font tourner Go en production. Les postes Rust se concentrent dans la programmation système, la blockchain et une poignée d'entreprises bien connues comme AWS, Cloudflare et Discord.

Go est-il plus facile à apprendre que Rust ?

Oui, bien plus facile. Go compte 25 mots-clés, une petite bibliothèque standard et une culture de la « seule façon évidente », et la plupart des ingénieurs contribuent de façon productive dès leur première semaine. Rust vous demande d'apprendre le borrow checker, les durées de vie, les trait bounds et la sémantique async avant de pouvoir construire quoi que ce soit de non trivial.

Sources

Sources primaires citées dans cet article (dernière vérification le 29 avril 2026) :

• Blog technique de Discord : Why Discord is switching from Go to Rust
• Cloudflare : How we built Pingora
• Werner Vogels : Just make it scale (Aurora DSQL)
• AWS : annonce de l'ouverture du code de Firecracker
• Dépôt GitHub de Firecracker
• Notes de version de Go 1.26
• The Green Tea Garbage Collector
• JetBrains : Go Language Trends and Ecosystem 2025
• 2025 Stack Overflow Developer Survey
• Cancelling async Rust, par Sunshowers
• Oxide RFD 400 : Dealing with cancel safety in async Rust
• Salary.com : salaire d'un développeur Golang
• Salary.com : salaire d'un développeur Rust
• Glassdoor : salaire d'un développeur Go
• Glassdoor : salaire d'un développeur Rust
• ZipRecruiter : salaire d'un développeur Rust
• Jobicy : salaire d'un développeur Go
• Axum is shaping the future of web development in Rust

Pour aller plus loin

Si vous avez opté pour Go, le cours Go Fundamentals de LevelUpGo vous mène de package main à un service prêt pour la production grâce à des leçons interactives qui se compilent et s'exécutent dans votre navigateur avec la dernière toolchain Go.

Quand la concurrence commence à compter, Go Concurrency Fundamentals couvre les goroutines, les channels, select et l'annulation via context. Le Go Generics Masterclass couvre les paramètres de type et les contraintes quand vous en avez besoin.

Pour enrichir votre portfolio, le capstone et les cours projets vous font construire des services complets :

• Go Capstone: Web Crawler
• Project: URL Shortener
• Project: In-Memory Cache
• Project: Task Queue
• Project: Log Aggregator

Pour aller plus loin dans la lecture : Quel est le meilleur langage de programmation pour le backend ?, 10 erreurs courantes à éviter en Go et Les nouveautés de Go 1.26.