Projets open source

Un framework Rust pour implémenter des résolveurs AWS AppSync Direct Lambda avec typage complet et validation à la compilation. Génère automatiquement les types Rust à partir du schéma GraphQL et route les opérations vers les bons handlers

• Génération de types à partir du schéma GraphQL via macro procédurale
• Routing automatique des opérations (Query, Mutation, Subscription) vers les implémentations métier
• 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

Instrumentation OpenTelemetry clé en main pour les fonctions AWS Lambda utilisant le SDK AWS pour Rust. Génère automatiquement des traces et logs structurés pour chaque appel AWS. Associée à l'exporteur X-Ray que j'ai écrit pour 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)
• Zéro Configuration : une simple macro suffit à tout instrumenter
• Compatible avec le runtime Lambda Rust officiel

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 : oublier la sort key, définir deux fois une condition, et autres mésusages similaires sont des erreurs de compilation
• Query & scan auto-paginés (collecte ou streaming)
• Support natif du pattern single-table (mono-table)

Une contribution upstream de 18k lignes sur 46 fichiers au projet OpenTelemetry Rust Contrib, apportant un support AWS X-Ray à l'écosystème OpenTelemetry Rust. La PR #549 a été mergée le 11 juin 2026, après revue par les mainteneurs du projet. C'est sur ce travail que repose l'exporteur X-Ray de awssdk-instrumentation.

• 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 banc d'essai Lambda convivial autour de la création d'archives S3 en streaming. Deux articles de blog y sont consacrés si vous voulez en savoir plus.

• Banc d'essai en parallèle classant les concurrents par coût réel d'invocation Lambda
• Lambda de contrôle validant l'archive ZIP octet par octet
• Bucket pré-rempli de 3 000 objets aléatoires (~15 Go)
• Concurrents ouverts aux contributions, dans n'importe quel langage
• Déploiement CI/CD depuis un simple fork du dépôt

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
• Déploiement CI/CD depuis un simple fork du dépôt

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
• Déploiement CI/CD depuis un simple fork du dépôt

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 variées (Ackermann, nombres premiers, DynamoDB). 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
• Déploiement CI/CD depuis un simple fork du dépôt