Backend development with Vert.x

Explore the core module of vortex, the foundational backend primitives like the base http server, tcp and udp servers, event bus, and json buffers, accessed via the vortex vertex object.

Define and run an http server with Vert.x, configure connection and request handlers, access headers, body, and uploads, and optionally upgrade to a web socket or upload to S3.

Create a simple tcp server with vertex, using a create net server and connect handler to read data, print it, and reply hello; listen on port 9000 and track connections.

Explore the vertex event bus as the nervous system of the framework, enabling topic-based publish-subscribe messaging to trigger decoupled handlers across the app.

Explore Vert.x timers to schedule a one-off delay with set timer, or run code periodically every 3 seconds, enabling non-blocking tasks like emails, reports, and cleanups.

Learn how buffers move data around in Vertex, create and grow buffers, append and set values, convert buffers to JSON, and map JSON to class objects.

Explore how Vert.x handles json with json objects, encoding and decoding, and converting between objects, maps, strings, and buffers, with default values and null safety for strongly typed objects.

Learn to use the Vertex file system to create, delete, move, copy, and read files and directories, and to open files with options for reading and writing at specific positions.

Learn Vertex futures and the asynchronous model, attaching on success or on failure handlers and using compose, then suspend with Kotlin coroutines to write non-blocking, sequential code.

discover how Vert.x uses an event loop as the main thread, avoids blocking it by using execute blocking on a worker thread, and completes a promise to return HTTP responses.

Scale a Vert.x http server from single-threaded to multi-threaded. Deploy multiple verticals with set instances to run on separate event loops and enable round-robin on a single port.

Pass a JSON config to a Vert.x deployment to set the HTTP port with defaults, use the event bus for cross-vertical messaging, and share state via concurrent maps.

Explore how to use the Vert.x web client to issue http requests, parse json responses, set headers and timeouts, and apply status and content-type predicates for robust API calls.

Master vert.x router to define get, post, put, and delete endpoints and route requests by path and method, including catch-all routes and using next to pass control.

Explore how the routing context in Vert.x router manages the request–response lifecycle, exposing request, response, headers, body, and file uploads, with query params, redirects, cookies, and inter-handler data sharing.

Discover how vert.x middleware runs between requests and responses, enabling logging and authentication with top-level handlers, next control, and built-in failure handling and body parsing.

Learn how to handle blocking code in vert.x by using blocking handlers or execute blocking to run on worker threads, keeping the event loop non-blocking and ensuring proper response timing.

Learn to parse JSON request bodies with a body handler in Vert.x, access data via the routing context, and use path parameters like /users/:id.

Upgrade http requests to web sockets to create a full-duplex chat app, manage connected sockets, broadcast messages to peers, and handle disconnections.

Build a Vert.x based API that accepts file uploads through post requests, handles access to the uploaded file path and content, and returns the file contents in the response.

Design a Kotlin-based CRUD API with Vert.x, using a user data model and in-memory db, implementing create, read, update, and delete endpoints, and middleware for token-based access.

Demonstrate futures, promises, and async coordination in vert.x by evolving a crud api: fire-and-forget and wait-for-success patterns, and composing multiple api calls.

Add rate limiting to your vert.x api with an in-memory sliding window middleware that enforces ten requests per second per ip, returning too many requests when exceeded.

Expose micrometer metrics in Vert.x via a Prometheus registry, enabling an http metrics endpoint that Prometheus scrapes every 15 seconds, and visualize with Grafana dashboards.

Discover how pebble template engine renders templates with JSON data to produce HTML as a response. Learn to define templates, pass data, and render dynamic server-side content in Vertex.

Replace futures with Kotlin suspending functions in Vert.x using await to get values directly and write non-blocking, imperative code with a code routine scope and routine dispatcher on event loop.

Use the Vert.x PostgreSQL client to model data, run migrations in Docker, perform read/write with prepared queries, manage transactions and batch inserts, and implement listen/notify pub-sub.

Thank you for completing the course; feel free to ask questions on StackOverflow tagged Vertex, and consider consulting options to deepen Vertex skills for server side backend applications.