Training & speaking at events
If the content on this blog or my talks have resonated with you, that’s the best thing I can hope for! If you’re interested in getting me to run a workshop/talk at your conference (or internally to your team), please do get in touch with me on firstname.lastname@example.org.
Below are some example of workshops and talks that I’m currently running.
Cloud native monitoring with Prometheus & Grafana
When it comes to monitoring tools in the Cloud Native space, Prometheus is definitely hard to miss. It has quickly risen to be top of the class, with overwhelming adoption from other pieces of the Cloud Native puzzle.
In this workshop, you will get to learn as much as possible to get you started with Prometheus for monitoring a service-oriented architecture:
- The core concepts of Prometheus
- Instrumenting your code to expose metrics
- Querying Prometheus to gain insights on how your applications behave
- Defining rules to trigger alerts based on metrics and thresholds
- Building Grafana dashboards combining multiple metrics
Contract testing in practice with Pact
End-to-end integration plays a strong part in testability, unfortunately when an application grows, these kind of tests become a burden: brittleness, slower feedback and overall poor return on investment to improve quality.
Contract testing brings an alternative approach for validating integration points in fast-changing distributed systems. Because contracts don’t need integration environments, they can give very fast feedback to prevent API and messaging breaking changes from being introduced early-on.
Contracts are also a catalyst for inter-team communications. They help interactions between services become a central attribute in designing solutions, as opposed to an emergency concern when they break at a late integration stage.
This workshop covers the core concepts of contracts testing and contracts can play a part in reducing the struggles of integration tests. The attendees will be working on practical examples of defining contracts between teams and services, as well as implement them using the Pact tool-chain.
High-level schedule of workshop:
- Overview contract testing concepts and Pact
- Hands-on activity: defining contracts between teams
- How-to & hands-on activities: using Pact to implement contract generation and validation
After this workshop, participants should:
- Have a good understanding of the consumer-driven contract testing pattern
- Know when and where to use contract tests instead of integration tests
- Be able to implement simple Pact tests for both consumer and providers
Building observable distributed systems
Being able to observe the state of a running application is key to understanding a system’s behaviour and essential if you want to fix production problems quickly and efficiently. Like a lot of other things, this is harder to do in distributed systems than it is with a monolith. At Poppulo we’ve been running a distributed system of hundreds of microservices in production for more than 4 years and we got to understand how critical this visibility is. If you want to succeed with operating a distributed system, observability should be an integral part of system design.
In this talk, I cover key techniques to build a clearer picture of distributed applications in production, including details on useful health checks, best practices for instrumentation with metrics, logging and tracing.
Consumer-driven contracts: avoid microservices integration hell
Autonomy and isolation are some of the core values of microservices, allowing for independent changes and independent deployments. As loosely coupled services interact on interfaces managed under different life-cycles and even different teams, making sure that a simple change did not break the application can turn into an integration nightmare.
Consumer-Driven Contracts testing brings an alternative integration testing approach for distributed systems, relying less on live-like integration environments and more on making interactions explicit and quickly verifiable.
This talk will cover how to use CDCs part of your pipeline with Pact and how it can improve collaboration and confidence between teams when designing APIs.
Changing tyres on a moving car: the journey to zero-downtime deployments
Applications built over the years carry historical design assumptions, such as: it is acceptable to take a system out for upgrade maintenance for a few hours every 6 months.
In today’s world, embracing continuous delivery practices means more frequent releases, which means more downtime. Besides, finding a good maintenance window becomes a struggle with worldwide users, as well as for the operators managing the upgrade out of business hours.
In this talk, I demonstrate that by mapping out complex deployments processes, it becomes possible to prioritise work and progressively reduce the deployment impact. I will also give practical advice on how to tackle blockers to zero-downtime deployments, such as:
- Migrating database schemas while keeping an application running
- Ensuring backward compatibility of messages and APIs
- Dealing with long-running background jobs
- Mitigating user session loss
Deploying without the comfort of a maintenance window also means that stability during the upgrade is a critical concern. I will go through how it can be achieved through systematic pipeline automation and good system visibility to help operators during the upgrade.
The trick is: zero-downtime doesn’t mean everything is up or running the latest version, it only means nobody notices!