Projets open source

Un framework Rust pour implémenter des résolveurs AWS AppSync Direct Lambda avec une sécurité de types complète et une validation à la compilation. Génère automatiquement les types Rust à partir du schéma GraphQL, route les opérations vers les bons handlers et applique le contrat d'erreurs AppSync.

• Génération de types à partir du schéma GraphQL via macro procédurale
• Routing automatique des opérations (Query, Mutation, Subscription)
• Gestion des erreurs typée et conforme au protocole AppSync
• Support de l'authentification multi-mode (API key, Cognito, IAM, OIDC)
• Compatible avec le runtime Lambda Rust officiel (aws-lambda-rust-runtime)

Instrumentation OpenTelemetry clé en main pour les fonctions AWS Lambda utilisant le SDK AWS pour Rust. Génère automatiquement des traces, métriques et logs structurés pour chaque appel AWS. Associée à l'exporteur X-Ray que j'ai apporté à opentelemetry-rust-contrib, elle fait remonter nativement les traces dans l'écosystème d'observabilité AWS.

• Traces OpenTelemetry automatiques pour tous les appels AWS SDK
• Métriques de latence et de taux d'erreur par service et opération
• Exporteur AWS X-Ray optionnel (via ma contribution à opentelemetry-rust-contrib)
• Configuration zéro : une macro suffit à tout instrumenter
• Compatible avec tout runtime Lambda Rust

Une façade typée et ergonomique au-dessus du client DynamoDB de l'AWS SDK pour Rust. Élimine les key maps manuels, les chaînes d'expression, les boucles de pagination et le découpage des batchs — tout en garantissant l'utilisation correcte à la compilation grâce à des builders typestate et à un schéma encodé dans le système de types.

• Câblage d'items zéro-boilerplate via macros déclaratives (définitions de table, d'attribut et d'index comme zero-sized types)
• Builders composables et typés pour les expressions de condition et d'update — plus de gestion manuelle des `#name` / `:value`
• Builders d'opérations en typestate : fournir une sort key sur une table qui n'en a pas, définir deux fois une condition, et autres mésusages similaires sont des erreurs de compilation
• Query & scan auto-paginés (collecte ou streaming) et batch writes auto-découpés avec retry
• Support natif du pattern single-table (mono-table)

Une contribution upstream d'environ 18 000 lignes au projet OpenTelemetry Rust Contrib, apportant un support AWS X-Ray à l'écosystème OpenTelemetry Rust. C'est sur ce travail que repose l'exporteur X-Ray de awssdk-instrumentation ; il est actuellement distribué via une crate temporaire publiée (opentelemetry-aws-temporary-fork) en attendant le merge de la PR upstream #549.

• Exporteur de spans et traces X-Ray, avec mapping de la sémantique OpenTelemetry vers le modèle de données X-Ray
• Client daemon X-Ray pour la livraison UDP vers l'agent X-Ray local
• Client stdout pour le tracing depuis les environnements sans daemon (ingestion CloudWatch Logs, debug local)

Un jeu d'économie multijoueur qui met en scène la stack RustySL complète, de bout en bout, sur AWS. Construit sur AppSync avec des résolveurs Lambda Rust directs propulsés par lambda-appsync, un backend DynamoDB single-table exploité via dynamodb-facade, et instrumenté par awssdk-instrumentation — le tout derrière un frontend SvelteKit statique sur CloudFront et déployé via CodePipeline V2.

• Résolveurs Lambda Rust directs sur AppSync, avec batching et souscriptions
• Sous-stack dédiée comparant côte à côte six stratégies d'instrumentation Lambda (4 Python, 2 Rust)
• Design DynamoDB single-table avec authentification Cognito et tracing X-Ray

Un jeu de clic interactif qui benchmarke en temps réel quatre implémentations de résolveurs AppSync : Lambda Rust, Lambda Python, résolveur JavaScript et résolveur VTL. Le résolveur Rust est construit avec lambda-appsync et dynamodb-facade, et le projet sert de déploiement de référence pour les deux crates.

• Benchmark à quatre résolveurs (Rust / Python / JS / VTL) piloté par les clics des joueurs
• Frontend Vue.js sur CloudFront, déploiement CodePipeline, authentification Cognito
• CLI de load-test (simulate_players) pour le benchmarking synthétique

La toute première démo : une comparaison frontale de fonctions AWS Lambda en Rust et en Python, exposées via des API Gateway parallèles et benchmarkées sur des charges CPU-bound (Ackermann, nombres premiers). Les résultats publiés montrent Rust environ 50× plus rapide, 33× moins cher et 4× moins gourmand en mémoire que Python sur les mêmes tâches.

• Deux API Gateway parallèles, l'une Rust l'autre Python, partageant un backend DynamoDB
• Charges CPU conçues pour stresser les chemins de cold-start et d'exécution à chaud
• Requêtes CloudWatch Log Insights pour des mesures reproductibles, résultats publiés dans un tableur public