From f3a32c62c4cef04ca8b699bdc242a5a9d8fb70b3 Mon Sep 17 00:00:00 2001 From: Kamil Kulig Date: Sun, 15 Feb 2026 15:50:50 +0100 Subject: [PATCH 1/3] draft of call for proposal --- grpc/call_for_proposal.md | 122 +++++++++++++++++++++++++++++++++++ mongodb/call_for_proposal.md | 11 ++++ 2 files changed, 133 insertions(+) create mode 100644 grpc/call_for_proposal.md create mode 100644 mongodb/call_for_proposal.md diff --git a/grpc/call_for_proposal.md b/grpc/call_for_proposal.md new file mode 100644 index 0000000..4955587 --- /dev/null +++ b/grpc/call_for_proposal.md @@ -0,0 +1,122 @@ +# gRPC for Beginners + + +## Short description +This workshop is designed for those who are new to gRPC and are eager to learn how to build high-performance microservices with it. In this hands-on workshop, you will learn the basics of gRPC, a modern RPC framework, and how to use it with Python. We will start with an introduction to gRPC and where it excels over traditional REST APIs. We will then dive into the specifics of gRPC, including Protocol Buffers, service definition, and the four communication patterns. You will learn how to implement services, define messages, and handle different types of communication. A pre-configured Docker Compose environment with Prometheus, Grafana, and test suite will be provided so you can focus entirely on writing gRPC code and measuring performance in real-time. You will also cover best practices for error handling, authentication, testing, and performance optimization. By the end of this workshop, you will have a solid understanding of gRPC and how to use it in your Python applications. You will be equipped with the knowledge and skills to start building efficient microservices with gRPC. A basic understanding of Python and HTTP/REST is necessary to get the most out of this workshop. Preparation: Participants only need to bring laptops with Docker and Docker Compose installed. All other tools, dependencies, and boilerplate code will be provided pre-configured. Join us in this exciting hands-on workshop and start your journey in the world of high-performance RPC with gRPC! + +## Detailed abstract + +This workshop, "gRPC for Beginners", is a comprehensive introduction to gRPC, a modern Remote Procedure Call framework, tailored specifically for Python developers who are new to gRPC. + +Section 1: Introduction to gRPC and RPC Concepts +We will begin with an overview of RPC concepts and why gRPC is a powerful tool for building microservices. We will compare gRPC with REST APIs and discuss its advantages including performance, type safety, and code generation. This section will provide a solid foundation for understanding gRPC's role in modern distributed systems. + +Section 2: Protocol Buffers and Service Definition +Next, we will delve into Protocol Buffers (protobuf), gRPC's serialization format. We will explore how to define messages and services using the .proto syntax. This section will give you a clear understanding of how gRPC structures data and defines service contracts. + +Section 3: Implementing gRPC Services +In this section, we will learn how to implement gRPC services using Python. Through hands-on exercises, you will create servers and clients, understanding the four communication patterns: unary, server streaming, client streaming, and bidirectional streaming. + +Section 4: Testing, Performance & Monitoring +We will measure real-world performance using pre-configured benchmarking tools, write unit tests for your services, and visualize metrics in Grafana. This hands-on approach ensures you understand not just how to build gRPC services, but how to optimize and monitor them in production. + +By the end of this workshop, participants will have a thorough understanding of gRPC and its application in Python microservices. They will be equipped with the knowledge and skills to start building efficient distributed systems with gRPC. This workshop requires a basic understanding of Python and HTTP/REST concepts. + +## Proposal agenda + +1. **Welcome & Introduction** (10 min) + - What is gRPC and why it matters + - RPC concepts overview + +2. **gRPC vs REST** (5 min) + - Quick comparison: performance, type safety + - Why & when choose gRPC + +3. **Protocol Buffers Hands-On** (30 min) + - 📋 **Task**: Define a simple service in .proto file + - Message definition, nested types + - Service definition and RPC methods + - Code generation walkthrough + +4. **Building Your First gRPC Service** (40 min) + - � **Individual Exercise**: Implement your own server and client + - Build a user service with CRUD operations + - Test with provided client + - Debugging and troubleshooting + +5. **Communication Patterns** (30 min) + - Overview of 4 patterns (unary, server streaming, client streaming, bidirectional) + - 📋 **Task**: Implement streaming example (chat service) + - Extend your service to support bidirectional streaming + - Performance implications of each pattern + +6. **Asynchronicity in gRPC** (20 min) + - async/await patterns in Python + - 📋 **Task**: Convert your blocking service to async + - Benefits: handling concurrent requests efficiently + - Live demo of async performance + +7. **Testing, Performance & Monitoring** (35 min) + - Pre-configured test suite with pytest + - 📋 **Task**: Write unit tests for your service (templates provided) + - Running performance benchmarks with ghz + - Visualizing metrics in Grafana dashboard + - 📊 Live demo: See your service performance metrics in real-time + - Using grpcurl for debugging + - Common issues and solutions + +8. **Error Handling & Best Practices** (20 min) + - gRPC status codes and error handling + - 📋 **Task**: Add proper error handling to your service + - Retry strategies and timeouts + - Performance optimization tips + +9. **Real-World Topics** (20 min) + - Authentication (mTLS, API keys) + - Interceptors (middleware pattern) + - Monitoring and logging basics + - 📋 **Optional Task**: Add interceptor to your service + +10. **Deployment Basics** (15 min) + - Containerizing gRPC services (Docker basics) + - Environment configuration + - Cloud deployment overview (brief intro) + +11. **Final Review & Next Steps** (10 min) + - Recap of core concepts learned + - Common pitfalls to avoid + - Resources for continuing your gRPC journey + - Next projects to build + - Q&A and open discussion + +## Pre-Configured Docker Compose Environment + +All participants receive a ready-to-use Docker Compose setup that includes: + +**Services:** +- **gRPC Services** (Port 50051) - your code runs here +- **Prometheus** (Port 9090) - metrics collection +- **Grafana** (Port 3000) - visualization dashboard with pre-built gRPC dashboards +- **ghz** - performance benchmarking tool (pre-configured benchmark scripts) +- **Redis** (Port 6379) - optional for cache experiments + +**Pre-built Components:** +- Test suite templates with pytest fixtures +- Performance benchmark scripts (latency, throughput, concurrent connections) +- Grafana dashboards showing: + - gRPC latency percentiles (p50, p95, p99) + - Request throughput (requests/sec) + - Error rates and status codes + - Server resource usage +- Docker networking configured for easy service communication + +**Your Role:** +Write your gRPC service code in `service.py` - everything else runs automatically. See your metrics update live on Grafana as you code! + +**Total Duration: 240 minutes (4 hours)** +**Format**: Mix of lecture (40 min) + individual hands-on exercises (180 min) + testing & discussion (20 min) +**Recommended Structure**: +- First 90 min: Core concepts + first service (Docker up and running) +- 15 min break +- Next 85 min: Advanced patterns + testing (write tests, run benchmarks) +- Final 20 min: Performance comparison + discussion diff --git a/mongodb/call_for_proposal.md b/mongodb/call_for_proposal.md new file mode 100644 index 0000000..0e6909a --- /dev/null +++ b/mongodb/call_for_proposal.md @@ -0,0 +1,11 @@ +# MongoDB for Beginners + + +## Short description +This workshop is designed for those who are new to MongoDB and are eager to learn how to incorporate it into their Python projects. In this hands-on workshop, you will learn the basics of MongoDB, a leading NoSQL database, and how to use it with Python. We will start with an introduction to NoSQL databases and where they shine over traditional SQL databases. We will then dive into the specifics of MongoDB, including its architecture, data model, and the philosophy of “documents”. You will learn how to perform CRUD (Create, Read, Update, Delete) operations. We will also cover how to model data effectively using MongoDB’s flexible, JSON-like documents. By the end of this workshop, you will have a solid understanding of MongoDB and how to use it in your Python applications. You will be equipped with the knowledge and skills to start using MongoDB for managing data in your own projects. No prior experience with MongoDB is required, but a basic understanding of Python is necessary to get the most out of this workshop. Preparation: Participants are required to bring their own laptops with the following software pre-installed: Python 3.10 or later MongoDB Community Server or create account on MongoDB Atlas Join us in this exciting workshop and start your journey in the world of NoSQL databases with MongoDB! + +## Detailed abstract + +This workshop, “MongoDB for Beginners”, is a comprehensive introduction to MongoDB, a leading NoSQL database, tailored specifically for Python developers who are new to MongoDB. Section 1: Introduction to NoSQL Databases We will begin with an overview of NoSQL databases, discussing their advantages and use cases over traditional SQL databases. This section will provide a solid foundation for understanding why MongoDB is a powerful tool for modern web development. Section 2: Understanding MongoDB Next, we will delve into the specifics of MongoDB. We will explore its unique architecture, data model, and the concept of “documents”. This section will give you a clear understanding of how MongoDB stores and retrieves data. Section 3: CRUD Operations with PyMongo In this section, we will learn how to perform CRUD (Create, Read, Update, Delete) operations using PyMongo, the Python driver for MongoDB. Through hands-on exercises, you will gain practical experience in manipulating data in MongoDB using Python. Section 4: Data Modeling in MongoDB Finally, we will cover how to effectively model data using MongoDB’s flexible, JSON-like documents. We will discuss various strategies for structuring your data to optimize performance and maintainability. By the end of this workshop, participants will have a thorough understanding of MongoDB and its application in Python projects. They will be equipped with the knowledge and skills to start using MongoDB for managing data in their own applications. This workshop requires a basic understanding of Python. No prior experience with MongoDB or other NoSQL databases is necessary. + +## Proposal agenda \ No newline at end of file From 1bae45ad1481d671c408ddf74acc3323268598f4 Mon Sep 17 00:00:00 2001 From: Kamil Kulig Date: Sun, 15 Feb 2026 23:44:02 +0100 Subject: [PATCH 2/3] final draft --- grpc/call_for_proposal.md | 120 +++++--------------------------------- 1 file changed, 14 insertions(+), 106 deletions(-) diff --git a/grpc/call_for_proposal.md b/grpc/call_for_proposal.md index 4955587..4fb5389 100644 --- a/grpc/call_for_proposal.md +++ b/grpc/call_for_proposal.md @@ -2,121 +2,29 @@ ## Short description -This workshop is designed for those who are new to gRPC and are eager to learn how to build high-performance microservices with it. In this hands-on workshop, you will learn the basics of gRPC, a modern RPC framework, and how to use it with Python. We will start with an introduction to gRPC and where it excels over traditional REST APIs. We will then dive into the specifics of gRPC, including Protocol Buffers, service definition, and the four communication patterns. You will learn how to implement services, define messages, and handle different types of communication. A pre-configured Docker Compose environment with Prometheus, Grafana, and test suite will be provided so you can focus entirely on writing gRPC code and measuring performance in real-time. You will also cover best practices for error handling, authentication, testing, and performance optimization. By the end of this workshop, you will have a solid understanding of gRPC and how to use it in your Python applications. You will be equipped with the knowledge and skills to start building efficient microservices with gRPC. A basic understanding of Python and HTTP/REST is necessary to get the most out of this workshop. Preparation: Participants only need to bring laptops with Docker and Docker Compose installed. All other tools, dependencies, and boilerplate code will be provided pre-configured. Join us in this exciting hands-on workshop and start your journey in the world of high-performance RPC with gRPC! -## Detailed abstract +This hands-on workshop introduces gRPC, a modern RPC framework for building microservices. Learn Protocol Buffers, implement gRPC services from scratch, and explore communication patterns in Python. Discover how gRPC compares to REST APIs and use pre-configured Docker environments to test, benchmark, and monitor your services. By the end, you'll have practical knowledge to build microservices with gRPC. Basic Python knowledge required. All tools and infrastructure provided—bring a laptop with Docker installed. -This workshop, "gRPC for Beginners", is a comprehensive introduction to gRPC, a modern Remote Procedure Call framework, tailored specifically for Python developers who are new to gRPC. +## Detailed abstract -Section 1: Introduction to gRPC and RPC Concepts -We will begin with an overview of RPC concepts and why gRPC is a powerful tool for building microservices. We will compare gRPC with REST APIs and discuss its advantages including performance, type safety, and code generation. This section will provide a solid foundation for understanding gRPC's role in modern distributed systems. +This workshop, "gRPC for Beginners", is a practical 3-hour introduction to gRPC tailored for Python developers. -Section 2: Protocol Buffers and Service Definition -Next, we will delve into Protocol Buffers (protobuf), gRPC's serialization format. We will explore how to define messages and services using the .proto syntax. This section will give you a clear understanding of how gRPC structures data and defines service contracts. +You'll start by understanding RPC concepts and comparing gRPC with REST APIs to grasp when each is appropriate. Next, you'll dive into Protocol Buffers—gRPC's serialization format—and learn how to define services and messages. The core focus is building a complete gRPC service from scratch, implementing both server and client code. -Section 3: Implementing gRPC Services -In this section, we will learn how to implement gRPC services using Python. Through hands-on exercises, you will create servers and clients, understanding the four communication patterns: unary, server streaming, client streaming, and bidirectional streaming. +We'll explore the four communication patterns (unary, server streaming, client streaming, and bidirectional streaming) with hands-on examples. You'll then move to testing, performance benchmarking, and monitoring using pre-configured tools. -Section 4: Testing, Performance & Monitoring -We will measure real-world performance using pre-configured benchmarking tools, write unit tests for your services, and visualize metrics in Grafana. This hands-on approach ensures you understand not just how to build gRPC services, but how to optimize and monitor them in production. +All exercises use a ready-to-use Docker Compose environment so you can focus entirely on writing gRPC code. By the end, you'll understand gRPC fundamentals and be equipped to build and optimize microservices. -By the end of this workshop, participants will have a thorough understanding of gRPC and its application in Python microservices. They will be equipped with the knowledge and skills to start building efficient distributed systems with gRPC. This workshop requires a basic understanding of Python and HTTP/REST concepts. +Requirements: Basic Python knowledge and Docker installed. ## Proposal agenda 1. **Welcome & Introduction** (10 min) - - What is gRPC and why it matters - - RPC concepts overview - -2. **gRPC vs REST** (5 min) - - Quick comparison: performance, type safety - - Why & when choose gRPC - +2. **gRPC vs REST** (20 min) 3. **Protocol Buffers Hands-On** (30 min) - - 📋 **Task**: Define a simple service in .proto file - - Message definition, nested types - - Service definition and RPC methods - - Code generation walkthrough - -4. **Building Your First gRPC Service** (40 min) - - � **Individual Exercise**: Implement your own server and client - - Build a user service with CRUD operations - - Test with provided client - - Debugging and troubleshooting - -5. **Communication Patterns** (30 min) - - Overview of 4 patterns (unary, server streaming, client streaming, bidirectional) - - 📋 **Task**: Implement streaming example (chat service) - - Extend your service to support bidirectional streaming - - Performance implications of each pattern - -6. **Asynchronicity in gRPC** (20 min) - - async/await patterns in Python - - 📋 **Task**: Convert your blocking service to async - - Benefits: handling concurrent requests efficiently - - Live demo of async performance - -7. **Testing, Performance & Monitoring** (35 min) - - Pre-configured test suite with pytest - - 📋 **Task**: Write unit tests for your service (templates provided) - - Running performance benchmarks with ghz - - Visualizing metrics in Grafana dashboard - - 📊 Live demo: See your service performance metrics in real-time - - Using grpcurl for debugging - - Common issues and solutions - -8. **Error Handling & Best Practices** (20 min) - - gRPC status codes and error handling - - 📋 **Task**: Add proper error handling to your service - - Retry strategies and timeouts - - Performance optimization tips - -9. **Real-World Topics** (20 min) - - Authentication (mTLS, API keys) - - Interceptors (middleware pattern) - - Monitoring and logging basics - - 📋 **Optional Task**: Add interceptor to your service - -10. **Deployment Basics** (15 min) - - Containerizing gRPC services (Docker basics) - - Environment configuration - - Cloud deployment overview (brief intro) - -11. **Final Review & Next Steps** (10 min) - - Recap of core concepts learned - - Common pitfalls to avoid - - Resources for continuing your gRPC journey - - Next projects to build - - Q&A and open discussion - -## Pre-Configured Docker Compose Environment - -All participants receive a ready-to-use Docker Compose setup that includes: - -**Services:** -- **gRPC Services** (Port 50051) - your code runs here -- **Prometheus** (Port 9090) - metrics collection -- **Grafana** (Port 3000) - visualization dashboard with pre-built gRPC dashboards -- **ghz** - performance benchmarking tool (pre-configured benchmark scripts) -- **Redis** (Port 6379) - optional for cache experiments - -**Pre-built Components:** -- Test suite templates with pytest fixtures -- Performance benchmark scripts (latency, throughput, concurrent connections) -- Grafana dashboards showing: - - gRPC latency percentiles (p50, p95, p99) - - Request throughput (requests/sec) - - Error rates and status codes - - Server resource usage -- Docker networking configured for easy service communication - -**Your Role:** -Write your gRPC service code in `service.py` - everything else runs automatically. See your metrics update live on Grafana as you code! - -**Total Duration: 240 minutes (4 hours)** -**Format**: Mix of lecture (40 min) + individual hands-on exercises (180 min) + testing & discussion (20 min) -**Recommended Structure**: -- First 90 min: Core concepts + first service (Docker up and running) -- 15 min break -- Next 85 min: Advanced patterns + testing (write tests, run benchmarks) -- Final 20 min: Performance comparison + discussion +4. **Building Your First gRPC Service** (30 min) +5. **Communication Patterns** (20 min) +6. **Testing** (20 min) +7. **Performance** (20 min) +8. **Monitoring** (20 min) +9. **Review & Q&A** (10 min) From 79ce692d75a43ba9bcaef6f91aedde57f51fa746 Mon Sep 17 00:00:00 2001 From: Kamil Kulig Date: Fri, 20 Feb 2026 22:02:58 +0100 Subject: [PATCH 3/3] chore: add info about instructor --- grpc/call_for_proposal.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/grpc/call_for_proposal.md b/grpc/call_for_proposal.md index 4fb5389..319f7e2 100644 --- a/grpc/call_for_proposal.md +++ b/grpc/call_for_proposal.md @@ -27,4 +27,8 @@ Requirements: Basic Python knowledge and Docker installed. 6. **Testing** (20 min) 7. **Performance** (20 min) 8. **Monitoring** (20 min) -9. **Review & Q&A** (10 min) +9. **Review & Q&A** (10 min) + +## About the Instructor + +💼 Building at CTHINGS.CO | 💻 programmer, 🌟✨🏆 leader, 🐍 python lover, 🎮 gamer, 🕺 king of disco, ⚽️🏀🏈🥊 love sport in every form, 🇵🇱 from Poland \ No newline at end of file